113 lines
3.8 KiB
Python
113 lines
3.8 KiB
Python
# -*- encoding: utf-8 -*-
|
|
import matplotlib
|
|
import numpy as N
|
|
from scipy import optimize as opt, optimize, odr
|
|
#from QDS import mini_func, multi_hn
|
|
|
|
__author__ = 'markusro'
|
|
|
|
|
|
def fit_anneal(x, y, p0, fixed):
|
|
bounds = [(0, 1e14), (0, 1)]
|
|
for i in xrange(len(p0[2:]) / 4):
|
|
bounds.append((1e-4, 1e12)) # delta_eps
|
|
bounds.append((1e-12, 1e3)) # tau
|
|
bounds.append((0.1, 1)) # a
|
|
bounds.append((0.1, 1)) # b
|
|
ret = opt.anneal(mini_func, p0,
|
|
args=(x, y),
|
|
maxeval=20000,
|
|
maxiter=30000,
|
|
lower=[b[0] for b in bounds],
|
|
upper=[b[1] for b in bounds],
|
|
dwell=100,
|
|
full_output=1)
|
|
#pmin, func_min, final_Temp, cooling_iters,accepted_tests, retval
|
|
#retval : int
|
|
#Flag indicating stopping condition::
|
|
|
|
# 0 : Points no longer changing
|
|
# 1 : Cooled to final temperature
|
|
# 2 : Maximum function evaluations
|
|
# 3 : Maximum cooling iterations reached
|
|
# 4 : Maximum accepted query locations reached
|
|
# 5 : Final point not the minimum amongst encountered points
|
|
|
|
print "Stop reason", ret
|
|
return ret[0]
|
|
|
|
|
|
def fit_lbfgsb(x, y, p0, fixed):
|
|
# TODO fixed parameters…
|
|
bounds = [(0, None), (0, 1)]
|
|
for i in xrange(len(p0[3:]) / 4):
|
|
bounds.append((1e-4, 1e12)) # delta_eps
|
|
bounds.append((1e-12, 1e3)) # tau
|
|
bounds.append((0.1, 1)) # a
|
|
bounds.append((0.1, 1)) # b
|
|
|
|
x, f_minvalue, info_dict = opt.fmin_l_bfgs_b(mini_func, p0,
|
|
fprime=None,
|
|
args=(x, y),
|
|
approx_grad=True,
|
|
bounds=bounds,
|
|
iprint=0,
|
|
maxfun=4000)
|
|
if info_dict['warnflag'] != 0:
|
|
print info_dict["task"]
|
|
return x
|
|
|
|
|
|
def fit_odr(x, y, p0, fixed):
|
|
dat = odr.Data(x, y, 1.0 / y)
|
|
mod = odr.Model(multi_hn)
|
|
fit = odr.ODR(dat, mod, p0, ifixx=(0,), ifixb=fixed, maxit=2000)
|
|
fit.run()
|
|
return fit.output.beta
|
|
|
|
|
|
def hn(p, nu):
|
|
delta_eps, tau, a, b = p
|
|
om = 2 * N.pi * nu
|
|
Phi = N.arctan((om * tau) ** a * N.sin(N.pi * a / 2.) / (1. + (om * tau) ** a * N.cos(N.pi * a / 2.)))
|
|
e_loss = delta_eps * (1 + 2 * (om * tau) ** a * N.cos(N.pi * a / 2.) + (om * tau) ** (2. * a) ) ** (
|
|
-b / 2.) * N.sin(b * Phi)
|
|
e_stor = delta_eps * (1 + 2 * (om * tau) ** a * N.cos(N.pi * a / 2.) + (om * tau) ** (2. * a) ) ** (
|
|
-b / 2.) * N.cos(b * Phi)
|
|
return 2 * e_loss
|
|
|
|
|
|
def id_to_color(id):
|
|
"""
|
|
|
|
"""
|
|
colors = ['b', 'r', 'g', 'c', 'm', 'y', 'k']
|
|
conv = matplotlib.colors.ColorConverter()
|
|
return conv.to_rgb(colors[id % len(colors)])
|
|
|
|
|
|
def mini_func(p, x, y):
|
|
res = y - multi_hn(p, x)
|
|
# apply weights
|
|
res /= 1 / y
|
|
return N.sqrt(N.dot(res, res))
|
|
|
|
|
|
def multi_hn(p, nu):
|
|
conductivity = p[1]
|
|
cond_beta = p[2]
|
|
om = 2 * N.pi * nu
|
|
e_loss = conductivity / om ** cond_beta
|
|
e_loss += p[0]
|
|
#for key, igroup in groupby(p[3:], lambda x: x//4):
|
|
for i in xrange(len(p[3:]) / 4):
|
|
delta_eps, tau, a, b = p[3 + i * 4:3 + (i + 1) * 4]
|
|
#delta_eps, tau, a, b = list(igroup)
|
|
#print delta_eps,tau,a,b
|
|
#a = 0.5 *(1 + N.tanh(a))
|
|
#b = 0.5 *(1 + N.tanh(b))
|
|
Phi = N.arctan((om * tau) ** a * N.sin(N.pi * a / 2.) / (1. + (om * tau) ** a * N.cos(N.pi * a / 2.)))
|
|
e_loss += 2 * delta_eps * (1 + 2 * (om * tau) ** a * N.cos(N.pi * a / 2.) + (om * tau) ** (2. * a) ) ** (
|
|
-b / 2.) * N.sin(b * Phi)
|
|
#e_stor = delta_eps * (1+ 2*(om*tau)**a * N.cos(N.pi*a/2.) + (om*tau)**(2.*a) )**(-b/2.)*N.cos(b*Phi)
|
|
return e_loss |