def SSA_MA_complex(self, Desc, sub1, sub2, complex, kf, kr): #rescale kf for second order stochastic propensity if str(self.pvaldict[kf] ) == self.SSAmodel.listOfParameters[kf].expression: self.SSAmodel.setParameter( kf, self.SSAmodel.listOfParameters[kf].expression + '/(' + str(self.vol) + ')') rxn1 = stk.Reaction( name=Desc + "_formation", reactants={ self.species_array[self.ydict[sub1]]: 1, self.species_array[self.ydict[sub2]]: 1 }, products={self.species_array[self.ydict[complex]]: 1}, massaction=True, rate=self.param_array[self.pdict[kf]]) self.SSAmodel.addReaction(rxn1) rxn2 = stk.Reaction( name=Desc + "degradation", reactants={self.species_array[self.ydict[complex]]: 1}, products={ self.species_array[self.ydict[sub1]]: 1, self.species_array[self.ydict[sub2]]: 1 }, massaction=True, rate=self.param_array[self.pdict[kr]]) self.SSAmodel.addReaction(rxn2) #print Desc+' added successfully.' return
def SSA_MA_meanfield(self, sharedspecies, indx, xlen, indy, ylen, kcouple): #set-up indexes for mixing. Note that this makes sure there is only one reaction each time #since the inxed relationship only goes in one direction annt = None index = '_' + str(indx) + '_' + str(indy) if indx + 1 == xlen: ind_x1 = '_' + str(0) + '_' + str(indy) else: ind_x1 = '_' + str(indx + 1) + '_' + str(indy) if indy + 1 == ylen: ind_y1 = '_' + str(indx) + '_' + str(0) else: ind_y1 = '_' + str(indx) + '_' + str(indy + 1) rctsf = {self.species_array[self.ydict[sharedspecies + index]]: 1} prodsxf = {self.species_array[self.ydict[sharedspecies + ind_x1]]: 1} prodsyf = {self.species_array[self.ydict[sharedspecies + ind_y1]]: 1} prodsr = {self.species_array[self.ydict[sharedspecies + index]]: 1} rctsxr = {self.species_array[self.ydict[sharedspecies + ind_x1]]: 1} rctsyr = {self.species_array[self.ydict[sharedspecies + ind_y1]]: 1} propfcnxr = kcouple + '*' + sharedspecies + ind_x1 #('+sharedspecies+ind_x1+'-'+sharedspecies+index+')' propfcnyr = kcouple + '*' + sharedspecies + ind_y1 #('+sharedspecies+ind_y1+'-'+sharedspecies+index+')' propfcnxf = kcouple + '*' + sharedspecies + index #('+sharedspecies+index+'-'+sharedspecies+ind_x1+')' propfcnyf = kcouple + '*' + sharedspecies + index #('+sharedspecies+index+'-'+sharedspecies+ind_y1+')' #Add forward and backward mixing for x and y both rxn1 = stk.Reaction(name=sharedspecies + 'mixing' + index + '_xf', reactants=rctsf, products=prodsxf, propensity_function=propfcnxf, annotation=annt) self.SSAmodel.addReaction(rxn1) rxn3 = stk.Reaction(name=sharedspecies + 'mixing' + index + '_xr', reactants=rctsxr, products=prodsr, propensity_function=propfcnxr, annotation=annt) self.SSAmodel.addReaction(rxn3) rxn2 = stk.Reaction(name=sharedspecies + 'mixing' + index + '_yf', reactants=rctsf, products=prodsyf, propensity_function=propfcnyf, annotation=annt) self.SSAmodel.addReaction(rxn2) rxn4 = stk.Reaction(name=sharedspecies + 'mixing' + index + '_yr', reactants=rctsyr, products=prodsr, propensity_function=propfcnyr, annotation=annt) self.SSAmodel.addReaction(rxn4)
def SSA_MA_deg(self, Desc, S, k): rxn = stk.Reaction(name=Desc, reactants={self.species_array[self.ydict[S]]: 1}, propensity_function=k + '*' + S) self.SSAmodel.addReaction(rxn) #print Desc+' added successfully.' return
def SSA_MA_tln(self, Desc, P, k, mRNA): rxn = stk.Reaction(name=Desc, products={self.species_array[self.ydict[P]]: 1}, propensity_function=mRNA + "*" + k, annotation="EmptySet->" + P) self.SSAmodel.addReaction(rxn) #print Desc+' added successfully.' return
def SSA_Ptf(self, Desc, per, tf, kf, kr): rxn1 = stk.Reaction(name=Desc + "_formation", reactants={self.species_array[self.ydict[per]]: 1}, products={self.species_array[self.ydict[tf]]: 1}, massaction=True, rate=self.param_array[self.pdict[kf]]) self.SSAmodel.addReaction(rxn1) rxn2 = stk.Reaction(name=Desc + "degradation", reactants={self.species_array[self.ydict[tf]]: 1}, products={self.species_array[self.ydict[per]]: 1}, massaction=True, rate=self.param_array[self.pdict[kr]]) self.SSAmodel.addReaction(rxn2) #print Desc+' added successfully.' return
def SSA_MF_deg(self, Desc, S, k, xlen, ylen): cellcount = xlen * ylen rxn = stk.Reaction(name=Desc, reactants={self.species_array[self.ydict[S]]: 1}, propensity_function=k + '*' + S + '/' + str(cellcount)) self.SSAmodel.addReaction(rxn) #print Desc+' added successfully.' return
def SSA_MA_cytonuc(self, Desc, cyto, nuc, kf, kr): #rescale kf for second order stochastic propensity rxn1 = stk.Reaction( name=Desc + "_tonuc", reactants={self.species_array[self.ydict[cyto]]: 1}, products={self.species_array[self.ydict[nuc]]: 1}, massaction=True, rate=self.param_array[self.pdict[kf]]) self.SSAmodel.addReaction(rxn1) rxn2 = stk.Reaction(name=Desc + "_tocyto", reactants={self.species_array[self.ydict[nuc]]: 1}, products={self.species_array[self.ydict[cyto]]: 1}, massaction=True, rate=self.param_array[self.pdict[kr]]) self.SSAmodel.addReaction(rxn2) #print Desc+' added successfully.' return
def SSA_tyson_y(self, Desc, Y, a0, a1, a2): rcts = {self.species_array[self.ydict[Y]]: 1} prods = {} propfcn = Y + '/(a0 + a1*(' + Y + '/' + str( self.vol) + ') + a2*' + Y + '*' + Y + '/(' + str( self.vol) + '*' + str(self.vol) + '))' rxn = stk.Reaction(name=Desc, reactants=rcts, products=prods, propensity_function=propfcn, annotation=0) self.SSAmodel.addReaction(rxn) return
def SSA_PR16f(self, Desc, prod, act, rep1, rep2, vtr, vtp, knp): rcts = {} prods = {self.species_array[self.ydict[prod]]: 1} om = str(self.vol) propfcn = om + '*(' + vtr + '*(' + act + '/' + om + ')+' + vtp + ')/(' + knp + '+(' + rep1 + '/' + om + ')+(' + rep2 + '/' + om + '))' annt = 0 rxn = stk.Reaction(name=Desc, reactants=rcts, products=prods, propensity_function=propfcn, annotation=annt) self.SSAmodel.addReaction(rxn)
def SSA_tyson_y(self, Desc, Y, a0, a1, a2, tc=None): rcts = {self.species_array[self.ydict[Y]]: 1} prods = {} propfcn = (Y + '/(' + a0 + '+ ' + a1 + '*(' + Y + '/' + str(self.vol) + ') + ' + a2 + '*' + Y + '*' + Y + '/(' + str(self.vol) + '*' + str(self.vol) + '))') if tc: propfcn = tc + '*' + propfcn rxn = stk.Reaction(name=Desc, reactants=rcts, products=prods, propensity_function=propfcn, annotation=0) self.SSAmodel.addReaction(rxn) return
def SSA_MM_P_Goodwin(self, Desc, Prod=None, Rep=None, P=None): """ Peter's hacked function to allow for hill kinetics in Goodwin Model """ # Add the 3rd order hill term vmax_expr = str(self.vol) km0_expr = '1' rep_expr = '*'.join(['(' + Rep + '/' + str(self.vol) + ')'] * int(P)) propfcn = vmax_expr + '/(' + km0_expr + '+' + rep_expr + ')' rxn = stk.Reaction(name=Desc, products={self.species_array[self.ydict[Prod]]: 1}, propensity_function=propfcn, annotation="EmptySet->" + Prod) self.SSAmodel.addReaction(rxn)
def SSA_MA(self, name='', reactants={}, products={}, rate=''): """ Deal with mass-action rates where volume affects the stochastic propensity """ # Scale rate by appropriate volume power degree = sum(reactants.values()) if str(self.pvaldict[rate.name]) == rate.expression: self.SSAmodel.setParameter( rate.name, (rate.expression + '/pow(' + str(self.vol) + ', ' + str(degree - 1) + ')')) rxn = stk.Reaction(name=name, reactants=reactants, products=products, massaction=True, rate=rate) self.SSAmodel.addReaction(rxn)
def SSA_tyson_x(self, Desc, X, Y, P): rcts = {} prods = {self.species_array[self.ydict[X]]: 1} exp_P = int(float(self.SSAmodel.listOfParameters[P].expression)) ymult = Y + ('*' + Y) * (exp_P - 1) volmult = '(' + str( self.vol) + ('*' + str(self.vol)) * (exp_P - 1) + ')' propfcn = str(self.vol) + '*1/(1+(' + ymult + '/(' + volmult + ')))' rxn = stk.Reaction(name=Desc, reactants=rcts, products=prods, propensity_function=propfcn, annotation=None) self.SSAmodel.addReaction(rxn) return
def SSAnetwork(fn,y0in,param,adjacency): """ This is the network-level SSA model, with coupling. Call with: SSAcoupled,state_names,param_names = SSAmodelC(ODEmodel(),y0in,param) To uncouple the model, set adjacency matrix to zeros """ #Converts concentration to population y0in_ssa = (vol*y0in).astype(int) #collects state and parameter array to be converted to species and parameter objects, #makes copies of the names so that they are on record species_array = [] state_names=[] if randomy0==False: y0in_pop = [] #coupling section=========================== for indx in range(cellcount): index = '_'+str(indx)+'_0' #loops to include all species, normally this is the only line needed without index species_array = species_array + [fn.inputSX(cs.DAE_X)[i].getDescription()+index for i in xrange(EqCount)] state_names = state_names + [fn.inputSX(cs.DAE_X)[i].getDescription()+index for i in xrange(EqCount)] if randomy0==False: y0in_pop = np.append(y0in_pop, y0in_ssa) if randomy0 == True: #random initial locations y0in_pop = 1*np.ones(EqCount*cellcount) for i in range(len(y0in_pop)): y0in_pop[i] = vol*4*random.random() #=========================================== param_array = [fn.inputSX(cs.DAE_P)[i].getDescription() for i in xrange(ParamCount)] param_names = [fn.inputSX(cs.DAE_P)[i].getDescription() for i in xrange(ParamCount)] #Names model SSAmodel = stk.StochKitModel(name=modelversion) #creates SSAmodel class object SSA_builder = mb.SSA_builder(species_array,param_array,y0in_pop,param,SSAmodel,vol) #coupling section for indx in range(cellcount): index = '_'+str(indx)+'_0' #Coupled terms - - ------------------------------------------------- #loops for all cells accumulating their input avg = '0' mcount = 0 for fromcell in range(cellcount): if adjacency[fromcell,indx]!= 0: #The Coupling Part mcount = mcount+1 avg = avg+'+M_'+str(fromcell)+'_0' weight = 1.0/mcount #FIXES PARAMETERS FROM DETERMINISTIC TO STOCHASTIC VALUES if (str(SSA_builder.pvaldict['vs0']) == SSA_builder.SSAmodel.listOfParameters['vs0'].expression): SSA_builder.SSAmodel.setParameter('vs0', SSA_builder.SSAmodel.listOfParameters['vs0'].expression+'*('+str(SSA_builder.vol)+')') if (str(SSA_builder.pvaldict['k1']) == SSA_builder.SSAmodel.listOfParameters['k1'].expression): SSA_builder.SSAmodel.setParameter('k1', SSA_builder.SSAmodel.listOfParameters['k1'].expression+'*('+str(SSA_builder.vol)+')') if (str(SSA_builder.pvaldict['alocal']) == SSA_builder.SSAmodel.listOfParameters['alocal'].expression): SSA_builder.SSAmodel.setParameter('alocal', SSA_builder.SSAmodel.listOfParameters['alocal'].expression+'*('+str(SSA_builder.vol)+')') ##### #Adds reaction for coupling rxn=stk.Reaction(name='Cell'+str(indx)+'_Reaction0', reactants={}, products={'M_'+str(indx)+'_0':1}, propensity_function=('std::max(0.0,(vs0+alocal*(('+avg+')*' +str(weight)+'-M_'+str(indx)+'_0)))'+ '*pow(k1,n)/(pow(k1,n)+pow(Pn_'+str(indx)+'_0,n))'),annotation='')# SSAmodel.addReaction(rxn) #------------------------------------------------------------------- # REACTIONS SSA_builder.SSA_MM('Cell'+str(indx)+'_Reaction1','vm', km=['km'],Rct=['M'+index]) SSA_builder.SSA_MA_tln('Cell'+str(indx)+'_Reaction2', 'Pc'+index, 'ks','M'+index) SSA_builder.SSA_MM('Cell'+str(indx)+'_Reaction3','vd', km=['kd'],Rct=['Pc'+index]) #The complexing four: SSA_builder.SSA_MA_cytonuc('Cell'+str(indx)+'_Reaction4','Pc'+index, 'Pn'+index,'k1_','k2_') return SSAmodel,state_names,param_names
def SSAmodel(fn,y0in,param): """ This is the network-level SSA model, with coupling. Call with: SSAcoupled,state_names,param_names = SSAmodelC(ODEmodel(),y0in,param) By default, there is no coupling in this model. """ #Converts concentration to population y0in_pop = (vol*y0in).astype(int) #collects state and parameter array to be converted to species and parameter objects, #makes copies of the names so that they are on record species_array = [fn.inputExpr(cs.DAE_X)[i].getName() for i in xrange(EqCount)] param_array = [fn.inputExpr(cs.DAE_P)[i].getName() for i in xrange(ParamCount)] state_names = [fn.inputExpr(cs.DAE_X)[i].getName() for i in xrange(EqCount)] param_names = [fn.inputExpr(cs.DAE_P)[i].getName() for i in xrange(ParamCount)] #creates SSAmodel class object SSAmodel = stk.StochKitModel(name=modelversion) SSA_builder = mb.SSA_builder(species_array,param_array,y0in_pop,param,SSAmodel,vol) #FIXES PARAMETERS FROM DETERMINISTIC TO STOCHASTIC VALUES if (str(SSA_builder.pvaldict['vs0']) == SSA_builder.SSAmodel.listOfParameters['vs0'].expression): SSA_builder.SSAmodel.setParameter('vs0', SSA_builder.SSAmodel.listOfParameters['vs0'].expression+'*('+str(SSA_builder.vol)+')') if (str(SSA_builder.pvaldict['k1']) == SSA_builder.SSAmodel.listOfParameters['k1'].expression): SSA_builder.SSAmodel.setParameter('k1', SSA_builder.SSAmodel.listOfParameters['k1'].expression+'*('+str(SSA_builder.vol)+')') if (str(SSA_builder.pvaldict['alocal']) == SSA_builder.SSAmodel.listOfParameters['alocal'].expression): SSA_builder.SSAmodel.setParameter('alocal', SSA_builder.SSAmodel.listOfParameters['alocal'].expression+'*('+str(SSA_builder.vol)+')') # REACTIONS rxn0=stk.Reaction(name='Reaction0', reactants={}, products={'M':1}, propensity_function=( 'vs0*pow(k1,n)/(pow(k1,n)+pow(Pn,n))'),annotation='') SSAmodel.addReaction(rxn0) SSA_builder.SSA_MM('Reaction1','vm', km=['km'],Rct=['M']) SSA_builder.SSA_MA_tln('Reaction2', 'Pc', 'ks','M') SSA_builder.SSA_MM('Reaction3','vd', km=['kd'],Rct=['Pc']) SSA_builder.SSA_MA_cytonuc('Reaction4','Pc', 'Pn','k1_','k2_') return SSAmodel,state_names,param_names
def SSA_genMM(self, Desc, vmax, km=None, Sub=None, Prod=None, Act=None, CInh=None, UCInh=None, NCInh=None): """general michaelis-menten term that includes re-scaling for a population model """ #counts components try: rctcount = len(Rct) except: rctcount = 0 try: prodcount = len(Prod) except: prodcount = 0 try: actcount = len(Act) except: actcount = 0 try: repcount = len(Rep) except: repcount = 0 #Adds Reactants rcts = {} if Rct is not None: rcts.update({self.species_array[self.ydict[Rct[0]]]: 1}) #Adds Products prods = {} for i in range(prodcount): prods.update({self.species_array[self.ydict[Prod[i]]]: 1}) #redefine vmax -- need some way to determine if it has been updated or not if str(self.pvaldict[vmax] ) == self.SSAmodel.listOfParameters[vmax].expression: self.SSAmodel.setParameter( vmax, self.SSAmodel.listOfParameters[vmax].expression + '*(' + str(self.vol) + '**2)/(' + str(self.vol) + '**(' + str(actcount + (Rct is not None)) + '))') if len(km) == 1: #redefine k -- need some way to determine if it has been updated or not if str(self.pvaldict[km[0]]) == self.SSAmodel.listOfParameters[ km[0]].expression: self.SSAmodel.setParameter( km[0], self.SSAmodel.listOfParameters[km[0]].expression + '*(' + str(self.vol) + ')') #propensity funtion setup rctmult = '' rctsum = '' for i in range(Rct is not None): rctmult = rctmult + '*' + Rct[i] for i in range(rctcount): rctsum = rctsum + '+' + Rct[i] actmult = '' actsum = '' for i in range(actcount): actsum = actsum + '+' + Act[i] actmult = actmult + '*' + Act[i] repmult = '' repsum = '' for i in range(repcount): repsum = repsum + '+' + Rep[i] repmult = repmult + '*' + Rep[i] #creates the propensity function propfcn = vmax + rctmult + actmult + '/(' + km[ 0] + rctsum + actsum + repsum + ')' annt = 0 #no annotations necessary yet rxn = stk.Reaction(name=Desc, reactants=rcts, products=prods, propensity_function=propfcn, annotation=annt) self.SSAmodel.addReaction(rxn) #print Desc+' added successfully.' return
def ssa_resync(fn, y0in_desync, param, cellcount, adjacency, couplingstr=couplingstr, vol=40): """ This is the network-level SSA model, with coupling. Call with: SSAcoupled,state_names,param_names = SSAmodelC(ODEmodel(),y0in,param) To uncouple the model, set adjacency matrix to zeros """ #collects state and parameter array to be converted to species and parameter objects, #makes copies of the names so that they are on record species_array = [] state_names = [] #coupling section=========================== for indx in range(cellcount): index = '_' + str(indx) + '_0' #loops to include all species, normally this is the only line needed without index species_array = species_array + [ fn.inputExpr(cs.DAE_X)[i].getName() + index for i in xrange(EqCount) ] state_names = state_names + [ fn.inputExpr(cs.DAE_X)[i].getName() + index for i in xrange(EqCount) ] y0in_pop = y0in_desync #=========================================== param_array = [ fn.inputExpr(cs.DAE_P)[i].getName() for i in xrange(ParamCount) ] param_names = [ fn.inputExpr(cs.DAE_P)[i].getName() for i in xrange(ParamCount) ] #Names model SSAmodel = stk.StochKitModel(name=modelversion) #creates SSAmodel class object SSA_builder = mb.SSA_builder(species_array, param_array, y0in_pop, param, SSAmodel, vol) # now set up mean field(?) coupling for all uncoupled cells #coupling section for indx in range(cellcount): index = '_' + str(indx) + '_0' #Coupled terms - - ------------------------------------------------- #loops for all cells accumulating their input avg = 'M' + index mcount = 1 for fromcell in range(cellcount): if adjacency[fromcell, indx] != 0: #The Coupling Part mcount = mcount + couplingstr avg = avg + '+M_' + str(fromcell) + '_0*' + str(couplingstr) if mcount == 1: # then the cell is "uncoupled" so we'll put it to a mean field for fromcell in range(cellcount): mcount += couplingstr * 0.25 / cellcount avg = avg + '+M_' + str(fromcell) + '_0*0.33*' + str( couplingstr / cellcount) weight = 1.0 / mcount #FIXES PARAMETERS FROM DETERMINISTIC TO STOCHASTIC VALUES if (str(SSA_builder.pvaldict['vs0']) == SSA_builder.SSAmodel.listOfParameters['vs0'].expression): SSA_builder.SSAmodel.setParameter( 'vs0', SSA_builder.SSAmodel.listOfParameters['vs0'].expression + '*(' + str(SSA_builder.vol) + ')') if (str(SSA_builder.pvaldict['k1']) == SSA_builder.SSAmodel.listOfParameters['k1'].expression): SSA_builder.SSAmodel.setParameter( 'k1', SSA_builder.SSAmodel.listOfParameters['k1'].expression + '*(' + str(SSA_builder.vol) + ')') if (str(SSA_builder.pvaldict['alocal']) == SSA_builder.SSAmodel.listOfParameters['alocal'].expression): SSA_builder.SSAmodel.setParameter( 'alocal', SSA_builder.SSAmodel.listOfParameters['alocal'].expression + '*(' + str(SSA_builder.vol) + ')') ##### #Adds reaction rxn = stk.Reaction( name='Cell' + str(indx) + '_Reaction0', reactants={}, products={'M_' + str(indx) + '_0': 1}, propensity_function=('std::max(0.0,(vs0+alocal*((' + avg + ')*' + str(weight) + '-M_' + str(indx) + '_0)))' + '*pow(k1,n)/(pow(k1,n)+pow(Pn_' + str(indx) + '_0,n))'), annotation='') # SSAmodel.addReaction(rxn) #------------------------------------------------------------------- # REACTIONS SSA_builder.SSA_MM('Cell' + str(indx) + '_Reaction1', 'vm', km=['km'], Rct=['M' + index]) SSA_builder.SSA_MA_tln('Cell' + str(indx) + '_Reaction2', 'Pc' + index, 'ks', 'M' + index) SSA_builder.SSA_MM('Cell' + str(indx) + '_Reaction3', 'vd', km=['kd'], Rct=['Pc' + index]) #The complexing four: SSA_builder.SSA_MA_cytonuc('Cell' + str(indx) + '_Reaction4', 'Pc' + index, 'Pn' + index, 'k1_', 'k2_') print 'weak, mean-field coupling' return SSAmodel, state_names, param_names
def ssa_resync(fn, y0in_desync, param, cellcount, adjacency): """ This is the network-level SSA model, with coupling. Call with: SSAcoupled,state_names,param_names = SSAmodelC(ODEmodel(),y0in,param) To uncouple the model, set adjacency matrix to zeros """ #Converts concentration to population y0in_ssa = (vol * y0in).astype(int) #collects state and parameter array to be converted to species and parameter objects, #makes copies of the names so that they are on record species_array = [] state_names = [] y0in_pop = y0in_desync #coupling section=========================== for indx in range(cellcount): index = '_' + str(indx) + '_0' #loops to include all species, normally this is the only line needed without index species_array = species_array + [ fn.inputExpr(cs.DAE_X)[i].getName() + index for i in xrange(EqCount) ] state_names = state_names + [ fn.inputExpr(cs.DAE_X)[i].getName() + index for i in xrange(EqCount) ] if randomy0 == False: y0in_pop = np.append(y0in_pop, y0in_ssa) if randomy0 == True: #random initial locations y0in_pop = 1 * np.ones(EqCount * cellcount) for i in range(len(y0in_pop)): y0in_pop[i] = vol * 1 * random.random() #=========================================== param_array = [ fn.inputExpr(cs.DAE_P)[i].getName() for i in xrange(ParamCount) ] param_names = [ fn.inputExpr(cs.DAE_P)[i].getName() for i in xrange(ParamCount) ] #Names model SSAmodel = stk.StochKitModel(name=modelversion) #creates SSAmodel class object SSA_builder = mb.SSA_builder(species_array, param_array, y0in_pop, param, SSAmodel, vol) #coupling section for indx in range(cellcount): index = '_' + str(indx) + '_0' # REACTIONS #per mRNA SSA_builder.SSA_PR16f('per mRNA activation' + index, 'p' + index, 'CREB' + index, 'C1P' + index, 'C2P' + index, 'vtpr', 'vtpp', 'knpr') SSA_builder.SSA_MM('per mRNA degradation' + index, 'vdp', km=['kdp'], Rct=['p' + index]) #cry1 mRNA SSA_builder.SSA_MM('c1 mRNA repression' + index, 'vtc1r', km=['kncr'], Prod=['c1' + index], Rep=['C1P' + index, 'C2P' + index]) SSA_builder.SSA_MM('c1 mRNA degradation' + index, 'vdc1', km=['kdc'], Rct=['c1' + index]) #cry2 mRNA SSA_builder.SSA_MM('c2 mRNA repression' + index, 'vtc2r', km=['kncr'], Prod=['c2' + index], Rep=['C1P' + index, 'C2P' + index]) SSA_builder.SSA_MM('c2 mRNA degradation' + index, 'vdc2', km=['kdc'], Rct=['c2' + index]) #vip mRNA SSA_builder.SSA_MM('vip mRNA repression' + index, 'vtvr', km=['knvr'], Prod=['vip' + index], Rep=['C1P' + index, 'C2P' + index]) SSA_builder.SSA_MM('vip mRNA degradation' + index, 'vdv', km=['kdv'], Rct=['vip' + index]) #CRY1, CRY2, PER, VIP creation and degradation SSA_builder.SSA_MA_tln('PER translation' + index, 'P' + index, 'ktlnp', 'p' + index) SSA_builder.SSA_MA_tln('CRY1 translation' + index, 'C1' + index, 'ktlnc', 'c1' + index) SSA_builder.SSA_MA_tln('CRY2 translation' + index, 'C2' + index, 'ktlnc', 'c2' + index) SSA_builder.SSA_MM('PER degradation' + index, 'vdP', km=['kdP'], Rct=['P' + index]) SSA_builder.SSA_MM('C1 degradation' + index, 'vdC1', km=['kdC'], Rct=['C1' + index]) SSA_builder.SSA_MM('C2 degradation' + index, 'vdC2', km=['kdC'], Rct=['C2' + index]) SSA_builder.SSA_MA_deg('eVIP degradation' + index, 'eVIP' + index, 'kdVIP') #CRY1 CRY2 complexing SSA_builder.SSA_MA_complex('CRY1-P complex' + index, 'C1' + index, 'P' + index, 'C1P' + index, 'vaCP', 'vdCP') SSA_builder.SSA_MA_complex('CRY2-P complex' + index, 'C2' + index, 'P' + index, 'C2P' + index, 'vaCP', 'vdCP') SSA_builder.SSA_MM('C1P degradation' + index, 'vdC1n', km=['kdCn'], Rct=['C1P' + index, 'C2P' + index]) SSA_builder.SSA_MM('C2P degradation' + index, 'vdC2n', km=['kdCn'], Rct=['C2P' + index, 'C1P' + index]) #VIP/CREB Pathway SSA_builder.SSA_MM('CREB formation' + index, 'vgpka', km=['kgpka'], Prod=['CREB' + index], Act=['eVIP' + index]) SSA_builder.SSA_MM('CREB degradation' + index, 'vdCREB', km=['kdCREB'], Rct=['CREB' + index]) for currentcell in range(cellcount): for affectedcell in range(cellcount): if adjacency[currentcell, affectedcell] != 0: #The Coupling Part rxn = stk.Reaction( name='vip from ' + str(currentcell) + ' to ' + str(affectedcell), products={'eVIP_' + str(affectedcell) + '_0': 1}, propensity_function='vip_' + str(currentcell) + "_0*" + 'ktlnv' + '*' + str(adjacency[currentcell, affectedcell]), annotation='') SSAmodel.addReaction(rxn) return SSAmodel, state_names, param_names