Debian Codegraph @

eyesjunior/eyesjun/eyemath.py

raw
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