| 1 |
''' |
| 2 |
expEYES data analysis library using numpy and scipy |
| 3 |
Author : Ajith Kumar B.P, [email protected] |
| 4 |
License : GNU GPL version 3 |
| 5 |
''' |
| 6 |
|
| 7 |
import sys, time, math |
| 8 |
from numpy import * |
| 9 |
import numpy.fft |
| 10 |
from scipy import optimize |
| 11 |
from scipy.optimize import leastsq |
| 12 |
import scipy.optimize as optimize |
| 13 |
|
| 14 |
|
| 15 |
def find_peak(va): |
| 16 |
vmax = 0.0 |
| 17 |
size = len(va) |
| 18 |
index = 0 |
| 19 |
for i in range(1,size): # skip first 2 channels, DC |
| 20 |
if va[i] > vmax: |
| 21 |
vmax = va[i] |
| 22 |
index = i |
| 23 |
return index |
| 24 |
|
| 25 |
#-------------------------- Fourier Transform ------------------------------------ |
| 26 |
def fft(ya, si): |
| 27 |
''' |
| 28 |
Returns positive half of the Fourier transform of the signal ya. |
| 29 |
Sampling interval 'si', in milliseconds |
| 30 |
''' |
| 31 |
np = len(ya) |
| 32 |
v = array(ya) |
| 33 |
tr = abs(numpy.fft.fft(v))/np |
| 34 |
frq = numpy.fft.fftfreq(np, si * 1.0e-3) |
| 35 |
# the arguments for reshape must be integers: enforcing |
| 36 |
# the integer division by two. |
| 37 |
x = frq.reshape(2,np//2) |
| 38 |
y = tr.reshape(2,np//2) |
| 39 |
return x[0], y[0] |
| 40 |
|
| 41 |
def find_frequency(x,y): # Returns the fundamental frequency using FFT |
| 42 |
tx,ty = fft(y, x[1]-x[0]) |
| 43 |
index = find_peak(ty) |
| 44 |
if index == 0: |
| 45 |
return None |
| 46 |
else: |
| 47 |
return tx[index] |
| 48 |
|
| 49 |
#-------------------------- Sine Fit ------------------------------------------------ |
| 50 |
def sine_erf(p,y,x): |
| 51 |
return y - p[0] * sin(2*pi*p[1]*x+p[2])+p[3] |
| 52 |
|
| 53 |
def sine_eval(x,p): # y = a * sin(2*pi*f*x + phi)+ offset |
| 54 |
return p[0] * sin(2*pi*p[1]*x+p[2])-p[3] |
| 55 |
|
| 56 |
def sineFunc(x, a1, a2, a3, a4): |
| 57 |
return a4 + a1*sin(abs(a2*(2*pi))*x + a3) |
| 58 |
|
| 59 |
def fit_sine(xa,ya, freq = 0): # Time in mS, V in volts, freq in Hz, accepts numpy arrays |
| 60 |
size = len(ya) |
| 61 |
mx = max(ya) |
| 62 |
mn = min(ya) |
| 63 |
amp = (mx-mn)/2 |
| 64 |
if freq == 0: # Guess frequency not given |
| 65 |
freq = find_frequency(xa,ya) |
| 66 |
if freq == None: |
| 67 |
return None |
| 68 |
#print 'guess a & freq = ', amp, freq |
| 69 |
par = [abs(amp), freq*0.001, 0.0, 0.0] # Amp, freq, phase , offset |
| 70 |
par, pcov = optimize.curve_fit(sineFunc, xa, ya, par) |
| 71 |
if par[0] < 0: # Negative amplitude ? |
| 72 |
par[0] *= -1 |
| 73 |
par[2] += pi |
| 74 |
yfit = sine_eval(xa, par) |
| 75 |
return yfit,par |
| 76 |
|
| 77 |
|
| 78 |
#--------------------------Damped Sine Fit ------------------------------------------------ |
| 79 |
def dsine_erf(p,y,x): |
| 80 |
return y - p[0] * sin(2*pi*p[1]*x+p[2]) * exp(-p[4]*x) + p[3] |
| 81 |
|
| 82 |
def dsine_eval(x,p): |
| 83 |
return p[0] * sin(2*pi*p[1]*x+p[2]) * exp(-p[4]*x) - p[3] |
| 84 |
|
| 85 |
def fit_dsine(xlist, ylist, freq = 0): |
| 86 |
size = len(xlist) |
| 87 |
xa = array(xlist, dtype=float) |
| 88 |
ya = array(ylist, dtype=float) |
| 89 |
amp = (max(ya)-min(ya))/2 |
| 90 |
if freq == 0: |
| 91 |
freq = find_frequency(xa,ya) |
| 92 |
par = [amp, freq*0.001, 0.0, 0.0, 0.1] # Amp, freq, phase , offset, decay constant |
| 93 |
plsq = leastsq(dsine_erf, par,args=(ya,xa)) |
| 94 |
if plsq[1] > 4: |
| 95 |
return None |
| 96 |
yfit = dsine_eval(xa, plsq[0]) |
| 97 |
return yfit,plsq[0] |
| 98 |
|
| 99 |
#-------------------------- Exponential Fit ---------------------------------------- |
| 100 |
def exp_erf(p,y,x): |
| 101 |
return y - p[0] * exp(p[1]*x) + p[2] |
| 102 |
|
| 103 |
def exp_eval(x,p): |
| 104 |
return p[0] * exp(p[1]*x) -p[2] |
| 105 |
|
| 106 |
def fit_exp(xlist, ylist): |
| 107 |
size = len(xlist) |
| 108 |
xa = array(xlist, dtype=float) |
| 109 |
ya = array(ylist, dtype=float) |
| 110 |
maxy = max(ya) |
| 111 |
halfmaxy = maxy / 2.0 |
| 112 |
halftime = 1.0 |
| 113 |
for k in range(size): |
| 114 |
if abs(ya[k] - halfmaxy) < halfmaxy/100: |
| 115 |
halftime = xa[k] |
| 116 |
break |
| 117 |
par = [maxy, -halftime,0] # Amp, decay, offset |
| 118 |
plsq = leastsq(exp_erf, par,args=(ya,xa)) |
| 119 |
if plsq[1] > 4: |
| 120 |
return None |
| 121 |
yfit = exp_eval(xa, plsq[0]) |
| 122 |
return yfit,plsq[0] |
| 123 |
|
| 124 |
#-------------------------- Exponential Fit #2---------------------------------------- |
| 125 |
|
| 126 |
def exp_func(x, a, b, c): |
| 127 |
return a * exp(-x/ b) + c |
| 128 |
|
| 129 |
def fit_exp2(t,v): # accepts numpy arrays |
| 130 |
size = len(t) |
| 131 |
v80 = v[0] * 0.8 |
| 132 |
for k in range(size-1): |
| 133 |
if v[k] < v80: |
| 134 |
rc = t[k]/.223 |
| 135 |
break |
| 136 |
pg = [v[0], rc, 0] |
| 137 |
po, err = optimize.curve_fit(exp_func, t, v, pg) |
| 138 |
if abs(err[0][0]) > 0.1: |
| 139 |
return None, None |
| 140 |
vf = po[0] * exp(-t/po[1]) + po[2] |
| 141 |
return po, vf |
| 142 |
|
| 143 |
|
| 144 |
#-------------------------- Gauss Fit ---------------------------------------- |
| 145 |
def gauss_erf(p,y,x):#height, mean, sigma |
| 146 |
return y - p[0] * exp(-(x-p[1])**2 /(2.0 * p[2]**2)) |
| 147 |
|
| 148 |
def gauss_eval(x,p): |
| 149 |
return p[0] * exp(-(x-p[1])**2 /(2.0 * p[2]**2)) |
| 150 |
|
| 151 |
def fit_gauss(xlist, ylist): |
| 152 |
size = len(xlist) |
| 153 |
xa = array(xlist, dtype=float) |
| 154 |
ya = array(ylist, dtype=float) |
| 155 |
maxy = max(ya) |
| 156 |
halfmaxy = maxy / 2.0 |
| 157 |
for k in range(size): |
| 158 |
if abs(ya[k] - maxy) < maxy/100: |
| 159 |
mean = xa[k] |
| 160 |
break |
| 161 |
for k in range(size): |
| 162 |
if abs(ya[k] - halfmaxy) < halfmaxy/10: |
| 163 |
halfmaxima = xa[k] |
| 164 |
break |
| 165 |
sigma = mean - halfmaxima |
| 166 |
par = [maxy, halfmaxima, sigma] # Amplitude, mean, sigma |
| 167 |
plsq = leastsq(gauss_erf, par,args=(ya,xa)) |
| 168 |
if plsq[1] > 4: |
| 169 |
return None |
| 170 |
yfit = gauss_eval(xa, plsq[0]) |
| 171 |
return yfit,plsq[0] |
| 172 |
|
| 173 |
#-------------------------- liniar Fit ------------------------------------------------ |
| 174 |
def line_erf(p,y,x): |
| 175 |
return y - p[0] * x - p[1] |
| 176 |
|
| 177 |
def line_eval(x,p): # y = a * x + b |
| 178 |
return p[0] * x + p[1] |
| 179 |
|
| 180 |
def fit_line(xlist,ylist): # Time in mS, V in volts |
| 181 |
size = len(xlist) |
| 182 |
xa = array(xlist, dtype=float) |
| 183 |
ya = array(ylist, dtype=float) |
| 184 |
par = [1,1] # m, c |
| 185 |
plsq = leastsq(line_erf, par,args=(ya,xa)) |
| 186 |
if plsq[1] > 4: |
| 187 |
return None |
| 188 |
yfit = line_eval(xa, plsq[0]) |
| 189 |
return yfit,plsq[0] |
| 190 |
|
| 191 |
#-------------------------- Quadratic Fit ---------------------------------------- |
| 192 |
def qdr_erf(p,y,x): |
| 193 |
return y - (p[0] * x**2 +p[1]*x + p[2]) # ax^2 + bx + c |
| 194 |
|
| 195 |
def qdr_eval(x,p): |
| 196 |
return p[0] * x**2 +p[1]*x + p[2] |
| 197 |
|
| 198 |
def fit_qdr(xlist, ylist): |
| 199 |
size = len(xlist) |
| 200 |
xa = array(xlist, dtype=float) |
| 201 |
ya = array(ylist, dtype=float) |
| 202 |
par = [1, 1, 1] # a,b,c |
| 203 |
plsq = leastsq(qdr_erf, par,args=(ya,xa)) |
| 204 |
if plsq[1] > 4: |
| 205 |
return None |
| 206 |
yfit = qdr_eval(xa, plsq[0]) |
| 207 |
return yfit,plsq[0] |
| 208 |
|