diff --git a/TarunsModel/Simulation/TarunsModel.py b/TarunsModel/Simulation/TarunsModel.py new file mode 100644 index 00000000..35921467 --- /dev/null +++ b/TarunsModel/Simulation/TarunsModel.py @@ -0,0 +1,13 @@ + +from cc3d import CompuCellSetup + +from TarunsModelSteppables import TarunsModelSteppable +CompuCellSetup.register_steppable(steppable=TarunsModelSteppable(frequency=1)) + +from TarunsModelSteppables import ChemotaxisSteppable +CompuCellSetup.register_steppable(steppable=ChemotaxisSteppable(frequency=1)) + +from TarunsModelSteppables import PlotsSteppable +CompuCellSetup.register_steppable(steppable=PlotsSteppable(frequency=1)) + +CompuCellSetup.run() diff --git a/TarunsModel/Simulation/TarunsModel.xml b/TarunsModel/Simulation/TarunsModel.xml new file mode 100644 index 00000000..0a0c689f --- /dev/null +++ b/TarunsModel/Simulation/TarunsModel.xml @@ -0,0 +1,115 @@ + + + + + 1 + 10 + + + + + + + 100000 + 10.0 + + 2 + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + + + + + + + + + + + + + + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 10.0 + 4 + + + + + + + Virus + 10.0 + 0.0 + 1000/(300*300) + Medium + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/TarunsModel/Simulation/TarunsModelSteppables.py b/TarunsModel/Simulation/TarunsModelSteppables.py new file mode 100644 index 00000000..aadbcac8 --- /dev/null +++ b/TarunsModel/Simulation/TarunsModelSteppables.py @@ -0,0 +1,1133 @@ +from cc3d.core.PySteppables import * +import numpy as np + +min_to_mcs = 60.0 # min/mcs +days_to_mcs = min_to_mcs / 1440.0 # day/mcs +days_to_simulate = 30.0 + +virus_infection_feedback = 3 +use_LymphModel_outputs = True + +contact_cytotoxicity = True + +plot_Epithelial_cells = True +plot_Virus = True +plot_Tcells = True +plot_APC = True +plot_Dm = True +plot_Contact_Cytotoxicity = True +plot_viral_antibodies = True +plot_infected_antibodies = True +plot_current_virus_decay = True + +# TODO: add graphs for all state variables + + +# changed J6, added drt = 30; + +full_model_string = """ +/////////////////////// Reactions ////////////////////////////// + +//Tissue infection + +J1: D -> E; dE*E0; // E0 => initial number of E-cells +J2: E -> D; dE*E; +J3: E -> Ev; bE*V*E; +J4: Ev -> E; aE*Ev; +J5: Ev -> D; dEv*Ev; +J6: Ev -> D; kE*Tct*Ev/(KEv + Ev + Tct); + +J7: Tc -> Tct; g*Tc; +J8: Tct ->; dC*Tct; +J9: Tct ->; dT1*Tct*Da/(Da+dT2); + +J10: -> V; pV*Ev; +J11: V ->; cV*V; +J12: -> Da; bD*V*(D0-Da); // D0 => initial number of inactive D-cells +J13: Da ->; dD*Da; + +// Systemic reactions in Lymph + +J14: Da -> Dm; kD*Da; +J15: Dm ->; dDm*Dm; +J16: -> Tc; dC*Tc0; // Tc0 => initial number of naive Tc-cells +J17: Tc ->; dC*Tc; +J18: -> Tc; rT1*Dm*Tc/(Dm+rT2); +J19: Tc ->; dT1*Tc*Dm/(Dm+dT2); + +J20: -> Th1; sTh1*Th1/(1+Th2)^2; +J21: -> Th1; pTh1*Dm*(Th1^2)/(1+Th2)^2; +J22: Th1 ->; dTh1*Dm*(Th1^3)/(1+Th2); +J23: Th1 ->; mTh*Th1; +J24: -> Th2; sTh2*Th2/(1+Th2); +J25: -> Th2; pTh2*(ro+Th1)*Dm*(Th2^2)/((1+Th2)*(1+Th1+Th2)) +J26: Th2 ->; mTh*Th2; + +// Antibody production + +J27: -> B; dB*B0; // B0 => initial number of inactive B-cells +J28: B ->; dB*B; +J29: -> B; rB1*B*(Dm+h*Th2)/(Dm+h*Th2+rB2); +J30: B -> Pss; pS*B; +J31: B -> Psn; pS*B; +J32: B -> Pls; pL*B*Th2; +J33: B -> Pln; pL*B*Th2; +J34: Pss ->; dS*Pss; +J35: Psn ->; dS*Psn; +J36: Pls ->; dL*Pls; +J37: Pln ->; dL*Pln; +J38: Pss -> Pls; d*(1-v)*Pss; +J39: Psn -> Pln; d*(1-v)*Psn; +J40: -> Pss; b*v*Pss; +J41: -> Pls; b*v*Pls; +J42: -> Psn; b*v*Psn; +J43: -> Pln; b*v*Pln; +J44: Pls -> Pss; d*(1-v)*Pls; +J45: Pln -> Psn; d*(1-v)*Pln; + +J46: -> sIgM; pAS*Pss; +J47: -> nIgM; pAS*Psn; +J48: -> sIgG; pAS*Pls; +J49: -> nIgG; pAS*Pln; +J50: sIgM ->; dM*sIgM; +J51: sIgG ->; dG*sIgG; +J52: nIgM ->; dM*nIgM; +J53: nIgG ->; dG*nIgG; + +// Antibody feedback to tissue + +J54: Ev + nIgM -> D; eE*Ev*nIgM; +J55: Ev + nIgG -> D; eE*Ev*nIgG; +J56: V + sIgM ->; eV*V*sIgM; +J57: V + sIgG ->; eV*V*sIgG; + + +/////////////////// Parameters /////////////////////// + +// Epithelial infection + +dE=10^-3; +E0 = 5.0*10^5; +bE=7.0*10^-6; +dEv=0.12; +aE=5.0*10^-1; +pV=1.9; +cV=1.0; + +// Dendritic cell infection, activation, migration + +D0=10^4; +bD=10^-6; +dD=2.9; +kD = 0.5; +dDm = 0.5; + +// Cytotoxic T-cell activation, proliferation + +dC=2.0*10^-3; +Tc0=2.0*10^3; +rT1=3.5; +rT2=2.0*10^3; +dT1=1.0; +dT2=1.0; + +// T-cell mediated Cytotoxicity + +kE=1.19*10^-2 / 900; +g=0.15 * 900; // 900 rescaling for non-0 T cell pop in tissue +KEv = 500.0; + +// Helper T-cell activation, proliferation + +sTh1=1.0; +pTh1=0.012; +dTh1=0.001; +KTh1 =500.0; +mTh=0.0225; +sTh2=0.04; +pTh2=0.003; +ro=1.0; + +// B-cell activation, proliferation, differentiation + +dB=0.02; +B0=2.0*10^1; +rB1=4.5; +rB2=1*10^4; +h=1.0; + +// Plasma cell proliferation, differentiation and antibody production + +pS=3.0*10^-1; +pL=1.5*10^-4; +dS=0.2; +dL=0.02; +b=2.4*10^-2; +d=2.4*10^-2; +pAS=0.8*10^2; +pAL=1.2*10^2; +dG=0.5; +dM=2.0; + +// Switching functions of the Plasma Cells + +u = 0.5; +v = 0.5; + +// Antibody activity: virus and cell killing + +eE=0.0001; +eV=0.00018; + +////////////////// Initial Conditions ///////////////////// + +E = 5.0*10^5; // Uninfected epithelial cells +Ev = 10.0; // Virus-infected epithelial cells +V = 1000.0; // +Da = 0.0; // Infected-activated dendtritic cells in Tissue + +Dm = 0.0; // Migrated dendritic cells in Lymph +Tc = 1.0; // Effector cytotoxic T-cells in Lymph +Tct = 0.0; // Effector cytotoxic T-cells in Tissue +Th1 = 1.0; // Type I helper T-cells +Th2 = 1.0; // Type II helper T-cells + +B = 1.0; // Activated B-cells +pSs = 0.0; // SP-RBD-specific Short-living plasma cells +pLs = 0.0; // SP-RBD-specific Long-living plasma cells +pSn = 0.0; // NP-specific Short-living plasma cells +pLn = 0.0; // NP-specific Long-living plasma cells + +sIgM = 0.0; // SP-RBD-specific IgM +sIgG = 0.0; // SP-RBD-specific IgG +nIgM = 0.0; // NP-specific IgM +nIgG = 0.0; // NP-specific IgG +""" + +lymph_node_string = ''' +// Systemic reactions in Lymph + +J7: Tc -> Tct; g*Tc; +J8: Tct ->; dC*Tct; +J9: Tct ->; dT1*Tct*Da/(Da+dT2); + +J14: -> Dm; 0.0*kD*Da; // MUST STAY SHUT OFF, DM IS AN INPUT Dm are apc in lymph +J15: Dm ->; dDm*Dm; +J16: -> Tc; dC*Tc0; // Tc0 => initial number of naive Tc-cells +J17: Tc ->; dC*Tc; +J18: -> Tc; rT1*Dm*Tc/(Dm+rT2); +J19: Tc ->; dT1*Tc*Dm/(Dm+dT2); + +J20: -> Th1; sTh1*Th1/(1+Th2)^2; +J21: -> Th1; pTh1*Dm*(Th1^2)/(1+Th2)^2; +J22: Th1 ->; dTh1*Dm*(Th1^3)/(1+Th2); +J23: Th1 ->; mTh*Th1; +J24: -> Th2; sTh2*Th2/(1+Th2); +J25: -> Th2; pTh2*(ro+Th1)*Dm*(Th2^2)/((1+Th2)*(1+Th1+Th2)) +J26: Th2 ->; mTh*Th2; + +// Antibody production + +J27: -> B; dB*B0; // B0 => initial number of inactive B-cells +J28: B ->; dB*B; +J29: -> B; rB1*B*(Dm+h*Th2)/(Dm+h*Th2+rB2); +J30: B -> Pss; pS*B; +J31: B -> Psn; pS*B; +J32: B -> Pls; pL*B*Th2; +J33: B -> Pln; pL*B*Th2; +J34: Pss ->; dS*Pss; +J35: Psn ->; dS*Psn; +J36: Pls ->; dL*Pls; +J37: Pln ->; dL*Pln; +J38: Pss -> Pls; d*(1-v)*Pss; +J39: Psn -> Pln; d*(1-v)*Psn; +J40: -> Pss; b*v*Pss; +J41: -> Pls; b*v*Pls; +J42: -> Psn; b*v*Psn; +J43: -> Pln; b*v*Pln; +J44: Pls -> Pss; d*(1-v)*Pls; +J45: Pln -> Psn; d*(1-v)*Pln; + +J46: -> sIgM; pAS*Pss; +J47: -> nIgM; pAS*Psn; +J48: -> sIgG; pAS*Pls; +J49: -> nIgG; pAS*Pln; +J50: sIgM ->; dM*sIgM; +J51: sIgG ->; dG*sIgG; +J52: nIgM ->; dM*nIgM; +J53: nIgG ->; dG*nIgG; + +// Antibody feedback to tissue + +J54: Ev + nIgM -> D; eE*Ev*nIgM; +J55: Ev + nIgG -> D; eE*Ev*nIgG; +J56: V + sIgM ->; eV*V*sIgM; +J57: V + sIgG ->; eV*V*sIgG; + + +/////////////////// Parameters /////////////////////// + +// Epithelial infection + +dE=10^-3; +E0 = 5.0*10^5; +bE=7.0*10^-6; +dEv=0.12; +aE=5.0*10^-1; +pV=1.9; +cV=1.0; + +// Dendritic cell infection, activation, migration + +D0=10^4; +bD=10^-6; +dD=2.9; +kD = 0.5; +dDm = 0.5; + +// Cytotoxic T-cell activation, proliferation + +dC=2.0*10^-3; +Tc0=2.0*10^3; +rT1=3.5; +rT2=2.0*10^3; +dT1=1.0; +dT2=1.0; + +// T-cell mediated Cytotoxicity + +kE=1.19*10^-2 / 900; +g=0.15 * 900; // 900 rescaling for non-0 T cell pop in tissue +KEv = 500.0; + +// Helper T-cell activation, proliferation + +sTh1=1.0; +pTh1=0.012; +dTh1=0.001; +KTh1 =500.0; +mTh=0.0225; +sTh2=0.04; +pTh2=0.003; +ro=1.0; + +// B-cell activation, proliferation, differentiation + +dB=0.02; +B0=2.0*10^1; +rB1=4.5; +rB2=1*10^4; +h=1.0; + +// Plasma cell proliferation, differentiation and antibody production + +pS=3.0*10^-1; +pL=1.5*10^-4; +dS=0.2; +dL=0.02; +b=2.4*10^-2; +d=2.4*10^-2; +pAS=0.8*10^2; +pAL=1.2*10^2; +dG=0.5; +dM=2.0; + +// Switching functions of the Plasma Cells + +u = 0.5; +v = 0.5; + +// Antibody activity: virus and cell killing + +eE=0.0001; +eV=0.00018; + +////////////////// Initial Conditions ///////////////////// + +E = 5.0*10^5; // Uninfected epithelial cells +Ev = 10.0; // Virus-infected epithelial cells +V = 1000.0; // +Da = 0.0; // Infected-activated dendtritic cells in Tissue + +Dm = 0.0; // Migrated dendritic cells in Lymph +Tc = 1.0; // Effector cytotoxic T-cells in Lymph +Tct = 0.0; // Effector cytotoxic T-cells in Tissue +Th1 = 1.0; // Type I helper T-cells +Th2 = 1.0; // Type II helper T-cells + +B = 1.0; // Activated B-cells +pSs = 0.0; // SP-RBD-specific Short-living plasma cells +pLs = 0.0; // SP-RBD-specific Long-living plasma cells +pSn = 0.0; // NP-specific Short-living plasma cells +pLn = 0.0; // NP-specific Long-living plasma cells + +sIgM = 0.0; // SP-RBD-specific IgM +sIgG = 0.0; // SP-RBD-specific IgG +nIgM = 0.0; // NP-specific IgM +nIgG = 0.0; // NP-specific IgG +''' + + +class TarunsModelSteppable(SteppableBasePy): + def __init__(self, frequency=1): + SteppableBasePy.__init__(self, frequency) + + def get_ode_parameters(self): + + ode_params = {'dE': 1e-3, 'E0': 5e-2, 'bE': 3e-6, 'aE': 5e-2, 'V0': 10.0, 'pV': 19.0, 'cV': 1.0, + 'kE': 1.19e-2 / 900, 'g': 0.15 * 900, # rescaling for non - 0 T cell pop in tissue (/900*900) + 'tC': 0.5, # not included in the model + 'eE': 0.05, 'eV': 16.0, 'D0': 1e3, 'bD': 1e-7, + 'dD': 2.9, 'kD': 0.5, + 'tD': 1.0, # not included in the model + 'dDm': 0.5, 'dC': 10.1e-3, 'Tc0': 5e2, 'rT1': 1.3, 'rT2': 100.0, + 'dT1': 5.0, 'dT2': 200.0, 'sTh1': 0.25, 'pTh1': 0.4, 'dTh1': 0.03, 'mTh': 0.25, 'sTh2': 0.001, + 'pTh2': 0.0022, 'ro': 0.2, 'dB': 0.0009, 'B0': 1e3, 'rB1': 1e2, 'rB2': 2e5, 'h': 100, 'pS': 0.1, + 'pL': 8e-3, 'dS': 0.002, 'dL': 0.02, 'b': 2.4e-4, 'd': 2.4e-2, 'pAS': 0.8, 'pAL': 1.2, 'dG': 0.04, + 'dM': 0.2, 'pT2': 600.0, 'v': 0.5, + 'proport_init_inf': 0.01 # unused + } + ode_params['E'] = ode_params['E0'] - 1 + ode_params['Ev'] = 1 + ode_params['V'] = 0 + ode_params['Th1'] = 10.0 + ode_params['Th2'] = 10.0 + ode_params['drt'] = 3.0 + + return ode_params + + def decay_exp_prob(self, p): + return 1 - np.exp(-p) + + def seed_epithelial_sheet(self): + for x in range(0, self.dim.x, int(3)): + for y in range(0, self.dim.y, int(3)): + cell = self.new_cell(self.E) + self.cellField[x:x + int(3), y:y + int(3), 0] = cell + + def init_variables(self): + # Updating max simulation steps using scaling factor to simulate 10 days + self.add_free_floating_antimony(model_string=full_model_string, model_name='FullModel', step_size=days_to_mcs) + self.add_free_floating_antimony(model_string=lymph_node_string, model_name='LymphModel', step_size=days_to_mcs) + self.get_xml_element('simulation_steps').cdata = days_to_simulate / days_to_mcs + # self.initial_uninfected = len(self.cell_list_by_type(self.E)) + self.get_xml_element('virus_decay').cdata = self.sbml.FullModel['cV'] * days_to_mcs + lattice_factor = .14 + self.max_virus_gamma = .75 * float(self.get_xml_element("virus_D").cdata) / lattice_factor + self.scalar_virus = self.sbml.FullModel['V'] + self.shared_steppable_vars['CC3D_lymph_APC_count'] = 0.0 + self.shared_steppable_vars['Active_APCs'] = 0.0 + self.shared_steppable_vars['ODE_Killing'] = 0.0 + self.shared_steppable_vars['Contact_Killing'] = 0.0 + self.virus_secretor = self.get_field_secretor("Virus") + + def seed_APC_cells(self): + numberAPC = 0.0 + while numberAPC < round(self.sbml.FullModel['D0'] / self.sbml.FullModel['E0'] * self.initial_uninfected): + x = np.random.randint(10, self.dim.x - 10) + y = np.random.randint(10, self.dim.y - 10) + if not self.cell_field[x, y, 1]: + cell = self.new_cell(self.APC) + self.cell_field[x:x + 3, y:y + 3, 1] = cell + cell.targetVolume = cell.volume + .5 + cell.lambdaVolume = cell.volume * 3 + cell.dict['Activation_State'] = 0 # in tissue + numberAPC += 1 + + def new_T_cell_in_location(self, x, y, z): + # print('in net t cell func') + cell = self.new_cell(self.TCELL) + cell.dict['body_count'] = 0 + self.cell_field[x:x + 3, y:y + 3, z] = cell + cell.targetVolume = cell.volume + .5 + cell.lambdaVolume = cell.volume * 3 + cd = self.chemotaxisPlugin.addChemotaxisData(cell, "Virus") + cd.setLambda(0) + cd.assignChemotactTowardsVectorTypes([self.MEDIUM]) + return cell + + def start(self): + self.seed_epithelial_sheet() + + self.init_variables() + p_Ev = self.sbml.FullModel['Ev'] / self.sbml.FullModel['Ev'] + # print('@@@@@@@@@@@@@@@@@@@@@@@\n', p_Ev, '\n@@@@@@@@@@@@@@@@@@@@@@') + proport_inf = False + if proport_inf: + for cell in self.cell_list_by_type(self.E): + if np.random.random() <= p_Ev: + # print('@@@@@@@@@@@@@@@@@@@@@@@\ninit infected\n@@@@@@@@@@@@@@@@@@@@@@') + cell.type = self.EV + else: + cells = [cell for cell in self.cell_list_by_type(self.E)] + np.random.shuffle(cells) + cell = cells[0] + cell.type = self.EV + self.initial_uninfected = len(self.cell_list_by_type(self.E)) + self.seed_APC_cells() + + def J1_DtoE(self, cell): + ## Transition from D to E + # J1: D -> E; dE*E0; // E0 => initial number of E-cells + + # 1 - np.exp(-self.sbml.FullModel['dE'] * days_to_mcs) ~ 1 - ( 1 - self.sbml.FullModel['dE'] * days_to_mcs) + # = self.sbml.FullModel['dE'] * days_to_mcs + p = self.decay_exp_prob(self.sbml.FullModel['dE'] * self.sbml.FullModel['E0'] * days_to_mcs) + if p > np.random.random(): + cell.type = self.E + + def J2_EtoD(self, cell): + ## Transition from E to D + # J2: E -> D; dE * E; + # print('J2',self.sbml.FullModel['dE'] * days_to_mcs) + if self.decay_exp_prob(self.sbml.FullModel['dE'] * days_to_mcs) > np.random.random(): + cell.type = self.D + + def J3_EtoEv(self, cell): + ## Transition from E to Ev + # J3: E -> Ev; bE*V*E; + if virus_infection_feedback == 1: + bE = self.sbml.FullModel['bE'] * days_to_mcs + V = self.sbml.FullModel['V'] + elif virus_infection_feedback == 2: + bE = self.sbml.FullModel['bE'] * days_to_mcs + V = self.scalar_virus + elif virus_infection_feedback == 3: + bE = self.sbml.FullModel['bE'] * days_to_mcs * self.initial_uninfected + V = self.virus_secretor.amountSeenByCell(cell) + else: # in case of things breaking have a default + bE = self.sbml.FullModel['bE'] * days_to_mcs + V = self.sbml.FullModel['V'] + p_EtoEv = self.decay_exp_prob(bE * V) + # p_EtoEv = bE * V + + if p_EtoEv > np.random.random(): + cell.type = self.EV + # print('infected', cell.id) + # print('prob infect', p_EtoEv) + # print('old prob inf', bE * V) + + def J4_EvtoE(self, cell): + ## Transition from Ev to E + # J4: Ev -> E; aE*Ev; + if self.decay_exp_prob(self.sbml.FullModel['aE'] * days_to_mcs) > np.random.random(): + cell.type = self.E + # print('became healthy', cell.id) + + def J5_EvtoD(self, cell): + ## Transition from Ev to D + # J5: Ev -> D; dEv*Ev; + dE = self.sbml.FullModel['dEv'] * days_to_mcs + p_EvtoD = self.decay_exp_prob(dE) + if p_EvtoD > np.random.random(): + cell.type = self.D + # print('j5', p_EvtoD) + # print('died from j5', cell.id) + + def J6_EvtoD_ODE_killing(self, cell, Tct): + ## Transition from Ev to D + # Tct is new tc in tissue, was g*Tc + # J6: Ev -> D; kE*Tct*Ev/(KEv + Ev + Tct); + p = self.sbml.FullModel['kE'] * Tct * 1 / (self.sbml.FullModel['KEv'] + 1 + Tct) + p_EvtoD = self.decay_exp_prob(p) + if p_EvtoD > np.random.random(): + if not contact_cytotoxicity: + cell.type = self.D + self.shared_steppable_vars['ODE_Killing'] += 1 + + def J7_Tct_seeding(self): + # J7: -> Tct; g*Tc; + use_LymphModel_outputs = False + if use_LymphModel_outputs: + n_tct = self.sbml.LymphModel['Tct'] * \ + self.initial_uninfected / self.sbml.FullModel['E0'] + else: + n_tct = self.sbml.FullModel['Tct'] * \ + self.initial_uninfected / self.sbml.FullModel['E0'] + lm_n_tct = self.sbml.LymphModel['Tct'] * \ + self.initial_uninfected / self.sbml.FullModel['E0'] + print(n_tct, len(self.cell_list_by_type(self.TCELL)), lm_n_tct) + if int(n_tct) > len(self.cell_list_by_type(self.TCELL)): + for i in range(int(round(n_tct - len(self.cell_list_by_type(self.TCELL))))): + cell = False + while not cell: + x = np.random.randint(0, self.dim.x - 3) + y = np.random.randint(0, self.dim.y - 3) + if not self.cell_field[x, y, 1]: + cell = self.new_T_cell_in_location(x, y, 1) + return + + def J8_J9_Tct_death(self, cell, tissue_apc): + # change if to be on the call to this function + + # J8: Tct ->; dC * Tct; + # J9: Tct ->; dT1 * Tct * Da / (Da + dT2); + + dC = self.sbml.FullModel['dC'] * days_to_mcs + dT1 = self.sbml.FullModel['dT1'] * days_to_mcs + dT2 = self.sbml.FullModel['dT2'] * days_to_mcs * self.initial_uninfected / self.sbml.FullModel['E0'] + p = dC * 1 + dT1 * 1 * tissue_apc / (dT2 + tissue_apc) + p = self.decay_exp_prob(p) + if p > np.random.random(): + cell.targetVolume = 0 + cell.lambdaVolume = 99 + return + + def J10_virus_production(self): + ## Virus Production + # J7: -> V; pV*Ev; + virus_production = 0.0 + pV = self.sbml.FullModel['pV'] * days_to_mcs * self.sbml.FullModel['E0'] / self.initial_uninfected + for cell in self.cell_list_by_type(self.EV): + release = self.virus_secretor.secreteInsideCellTotalCount(cell, pV / cell.volume) + virus_production += abs(release.tot_amount) + return virus_production + + def old_J8_virus_decay(self): + # no longer used, now update_scalar_virus does all the work + ## Virus Decay + # J8: V ->; cV*V; + cV = self.sbml.FullModel['cV'] * days_to_mcs + virus_decay = cV * self.scalar_virus + + def J12_J13_APC_activation_deactivation(self): + tissue_apc = 0 + lymph_apc = 0 + node_apc = 0 + just_moved_in_to_node = 0 + # activated_APC_count = 0 + for cell in self.cell_list_by_type(self.APC): + # if cell.dict == 0 -> in tissue; keep logic (J12: -> Da; bD*V*(D0-Da);) but replace cell.dict[ + # 'Activation_State'] = True by cell.dict['Activation_State'] = 1, this cell is now in transit: + # tissue_apc -= 1; lymph_apc+=1 + ######################## + # add this elif elif cell.dict['Activation_State'] = 1; go from the lymph to the + # node by p_transition = 1/delay [rescaled] if p_transition > dice_roll: cell.dict['Activation_State'] = + # 2 this cell is now in the lymph; lymph_apc-=1 node_apc+=1 ## replace the elif cell.dict[ + # 'Activation_State']: elif cell.dict['Activation_State'] == 2; keep logic replace cell.dict[ + # 'Activation_State'] = False by cell.dict['Activation_State'] = 0 ## then number of apc in node is + # cell.dict['Activation_State'] == 2 * self.sbml.LymphModel['kD'] / delay + if cell.dict['Activation_State'] == 0: # in tissue + ## Infection and Activation of APC + # J12: -> Da; bD*V*(D0-Da); + tissue_apc += 1 + bD = (self.sbml.FullModel['bD'] * days_to_mcs) * (self.sbml.FullModel['D0'] * self.initial_uninfected / + self.sbml.FullModel['E0']) + # V should be local instead of the total virus + V = self.virus_secretor.amountSeenByCell(cell) * self.initial_uninfected + # V = self.sbml.FullModel['V'] / self.sbml.FullModel['E0'] * self.initial_uninfected + + p_tissue_2_lymph = self.decay_exp_prob(bD * V) + if p_tissue_2_lymph > np.random.random(): + cell.dict['Activation_State'] = 1 + tissue_apc -= 1 + lymph_apc += 1 + elif cell.dict['Activation_State'] == 1: # in lymph + # transport of apc to lymph + lymph_apc += 1 + # todo: rethink this probability and find a good parameter for transport + p_lymph_2_node = 1 / 50 # PLACEHOLDER + if p_lymph_2_node > np.random.random(): + cell.dict['Activation_State'] = 2 + lymph_apc -= 1 + node_apc += 1 + just_moved_in_to_node += 1 + elif cell.dict['Activation_State'] == 2: + # J13: Da ->; dD*Da; + node_apc += 1 + dD = self.sbml.FullModel['dD'] * days_to_mcs + p_lymph_2_tissue = self.decay_exp_prob(dD) + if p_lymph_2_tissue > np.random.random(): + cell.dict['Activation_State'] = 0 + node_apc -= 1 + tissue_apc += 1 + self.shared_steppable_vars['Active_APCs'] = node_apc # lymph_apc + node_apc + return tissue_apc, lymph_apc, node_apc, just_moved_in_to_node + + def J14_APC_travel_Lymph_Model_input(self, just_moved_in_to_node): + ## APC "travel" to lymph node + # we'll implement it as a signal that is proportional to the activated apcs + # J14: -> Dm; kD*Da; // Dm are apc in lymph + # print(node_apc) + self.sbml.LymphModel['Dm'] += max(0, (just_moved_in_to_node * self.sbml.FullModel['D0'] * + self.initial_uninfected / self.sbml.FullModel['E0'])) + + def old_J13_Tcell_stable_population_seeding(self): + ## Tcell seeding + # J13: -> Tc; dc*g*Tc0; + if use_LymphModel_outputs: + dc = self.sbml.LymphModel['dC'] * days_to_mcs + g = self.sbml.LymphModel['g'] + Tc0 = self.sbml.LymphModel['Tc0'] / self.sbml.FullModel['E0'] * self.initial_uninfected + else: + dc = self.sbml.FullModel['dC'] * days_to_mcs + g = self.sbml.FullModel['g'] + Tc0 = self.sbml.FullModel['Tc0'] / self.sbml.FullModel['E0'] * self.initial_uninfected + cell = False + if self.decay_exp_prob(dc * g * Tc0) > np.random.random(): + while not cell: + x = np.random.randint(0, self.dim.x - 3) + y = np.random.randint(0, self.dim.y - 3) + if not self.cell_field[x, y, 1]: + cell = self.new_T_cell_in_location(x, y, 1) + + def old_J14_Tcell_clearance(self): + ## Clearance of Tcells + # J14: Tc ->; dc*Tc; + + for cell in self.cell_list_by_type(self.TCELL): + dc = self.decay_exp_prob(self.sbml.FullModel['dC'] * days_to_mcs) + if dc > np.random.random(): + cell.targetVolume = 0.0 + + def old_J15a_Tcell_inflamatory_seeding(self): # REMOVE!!! + # equation changed no longer used + return + ## Tcell seeding + # J15a: Dm -> Tc; Dm ; + # J15a: -> Tc; Dm ; + g = self.sbml.FullModel['g'] + + if use_LymphModel_outputs: + Dm = self.sbml.LymphModel['Dm'] * days_to_mcs / self.sbml.FullModel['E0'] * self.initial_uninfected + else: + Dm = self.sbml.FullModel['Dm'] * days_to_mcs / self.sbml.FullModel['E0'] * self.initial_uninfected + + if self.decay_exp_prob(Dm * g) > np.random.random(): + cells_to_seed = max(1, round(Dm * g)) + for i in range(cells_to_seed): + cell = False + while not cell: + x = np.random.randint(0, self.dim.x - 3) + y = np.random.randint(0, self.dim.y - 3) + if not self.cell_field[x, y, 1]: + cell = self.new_T_cell_in_location(x, y, 1) + + def old_J15b_Tcell_inflamatory_seeding(self): + ## Tcell seeding + # J15b: -> Tc; rT1 * Dm * Tc / (Dm + pT2) + if use_LymphModel_outputs: + rT1 = self.sbml.LymphModel['rT1'] * days_to_mcs + Dm = self.sbml.LymphModel['Dm'] / self.sbml.FullModel['E0'] * self.initial_uninfected + Tc = self.sbml.LymphModel['Tc'] / self.sbml.FullModel['E0'] * self.initial_uninfected + pT2 = self.sbml.LymphModel['pT2'] / self.sbml.FullModel['E0'] * self.initial_uninfected + g = self.sbml.LymphModel['g'] + else: + rT1 = self.sbml.FullModel['rT1'] * days_to_mcs + Dm = self.sbml.FullModel['Dm'] / self.sbml.FullModel['E0'] * self.initial_uninfected + Tc = self.sbml.FullModel['Tc'] / self.sbml.FullModel['E0'] * self.initial_uninfected + pT2 = self.sbml.FullModel['pT2'] / self.sbml.FullModel['E0'] * self.initial_uninfected + g = self.sbml.FullModel['g'] + + if self.decay_exp_prob(g * rT1 * Dm * Tc / (Dm + pT2)) > np.random.random(): + cells_to_seed = max(1, round(g * rT1 * Dm * Tc / (Dm + pT2))) + for i in range(cells_to_seed): + cell = False + while not cell: + x = np.random.randint(0, self.dim.x - 3) + y = np.random.randint(0, self.dim.y - 3) + if not self.cell_field[x, y, 1]: + cell = self.new_T_cell_in_location(x, y, 1) + + def old_J15_Tcell_inflamatory_seeding(self): + # self.J15a_Tcell_inflamatory_seeding() + self.old_J15b_Tcell_inflamatory_seeding() + + def old_J16_Tcell_clearance(self): + # TODO: NEEDs RESCALING + # Tcell clearance + # J16: Tc ->; dT1 * Tc * Ev/(Ev+dT2) + Ev = len(self.cell_list_by_type(self.EV)) + dT1 = self.sbml.FullModel['dT1'] * days_to_mcs * 3 + dT2 = self.sbml.FullModel['dT1'] * days_to_mcs / self.sbml.FullModel['E0'] * self.initial_uninfected + for cell in self.cell_list_by_type(self.TCELL): + if self.decay_exp_prob(dT1 * Ev / (Ev + dT2)) > np.random.random(): + cell.targetVolume = 0.0 + + def old_J49_Ev2D_from_nIgM(self, cell): + ## Transition from Ev to D + # J49: Ev -> D; eE * Ev * nIgM; + if use_LymphModel_outputs: + nIgM = self.sbml.LymphModel['nIgM'] + eE = self.sbml.LymphModel['eE'] + else: + nIgM = self.sbml.FullModel['nIgM'] + eE = self.sbml.FullModel['eE'] + p_Ev2D = nIgM * eE * days_to_mcs # * self.initial_uninfected / self.sbml.FullModel['E0'] + p_Ev2D = (p_Ev2D) + if p_Ev2D > np.random.random(): + cell.type = self.D + # print('killed by anti bodies M', cell.id) + # print(p_Ev2D) + return + + def old_J50_Ev2D_from_nIgG(self, cell): + # J50: Ev -> D; eE * Ev * nIgG; + if use_LymphModel_outputs: + nIgG = self.sbml.LymphModel['nIgG'] + eE = self.sbml.LymphModel['eE'] + else: + nIgG = self.sbml.FullModel['nIgG'] + eE = self.sbml.FullModel['eE'] + p_Ev2D = nIgG * eE * days_to_mcs # * self.initial_uninfected / self.sbml.FullModel['E0'] + p_Ev2D = self.decay_exp_prob(p_Ev2D) + if p_Ev2D > np.random.random(): + cell.type = self.D + # print('killed by anti bodies G', cell.id) + # print(p_Ev2D) + return + + def J54_J55_antibody_cell_death(self): + # J54: Ev + nIgM -> D; eE * Ev * nIgM; + # J55: Ev + nIgG -> D; eE * Ev * nIgG; + if use_LymphModel_outputs: + nIgM = self.sbml.LymphModel['nIgM'] + nIgG = self.sbml.LymphModel['nIgG'] + eE = self.sbml.LymphModel['eE'] + else: + nIgM = self.sbml.FullModel['nIgM'] + nIgG = self.sbml.FullModel['nIgG'] + eE = self.sbml.FullModel['eE'] + p = days_to_mcs * eE * (nIgG + nIgM) + p = self.decay_exp_prob(p) + for cell in self.cell_list_by_type(self.EV): + if p > np.random.random(): + cell.type = self.D + return + + def J56_J57_update_virus_decay(self): + # J8: V ->; cV*V; + # J56: V + sIgM ->; eV*V*sIgM; + # J57: V + sIgG ->; eV*V*sIgG; + + if use_LymphModel_outputs: + gamma = (self.sbml.LymphModel['eV'] * (self.sbml.LymphModel['sIgM'] + self.sbml.LymphModel['nIgM']) + + self.sbml.LymphModel['cV']) * days_to_mcs + else: + gamma = (self.sbml.FullModel['eV'] * (self.sbml.FullModel['sIgM'] + self.sbml.FullModel['nIgM']) + + self.sbml.FullModel['cV']) * days_to_mcs + + effective_gamma = min(self.max_virus_gamma, gamma) + # effective_gamma = (gamma_sIgM + gamma_sIgG + self.sbml.FullModel['cV']) * days_to_mcs + self.get_xml_element('virus_decay').cdata = effective_gamma + + return effective_gamma + + def update_scalar_virus(self, virus_production, current_gamma): + # does the work that J8 used to do + if self.mcs % 50 == 0 and self.mcs > 0: + # do the actual integral + self.scalar_virus = self.virus_secretor.totalFieldIntegral() + return + virus_decay = current_gamma * self.scalar_virus + self.scalar_virus += virus_production - virus_decay + self.shared_steppable_vars['scalar_virus'] = self.scalar_virus + return + + def lymph_model_input(self, Ev, Da): + Ev *= self.sbml.FullModel['E0'] / self.initial_uninfected + self.sbml.LymphModel['Ev'] = Ev + self.sbml.LymphModel['Da'] = Da + self.sbml.LymphModel['V'] = self.scalar_virus + + def contact_killing(self, cell): + + for neighbor, common_surface_area in self.get_cell_neighbor_data_list(cell): + if neighbor: + if neighbor.type == self.EV: + self.shared_steppable_vars['Contact_Killing'] += 1 + if contact_cytotoxicity: + neighbor.type = self.D + cell.dict['body_count'] += 1 + # print('killed by contact killing', cell.id) + + def test_prints(self): + print('taruns\tcc3d') + print('Tc', self.sbml.FullModel['Tc'], self.sbml.LymphModel['Tc']) + print('Th1', self.sbml.FullModel['Th1'], self.sbml.LymphModel['Th1']) + print('Th2', self.sbml.FullModel['Th2'], self.sbml.LymphModel['Th2']) + # print('Da', self.sbml.FullModel['Da'], self.sbml.LymphModel['Da']) + print('Dm', self.sbml.FullModel['Dm'], self.sbml.LymphModel['Dm']) + + def step(self, mcs): + # self.test_prints() + # print(mcs) + self.shared_steppable_vars['Contact_Killing'] = 0 + + for cell in self.cell_list_by_type(self.D): + self.J1_DtoE(cell) + + for cell in self.cell_list_by_type(self.E): + self.J2_EtoD(cell) + + # self.virus_secretor = self.get_field_secretor("Virus") + for cell in self.cell_list_by_type(self.E): + self.J3_EtoEv(cell) + + for cell in self.cell_list_by_type(self.EV): + self.J4_EvtoE(cell) + + for cell in self.cell_list_by_type(self.EV): + self.J5_EvtoD(cell) + + self.J7_Tct_seeding() + Tct = len(self.cell_list_by_type(self.TCELL)) / self.initial_uninfected * self.sbml.FullModel['E0'] + + for cell in self.cell_list_by_type(self.EV): + self.J6_EvtoD_ODE_killing(cell, Tct) + + # for cell in self.cell_list_by_type(self.EV): + # self.old_J49_Ev2D_from_nIgM(cell) + # + # for cell in self.cell_list_by_type(self.EV): + # self.old_J50_Ev2D_from_nIgG(cell) + + self.J54_J55_antibody_cell_death() + + virus_production = self.J10_virus_production() + + current_gamma = self.J56_J57_update_virus_decay() + self.update_scalar_virus(virus_production, current_gamma) + # activated_APC_count = 0 + + tissue_apc, lymph_apc, node_apc, just_moved_in_to_node = self.J12_J13_APC_activation_deactivation() + if use_LymphModel_outputs: + Da = tissue_apc + else: + Da = self.sbml.FullModel['Da'] + for cell in self.cell_list_by_type(self.TCELL): + self.J8_J9_Tct_death(cell, Da) + + self.J14_APC_travel_Lymph_Model_input(just_moved_in_to_node) + + # self.old_J13_Tcell_stable_population_seeding() + # + # self.old_J14_Tcell_clearance() + # + # self.old_J15_Tcell_inflamatory_seeding() + # + # self.old_J16_Tcell_clearance() + + ## Tcell Contact Killing + for cell in self.cell_list_by_type(self.TCELL): + self.contact_killing(cell) + + # update lymph model inputs + self.lymph_model_input(len(self.cell_list_by_type(self.EV)), node_apc) + + # if use_LymphModel_outputs: + # self.lymph_model_input(len(self.cell_list_by_type(self.EV)), node_apc) + # else: + # self.lymph_model_input(len(self.cell_list_by_type(self.EV)), self.sbml.FullModel['Da']) + ## Step SBML forward + self.timestep_sbml() + + +class ChemotaxisSteppable(SteppableBasePy): + def __init__(self, frequency=1): + SteppableBasePy.__init__(self, frequency) + + def start(self): + for cell in self.cell_list_by_type(self.APC, self.TCELL): + cd = self.chemotaxisPlugin.addChemotaxisData(cell, "Virus") + cd.setLambda(0) + cd.assignChemotactTowardsVectorTypes([self.MEDIUM]) + self.secretor = self.get_field_secretor("Virus") + + def step(self, mcs): + lambda_chemotaxis = 250.0 * 2 + for cell in self.cell_list_by_type(self.APC, self.TCELL): + cd = self.chemotaxisPlugin.getChemotaxisData(cell, "Virus") + cd.setLambda(0) + concentration = self.secretor.amountSeenByCell(cell) + if concentration: + cd.setLambda(lambda_chemotaxis / (1 + concentration)) + + +class PlotsSteppable(SteppableBasePy): + def __init__(self, frequency=1): + SteppableBasePy.__init__(self, frequency) + + def start(self): + self.seed = 0 + self.initial_uninfected = len(self.cell_list_by_type(self.E)) + + if plot_Epithelial_cells: + self.plot_win = self.add_new_plot_window(title='Epithelial Cells', + x_axis_title='Time (days)', + y_axis_title='Fraction of Cells', x_scale_type='linear', + y_scale_type='linear', + grid=True) + + self.plot_win.add_plot("ODEE", style='Lines', color='blue', size=5) + self.plot_win.add_plot("ODEEv", style='Lines', color='yellow', size=5) + self.plot_win.add_plot("ODED", style='Lines', color='red', size=5) + + self.plot_win.add_plot("CC3DE", style='Dots', color='blue', size=5) + self.plot_win.add_plot("CC3DEv", style='Dots', color='yellow', size=5) + self.plot_win.add_plot("CC3DD", style='Dots', color='red', size=5) + + if plot_Virus: + self.plot_win2 = self.add_new_plot_window(title='Virus', + x_axis_title='Time (days)', + y_axis_title='Virus', x_scale_type='linear', + y_scale_type='linear', + grid=True) + + self.plot_win2.add_plot("ODEV", style='Lines', color='yellow', size=5) + self.plot_win2.add_plot("CC3DV", style='Dots', color='red', size=5) + + if plot_Tcells: + self.plot_win3 = self.add_new_plot_window(title='Epithelial Tcells', + x_axis_title='Time (days)', + y_axis_title='Number of Cells', x_scale_type='linear', + y_scale_type='linear', + grid=True) + + self.plot_win3.add_plot("ODETc", style='Lines', color='yellow', size=5) + self.plot_win3.add_plot("CC3DTc", style='Dots', color='red', size=5) + + if plot_APC: + self.plot_win4 = self.add_new_plot_window(title='Epithelial APC', + x_axis_title='Time (days)', + y_axis_title='Number of Cells', x_scale_type='linear', + y_scale_type='linear', + grid=True) + + self.plot_win4.add_plot("ODEAPC", style='Lines', color='yellow', size=5) + self.plot_win4.add_plot("CC3DAPC0", style='Dots', color='orange', size=5) + self.plot_win4.add_plot("CC3DAPC", style='Dots', color='red', size=5) + + if plot_Dm: + self.plot_win5 = self.add_new_plot_window(title='Lymph node APC', + x_axis_title='Time (days)', + y_axis_title='Number of Cells', x_scale_type='linear', + y_scale_type='linear', + grid=True) + + self.plot_win5.add_plot("ODEAPC", style='Lines', color='yellow', size=5) + # self.plot_win5.add_plot("CC3DAPC0", style='Lines', color='orange', size=5) + + self.plot_win5.add_plot("CC3DAPC", style='Dots', color='red', size=5) + + if contact_cytotoxicity and plot_Contact_Cytotoxicity: + self.plot_win6 = self.add_new_plot_window(title='Contact Cytotoxicity', + x_axis_title='Time (days)', + y_axis_title='Number of Cells', x_scale_type='linear', + y_scale_type='linear', + grid=True) + + self.plot_win6.add_plot("ODECC", style='Lines', color='yellow', size=5) + self.plot_win6.add_plot("CC3DCC", style='Dots', color='red', size=5) + self.plot_win6.add_plot("body_count", style='Dots', color='blue', size=5) + if plot_viral_antibodies: + self.plot_win7 = self.add_new_plot_window(title='Viral Anti-Bodies', + x_axis_title='Time (days)', + y_axis_title='Conc', x_scale_type='linear', + y_scale_type='log', + grid=True) + + self.plot_win7.add_plot("sIgM control SBML", style='Lines', color='yellow', size=5) + self.plot_win7.add_plot("sIgG control SBML", style='Lines', color='magenta', size=5) + + self.plot_win7.add_plot("sIgM CC3D SBML", style='Dots', color='yellow', size=5) + self.plot_win7.add_plot("sIgG CC3D SBML", style='Dots', color='magenta', size=5) + + if plot_infected_antibodies: + self.plot_win8 = self.add_new_plot_window(title='Infected Cell Anti-Bodies', + x_axis_title='Time (days)', + y_axis_title='Conc', x_scale_type='linear', + y_scale_type='log', + grid=True) + self.plot_win8.add_plot("nIgM control SBML", style='Lines', color='yellow', size=5) + self.plot_win8.add_plot("nIgG control SBML", style='Lines', color='magenta', size=5) + + self.plot_win8.add_plot("nIgM CC3D SBML", style='Dots', color='yellow', size=5) + self.plot_win8.add_plot("nIgG CC3D SBML", style='Dots', color='magenta', size=5) + if plot_current_virus_decay: + self.plot_win9 = self.add_new_plot_window(title='effective virus decay', + x_axis_title='Time (days)', + y_axis_title='gamma', x_scale_type='linear', + y_scale_type='linear', + grid=True) + self.plot_win9.add_plot('ODE effective decay', style='Lines', color='yellow', size=5) + self.plot_win9.add_plot('CC3D effective decay', style='Dots', color='red', size=5) + + def step(self, mcs): + + if plot_Epithelial_cells: + self.plot_win.add_data_point("ODEE", mcs * days_to_mcs, + self.sbml.FullModel['E'] / self.sbml.FullModel['E0']) + self.plot_win.add_data_point("ODEEv", mcs * days_to_mcs, + self.sbml.FullModel['Ev'] / self.sbml.FullModel['E0']) + self.plot_win.add_data_point("ODED", mcs * days_to_mcs, + self.sbml.FullModel['D'] / self.sbml.FullModel['E0']) + self.plot_win.add_data_point("CC3DE", mcs * days_to_mcs, + len(self.cell_list_by_type(self.E)) / self.initial_uninfected) + self.plot_win.add_data_point("CC3DEv", mcs * days_to_mcs, + len(self.cell_list_by_type(self.EV)) / self.initial_uninfected) + self.plot_win.add_data_point("CC3DD", mcs * days_to_mcs, + len(self.cell_list_by_type(self.D)) / self.initial_uninfected) + if plot_Virus: + secretor = self.get_field_secretor("Virus") + self.field_virus = 0.0 + for cell in self.cell_list_by_type(self.E, self.EV, self.D): + self.field_virus += secretor.amountSeenByCell(cell) + self.plot_win2.add_data_point("ODEV", mcs * days_to_mcs, + self.sbml.FullModel['V']) + # self.plot_win2.add_data_point("CC3DV", mcs * days_to_mcs, 2 * self.field_virus) + self.plot_win2.add_data_point("CC3DV", mcs * days_to_mcs, self.shared_steppable_vars['scalar_virus']) + + if plot_Tcells: + self.plot_win3.add_data_point("CC3DTc", mcs * days_to_mcs, + len(self.cell_list_by_type(self.TCELL))) + self.plot_win3.add_data_point("ODETc", mcs * days_to_mcs, self.sbml.FullModel['Tct'] * + self.initial_uninfected / self.sbml.FullModel['E0']) + + if plot_APC: + self.plot_win4.add_data_point("ODEAPC", mcs * days_to_mcs, + self.sbml.FullModel['Da'] / self.sbml.FullModel['E0']) + self.plot_win4.add_data_point("CC3DAPC0", mcs * days_to_mcs, + len(self.cell_list_by_type(self.APC)) / self.initial_uninfected) + self.plot_win4.add_data_point("CC3DAPC", mcs * days_to_mcs, + self.shared_steppable_vars['Active_APCs'] / self.initial_uninfected) + # self.plot_win4.add_data_point("CC3DAPC", mcs * days_to_mcs, + # self.sbml.LymphModel['Da'] / self.sbml.FullModel['E0']) + + if plot_Dm: + self.plot_win5.add_data_point("ODEAPC", mcs * days_to_mcs, + self.sbml.FullModel['Dm'] / self.sbml.FullModel['E0']) + + # self.plot_win5.add_data_point("ODEAPC", mcs * days_to_mcs, + # self.sbml.FullModel['Dm'] / self.sbml.FullModel['E0']) + self.plot_win5.add_data_point("CC3DAPC", mcs * days_to_mcs, + self.sbml.LymphModel['Dm'] / self.sbml.FullModel['E0']) + + if contact_cytotoxicity and plot_Contact_Cytotoxicity: + self.plot_win6.add_data_point("ODECC", mcs * days_to_mcs, + self.sbml.FullModel['J6'] / self.sbml.FullModel['E0']) + # g * Tc + # self.plot_win6.add_data_point("ODECC", mcs * days_to_mcs, self.shared_steppable_vars['ODE_Killing']) + self.plot_win6.add_data_point("CC3DCC", mcs * days_to_mcs, + self.shared_steppable_vars['Contact_Killing'] / self.initial_uninfected) + + if plot_viral_antibodies: + self.plot_win7.add_data_point("sIgM control SBML", mcs * days_to_mcs, self.sbml.FullModel['sIgM']) + self.plot_win7.add_data_point("sIgG control SBML", mcs * days_to_mcs, self.sbml.FullModel['sIgG']) + + self.plot_win7.add_data_point("sIgM CC3D SBML", mcs * days_to_mcs, self.sbml.LymphModel['sIgM']) + self.plot_win7.add_data_point("sIgG CC3D SBML", mcs * days_to_mcs, self.sbml.LymphModel['sIgG']) + if plot_infected_antibodies: + self.plot_win8.add_data_point("nIgM control SBML", mcs * days_to_mcs, self.sbml.FullModel['nIgM']) + self.plot_win8.add_data_point("nIgG control SBML", mcs * days_to_mcs, self.sbml.FullModel['nIgG']) + + self.plot_win8.add_data_point("nIgM CC3D SBML", mcs * days_to_mcs, self.sbml.LymphModel['nIgM']) + self.plot_win8.add_data_point("nIgG CC3D SBML", mcs * days_to_mcs, self.sbml.LymphModel['nIgG']) + if plot_current_virus_decay: + ode_g = (self.sbml.FullModel['eV'] * (self.sbml.FullModel['sIgM'] + self.sbml.FullModel['nIgM']) + + self.sbml.FullModel['cV']) * days_to_mcs + if ode_g != 0: + self.plot_win9.add_data_point('ODE effective decay', mcs * days_to_mcs, ode_g) + cc3d_g = self.get_xml_element('virus_decay').cdata + if cc3d_g != 0: + self.plot_win9.add_data_point('CC3D effective decay', mcs * days_to_mcs, cc3d_g) diff --git a/TarunsModel/TarunsModel.cc3d b/TarunsModel/TarunsModel.cc3d new file mode 100644 index 00000000..b5ee4b01 --- /dev/null +++ b/TarunsModel/TarunsModel.cc3d @@ -0,0 +1,5 @@ + + Simulation/TarunsModel.xml + Simulation/TarunsModel.py + Simulation/TarunsModelSteppables.py + diff --git a/TarunsModel/diagram.png b/TarunsModel/diagram.png new file mode 100644 index 00000000..ae7ca1e9 Binary files /dev/null and b/TarunsModel/diagram.png differ diff --git a/TarunsModel/e1701676.full.pdf b/TarunsModel/e1701676.full.pdf new file mode 100644 index 00000000..87295b9a Binary files /dev/null and b/TarunsModel/e1701676.full.pdf differ diff --git a/TarunsModel/tellurium_form_corrections_22_07_2020.ipynb b/TarunsModel/tellurium_form_corrections_22_07_2020.ipynb new file mode 100644 index 00000000..bf8ffffd --- /dev/null +++ b/TarunsModel/tellurium_form_corrections_22_07_2020.ipynb @@ -0,0 +1,272 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import tellurium as te" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model_string = '''\n", + "// Equations\n", + "J1: D -> E; dE*D;\n", + "J2: E -> D; dE*E;\n", + "J3: E -> Ev; bE*V*E;\n", + "J4: Ev -> E; aE*Ev;\n", + "J5: Ev -> D; dE*Ev;\n", + "\n", + "//J6: Ev -> D; kE*g*Ev*Tc;\n", + "\n", + "J6: Ev -> D; drt * g * Tc * Ev / (1000 + Ev + g * Tc);\n", + "\n", + "//J6: Ev -> D; drt * g * Tc * Ev /( Kev + Ev);\n", + "\n", + "J7: -> V; pV*Ev;\n", + "J8: V ->; cV*V; # v0 -> v1; v1 =cV*v0\n", + "\n", + "J9: -> Da; bD*V*(D0-Da);\n", + "J10: Da ->; dD*Da;\n", + "\n", + "// bellow is lymph\n", + "\n", + "J11: -> Dm; kD*Da;\n", + "J12: Dm ->; dDm*Dm;\n", + "J13: -> Tc; dC*Tc0;\n", + "J14: Tc ->; dC*Tc;\n", + "//# J15: Dm -> Tc; rT1*Dm*Tc/(Dm+pT2) + Dm; \n", + "J15: -> Tc; rT1*Dm*Tc/(Dm+pT2); \n", + "//J16: Tc ->; dT1*Tc*Ev/(Ev+dT2);\n", + "J16: Tc ->; dT1*Tc*Dm/(Dm+dT2);\n", + "\n", + "J17: -> Th1; sTh1*Th1/(1+Th2)^2;\n", + "//J18: Dm -> Th1; pTh1*Dm*(Th1^2)/(1+Th2)^2 + Dm;\n", + "J18: -> Th1; pTh1*Dm*(Th1^2)/(1+Th2)^2;\n", + "J19: Th1 ->; dTh1*Dm*(Th1^3)/(1+Th2);\n", + "J20: Th1 ->; mTh*Th1;\n", + "J21: -> Th2; sTh2*Th2/(1+Th2);\n", + "# J22: Dm -> Th2; pTh2*(r+Th1)*Dm*(Th2^2)/((1+Th2)*(1+Th1+Th2)) + Dm\n", + "J22: -> Th2; pTh2*(r+Th1)*Dm*(Th2^2)/((1+Th2)*(1+Th1+Th2)) \n", + "J23: Th2 ->; mTh*Th2;\n", + "\n", + "// new eqs\n", + "\n", + "J24: -> B; dB*B0;\n", + "J25: B ->; dB*B;\n", + "//J26: Dm + Th2 -> B; rB1*B*(Dm+h*Th2)/(Dm+h*Th2+rB2);\n", + "J26: -> B; rB1*B*(Dm+h*Th2)/(Dm+h*Th2+rB2);\n", + "\n", + "J27: B -> Pss; pS*B;\n", + "J28: B -> Psn; pS*B;\n", + "J29: B -> Pls; pL*B*Th2;\n", + "J30: B -> Pln; pL*B*Th2;\n", + "J31: Pss ->; dS*Pss;\n", + "J32: Psn ->; dS*Psn;\n", + "J33: Pls ->; dL*Pls;\n", + "J34: Pln ->; dL*Pln;\n", + "J35: Pss -> Pls; d*(1-v)*Pss;\n", + "J36: Psn -> Pln; d*(1-v)*Psn;\n", + "J37: -> Pss; b*v*Pss;\n", + "J37a: -> Pls; b*v*Pls;\n", + "J38: -> Psn; b*v*Psn;\n", + "J38a: -> Pln; b*v*Pln;\n", + "J39: Pls -> Pss; d*(1-v)*Pls;\n", + "J40: Pln -> Psn; d*(1-v)*Pln; \n", + "\n", + "J41: -> sIgM; pAS*Pss;\n", + "J42: -> nIgM; pAS*Psn;\n", + "J43: -> sIgG; pAS*Pls;\n", + "J44: -> nIgG; pAS*Pln;\n", + "J45: sIgM ->; dM*sIgM;\n", + "J46: sIgG ->; dG*sIgG;\n", + "J47: nIgM ->; dM*nIgM;\n", + "J48: nIgG ->; dG*nIgG; \n", + "// feed back to tissue\n", + "J49: Ev + nIgM -> D; eE*Ev*nIgM; // reevaluate these set (49-52) due to anti-bodies being consumed \n", + "J50: Ev + nIgG -> D; eE*Ev*nIgG;\n", + "//J51: V ->; eV*V*sIgM; # v1->v2; v2= sIgM * eV * v1 = sIgM * eV *cV * v0\n", + "J51: V + sIgM ->; eV*V*sIgM;\n", + "//J52: V ->; eV*V*sIgG;\n", + "J52: V + sIgG ->; eV*V*sIgG;\n", + "\n", + "\n", + "// Parameters\n", + "dE=10^-3;\n", + "E0=5*10^5;\n", + "bE=3*10^-6;\n", + "aE=5.0*10^-2;\n", + "V0=10;\n", + "pV=19;\n", + "cV=1;\n", + "kE=1.19*10^-3 / 900; // 900 rescaling for non-0 T cell pop in tissue\n", + "g=0.15 * 900;\n", + "\n", + "drt = 30;\n", + "Kev = Tc0;\n", + "\n", + "tC=0.5;// not included in the model\n", + "eE=0.05;\n", + "eV=16;\n", + "D0=10^3;\n", + "bD=10^-2;\n", + "dD=2.9;\n", + "kD=0.5;\n", + "tD=1;// not included in the model\n", + "dDm=0.5;\n", + "dC=10.1*10^-3;\n", + "Tc0=5*10^2;\n", + "rT1=1.3;\n", + "rT2=1;\n", + "dT1=5.0;\n", + "dT2=2000;\n", + "sTh1=2.5;\n", + "pTh1=4;\n", + "dTh1=0.03;\n", + "mTh=0.25;\n", + "sTh2=0.001;\n", + "pTh2=0.0012;\n", + "r=0.2;\n", + "dB=0.0009;\n", + "B0=1*10^3;\n", + "rB1=100;\n", + "rB2=2*10^5;\n", + "h=100;\n", + "pS=10^-1;\n", + "pL=8*10^-3;\n", + "dS=0.002;\n", + "dL=0.02;\n", + "b=2.4*10^-4;\n", + "d=2.4*10^-2;\n", + "pAS=0.2;\n", + "pAL=0.3;\n", + "dG=0.04;\n", + "dM=0.2;\n", + "pT2=600;\n", + "v = 0.5\n", + "// Initial Conditions\n", + "E = E0;\n", + "V = 10;\n", + "Th1=10;\n", + "Th2=10;\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "rr = te.loadAntimonyModel(model_string)\n", + "#n=rr.simulate(0,20,4000,['time','I1','I2','I2D1','I2D2','I2D3','I2D4','I2D5','I2D'])\n", + "#n=rr.simulate(0,20,10000,['time','TE','I1','I2','V','Cyto','LymphCyto','LymphE','E'])\n", + "#n=rr.simulate(0,20,4000,['time','I1','I2','E','EM','V','I2D'])\n", + "\n", + "#rr.plot(n,logy=True, ylim=[1, 5E7])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rr.resetAll()\n", + "n = rr.simulate(0,20,4000,['time','Tc'])\n", + "rr.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAD8CAYAAACLrvgBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3X9cVHW+P/DXYYYfIj8EFAQxEYYU\nECQFpV/exCXUDDVdoa2k1OyqraW7Zd2+btndVtu969qmucuGhV2TykpME90096aJiL8qKRcNjEFU\nGEBA+TUzn+8fOKMkyIAMZ87M6/l49EjOnJnPm8MwLz6fzznnIwkhBIiIiCzgJHcBRESkHAwNIiKy\nGEODiIgsxtAgIiKLMTSIiMhiDA0iIrIYQ4OIiCzG0CAiIosxNIiIyGJquQvoaf3790dISIjcZRAR\nKUpJSQkqKys73c/uQiMkJAQFBQVyl0FEpChxcXEW7cfhKSIishhDg4iILMbQICIii9ndnAYRkbW1\ntLRAq9WisbFR7lK6zM3NDcHBwXB2du7W8xkaRERdpNVq4enpiZCQEEiSJHc5FhNCQKfTQavVYujQ\nod16DQ5PERF1UWNjI/z8/BQVGAAgSRL8/PxuqYfE0CAi6galBYbJrdbN4SkiO2Y0CryXdxZ7f7gI\nPw8XzBwdjLvC+stdFikYQ4PIjq347CSyDp41f/3J0TL8IiIAq2ZEo7+Hq4yV0a1QqVSIjo42f52W\nloYXXnihV9pmaBDZqWM/VSPr4Fk4qyT8ftoIlF9qROZXxfji+wuYuKYaf0mNxb3hA+Quk7qhT58+\nOH78uCxtc06DyE69+3UJAGDOPUORGn8bnv3F7di1ZBwSQn1RWd+M9A35eGvfaQgh5C2UesTOnTsx\na9Ys89f79u3Dgw8+2OPtsKdBZIea9AbsPnkBAPBYwhDz9qB+fbBpXgLe2FOEv+4pwh9zT+Gb0kv4\nn1kj4eHKj4PuCHlhh1Vet2TVAx0+1tDQgNjYWPPXL774ImbMmIGnnnoKly9fRt++ffHBBx8gNTW1\nx+tiT4PIDhWUVKOhxYCIQC8E+7i3eUzlJGFp0u14e3YcPF3VyD15HtPWHcCZinqZqqWuMg1Pmf5L\nTU2FWq3GxIkT8dlnn0Gv12PHjh2YOnVqj7dt8Z8WBoMBcXFxGDRoELZv347i4mKkpaWhqqoKo0aN\nwnvvvQcXFxc0NTVh9uzZOHLkCPz8/PDBBx+Yb1W+cuVKZGZmQqVS4a9//SuSk5MBALm5uXjmmWdg\nMBgwb94884ROR20Q0c3tP916i+tx4R2fKfWLyADkPH03nnrvCIou1mPq2gNYPWsk7o8a2Ftl2oWb\n9Qh6W2pqKtatWwdfX1/Ex8fD09Ozx9uwuKfxxhtvICIiwvz1smXLsGTJEhQVFcHHxweZmZkAgMzM\nTPj4+OD06dNYsmQJli1bBgAoLCxEdnY2Tp48idzcXCxcuBAGgwEGgwGLFi3Czp07UVhYiM2bN6Ow\nsPCmbRDRzX2jrQEAjB7ic9P9Qgd44NNFd2Ny9EDUN+kx/70jWL37FIxGznMo0X333YejR4/iH//4\nh1WGpgALQ0Or1WLHjh2YN28egNZL0ffu3YuZM2cCANLT07F161YAQE5ODtLT0wEAM2fOxJ49eyCE\nQE5ODtLS0uDq6oqhQ4dCo9EgPz8f+fn50Gg0CA0NhYuLC9LS0pCTk3PTNoioY0IInDxXCwCIGuTd\n6f4ermqs+9UoLJs4HE4S8Ne9pzE36zAuXWmxdqnUTaY5DdN/ptEZlUqFKVOmYOfOnZgyZYpV2rZo\neOrZZ5/FH//4R9TV1QEAdDod+vXrB7W69enBwcEoKysDAJSVlWHw4MGtL65Ww9vbGzqdDmVlZUhI\nSDC/5vXPMe1v2n7o0KGbtvFzGRkZyMjIAABUVFRY/t0T2aFzlxpRc6UF/dydEeTtZtFzJEnCgvvC\nMGKQF369+Ri+PFWBlHX7kfFYHIYN7PkhDro1BoOhw8fWrl2LtWvXWq3tTnsa27dvh7+/P0aPHm3e\n1t4peqZL0zt6rKe2t2f+/PkoKChAQUEBBgzgeefk2P59vvWPu4iBXl2+ZcS94QPw2dP3IDLQC2d1\nVzBt3QFs/+acNcokheo0NA4cOIBt27YhJCQEaWlp2Lt3L5599lnU1NRAr9cDaB2+CgoKAtDaIygt\nLQUA6PV6XLp0Cb6+vm22X/+cjrb379+/wzaIqGMlussAgKED+nbr+YN93fHxgrsw/Y5BaGgx4On3\nj+EPn38PvcHYk2WSQnUaGitXroRWq0VJSQmys7ORmJiITZs2Yfz48diyZQsAICsry3xqV0pKCrKy\nsgAAW7ZsQWJiIiRJQkpKCrKzs9HU1ITi4mIUFRVhzJgxiI+PR1FREYqLi9Hc3Izs7GykpKRAkqQO\n2yCijp3VXQEAhPi5d7Jnx/q4qLB61ki88mAkVE4SMv7vR6S/k4+qy809VabiKfWiyFutu9vXabz+\n+utYvXo1NBoNdDod5s6dCwCYO3cudDodNBoNVq9ejVWrVgEAoqKiMGvWLERGRmLixIlYt24dVCoV\n1Go11q5di+TkZERERGDWrFmIioq6aRtE1LGzV3sat/l2r6dhIkkSHr97KN6fNxb9PVxw4LQOD765\nH9+VXeqJMhXNzc0NOp1OccFhWk/Dzc2yua72SEJp33Un4uLiUFBQIHcZRLJJ/PM+/FhxGTufuRcR\ngV498prllxqw4H+P4nhpDVzVTvjD9GjMGB3cI6+tRPa4cp+ln528bwCRHTEaBbRVDQCAIbcwPPVz\ngd598MFTCXhl20lszi/Fbz46gRPaGvy/ByLhona8G0s4Ozt3e+U7pXO8nzaRHau83IRmgxE+7s5w\nd+nZvwld1SqsfCgGKx+KhovKCRsPnsUjb+fhYp3y/tqm7mNoENmRi7VNAIAAr+6PWXfm4TG34YOn\nEjDQyw2HS6rx4Jv7ceRstdXaI9vC0CCyIxdqW//qH2jhRX3ddcdtPvjs1/dgzFBfXKhtQlrGQWw6\ndFZxE8PUdQwNIjtywdTT8LRuaADAAE9XbJo3Fk/cHYIWg8BLn36HFz7+Fo0tHV+tTMrH0CCyI+ev\n9jQCvHpnKVdnlRNefjAKf0kdCVe1Ez4oKMUv/3YQpVVXeqV96n0MDSI7cvFqaPhbcU6jPdPvCMbH\nC+7CYN8++LbsEh5cux/7Tl3s1RqodzA0iOzIBXNPo3dDAwBGDPLG9qfvReJwf9RcacET7x7GX/75\nb95m3c4wNIjsyPmrcxoDZQgNAPB2d8bbs+Pw2/tvBwC8sacIT7x7GNW8/YjdYGgQ2ZHK+tbQ6O8p\n3wqXTk4Snk4Mx8Y5Y+Db1wX/+ncFpry5HydKa2SriXoOQ4PITgghzH/R+7jLvyzyveEDsP3X9yB2\ncD+U1TTgl3/jabn2gKFBZCfqmvTQGwX6uqjg5qySuxwAQFC/PvjwqTsx+84haDYY8dKn3+E3H51A\nQzNPy1UqhgaRnTD3MvrK38u4novaCa9OHYE1qbHo46zCJ0fLMP2tAyipvCx3adQNDA0iO6G7Ghp+\nNhYaJtPuGISti+5GaP+++OF8HR58cz92nzwvd1nURQwNIjthqz2N6w0b6Imcp+/GxKiBqGvSY/57\nR7Bq5w9cFVBBGBpEdsK0qp6vDUyC34ynmzPWPzoKL02OgMpJwt/+dQaPZeajoq5J7tLIAgwNIjtR\nfcX2exomkiThyXGh2DRvLPp7uOLgjzpMefMrFJRUyV0adYKhQWQnTHMavgoIDZOEUD98vvgejAkx\n3S03Dxv2F/O0XBvG0CCyE9UKDA2g9T5Zm54ciyfvHQq9UeDV7YV4evMx1Dfp5S6N2sHQILITVZdb\nANjGhX1d5axywksPROKtR0bBw1WNHd+UY+ra/Si6UCd3afQzDA0iO2Ga01BaT+N6k6MDkfP03bg9\nwANnKi5j6roD2HbinNxl0XUYGkR24totRJxlruTWhA3wwNZFd2NabBCuNBuwePMxvLLtJJr1PC3X\nFjA0iOxEbWPrHIB3H2WHBgC4u6jxl9RY/Pe0EXBWSXj36xKkZhxE+aUGuUtzeAwNIjtR19g6p+Hh\nppa5kp4hSRIeSxiCD5+6E0Hebjj2Uw0e+Ot+7C+qlLs0h8bQILIDzXojmvRGqJwk9LGRmxX2lDtu\n88H2xffi3vD+qLrcjMc2HMLavUVc3EkmDA0iO2DqZXi6qSFJkszV9Dzfvi5494kxWDwhHEIA/7P7\n35i3sQCXrrTIXZrDYWgQ2QHTNQ2edjI01R6Vk4SlSbfjncfj4d3HGXt/uIgpa7/Cd2WX5C7NoTA0\niOxA3dVJcA9X5U+Cd2b8cH9s//U9iB7kjdKqBjy0/mt8cPgnuctyGAwNIjtQe93wlCMY7OuOj/7z\nTvxq7G1o1hux7ONv8dxHJ9DYwsWdrI2hQWQHTD0NLwcJDQBwc1bhD9Oj8T+/HAlXtRM+OqLFQ299\njbM6Lu5kTQwNIjtQbx6ecpzQMJk5OhifLrwbQ/zcUVheiylv7sc/Cy/IXZbdYmgQ2YFrZ0/Z/5xG\neyKDvLDt6Xtwf2QA6hr1eHJjAV7P5eJO1sDQILIDpuEpR5nTaI93H2f8/bHReHHScDhJwPp9XNzJ\nGhgaRHbg2im3jtnTMJEkCU/9Rxg2zUvg4k5WwtAgsgOm+07Zyy1EbtWdYX7YsfgexIf4mBd3yuTi\nTj2CoUFkB0xzGo509lRnArzc8P6TCebFnf57eyGefp+LO90qhgaRHeCcRvtuWNzp23KkcHGnW8LQ\nILIDpr+eHeGK8O64fnGnH68u7pRzvEzushSp09BobGzEmDFjMHLkSERFReHll18GABQXF2Ps2LEI\nDw9HamoqmptbF4BpampCamoqNBoNxo4di5KSEvNrrVy5EhqNBsOGDcOuXbvM23NzczFs2DBoNBqs\nWrXKvL2jNoiorToHuyK8O36+uNMz2cfxcs53XNypizoNDVdXV+zduxcnTpzA8ePHkZubi7y8PCxb\ntgxLlixBUVERfHx8kJmZCQDIzMyEj48PTp8+jSVLlmDZsmUAgMLCQmRnZ+PkyZPIzc3FwoULYTAY\nYDAYsGjRIuzcuROFhYXYvHkzCgsLAaDDNoioLQ5PWebniztlHTyL1IyDOFfDxZ0s1WloSJIEDw8P\nAEBLSwtaWlogSRL27t2LmTNnAgDS09OxdetWAEBOTg7S09MBADNnzsSePXsghEBOTg7S0tLg6uqK\noUOHQqPRID8/H/n5+dBoNAgNDYWLiwvS0tKQk5MDIUSHbRBRW/WNPOXWUu0t7jTlTS7uZCmL5jQM\nBgNiY2Ph7++PpKQkhIWFoV+/flCrW/+qCQ4ORllZ6/hgWVkZBg8eDABQq9Xw9vaGTqdrs/3653S0\nXafTddgGEV1jNArUNzvubUS6i4s7dY9FoaFSqXD8+HFotVrk5+fj+++/v2Ef08Iv7Z0HLUlSj21v\nT0ZGBuLi4hAXF4eKiopOvx8ie1LfrIcQQF8XFVRO9rcAkzV1tLhTzRXOn3akS2dP9evXD/fddx/y\n8vJQU1MDvb71rxutVougoCAArT2C0tJSAIBer8elS5fg6+vbZvv1z+loe//+/Tts4+fmz5+PgoIC\nFBQUYMCAAV35logUr45DU7fEvLjTE/Ho5351cac396PwXK3cpdmkTkOjoqICNTU1AICGhgZ88cUX\niIiIwPjx47FlyxYAQFZWFqZOnQoASElJQVZWFgBgy5YtSExMhCRJSElJQXZ2NpqamlBcXIyioiKM\nGTMG8fHxKCoqQnFxMZqbm5GdnY2UlBRIktRhG0R0TT2vBu8R44f547OnWxd30lY3YMb6r7Hjm3K5\ny7I5nYZGeXk5xo8fj5iYGMTHxyMpKQlTpkzB66+/jtWrV0Oj0UCn02Hu3LkAgLlz50Kn00Gj0WD1\n6tXmU2ijoqIwa9YsREZGYuLEiVi3bh1UKhXUajXWrl2L5ORkREREYNasWYiKigKADtsgomt4um3P\nMS3u9NAdg9DQYsCi94/iT7t+gIHzHGaSsLObscTFxaGgoEDuMoh6zZc/XMQT7x7GuNsHYOOcMXKX\nYxeEENhwoASv7SiEUQCJw/2xJi0WXnY8BGjpZyevCCdSOEdb6rU3SJKEufcMxcY5Y83zHNPWHcCZ\ninq5S5MdQ4NI4cy3Refptj3unvD+2LboHgwf6IkfKy5j2toD2PuDY68KyNAgUjheDW5dt/m54+MF\nd2HSiIGoa9JjblYB1n152mFvs87QIFI4R1/qtTf0dVXjrUdG4bf33w4A+NOuU3h68zE0NBtkrqz3\nMTSIFM58yi2Hp6xKkiQ8nRiOfzwW13qb9W/KkZZxEBdrG+UurVcxNIgUjsNTvesXkQH4dOFdCPbp\ngxPaS5i27gC+L3ecCwEZGkQKV8srwntdeIAnti66G6Nu64dzlxoxc/3X+PKHi3KX1SsYGkQKx4v7\n5NHfwxXvP5mAlJFBuNxswNysw3j3QLHcZVkdQ4NI4cyn3DI0ep2bswpvpMXimQnhMArglc8K8XLO\nd9Ab7HdhJ4YGkcLxhoXykiQJS5Jux5rUWLionJB18Cye3FiAK1dvV29vGBpECsfhKdsw7Y5B2PTk\nWPi4O+PLUxX41T8Ooeqy/d1inaFBpGBCCPPwFE+5lV98iC8+XtB6ZtXx0hrM/NvX0FZfkbusHsXQ\nIFKwJr0RLQYBF5UT3JxVcpdDAEIHeOCTBXeZbz3y0Ftf29UpuQwNIgXjzQptk7+XGz78zzuREOqL\ni3VNmPX3g8j7USd3WT2CoUGkYHVcgMlmebk5490nxmBy9EDUNeoxOzMfu0+el7usW8bQIFKwel4N\nbtPcnFV48+FRmH3nEDQbjFi46Si2f3NO7rJuCUODSMHMp9u68nRbW6VykrAiJQoL7guD3iiwePMx\nfHxEK3dZ3cbQIFIwnm6rDJIk4fnkYViadDuMAvjNRyew6dBZucvqFoYGkYLVNXFOQykkScLiCeF4\ncdJwAMBLn36HDfuVd9sRhgaRgpmGp+x57Wp789R/hGFFShQA4NXthXhHYferYmgQKRiHp5Qp/a4Q\nvDZ9BABgxWeFeP/QTzJXZDmGBpGC1XEBJsV6ZOwQvPxgJADgpa3f4pOjypgcZ2gQKVg9b1aoaE/c\nPRTLJg6HEMBvPzqBHd+Uy11SpxgaRApW18ThKaVbcF+Y+dbqz2Qfw75Ttr2YE0ODSMG41Kt9ePYX\n4Zg/LhR6o8DCTUfxrfaS3CV1iKFBpGC1DA27IEkSXpg4HNPvGIQrzQY88W4+ftLZ5t1xGRpEClZv\nPnuKcxpK5+Qk4fUZMbhH0x+V9c1Ifycfuvomucu6AUODSME4PGVfXNROWP/oKEQGeqG48jLmbSxA\nY4tB7rLaYGgQKRhPubU/nm7OePeJeAzq1wfHfqrBf33yLYQQcpdlxtAgUii9wYiGFgMkCejrwtCw\nJ/5ebvjH7Dj0cVbhk2NlePsr27lqnKFBpFDXL/Pq5CTJXA31tMggL6yeNRIAsHLn9zZzKi5Dg0ih\neN8p+zcpOtB8DcevNx9DceVluUtiaBAplWmpV85n2LdnJoQjOSoAdY16LNp0VPaJcYYGkUJx1T7H\n4OQk4U+/HIkhfu4oLK/F73cUyluPrK0TUbfxdFvH4eXmjHW/GgUXlRP+N+8nfHZCviVjGRpECmW6\n75QH5zQcwohB3lg+JQIA8OIn38o2v8HQIFIoDk85nkcThuCB6EDUN+mx9MPj0BuMvV4DQ4NIoXjf\nKccjSRL+MD0aA73ccOynGvz9/37s9Ro6DY3S0lKMHz8eERERiIqKwhtvvAEAqKqqQlJSEsLDw5GU\nlITq6moAgBACixcvhkajQUxMDI4ePWp+raysLISHhyM8PBxZWVnm7UeOHEF0dDQ0Gg0WL15svvqx\nozaIiKfcOipvd2f8cWYMAGDNF/9G4bnaXm2/09BQq9X485//jO+//x55eXlYt24dCgsLsWrVKkyY\nMAFFRUWYMGECVq1aBQDYuXMnioqKUFRUhIyMDCxYsABAawCsWLEChw4dQn5+PlasWGEOgQULFiAj\nI8P8vNzcXADosA0iurbUK0+5dTzjbh+ARxNuQ4tBYOmHx9Gk773TcDsNjcDAQIwaNQoA4OnpiYiI\nCJSVlSEnJwfp6ekAgPT0dGzduhUAkJOTg9mzZ0OSJCQkJKCmpgbl5eXYtWsXkpKS4OvrCx8fHyQl\nJSE3Nxfl5eWora3FnXfeCUmSMHv27Dav1V4bRHTtinAOTzmm/5ocgSF+7vjhfB3W7zvTa+12aU6j\npKQEx44dw9ixY3HhwgUEBgYCaA2WixdbL3EvKyvD4MGDzc8JDg5GWVnZTbcHBwffsB1Ah20Q0fWn\n3HJ4yhG5u6jxxxmtw1RvfXkGpy/W90q7FodGfX09ZsyYgTVr1sDLy6vD/dq7G6MkSV3e3hUZGRmI\ni4tDXFwcKioquvRcIqXi8BSNDfVDatxgNBuMeOnT3rkbrkWh0dLSghkzZuCRRx7BQw89BAAICAhA\neXnrIujl5eXw9/cH0NpTKC0tNT9Xq9UiKCjoptu1Wu0N22/Wxs/Nnz8fBQUFKCgowIABAyz+5omU\nzDwR3oeh4chenDwc/T1ccKi4Ch8VaDt/wi3qNDSEEJg7dy4iIiKwdOlS8/aUlBTzGVBZWVmYOnWq\nefvGjRshhEBeXh68vb0RGBiI5ORk7N69G9XV1aiursbu3buRnJyMwMBAeHp6Ii8vD0IIbNy4sc1r\ntdcGEQG1Da09DZ495dj6ubtg+ZRIDPRyg5+Hi/UbFJ346quvBAARHR0tRo4cKUaOHCl27NghKisr\nRWJiotBoNCIxMVHodDohhBBGo1EsXLhQhIaGihEjRojDhw+bXyszM1OEhYWJsLAwsWHDBvP2w4cP\ni6ioKBEaGioWLVokjEajEEJ02MbNjB49utN9iOzBiN/liiHLtovqy01yl0IyMxqNor6x5ZZew9LP\nTkkIG1oSqgfExcWhoKBA7jKIrMpoFAh76XMIAZx+bRLUKl6nS7fG0s9OvtOIFKi+WQ8hgL4uKgYG\n9Sq+24gUyDSfwdNtqbcxNIgUiGdOkVwYGkQKxAv7SC4MDSIFMl3Yx1uIUG9jaBApkGl9cF6jQb2N\noUGkQFzqleTC0CBSIM5pkFwYGkQKVMs5DZIJQ4NIgWobTKfcsqdBvYuhQaRAdeaJcPY0qHcxNIgU\niBPhJBeGBpEC1fGUW5IJQ4NIgWp59hTJhKFBpEC8IpzkwtAgUiDOaZBcGBpECqM3GHGl2QAnCejr\nwtCg3sXQIFIYUy/Dw1UNJydJ5mrI0TA0iBTGfLNCXthHMmBoEClMzZXW0PBxd5G5EnJEDA0iham5\nutRrP3f2NKj3MTSIFKbmSjMAwJvDUyQDhgaRwly62tNgaJAcGBpECmOa0+DwFMmBoUGkMObQ6MOJ\ncOp9DA0ihTEPT7GnQTJgaBApzKWG1onwfpzTIBkwNIgU5tqcBoenqPcxNIgUhtdpkJwYGkQKc20i\nnKFBvY+hQaQgQgjznAbvPUVyYGgQKciVZgNaDAJ9nFVwc1bJXQ45IIYGkYJwPoPkxtAgUhDed4rk\nxtAgUhDeQoTkxtAgUhDd5daehp+Hq8yVkKNiaBApiK6+CQDg15cX9pE8GBpECqKrv9rT6MueBsmD\noUGkIKbhKV8P9jRIHp2Gxpw5c+Dv748RI0aYt1VVVSEpKQnh4eFISkpCdXU1gNYLjxYvXgyNRoOY\nmBgcPXrU/JysrCyEh4cjPDwcWVlZ5u1HjhxBdHQ0NBoNFi9eDCHETdsgcmSm4an+HJ4imXQaGo8/\n/jhyc3PbbFu1ahUmTJiAoqIiTJgwAatWrQIA7Ny5E0VFRSgqKkJGRgYWLFgAoDUAVqxYgUOHDiE/\nPx8rVqwwh8CCBQuQkZFhfp6prY7aIHJknAgnuXUaGuPGjYOvr2+bbTk5OUhPTwcApKenY+vWrebt\ns2fPhiRJSEhIQE1NDcrLy7Fr1y4kJSXB19cXPj4+SEpKQm5uLsrLy1FbW4s777wTkiRh9uzZbV6r\nvTaIHFmVaXiKPQ2SSbfmNC5cuIDAwEAAQGBgIC5evAgAKCsrw+DBg837BQcHo6ys7Kbbg4ODb9h+\nszaIHFmlaXiKcxokE3VPvphpPuJ6kiR1eXtXZWRkICMjAwBQUVHR5ecTKUGT3oC6Rj3UThK83Hhx\nH8mjWz2NgIAAlJeXAwDKy8vh7+8PoLWnUFpaat5Pq9UiKCjoptu1Wu0N22/WRnvmz5+PgoICFBQU\nYMCAAd35lohsXvXl1qvBffq6wMmp639cEfWEboVGSkqK+QyorKwsTJ061bx948aNEEIgLy8P3t7e\nCAwMRHJyMnbv3o3q6mpUV1dj9+7dSE5ORmBgIDw9PZGXlwchBDZu3Njmtdprg8hRVfLCPrIBnQ5P\nPfzww9i3bx8qKysRHByMFStW4IUXXsCsWbOQmZmJ2267DR999BEAYPLkyfj888+h0Wjg7u6Od955\nBwDg6+uL5cuXIz4+HgDwu9/9zjy5vn79ejz++ONoaGjApEmTMGnSJADosA0iR3XtzCmGBslHEu1N\nLChYXFwcCgoK5C6DqMd9VFCK57Z8g2mxQViTdofc5ZCdsfSzk1eEEynExbrW4akAbzeZKyFHxtAg\nUojzlxoBAAGeDA2SD0ODSCEu1LaGxkD2NEhGDA0ihTCFRoAXQ4Pkw9AgUogLtVfnNLx43ymSD0OD\nSAEMRoGKq9dp+HNOg2TE0CBSAF19EwxGgf4eLnBR89eW5MN3H5ECnL86n8FeBsmNoUGkAOWXeOYU\n2QaGBpEClFZdAQAE+/SRuRJydAwNIgXQVjcAAAb7uMtcCTk6hgaRAph6GoN92dMgeTE0iBSgtNo0\nPMWeBsmLoUFk44QQKK3i8BTZBoYGkY3TXW5GQ4sBnm5qeLtzmVeSF0ODyMb9ZJrPYC+DbABDg8jG\nnblYDwAI8/eQuRIihgaRzTt9NTQ0AxgaJD+GBpGNM4cGexpkAxgaRDbudAVDg2wHQ4PIhjW2GFBa\ndQUqJwkh/TkRTvJjaBDZsKIL9TAKYIifO1zVKrnLIWJoENmyb8suAQBiBnnLXAlRK4YGkQ37tqwG\nADCCoUE2gqFBZMO+0V7taQTHNotjAAAK8UlEQVT3k7kSolYMDSIb1dhiwKnzdZAkICrIS+5yiAAw\nNIhs1pGz1dAbBSIDvdDXVS13OUQAGBpENuvrM5UAgLvC/GSuhOgahgaRjfr6jA4AcJemv8yVEF3D\n0CCyQZX1TThRWgNnlYT4EF+5yyEyY2gQ2aDc787DKIB7wwfAg/MZZEMYGkQ26PNvywEAk0YMlLkS\norYYGkQ25seKenx9Rgc3ZyfcH8nQINvC0CCyMVlflwAApsUO4vKuZHMYGkQ2pLTqCjYfLgUApN8V\nIm8xRO1gaBDZCCEEXt1eiGa9EdNigxARyKvAyfYwNIhsxDsHSvDPwgvwdFXjuYnD5S6HqF08l49I\nZkIIZH1dgle3FwIAXnsoGoP69ZG5KqL22XxPIzc3F8OGDYNGo8GqVavkLoeoR506X4d5WQV45bPW\nwPivycORMjJI5qqIOmbTPQ2DwYBFixbhn//8J4KDgxEfH4+UlBRERkbKXRpRlxmNApX1TTh1oQ5H\nzlbjy1MVOFHaul5GXxcVVs6IYWCQzbPp0MjPz4dGo0FoaCgAIC0tDTk5OVYJDV19E8TVfwtxbbtA\nmy/a+2eH+4sO929/H7TZ5xZes4PXgUWvY0G7FuzTplVb+F4seM2b/az1RgG9wYgWgxEtBgG9sfX/\nLQYj9Kb/X93nSrMBdY161DW2oK5Rj9rGFujqm6GtaUCz3nj9NwEPVzWm3zEIv56ggb+nG4hsnU2H\nRllZGQYPHmz+Ojg4GIcOHbJKW/e8/iUaWgxWeW0iE9++Lhji545Rt/kgPsQH/3G7P/q4cO1vUg6b\nDg3Rzp+ukiTdsC0jIwMZGRkAgIqKim615dvXBY3XhUbbZqR2t1+/S9vtlux/4/dxw/638JodlG/R\n/pa027ZmC16ni98LLKqtizV0cCAs2V+tkqB2kuCscoKzyunq105wVknmr51VTlA7SejjrIKnmxqe\nbs7w6uMMTzc1fNxdMMinD+8jRYpn0+/g4OBglJaWmr/WarUICrpxzHf+/PmYP38+ACAuLq5bbR14\nIbF7RRIRORCbPnsqPj4eRUVFKC4uRnNzM7Kzs5GSkiJ3WUREDsumexpqtRpr165FcnIyDAYD5syZ\ng6ioKLnLIiJyWDYdGgAwefJkTJ48We4yiIgINj48RUREtoWhQUREFmNoEBGRxRgaRERkMYYGERFZ\nTBLtXXatYP3790dISEi3nltRUYEBAwb0bEE9gHV1DevqGtbVNfZaV0lJCSorKzvdz+5C41bExcWh\noKBA7jJuwLq6hnV1DevqGkevi8NTRERkMYYGERFZTPXKK6+8IncRtmT06NFyl9Au1tU1rKtrWFfX\nOHJdnNMgIiKLcXiKiIgs5pChkZubi2HDhkGj0WDVqlU3PN7U1ITU1FRoNBqMHTsWJSUlVq+ptLQU\n48ePR0REBKKiovDGG2/csM++ffvg7e2N2NhYxMbG4tVXX7V6XQAQEhKC6OhoxMbGtrteiRACixcv\nhkajQUxMDI4ePWr1mk6dOmU+DrGxsfDy8sKaNWva7NNbx2vOnDnw9/fHiBEjzNuqqqqQlJSE8PBw\nJCUlobq6ut3nZmVlITw8HOHh4cjKyrJ6Xc899xyGDx+OmJgYTJ8+HTU1Ne0+t7OfeU/X9corr2DQ\noEHmn9Xnn3/e7nM7+93t6bpSU1PNNYWEhCA2Nrbd51rzeHX02SDbe0w4GL1eL0JDQ8WZM2dEU1OT\niImJESdPnmyzz7p168RTTz0lhBBi8+bNYtasWVav69y5c+LIkSNCCCFqa2tFeHj4DXV9+eWX4oEH\nHrB6LT83ZMgQUVFR0eHjO3bsEBMnThRGo1EcPHhQjBkzphera/2ZBgQEiJKSkjbbe+t4/etf/xJH\njhwRUVFR5m3PPfecWLlypRBCiJUrV4rnn3/+hufpdDoxdOhQodPpRFVVlRg6dKioqqqyal27du0S\nLS0tQgghnn/++XbrEqLzn3lP1/Xyyy+LP/3pTzd9niW/uz1d1/WWLl0qVqxY0e5j1jxeHX02yPUe\nc7ieRn5+PjQaDUJDQ+Hi4oK0tDTk5OS02ScnJwfp6ekAgJkzZ2LPnj3tLj3bkwIDAzFq1CgAgKen\nJyIiIlBWVmbVNntKTk4OZs+eDUmSkJCQgJqaGpSXl/da+3v27EFYWBiGDBnSa21eb9y4cfD19W2z\n7fr3UHp6OrZu3XrD83bt2oWkpCT4+vrCx8cHSUlJyM3NtWpd999/P9Tq1hUREhISoNVqe6y9W6nL\nEpb87lqrLiEEPvzwQzz88MM91p6lOvpskOs95nChUVZWhsGDB5u/Dg4OvuHD+fp91Go1vL29odPp\neq3GkpISHDt2DGPHjr3hsYMHD2LkyJGYNGkSTp482Sv1SJKE+++/H6NHjzavxX49S46pNWVnZ3f4\nyyzH8QKACxcuIDAwEEDrL/3Fixdv2Efu47ZhwwZMmjSp3cc6+5lbw9q1axETE4M5c+a0O9Qi5/H6\n6quvEBAQgPDw8HYf763jdf1ng1zvMZtfhKmntddjkCSpy/tYS319PWbMmIE1a9bAy8urzWOjRo3C\n2bNn4eHhgc8//xzTpk1DUVGR1Ws6cOAAgoKCcPHiRSQlJWH48OEYN26c+XE5j1dzczO2bduGlStX\n3vCYXMfLUnIet9deew1qtRqPPPJIu4939jPvaQsWLMDy5cshSRKWL1+O3/zmN9iwYUObfeQ8Xps3\nb75pL6M3jtfNPhs6Yo1j5nA9jeDgYJSWlpq/1mq1CAoK6nAfvV6PS5cudas73VUtLS2YMWMGHnnk\nETz00EM3PO7l5QUPDw8ArSsatrS0WHSvmFtlOj7+/v6YPn068vPz2zxuyTG1lp07d2LUqFEICAi4\n4TG5jhcABAQEmIfoysvL4e/vf8M+ch23rKwsbN++HZs2berwA6Szn3lPCwgIgEqlgpOTE5588sl2\n25PreOn1enzyySdITU3tcB9rH6/2Phvkeo85XGjEx8ejqKgIxcXFaG5uRnZ2NlJSUtrsk5KSYj7L\nYMuWLUhMTLT6XzRCCMydOxcRERFYunRpu/ucP3/e/JdDfn4+jEYj/Pz8rFrX5cuXUVdXZ/737t27\n25xdArQer40bN0IIgby8PHh7e5u7zdZ2s78A5TheJte/h7KysjB16tQb9klOTsbu3btRXV2N6upq\n7N69G8nJyVatKzc3F6+//jq2bdsGd3f3dvex5Gfe066fA/v000/bbc+S311r+OKLLzB8+HAEBwe3\n+7i1j1dHnw2yvcduaRpdoXbs2CHCw8NFaGio+P3vfy+EEGL58uUiJydHCCFEQ0ODmDlzpggLCxPx\n8fHizJkzVq/pq6++EgBEdHS0GDlypBg5cqTYsWOHWL9+vVi/fr0QQog333xTREZGipiYGDF27Fhx\n4MABq9d15swZERMTI2JiYkRkZKT5eF1fl9FoFAsXLhShoaFixIgR4vDhw1avSwghLl++LHx9fUVN\nTY15mxzHKy0tTQwcOFCo1WoxaNAg8fbbb4vKykqRmJgoNBqNSExMFDqdTgghxOHDh8XcuXPNz83M\nzBRhYWEiLCxMbNiwwep1hYWFieDgYPN7zHSWYFlZmZg0aZIQouOfuTXrevTRR8WIESNEdHS0ePDB\nB8W5c+duqEuI9n93rVmXEEKkp6eb31MmvXm8OvpskOs9xivCiYjIYg43PEVERN3H0CAiIosxNIiI\nyGIMDSIishhDg4iILMbQICIiizE0iIjIYgwNIiKy2P8H1GME5INChX8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rr.resetAll()\n", + "n = rr.simulate(0,20,4000,['time','Ev'])\n", + "rr.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niIhoCIYDERENwXAgIqIhGA5ERDTE/wcBBEs90HEJEAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rr.resetAll()\n", + "#rr.simulate(0,2,4000)\n", + "#n = rr.simulate(0,20,4000,['time','Tc', 'Ev'])\n", + "n = rr.simulate(0,20,4000,['time','J6'])\n", + "rr.plot()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/TarunsModel/tellurium_form_corrections_22_07_2020.py b/TarunsModel/tellurium_form_corrections_22_07_2020.py new file mode 100644 index 00000000..718893bd --- /dev/null +++ b/TarunsModel/tellurium_form_corrections_22_07_2020.py @@ -0,0 +1,191 @@ + +# coding: utf-8 + +# In[3]: + + +import tellurium as te + + +# In[4]: + + +model_string = ''' +// Equations +J1: D -> E; dE*D; +J2: E -> D; dE*E; +J3: E -> Ev; bE*V*E; +J4: Ev -> E; aE*Ev; +J5: Ev -> D; dE*Ev; + +//J6: Ev -> D; kE*g*Ev*Tc; + +J6: Ev -> D; drt * g * Tc * Ev / (1000 + Ev + g * Tc); + +//J6: Ev -> D; drt * g * Tc * Ev /( Kev + Ev); + +J7: -> V; pV*Ev; +J8: V ->; cV*V; # v0 -> v1; v1 =cV*v0 + +J9: -> Da; bD*V*(D0-Da); +J10: Da ->; dD*Da; + +// bellow is lymph + +J11: -> Dm; kD*Da; +J12: Dm ->; dDm*Dm; +J13: -> Tc; dC*Tc0; +J14: Tc ->; dC*Tc; +//# J15: Dm -> Tc; rT1*Dm*Tc/(Dm+pT2) + Dm; +J15: -> Tc; rT1*Dm*Tc/(Dm+pT2); +//J16: Tc ->; dT1*Tc*Ev/(Ev+dT2); +J16: Tc ->; dT1*Tc*Dm/(Dm+dT2); + +J17: -> Th1; sTh1*Th1/(1+Th2)^2; +//J18: Dm -> Th1; pTh1*Dm*(Th1^2)/(1+Th2)^2 + Dm; +J18: -> Th1; pTh1*Dm*(Th1^2)/(1+Th2)^2; +J19: Th1 ->; dTh1*Dm*(Th1^3)/(1+Th2); +J20: Th1 ->; mTh*Th1; +J21: -> Th2; sTh2*Th2/(1+Th2); +# J22: Dm -> Th2; pTh2*(r+Th1)*Dm*(Th2^2)/((1+Th2)*(1+Th1+Th2)) + Dm +J22: -> Th2; pTh2*(r+Th1)*Dm*(Th2^2)/((1+Th2)*(1+Th1+Th2)) +J23: Th2 ->; mTh*Th2; + +// new eqs + +J24: -> B; dB*B0; +J25: B ->; dB*B; +//J26: Dm + Th2 -> B; rB1*B*(Dm+h*Th2)/(Dm+h*Th2+rB2); +J26: -> B; rB1*B*(Dm+h*Th2)/(Dm+h*Th2+rB2); + +J27: B -> Pss; pS*B; +J28: B -> Psn; pS*B; +J29: B -> Pls; pL*B*Th2; +J30: B -> Pln; pL*B*Th2; +J31: Pss ->; dS*Pss; +J32: Psn ->; dS*Psn; +J33: Pls ->; dL*Pls; +J34: Pln ->; dL*Pln; +J35: Pss -> Pls; d*(1-v)*Pss; +J36: Psn -> Pln; d*(1-v)*Psn; +J37: -> Pss; b*v*Pss; +J37a: -> Pls; b*v*Pls; +J38: -> Psn; b*v*Psn; +J38a: -> Pln; b*v*Pln; +J39: Pls -> Pss; d*(1-v)*Pls; +J40: Pln -> Psn; d*(1-v)*Pln; + +J41: -> sIgM; pAS*Pss; +J42: -> nIgM; pAS*Psn; +J43: -> sIgG; pAS*Pls; +J44: -> nIgG; pAS*Pln; +J45: sIgM ->; dM*sIgM; +J46: sIgG ->; dG*sIgG; +J47: nIgM ->; dM*nIgM; +J48: nIgG ->; dG*nIgG; +// feed back to tissue +J49: Ev + nIgM -> D; eE*Ev*nIgM; // reevaluate these set (49-52) due to anti-bodies being consumed +J50: Ev + nIgG -> D; eE*Ev*nIgG; +//J51: V ->; eV*V*sIgM; # v1->v2; v2= sIgM * eV * v1 = sIgM * eV *cV * v0 +J51: V + sIgM ->; eV*V*sIgM; +//J52: V ->; eV*V*sIgG; +J52: V + sIgG ->; eV*V*sIgG; + + +// Parameters +dE=10^-3; +E0=5*10^5; +bE=3*10^-6; +aE=5.0*10^-2; +V0=10; +pV=19; +cV=1; +kE=1.19*10^-3 / 900; // 900 rescaling for non-0 T cell pop in tissue +g=0.15 * 900; + +drt = 30; +Kev = Tc0; + +tC=0.5;// not included in the model +eE=0.05; +eV=16; +D0=10^3; +bD=10^-2; +dD=2.9; +kD=0.5; +tD=1;// not included in the model +dDm=0.5; +dC=10.1*10^-3; +Tc0=5*10^2; +rT1=1.3; +rT2=1; +dT1=5.0; +dT2=2000; +sTh1=2.5; +pTh1=4; +dTh1=0.03; +mTh=0.25; +sTh2=0.001; +pTh2=0.0012; +r=0.2; +dB=0.0009; +B0=1*10^3; +rB1=100; +rB2=2*10^5; +h=100; +pS=10^-1; +pL=8*10^-3; +dS=0.002; +dL=0.02; +b=2.4*10^-4; +d=2.4*10^-2; +pAS=0.2; +pAL=0.3; +dG=0.04; +dM=0.2; +pT2=600; +v = 0.5 +// Initial Conditions +E = E0; +V = 10; +Th1=10; +Th2=10; +''' + + +# In[5]: + + +rr = te.loadAntimonyModel(model_string) +#n=rr.simulate(0,20,4000,['time','I1','I2','I2D1','I2D2','I2D3','I2D4','I2D5','I2D']) +#n=rr.simulate(0,20,10000,['time','TE','I1','I2','V','Cyto','LymphCyto','LymphE','E']) +#n=rr.simulate(0,20,4000,['time','I1','I2','E','EM','V','I2D']) + +#rr.plot(n,logy=True, ylim=[1, 5E7]) + + +# In[6]: + + +rr.resetAll() +n = rr.simulate(0,20,4000,['time','Tc']) +rr.plot() + + +# In[7]: + + +rr.resetAll() +n = rr.simulate(0,20,4000,['time','Ev']) +rr.plot() + + +# In[8]: + + +rr.resetAll() +#rr.simulate(0,2,4000) +#n = rr.simulate(0,20,4000,['time','Tc', 'Ev']) +n = rr.simulate(0,20,4000,['time','J6']) +rr.plot() +