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()
