Surface NMR processing and inversion GUI
Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

rotate.py 11KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288
  1. # #################################################################################
  2. # # GJI final pub specs #
  3. # import matplotlib #
  4. # from matplotlib import rc #
  5. # matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath}"] #
  6. # rc('font',**{'family':'serif','serif':['timet']}) #
  7. # rc('font',**{'size':8}) #
  8. # rc('text', usetex=True) #
  9. # # converts pc that GJI is defined in to inches #
  10. # # In GJI \textwidth = 42pc #
  11. # # \columnwidth = 20pc #
  12. # def pc2in(pc): #
  13. # return pc*12/72.27 #
  14. # #################################################################################
  15. #from GJIPlot import *
  16. import numpy as np
  17. import matplotlib.pyplot as plt
  18. #from invertColours import *
  19. from akvo.tressel.decay import *
  20. from scipy import signal
  21. def quadrature(T, vL, wL, dt, xn, DT, t):
  22. # decimate
  23. # blind decimation
  24. # 1 instead of T
  25. irsamp = int(T) * int( (1./vL) / dt) # real
  26. iisamp = int( ((1./vL)/ dt) * ( .5*np.pi / (2.*np.pi) ) ) # imaginary
  27. dsamp = int( DT / dt) # real
  28. iisamp += dsamp
  29. ############################################################
  30. # simple quadrature-detection via sampling
  31. xr = xn[dsamp::irsamp]
  32. xi = xn[iisamp::irsamp]
  33. phase = np.angle( xr + 1j*xi )
  34. abse = np.abs( xr + 1j*xi )
  35. # times
  36. #ta = np.arange(0, TT, dt)
  37. #te = np.arange(DT, TT, TT/len(abse))
  38. #############################################################
  39. # hilbert transform
  40. ht = signal.hilbert(xn) #, 100))
  41. he = np.abs(ht) #, 100))
  42. hp = ((np.angle(ht[dsamp::irsamp])))
  43. #############################################################
  44. # Resample ht
  45. #htd = signal.decimate(he, 100, ftype='fir')
  46. #td = signal.decimate(t, 100, ftype='fir')
  47. #[htd, td] = signal.resample(he, 21, t)
  48. #toss first, and use every third
  49. #htd = htd[1::3]
  50. #td = td[1::3]
  51. #############################################################
  52. # Pre-envelope
  53. #gplus = xn + 1j*ht
  54. #############################################################
  55. # Complex envelope
  56. #gc = gplus / np.exp(1j*wL*t)
  57. #############################################################
  58. ## Design a low-pass filter
  59. FS = 1./dt # sampling rate
  60. FC = 10.05/(0.5*FS) # cutoff frequency at 0.05 Hz
  61. N = 11 # number of filter taps
  62. a = [1] # filter denominator
  63. b = signal.firwin(N, cutoff=FC, window='hamming') # filter numerator
  64. #############################################################
  65. ## In-phase
  66. #2*np.cos(wL*t)
  67. dw = 0 # -2.*np.pi*2
  68. Q = signal.filtfilt(b, a, xn*2*np.cos((wL+dw)*t)) # X
  69. I = signal.filtfilt(b, a, xn*2*np.sin((wL+dw)*t)) # Y
  70. ###############################################
  71. # Plots
  72. #plt.plot(ht.real)
  73. #plt.plot(ht.imag)
  74. #plt.plot(np.abs(ht))
  75. #plt.plot(gc.real)
  76. #plt.plot(gc.imag)
  77. #plt.plot(xn)
  78. #plt.plot(xn)
  79. #plt.plot(ta, xn)
  80. #plt.plot(te, abse, '-.', linewidth=2, markersize=10)
  81. #plt.plot(ta, he, '.', markersize=10 )
  82. #plt.plot(td, htd, color='green', linewidth=2)
  83. # Phase Plots
  84. #ax2 = plt.twinx()
  85. #ax2.plot(te, hp, '.', markersize=10, color='green' )
  86. #ax2.plot(te, phase, '-.', linewidth=2, markersize=10, color='green')
  87. return Q[N:-N], I[N:-N], t[N:-N]
  88. # #####################################################################
  89. # # regress raw signal
  90. #
  91. # #[peaks, times, ind] = peakPicker(xn, wL, dt)
  92. # #[a0,b0,rt20] = regressCurve(peaks, times) #,sigma2=1,intercept=True):
  93. #
  94. # dsamp = int( DT / dt) # real
  95. # # regress analytic signal
  96. # [a0,b0,rt20] = regressCurve(he[dsamp::], t[dsamp::], intercept=True) #,sigma2=1,intercept=True):
  97. # #[b0,rt20] = regressCurve(he[dsamp::], t[dsamp::], intercept=False) #,sigma2=1,intercept=True):
  98. # #[a0,b0,rt20] = regressCurve(he, t) #,sigma2=1,intercept=True):
  99. #
  100. # # regress downsampled
  101. # [a,b,rt2] = regressCurve(abse, t[dsamp::irsamp], intercept=True) #,sigma2=1,intercept=True):
  102. # #[b,rt2] = regressCurve(htd, td, intercept=False) #,sigma2=1,intercept=True):
  103. #
  104. # return irsamp, iisamp, htd, b0, rt20, ta, b, rt2, phase, td, he, dsamp
  105. # #return irsamp, iisamp, abse, a0, b0, rt20, times, a, b, rt2, phase
  106. def RotateAmplitude(X, Y, zeta, df, t):
  107. V = X + 1j*Y
  108. return np.abs(V) * np.exp( 1j * ( np.angle(V) - zeta - 2.*np.pi*df*t ) )
  109. #return np.abs(V) * np.exp( 1j * ( np.angle(V) - zeta - df*t ) )
  110. def bootstrapWindows(N, nboot, isum, adapt=False):
  111. """ Bootstraps noise as a function of gate width
  112. N = input noise signal
  113. nboot = number of boostrap windows to perform
  114. isum = length of windows (L_i)
  115. adapt = reduce nboot as window size increases
  116. """
  117. nc = np.shape(N)[0]
  118. Means = {}
  119. if adapt:
  120. Means = -9999*np.ones((len(isum), nboot//isum[0])) # dummy value
  121. for ii, nwin in enumerate(isum):
  122. for iboot in range(nboot//isum[ii]):
  123. cs = np.random.randint(0,nc-nwin)
  124. Means[ii,iboot] = np.mean( N[cs:cs+nwin] )
  125. Means = np.ma.masked_less(Means, -9995)
  126. else:
  127. Means = np.zeros((len(isum), nboot))
  128. for ii, nwin in enumerate(isum):
  129. for iboot in range(nboot):
  130. cs = np.random.randint(0,nc-nwin)
  131. Means[ii,iboot] = np.mean( N[cs:cs+nwin] )
  132. return Means, np.array(isum)
  133. def gateIntegrate(T2D, T2T, gpd, sigma, stackEfficiency=2.):
  134. """ Gate integrate the signal to gpd, gates per decade
  135. T2D = the time series to gate integrate, complex
  136. T2T = the abscissa values
  137. gpd = gates per decade
  138. sigma = estimate of standard deviation for theoretical gate noise
  139. stackEfficiency = exponential in theoretical gate noise, 2 represents ideal stacking
  140. """
  141. # use artificial time gates so that early times are fully captured
  142. T2T0 = T2T[0]
  143. T2TD = T2T[0] - (T2T[1]-T2T[0])
  144. T2T -= T2TD
  145. #####################################
  146. # calculate total number of decades #
  147. # windows edges are approximate until binning but will be adjusted to reflect data timing, this
  148. # primarily impacts bins with a few samples
  149. nd = np.log10(T2T[-1]/T2T[0])
  150. tdd = np.logspace( np.log10(T2T[0]), np.log10(T2T[-1]), (int)(gpd*nd)+1, base=10, endpoint=True)
  151. tdl = tdd[0:-1] # approximate window left edges
  152. tdr = tdd[1::] # approximate window right edges
  153. td = (tdl+tdr) / 2. # approximate window centres
  154. Vars = np.zeros( len(td) )
  155. htd = np.zeros( len(td), dtype=complex )
  156. isum = np.zeros( len(td), dtype=int )
  157. ii = 0
  158. for itd in range(len(T2T)):
  159. if ( round(T2T[itd], 4) > round(tdr[ii], 4) ):
  160. ii += 1
  161. # correct window edges to centre about data
  162. tdr[ii-1] = (T2T[itd-1]+T2T[itd])*.5
  163. tdl[ii ] = (T2T[itd-1]+T2T[itd])*.5
  164. isum[ii] += 1
  165. htd[ii] += T2D[ itd ]
  166. Vars[ii] += sigma**2
  167. td = (tdl+tdr) / 2. # actual window centres
  168. sigma2 = np.sqrt( Vars * ((1/(isum))**stackEfficiency) )
  169. # Reset abscissa where isum == 1
  170. # when there is no windowing going on
  171. td[isum==1] = T2T[0:len(td)][isum==1]
  172. tdd = np.append(tdl, tdr[-1])
  173. htd /= isum # average
  174. T2T += T2TD
  175. return td+T2TD, htd, tdd+T2TD, sigma2, isum # centre abscissa, data, window edges, error
  176. if __name__ == "__main__":
  177. dt = 1e-4
  178. TT = 1.5
  179. t = np.arange(0, TT, dt)
  180. vL = 2057.
  181. wL = 2.*np.pi*vL
  182. wL2 = 2.*np.pi*(vL-2.5) #-2) #-2.2) # 3 Hz off
  183. zeta = -np.pi/6. #4.234
  184. t2 = .150
  185. xs = np.exp(-t/t2) * np.cos(wL2*t + zeta)
  186. xe = np.exp(-t/t2)
  187. xn = xs + np.random.normal(0,.1,len(xs))# + (np.sign(xs)
  188. # np.random.random_integers(-1,1,len(xs))*0.6*np.random.lognormal(0, .35, len(xs)) + \
  189. # np.random.random_integers(-1,1,len(xs))*.004*np.random.weibull(.25, len(xs)), 60)))
  190. # quadrature detection downsampling
  191. T = 50 # sampling period, grab every T'th oscilation
  192. DT = .002 #85 # dead time ms
  193. #[irsamp, iisamp, abse, b0, rt20, times, b, rt2, phase, tdec, he, dsamp] = quadDetect(T, vL, wL, dt, xn, DT)
  194. [Q, I, tt] = quadrature(T, vL, wL, dt, xn, DT, t)
  195. [E0,df,phi,T2] = quadratureDetect(Q, I, tt)
  196. print("df", df)
  197. D = RotateAmplitude(I, Q, phi, df, tt)
  198. fig = plt.figure(figsize=[pc2in(20), pc2in(14)]) #
  199. ax1 = fig.add_axes([.125,.2,.8,.7])
  200. #ax1.plot(tt*1e3, np.exp(-tt/t2), linewidth=2, color='black', label="actual")
  201. ax1.plot(tt*1e3, D.imag, label="CA", color='red')
  202. ax1.plot(t*1e3, xn, color='blue', alpha=.25)
  203. ax1.plot(tt*1e3, I, label="inphase", color='blue')
  204. ax1.plot(tt*1e3, Q, label="quadrature", color='green')
  205. #ax1.plot(tt*1e3, np.angle( Q + 1j*I), label="angle", color='purple')
  206. GT, GD = gateIntegrate( D.imag, tt, 10 )
  207. GT, GDR = gateIntegrate( D.real, tt, 10 )
  208. GT, GQ = gateIntegrate( Q, tt, 10 )
  209. GT, GI = gateIntegrate( I, tt, 10 )
  210. #ax1.plot(tt*1e3, np.arctan( Q/I), label="angle", color='purple')
  211. #ax1.plot(GT*1e3, np.real(GD), 'o', label="GATE", color='purple')
  212. #ax1.plot(GT*1e3, np.real(GDR), 'o', label="GATE Real", color='red')
  213. #ax1.plot(GT*1e3, np.arctan( np.real(GQ)/np.real(GI)), 'o',label="GATE ANGLE", color='magenta')
  214. ax1.set_xlabel(r"time [ms]")
  215. ax1.set_ylim( [-1.25,1.65] )
  216. #light_grey = np.array([float(248)/float(255)]*3)
  217. legend = plt.legend( frameon=True, scatterpoints=1, numpoints=1, labelspacing=0.2 )
  218. #rect = legend.get_frame()
  219. fixLeg(legend)
  220. #rect.set_color('None')
  221. #rect.set_facecolor(light_grey)
  222. #rect.set_linewidth(0.0)
  223. #rect.set_alpha(0.5)
  224. # Remove top and right axes lines ("spines")
  225. spines_to_remove = ['top', 'right']
  226. for spine in spines_to_remove:
  227. ax1.spines[spine].set_visible(False)
  228. #ax1.xaxis.set_ticks_position('none')
  229. #ax1.yaxis.set_ticks_position('none')
  230. ax1.get_xaxis().tick_bottom()
  231. ax1.get_yaxis().tick_left()
  232. plt.savefig('rotatetime.pdf',dpi=600)
  233. plt.savefig('rotatetime.eps',dpi=600)
  234. # phase part
  235. plt.figure()
  236. plt.plot( tt*1e3, D.real, label="CA", color='red' )
  237. plt.show()
  238. exit()