def func(param, return_oofunvalue=False): num = len(param["Substrate"]) p, s = oovars(2, size = num) equations = [ (0==-param["Protein"]+(ones(num)+param['k1']*s)*p)(tol=tolerence), (0==-param['Substrate']+(ones(num)+param['k1']*p)*s)(tol=tolerence), ] startpoint = {p:param["Protein"], s:param['Substrate']} system = SNLE(equations, startpoint, iprint = -100) if local_constrained: # Slow but works when not close system.constraints = [ p > zeros(num), s > zeros(num), p < param['Protein'], s < param['Substrate'] ] solutions = system.solve('nssolve') else: # Fast and good if close solutions = system.solve('scipy_fsolve') P, S = p(solutions), s(solutions) return param['s']*(param['k1'])*P*S/param['Substrate']
def func(param, return_oofunvalue=False): #print traits #ImportOld.calltimes += 1 #print x #print "I have been called: " + str(ImportOld.calltimes) + " times" num = len(param["x"]) p = oovar(size=num) d = oovar(size=num) equations = [ (0 == -param["x"] + (ones(num) + param['k1'] * d) * p)(tol=1e-8), (0 == -param['NCPconc'] + (ones(num) + param['k1'] * p) * d)(tol=1e-8) ] startpoint = {p: param['x'], d: param['NCPconc']} system = SNLE(equations, startpoint, iprint=10) if Data.constrained: # Slow but works when not close system.constraints = [ p > zeros(num), d > zeros(num), p < param['x'], d < param['NCPconc'] ] solutions = system.solve('nssolve') else: # Fast and good if close solutions = system.solve('scipy_fsolve') P, D = p(solutions), d(solutions) return param['s'] * ( param['k1']) * P * D / param['NCPconc'] + param['offset']
def solve_gamma_3D(gammas): #y={eta_fixed, mu_fixed, nu_fixed} gamma_array = [] sol_1_array = [] sol_2_array = [] sol_3_array = [] sol_4_array = [] eta, mu, nu = oovars(3) start_point = {eta:3.0, mu:0.7, nu:0.20} for gamma in gammas: # gamma = gamma.tolist() global alpha, beta, tau_l, tau_k, Lambda, delta, A, N, phi_k, phi_l, theta # Set equations L = N * (mu * (1-mu/2) + theta * (1-mu)) f_1 = -nu - delta + N * mu * beta / (1 + beta) * ((1 - tau_l) * (1 - mu / 2) * (1 - alpha) * A * L**(-alpha) *eta ** (alpha - 1) - gamma) f_2 = mu * phi_k * alpha * (1-alpha)*A* L**(1-alpha) *eta**alpha / (alpha*A*L**(1-alpha)*eta**(alpha-1) + N*mu*gamma) + (1-mu)*phi_l* (tau_l*(1-alpha)**2*A*L**(-alpha)*eta**alpha + tau_k*alpha*(1-alpha)*A*L**(1-alpha)*eta**alpha-1) / (tau_l*(1-alpha)*A*L**(-alpha)*eta**(alpha-1) + tau_k*(alpha*A*L**(1-alpha)*eta**(alpha-1)+N*mu*gamma)-eta**(-1)) c_yk = 1/(1+beta) * ( (1-tau_l)* (1-mu)* (1-alpha)* A* eta**(alpha-1)* L**(-alpha) - gamma) c_ok = beta * (1-tau_k) * (1+alpha*A*eta**(alpha-1)*L**(1-alpha) - delta) / (1+beta) * ( (1-tau_l)* (1-mu)* (1-alpha)* A* eta**(alpha-1)* L**(-alpha) - gamma) c_yl = (1-tau_l)* theta * (1-alpha)* A* eta**(alpha-1)* L**(-alpha) c_ol = 1/(N*(1-mu)) * (tau_l*(1-alpha)*A*eta**(alpha-1)*L**(1-alpha) + tau_k* (alpha*A*eta**(alpha-1)*L**(1-alpha) +N*mu*gamma) - eta**(-1)) U_k = c_yk * c_ok**beta U_l = c_yl * c_ol**beta f3 = U_k-U_l equations = (f_1 == 0, f_2 == 0, f3 == 0) p = SNLE(equations, start_point) cons_1 = Lambda * A * eta ** alpha + tau_k * mu * gamma * eta - 1 cons_2 = eta - ((1 - alpha) * A) ** (-1 / alpha) cons_3 = (1 - tau_l) * (1 - mu) * (1 - alpha) * A * eta ** (alpha - 1) - gamma p.constraints = [0 < mu, mu < 1, cons_1 > 0, cons_2 > 0, cons_3 >=0, nu>0] r = p.solve('nssolve') sol_1, sol_2, sol_3 = r(eta, mu, nu) sol_4 = N * (sol_2 * (1-sol_2/2) + theta * (1-sol_2)) print('Solution: eta=%f, mu=%f, nu=%f, L=%f' % (sol_1, sol_2, sol_3, sol_4)) if r.stopcase>0: gamma_array.append(gamma) sol_1_array.append(sol_1) sol_2_array.append(sol_2) sol_3_array.append(sol_3) sol_4_array.append(sol_4) return gamma_array, sol_1_array, sol_2_array, sol_3_array, sol_4_array
def solve_eqn_np(theta, gamma, N): #y={eta_fixed, mu_fixed, nu_fixed} nu, eta, mu, = oovars(3) # start_point = {nu:0.08, eta:4, mu:0.8} # start_point = {nu:0.2, eta:3.4, mu:0.55} #Cololado # start_point = {nu:0.15, eta:2.5, mu:0.55} # Alabama not feasible start_point = {nu:0.2, eta:2.5, mu:0.55} global alpha, beta, tau_l, tau_k, Lambda, delta, A L = N*(mu*(1-mu/2)+(1-mu)*theta) f_1 = -nu - delta + N * mu * beta / (1 + beta) * ((1 - tau_l) * (1 - mu / 2) * (1 - alpha) * A * L**(-alpha) *eta ** (alpha - 1) - gamma) Log = log(((1-tau_l)*(1-mu)*(1-alpha)*A*L**(-alpha)*eta**(alpha-1) -gamma)/ ((1-tau_l)*(1-alpha)*A*L**(-alpha)*eta**(alpha-1)) -gamma) dV_yk = (1-alpha)*mu*eta - gamma/((1-tau_l)*A*L**(-alpha)*eta**(alpha-2))*Log dV_yl = (1-mu)*(1-alpha)*eta dV_ok = beta* mu * alpha * (1-alpha)*A* L**(1-alpha) *eta**alpha / (alpha*A*L**(1-alpha)*eta**(alpha-1) + N*mu*gamma) dV_ol = beta * (1-mu)* (tau_l*(1-alpha)**2*A*L**(-alpha)*eta**alpha + tau_k*alpha*(1-alpha)*A*L**(1-alpha)*eta**alpha-1) / (tau_l*(1-alpha)*A*L**(-alpha)*eta**(alpha-1) + tau_k*(alpha*A*L**(1-alpha)*eta**(alpha-1)+N*mu*gamma)-eta**(-1)) f_2 = dV_yk + dV_yl + dV_ok + dV_ol c_yk = 1/(1+beta) * ( (1-tau_l)* (1-mu)* (1-alpha)* A* eta**(alpha-1)* L**(-alpha) - gamma) c_ok = beta * (1-tau_k) * (1+alpha*A*eta**(alpha-1)*L**(1-alpha) - delta) / (1+beta) * ( (1-tau_l)* (1-mu)* (1-alpha)* A* eta**(alpha-1)* L**(-alpha) - gamma) c_yl = (1-tau_l)* theta * (1-alpha)* A* eta**(alpha-1)* L**(-alpha) c_ol = 1/(N*(1-mu)) * (tau_l*(1-alpha)*A*eta**(alpha-1)*L**(1-alpha) + tau_k* (alpha*A*eta**(alpha-1)*L**(1-alpha) +N*mu*gamma) - eta**(-1)) U_k = c_yk * c_ok**beta U_l = c_yl * c_ol**beta f_3 = U_k-U_l equations = (f_1 == 0, f_2 == 0, f_3==0) p = SNLE(equations, start_point) # cons_1 = Lambda * A * eta ** alpha + tau_k * mu * gamma * eta - 1 # cons_2 = eta - ((1 - alpha) * A) ** (-1 / alpha) cons_3 = (1 - tau_l) * (1 - mu) * (1 - alpha) * A * eta ** (alpha - 1) - gamma p.constraints = [nu>0, eta>0, 0< mu, mu < 1, cons_3 >0] # cons_1>=0, cons_2 >=0, r = p.solve('nssolve') nu_s, eta_s, mu_s = r(nu, eta, mu) print('Solution: x1=%f, x2=%f, x3=%f' %(nu_s, eta_s, mu_s)) L = N*(mu_s*(1-mu_s/2)+(1-mu_s)*theta) Y_K_ratio = A*eta_s**(alpha-1)*L**(1-alpha) return nu_s, Y_K_ratio, eta_s, mu_s, L
def func(param, return_oofunvalue=False, snle_style=False): #print traits #ImportOld.calltimes += 1 #print x #print "I have been called: " + str(ImportOld.calltimes) + " times" num = len(param["x"]) p = oovar(size=num) print param # equations = [ # (0.0 == param["x"] - p * (ones(num) + param['k1'] * s * (ones(num) + 2.0 * param['k2'] * p)))(tol=1e-12), # (0.0 == param["Substrate"] - s * (ones(num) + param['k1'] * p * (ones(num) + param['k2'] * p)))(tol=1e-12), # ] # m == k2/k1 # s = param["N"] equations = [ (0.0 == param['od'] * param["x"] - p * (ones(num) + param['k1'] * s * (ones(num) + 2.0 * param['k1'] * param['m'] * p)))(tol=1e-12) ] #startpoint = {p:param['x']/2.0, s:param['Substrate']/2.0} startpoint = {p: param['x']} #startpoint = {p:zeros(num), s:zeros(num)} system = SNLE(equations, startpoint, iprint=1000) if Data.local_constrained: # Slow but works when not close constraints = [ p > zeros(num), s > zeros(num), p < param['x'], s < param['Substrate'], p > param['x'] - 2 * param['Substrate'] ] system.constraints = constraints #solutions = system.solve('interalg') if Data.local_constrained: solutions = system.solve('nssolve') else: # Fast and good if close solutions = system.solve('scipy_fsolve') P = p(solutions) print "Protein:" print P return s * (ones(num) + param['k1'] * P * (ones(num) + param['k1'] * param['m'] * P)) / param['od']
def solve_eqn(nu, eta, phi_k, phi_l, tau_k, tau_l): #y={eta_fixed, mu_fixed, nu_fixed} theta, mu, gamma = oovars(3) start_point = {theta:0.5, mu:0.8, gamma:0.2} global alpha, beta, delta, A Lambda = alpha * tau_k + (1 - alpha) * tau_l # Set equations L = 1 N = L / (mu*(1-mu/2)+(1-mu)*theta) f_1 = -nu - delta + N * mu * beta / (1 + beta) * ((1 - tau_l) * (1 - mu / 2) * (1 - alpha) * A * L**(-alpha) *eta ** (alpha - 1) - gamma) f_2 = mu * phi_k * alpha * (1-alpha)*A* L**(1-alpha) *eta**alpha / (alpha*A*L**(1-alpha)*eta**(alpha-1) + N*mu*gamma) + (1-mu)*phi_l* (tau_l*(1-alpha)**2*A*L**(-alpha)*eta**alpha + tau_k*alpha*(1-alpha)*A*L**(1-alpha)*eta**alpha-1) / (tau_l*(1-alpha)*A*L**(-alpha)*eta**(alpha-1) + tau_k*(alpha*A*L**(1-alpha)*eta**(alpha-1)+N*mu*gamma)-eta**(-1)) c_yk = 1/(1+beta) * ( (1-tau_l)* (1-mu)* (1-alpha)* A* eta**(alpha-1)* L**(-alpha) - gamma) c_ok = beta * (1-tau_k) * (1+alpha*A*eta**(alpha-1)*L**(1-alpha) - delta) / (1+beta) * ( (1-tau_l)* (1-mu)* (1-alpha)* A* eta**(alpha-1)* L**(-alpha) - gamma) c_yl = (1-tau_l)* theta * (1-alpha)* A* eta**(alpha-1)* L**(-alpha) c_ol = 1/(N*(1-mu)) * (tau_l*(1-alpha)*A*eta**(alpha-1)*L**(1-alpha) + tau_k* (alpha*A*eta**(alpha-1)*L**(1-alpha) +N*mu*gamma) - eta**(-1)) U_k = c_yk * c_ok**beta U_l = c_yl * c_ol**beta f_3 = U_k-U_l equations = (f_1 == 0, f_2 == 0, f_3==0) p = SNLE(equations, start_point) cons_1 = Lambda * A * eta ** alpha + tau_k * mu * gamma * eta - 1 cons_2 = eta - ((1 - alpha) * A) ** (-1 / alpha) cons_3 = (1 - tau_l) * (1 - mu) * (1 - alpha) * A * eta ** (alpha - 1) - gamma p.constraints = [0 < mu, mu < 1, cons_1 > 0, cons_2 > 0, cons_3 >=0, N>1, gamma > 0, theta>0, theta<1 ] r = p.solve('nssolve') theta_s, mu_s, gamma_s = r(theta, mu, gamma) print('Solution: x1=%f, x2=%f, x3=%f' %(theta_s, mu_s, gamma_s)) # theta = ( 1/N - mu_s*( 1 - mu_s/2) )/(1 - mu_s) N = 1 / (mu_s*(1-mu_s/2)+(1-mu_s)*theta_s) return theta_s, mu_s, gamma_s, N, eta
def func(param, return_oofunvalue=False): #print param #ImportOld.calltimes += 1 #print "I have been called: " + str(ImportOld.calltimes) + " times" num = len(param["x"]) p = oovar(size=num) d = oovar(size=num) n = oovar(size=num) equations = [ (0 == (ones(num) + param['k1'] * d + param['k2'] * n + param['k2'] * param['k4'] * d * n) * p - exp(param['x']))(tol=1e-8), (0 == (ones(num) + param['k1'] * p + param['k2'] * param['k4'] * p * n) * d - param['dnaconc'])(tol=1e-8), (0 == (ones(num) + param['k2'] * p + param['k2'] * param['k4'] * p * d) * n - param['nconc'])(tol=1e-8) ] startpoint = {p: param['x'], d: param['dnaconc'], n: param['nconc']} system = SNLE(equations, startpoint, iprint=-1) if Data.constrained: # Slow but works when not close system.constraints = [ p > zeros(num), d > zeros(num), n > zeros(num), p < param['x'], d < param['dnaconc'], n < param['nconc'] ] solutions = system.solve('nssolve') else: # Fast and good if close solutions = system.solve('scipy_fsolve') P, D, N = p(solutions), d(solutions), n(solutions) #print "P: " + str(P) #print "D: " + str(D) #print "N: " + str(N) return log(param['s']) + log( (1.0 + param['k1'] * param['A'] * param['k2'] * param['k4'] * N)) - log(param['k1']) + log(P) + log(D) - log(param['dnaconc'])
def datafit(self, event, paramlinks, groups=[], ssrresult=None, timeresult=None, Main=False): def errfunc(fit_params, x=None, y=None, yerr=None, consts=None, traits=None, groups=None, snle_style=False): fitrun = fitfunc(fit_params, x, consts, traits, groups, return_oofunvalue=True, snle_style=snle_style) #print "Fit Params: " + str(fitrun) #print "Bad Fit Adjust: " + str(ssr_mod_for_bad_fit[0]) if snle_style: try: if fitrun[0]: fitrun[2].append(0 == ((fitrun[1] - y) / (array(yerr) + 1.0))**2.0) return [fitrun[2], fitrun[3], fitrun[4]] except: if fitrun[0]: fitrun[2].append(0 == ((fitrun[1] - y) / (array(yerr) + 1.0))**2.0) return [fitrun[2], fitrun[3]] else: return ((fitrun - y) / (array(yerr) + 1.0))**2.0 #*(1.0+ssr_mod_for_bad_fit) def fitfunc(fit_params, x, consts=None, traits=None, groups=None, return_oofunvalue=False, snle_style=False): reload(self.Parent.Parent.model) tempparam = OrderedDict() k = 0 m = 0 templist = list() for j in range(len(paramlinks.keys())): key = paramlinks.keys()[j] if (paramlinks[key][2].IsChecked()): tempparam[key] = fit_params[k] k += 1 elif (Main == True and self.use_individual_fit_params[key].GetValue()): tempparam[key] = list() for group in groups: tempparam[key].append( list( float(self.individualparamentrylinks[group] [key][1].GetValue()) * ones(len(Data.currentdata.x(groups=group))))) tempparam[key] = array(sum(tempparam[key], [])) else: try: tempparam[key] = consts[m] m += 1 except: pass tempparam["x"] = x tempparam.update(traits) #print "Fit Params: "+str(fit_params) #print "x values: "+str(x) #print "consts: "+str(consts) #print "traits: "+str(traits) #print "Results:" +str(self.Parent.Parent.model.func(x, tempparam, traits)) return self.Parent.Parent.model.func( tempparam, return_oofunvalue=return_oofunvalue, snle_style=snle_style) # Find Current Params params = OrderedDict() for param in paramlinks.keys(): params[param] = float(paramlinks[param][1].GetValue()) # Check for empty groups if groups == []: return False #from scipy.optimize import leastsq t = time() #results = fitting.solve('nlp:scipy_slsqp', iprint = 1) #results = fitting.solve('nlp:lincher', iprint = 1) print_level = 10 # Best so far if Data.constrained and Data.snle: #fitting = NLLSP( p0 = list() consts = list() ibounds = list() sp = OrderedDict() # Setup fitted params and consts for j in range(len(params.keys())): key = params.keys()[j] value = params.values()[j] if paramlinks[key][2].IsChecked(): try: point = oovar(size=len(value)) except TypeError: point = oovar() p0.append(point) sp[point] = value ibounds.append(Data.param_upper_bounds[key] > p0[-1] > Data.param_lower_bounds[key]) else: consts.append(array(value)) equations = [] startpoint = [] equations = errfunc(p0, y=Data.currentdata.y(groups=groups), yerr=Data.currentdata.yerr(groups=groups), consts=consts, traits=Data.currentdata.traits(groups=groups), x=Data.currentdata.x(groups=groups), groups=groups, snle_style=True) startpoint = equations[1] startpoint.update(sp) print startpoint fitting = SNLE( equations[0], startpoint, ftol=1e-10, ) equations[2].extend(ibounds) fitting.constraints = equations[2] #results = fitting.solve('nlp:ralg', iprint=print_level) results = fitting.solve('nssolve', iprint=print_level, maxIter=1e8) p1 = results.xf for key in p1: try: params[key] params[key] = p1[key] except: pass elif (not Data.constrained) and (not Data.snle): p0 = list() consts = list() ub = list() lb = list() # Setup fitted params and consts for j in range(len(params.keys())): key = params.keys()[j] value = params.values()[j] if paramlinks[key][2].IsChecked(): p0.append(array(value)) ub.append(Data.param_upper_bounds[key]) lb.append(Data.param_lower_bounds[key]) else: consts.append(array(value)) equations = partial( errfunc, y=Data.currentdata.y(groups=groups), yerr=Data.currentdata.yerr(groups=groups), consts=consts, traits=Data.currentdata.traits(groups=groups), x=Data.currentdata.x(groups=groups), groups=groups, snle_style=False, ) fitting = NLP( equations, p0, ) results = fitting.solve('scipy_leastsq', iprint=print_level, maxIter=1e8) p1 = results.xf i = 0 for j in range(len(params.keys())): key = params.keys()[j] if paramlinks[key][2].IsChecked(): params[key] = p1[i] i += 1 elif (Data.constrained) and (not Data.snle): p0 = list() consts = list() ub = list() lb = list() # Setup fitted params and consts for j in range(len(params.keys())): key = params.keys()[j] value = params.values()[j] if paramlinks[key][2].IsChecked(): p0.append(array(value)) ub.append(Data.param_upper_bounds[key]) lb.append(Data.param_lower_bounds[key]) else: consts.append(array(value)) fitting = NLP( partial( errfunc, y=Data.currentdata.y(groups=groups), yerr=Data.currentdata.yerr(groups=groups), consts=consts, traits=Data.currentdata.traits(groups=groups), x=Data.currentdata.x(groups=groups), groups=groups, snle_style=False, ), p0, ub=ub, lb=lb, ftol=1e-16, ) results = fitting.solve('ralg', iprint=print_level, maxIter=1e8) #results = fitting.solve('nssolve', iprint = print_level, maxIter = 1e8) p1 = results.xf i = 0 for j in range(len(params.keys())): key = params.keys()[j] if paramlinks[key][2].IsChecked(): params[key] = p1[i] i += 1 # Good if close #results = fitting.solve('nlp:scipy_cobyla', iprint = 1) #print('solution: '+str(results.xf)+'\n||residuals||^2 = '+str(results.ff)+'\nresiduals: ') if not Main: #print groups #print p1 #print Data.param_individual["3"].keys() #print Data.param try: i = 0 for key in params.keys(): if paramlinks[key][2].IsChecked(): Data.param_individual[groups][key] = p1[i] i += 1 except: print "More than one group was passed, when there should have been only one." #print Data.param_individual """ Cleanup and redraw """ for key in paramlinks.keys(): paramlinks[key][1].SetValue(str(params[key])) self.Parent.Parent.plotpanel.Update() self.xrange = Data.currentdata.x(groups=groups) currentfitvalues = fitfunc( p1, Data.currentdata.x(groups=groups), consts=consts, traits=Data.currentdata.traits(groups=groups), groups=groups) #ssr = sum((currentfitvalues - Data.currentdata.y(groups=groups)) ** 2) ssr = sum( map(lambda x: x**2, currentfitvalues - Data.currentdata.y(groups=groups))) / len(currentfitvalues) #print "SSR:" + str(ssr) Data.param = params ssrresult.SetLabel("SSR: " + str(ssr)) timeresult.SetLabel("Time Elapsed: %f" % (time() - t)) self.Parent.Parent.plotpanel.Update()