Initial commit

GUI/MatplotlibWidget.py

@@ -0,0 +1,93 @@
+####################################################
+# Adopted from pyqtgraph (MIT license)
+#from pyqtgraph.Qt import QtGui, QtCore, USE_PYSIDE
+USE_PYSIDE = True 
+
+import matplotlib
+matplotlib.use('Qt4Agg')
+#matplotlib.rcParams['backend.qt4']='PySide'
+
+if USE_PYSIDE == True: 
+    matplotlib.rcParams['backend.qt4']='PySide'
+    from PySide import QtCore, QtGui
+else:
+    from PyQt4 import QtCore, QtGui
+
+
+from matplotlib import rc                                                          #
+#matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath,amssymb}"] #
+#rc('font',**{'family':'serif','serif':['timet']})   
+rc('font',**{'size':8})                                                            #
+#rc('text', usetex=True)  
+
+from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.backends.backend_qt4agg import NavigationToolbar2QT as NavigationToolbar
+from matplotlib.figure import Figure
+
+class MatplotlibWidget(QtGui.QWidget):
+    """
+    Implements a Matplotlib figure inside a QWidget.
+    Use getFigure() and redraw() to interact with matplotlib.
+    
+    Example::
+    
+        mw = MatplotlibWidget()
+        subplot = mw.getFigure().add_subplot(111)
+        subplot.plot(x,y)
+        mw.draw()
+    """
+    
+    def __init__(self, parent=None, size=(5.0, 4.0), dpi=100):
+        # thingy is the designer designated parent, layout manager, etc.
+        self.size = size
+        self.dpi = dpi
+ 
+        #QtGui.QWidget.__init__(self, thingy) 
+        #super(thingy, self).__init__( MatplotlibWidget )
+        #super(MatplotlibWidget, self).__init__( self, parent )
+        super(MatplotlibWidget, self).__init__(parent)
+
+        self.fig = Figure(size, dpi=dpi)
+        self.canvas = FigureCanvas(self.fig)
+        self.canvas.setParent(self)
+        self.toolbar = NavigationToolbar(self.canvas, self)
+        
+        self.vbox = QtGui.QVBoxLayout()
+        self.vbox.addWidget(self.toolbar)
+        self.vbox.addWidget(self.canvas)
+        
+        self.setLayout(self.vbox)
+
+    def Clear(self):
+
+        for ax in self.fig.axes:
+            ax.cla()
+            #ax.draw()
+            self.fig.delaxes(ax)
+        
+        self.canvas.draw()
+       
+        #print ("axes", self.fig.axes)
+ 
+#         del self.fig
+#         del self.canvas
+#         del self.toolbar
+#         del self.vbox
+# 
+#         self.fig = Figure((3,4), dpi=self.dpi)
+#         self.canvas = FigureCanvas(self.fig)
+#         self.canvas.setParent(self)
+#         self.toolbar = NavigationToolbar(self.canvas, self)
+#         
+#         self.vbox = QtGui.QVBoxLayout()
+#         self.vbox.addWidget(self.toolbar)
+#         self.vbox.addWidget(self.canvas)
+        
+        #self.setLayout(self.vbox)
+        
+
+    def getFigure(self):
+        return self.fig
+        
+    def draw(self):
+        self.canvas.draw()

GUI/borehole.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'borehole.ui'
+#
+# Created: Sat Jun 14 21:58:30 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName(_fromUtf8("MainWindow"))
+        MainWindow.resize(818, 682)
+        self.centralwidget = QtGui.QWidget(MainWindow)
+        self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
+        MainWindow.setCentralWidget(self.centralwidget)
+        self.menubar = QtGui.QMenuBar(MainWindow)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 818, 19))
+        self.menubar.setObjectName(_fromUtf8("menubar"))
+        self.menuFile = QtGui.QMenu(self.menubar)
+        self.menuFile.setObjectName(_fromUtf8("menuFile"))
+        self.menuEdit = QtGui.QMenu(self.menubar)
+        self.menuEdit.setObjectName(_fromUtf8("menuEdit"))
+        self.menuHelp = QtGui.QMenu(self.menubar)
+        self.menuHelp.setObjectName(_fromUtf8("menuHelp"))
+        MainWindow.setMenuBar(self.menubar)
+        self.statusbar = QtGui.QStatusBar(MainWindow)
+        self.statusbar.setObjectName(_fromUtf8("statusbar"))
+        MainWindow.setStatusBar(self.statusbar)
+        self.actionLoad = QtGui.QAction(MainWindow)
+        self.actionLoad.setObjectName(_fromUtf8("actionLoad"))
+        self.action_Load_Dataset = QtGui.QAction(MainWindow)
+        self.action_Load_Dataset.setObjectName(_fromUtf8("action_Load_Dataset"))
+        self.action_Close = QtGui.QAction(MainWindow)
+        self.action_Close.setObjectName(_fromUtf8("action_Close"))
+        self.action_Quit = QtGui.QAction(MainWindow)
+        self.action_Quit.setObjectName(_fromUtf8("action_Quit"))
+        self.menuFile.addAction(self.actionLoad)
+        self.menuFile.addAction(self.action_Load_Dataset)
+        self.menuFile.addSeparator()
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.action_Quit)
+        self.menubar.addAction(self.menuFile.menuAction())
+        self.menubar.addAction(self.menuEdit.menuAction())
+        self.menubar.addAction(self.menuHelp.menuAction())
+
+        self.retranslateUi(MainWindow)
+        QtCore.QObject.connect(self.action_Quit, QtCore.SIGNAL(_fromUtf8("activated()")), MainWindow.close)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+    def retranslateUi(self, MainWindow):
+        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
+        self.menuFile.setTitle(_translate("MainWindow", "File", None))
+        self.menuEdit.setTitle(_translate("MainWindow", "Edit", None))
+        self.menuHelp.setTitle(_translate("MainWindow", "Help", None))
+        self.actionLoad.setText(_translate("MainWindow", "&Open record", None))
+        self.action_Load_Dataset.setText(_translate("MainWindow", "&Load Dataset", None))
+        self.action_Close.setText(_translate("MainWindow", "&Close", None))
+        self.action_Quit.setText(_translate("MainWindow", "&Quit", None))
+

GUI/quad_corr.py

@@ -0,0 +1,791 @@
+# import matplotlib as mpl
+# mpl.use("pgf")
+# pgf_with_pdflatex = {
+#     "pgf.texsystem": "pdflatex",
+#     "pgf.preamble": [
+#          r"\usepackage{amsmath}",
+#          r"\usepackage{amssymb}",
+#          r"\usepackage{timet}",
+#          ]
+# }
+#          #r"\usepackage[utf8x]{inputenc}",
+#          #r"\usepackage[T1]{fontenc}",
+#          #r"\usepackage{cmbright}",
+# mpl.rcParams.update(pgf_with_pdflatex)
+# 
+# from matplotlib import rc
+# rc('font',**{'family':'serif','serif':['times']})
+# ## for Palatino and other serif fonts use:
+# #rc('font',**{'family':'serif','serif':['Palatino']})
+# #rc('text', usetex=True)
+
+#import matplotlib
+#from matplotlib import rc
+
+#matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath}"]
+#rc('font',**{'family':'serif','serif':['timet']})
+#rc('text', usetex=True)
+from GJIPlot import *
+
+import numpy as np
+import matplotlib.pyplot as plt
+from smooth import smooth
+#from invertColours import *
+from decay import *
+from scipy import signal
+from notch import * 
+import rotate # why is it called loss?
+
+BLACK = False
+labs = 16
+
+if BLACK:
+    labcol = 'white'
+else:
+    labcol = 'black'
+
+def Kw(a, phi2, s, rT2, wL): 
+    return  a*((np.sin(phi2)*s + ((1/rT2)*np.sin(phi2)) + wL*np.cos(phi2) ) / (wL**2+(s+1/rT2)**2 ))
+
+
+def quadDetect(T, vL, wL, dt, xn, DT):
+    # decimate
+    # blind decimation
+    # 1 instead of T 
+    irsamp = (T) * int(  (1./vL) / dt) # real 
+    iisamp =       int(  ((1./vL)/ dt) * ( .5*np.pi / (2.*np.pi) ) ) # imaginary
+   
+
+    dsamp =  int( DT / dt) # real 
+
+    iisamp += dsamp
+
+    ############################################################
+    # simple quadrature-detection via sampling
+    xr = xn[dsamp::irsamp]
+    xi = xn[iisamp::irsamp]
+    phase = np.angle( xr + 1j*xi )
+    abse = np.abs( xr + 1j*xi )
+
+    # times
+    ta = np.arange(0, TT, dt)
+    te = np.arange(DT, TT, TT/len(abse))
+
+    #############################################################
+    # hilbert transform
+    ht = signal.hilbert(xn) #, 100))
+    he = np.abs(ht)         #, 100))
+    he = ht*np.exp( -1j*wL*t )  # ht*e^{-jwLt}  # phase envelope
+
+    #hp = ((np.angle(ht[dsamp::irsamp]))) 
+    #[Q, I, tt] = rotate.quadrature(T, vL, wL, dt, xn, DT, t)
+    [E0,df,phi,T2] = quadratureDetect(np.imag(he), np.real(he), t)
+    D = rotate.RotateAmplitude(np.real(he), np.imag(he), phi, df, t)
+    he = D.imag 
+    #print ("df", df, "phi", phi)
+    """
+    plt.plot(xn)
+    plt.plot(np.real(he))
+    plt.plot(np.imag(he))
+    plt.plot(D.imag)
+    plt.plot(D.real)
+    print ("phi", phi)
+    plt.plot( np.unwrap(np.arctan(np.unwrap(np.angle( he ) + np.pi/2 ))) )
+#    plt.plot(np.imag(ht))
+#    plt.plot(xn)
+
+    # plot FFT
+
+    XN  = np.fft.rfft(xn)
+    plt.figure()
+    plt.plot(XN.real, label='orig')
+    #XNN = XN * np.exp(1j*phi-1.)
+    """
+
+    """
+    phi = np.arange(-np.pi, np.pi, .001)
+    best = 1e12
+    bestPhi = 0
+    for p in phi:
+        XNN = XN * np.exp(1j*p)
+        if ( (np.linalg.norm( XNN.real[XNN.real < 0] )) < best):
+            best = np.linalg.norm( XNN.real[XNN.real < 0])
+            bestPhi = p
+        #print (len( XNN.real[XNN.real < 0] ))
+        #best = min(best, -( np.sum(XNN.real[XNN.real < 0]) ))
+        #print (XNN[XNN.real < 0]) 
+        #plt.plot(XNN.real[XNN.real<0])
+    print ("best", best, bestPhi)
+    XNN = XN * np.exp(1j*bestPhi)
+    """
+   
+    """ 
+    plt.plot(XNN.real, label='phased')
+    plt.plot(XNN.imag, label='imag')
+    plt.legend()
+    plt.figure()
+    plt.plot(np.angle(XN))
+    plt.plot(np.angle(XNN))
+    plt.show()
+    exit()
+    """
+
+    #############################################################
+    # Resample ht, no gate integrate
+    """
+    htd = signal.decimate(he, 100, ftype='fir') 
+    td = signal.decimate(t, 100, ftype='fir')
+    #[htd, td] = signal.resample(he, 21, t) 
+    #toss first, and use every third 
+    htd = htd[1::5]
+    td = td[1::5]
+    """
+
+    #############################################################
+    # Resample ht and gate integrate to 20 gates per decate
+    GPD = 20 # Gates per decade
+    GI = 15  # initial 15 times are just used
+
+    # first just resample to 20 Gates per decade
+    #nrs = (np.log(t[-1]) - np.log10(t[0]))
+    tdd = np.logspace( np.log10(16*dt), np.log10(t[-1]), 80-GI, base=10, endpoint=True) 
+    tdl = tdd[0:-1]    # these are left edges
+    tdr = tdd[1::]    # these are left edges
+    td = (tdl+tdr) / 2.
+    
+    # Just use the first 20 datapoints
+    td = np.concatenate( ([t[0:GI] ,  td]) )
+
+    htd = np.zeros( len(td) )
+    #htd[0:15] = he[0:15]
+    htd[0:GI] = he[0:GI]
+
+    ii = 15
+    isum = np.zeros( len(td) )
+    Vars = np.ones( len(td) ) * .15**2
+    isum [0:15] = 1
+    #Vars [0:15] = .15**2  # variance 
+    #var = .15**2
+    for itd in range(GI, len(he)):
+        #print (itd)   
+        if ( t[itd] > tdr[ii-GI] ):
+            ii += 1
+        isum[ii] += 1
+        htd[ii] += he[ itd ]
+        Vars[ii] += .15**2
+    htd /= isum
+    #Vars = ( Vars) / isum
+    Stds = np.sqrt( Vars) / isum
+    Vars = Stds**2 
+    #plt.figure()
+    #plt.gca().errorbar(  td, htd, fmt='o', yerr=Vars )
+    #plt.gca().set_xscale('log', basex=10)
+    
+    #    htd = he[itd] # (int)(dt*itd) ]
+    #td = []
+    # OK, so tdd are the desired time gates, but we might not be able to satisfy all of them
+
+        
+
+    #htdt = signal.decimate(he, 10, ftype='fir') 
+    ##tdt = signal.decimate(t, 10, ftype='fir')
+    #tdt = t[::10]
+    #[htd, td] = signal.resample(he, 21, t) 
+    
+    ##toss first, and use every third 
+    #htd = [] # htdt[1::5]
+    #td = tdt[1::15]
+    #for ix in np.arange(1,len(htdt),15):
+    #    if ix>15 and ix<len(htdt)-15:
+    #        htd.append( np.mean(htdt[ix-7:ix+8]) ) # stupid could do recursive but who gives a shit
+    #    else:
+    #        htd.append( htdt[ix] ) # stupid could do recursive but who gives a shit
+    
+    ###############################################
+    # Plots
+    #plt.plot(ta, xn)
+    #plt.plot(te, abse, '-.', linewidth=2, markersize=10)
+    #plt.plot(ta, he, '.', markersize=10 )
+    #plt.plot(td, htd, color='green', linewidth=2)
+    # Phase Plots
+    #ax2 = plt.twinx()
+    #ax2.plot(te, hp, '.', markersize=10, color='green' )
+    #ax2.plot(te, phase, '-.', linewidth=2, markersize=10, color='green')
+    #plt.show()
+    #exit()
+
+    #####################################################################
+    # regress raw signal
+    
+    #[peaks, times, ind] = peakPicker(xn, wL, dt)
+    #[a0,b0,rt20] =  regressCurve(peaks,  times) #,sigma2=1,intercept=True):
+    #plt.figure()
+    #plt.plot(Vars)
+    #plt.show()
+    #exit()
+
+    
+    dsamp = 1 # int( DT / dt) # real 
+    # regress analytic signal
+    [b0,rt20] =  regressCurve(he,  t, intercept=False) #, sigma2=(1./Stds)/np.max(1/Stds)) #,sigma2=1,intercept=True):
+    #[a0,b0,rt20] =  regressCurve(he,  t, intercept=True, sigma2=(1./Vars)/np.max(1/Vars)) #,sigma2=1,intercept=True):
+    #[b0,rt20] =  regressCurve(he[dsamp::],  t[dsamp::], intercept=False) #,sigma2=1,intercept=True):
+    #[a0,b0,rt20] =  regressCurve(he,  t) #,sigma2=1,intercept=True):
+   
+    # regress downsampled 
+    #[a,b,rt2] =  regressCurve(abse,  t[dsamp::irsamp], intercept=True) #,sigma2=1,intercept=True):
+    [b,rt2] =  regressCurve(htd,  td, intercept=False,  sigma2=(1./Stds)/np.max(1/Stds) ) #,sigma2=1,intercept=True):
+    
+    return irsamp, iisamp, htd, b0, rt20, ta, b, rt2, phi, td, he, Stds
+    #return irsamp, iisamp, abse, a0, b0, rt20, times, a, b, rt2, phase
+
+if __name__ == "__main__":
+    
+    dt = 1e-4
+    TT = 1.5
+    t = np.arange(0, TT, dt)
+    vL = 2000.
+    wL = 2.*np.pi*vL
+    wL2 = 2.*np.pi*(vL+10 ) # 3 Hz off 
+    zeta = -np.pi/2 # .0 #np.pi/2.21
+    t2 = .050
+
+    # TODO, show boxplots of error of regressions parameters, and randomly sample T2 and Vn0 for realistic parameters. 
+    # do a lot of random realizations.   
+
+    N = 5000
+    T2 =  [.03, .075, .125, .2, .250] # <=== Final 
+    #T2 =  [.3]
+    NT2 = len(T2)
+    RALL = np.zeros((N, NT2))
+    RDEC = np.zeros((N, NT2))
+    BALL = np.zeros((N, NT2))
+    BDEC = np.zeros((N, NT2))
+    RF = np.zeros((N, NT2))
+    AF = np.zeros((N, NT2))
+    RM = np.zeros((N, NT2))
+    AM = np.zeros((N, NT2))
+    RFC = np.zeros((N, NT2))
+    AFC = np.zeros((N, NT2))
+    
+    sT2 = [str(int(1e3*i)) for i in T2]
+    it2 = 0 
+    for t2 in T2:
+        print(("simulating", t2))
+
+
+        xe = np.exp(-t/t2)    
+ 
+        for it in range(N):
+        
+            zeta = (np.random.rand() - .5) #np.random.rand()
+            #print ("zeta", zeta)
+            # TODO, right here do distribution of phases  
+            xs = np.exp(-t/t2) * np.sin(wL*t + numpy.pi*zeta)  #\
+              # + np.exp(-t/t2) * np.sin(wL*t  ) 
+            
+            # pretty low, highly-correlated noise
+            #xn =  ( (smooth(np.random.normal(0,.4,len(xs)) + \
+            #    np.random.random_integers(-1,1,len(xs))*0.5*np.random.lognormal(0, .25, len(xs)) + \
+            #    np.random.random_integers(-1,1,len(xs))*.0002*np.random.weibull(.25, len(xs)), 60)))
+            #xn += np.random.normal( 0, .02,len(xs) ) 
+            #print(np.std(xn))
+
+            xc = np.random.normal(0,.01,len(xs))  + (np.sign(xs) *  (smooth(np.random.normal(0,.25,len(xs)+160) + \
+                np.random.random_integers(-1,1,len(xs)+160)*0.15*np.random.lognormal(0, .25, len(xs)+160) + \
+                np.random.random_integers(-1,1,len(xs)+160)*.0002*np.random.weibull(.25, len(xs)+160), 80))[80:-80] )           
+            
+            #print(np.std(xc))
+            
+            xn = xs + xc 
+
+
+            #xn += xs            
+
+            #nn = np.random.normal( 0, .15,len(xs) ) 
+            #xn = xs + nn # np.random.normal(0,.15,len(xs)) 
+            
+            #xn = xs + (np.sign(xs) *  np.absolute(smooth(np.random.normal(0,.5,len(xs))) )) #+ \
+                #np.random.random_integers(-1,1,len(xs))*0.6*np.random.lognormal(0, .35, len(xs)) + \
+                #np.random.random_integers(-1,1,len(xs))*.004*np.random.weibull(.25, len(xs)), 60)))
+
+
+            ###################################################################
+            # Bandpass filter, concatenate the two and run both directions
+            #xraw = xn
+            #plt.plot(xn)
+            
+            #xf = notch( xn[::-1], .925, 2000., dt )            
+            #xn = (xn[::-1]-xf)[::-1]
+            
+            #xf = notch( xn[::-1], .9, 2000., dt )            
+            #xn = (xn[::-1]-xf)[::-1]
+
+            """ 
+            print("sigma xf", np.std(xf))
+            print("sigma nn", np.std(nn))
+            print("sigma xn", np.std(xn[-100::]))
+            #plt.plot(xraw)
+            plt.plot(xn)
+            plt.plot(xs)
+            #plt.plot(xf)
+            #plt.plot(xn[::-1]-xf)
+            plt.show()
+            exit()
+            """
+
+            # quadrature detection downsampling
+            T = 50    # sampling period, grab every T'th oscilation
+            DT = 0. #.002 #85  # dead time ms
+            [irsamp, iisamp, abse, b0, rt20, times, b, rt2, phase, tdec, he, Stds] = quadDetect(T, vL, wL, dt, xn, DT)
+            RALL[it, it2] = 1e2 * ((rt20-t2)/t2)
+            BALL[it, it2] = 1e2*(b0 -1.)
+            BDEC[it, it2] = 1e2*(b - 1.)
+            RDEC[it, it2] = 1e2 * ((rt2-t2)/t2)
+
+            # Fourier domain fitting
+            dsamp = int( DT / dt) # real 
+            #X = np.fft.rfft(xn[dsamp::]) #* dt
+            #V = np.fft.fftfreq(len(xn[dsamp::]), dt)
+            X = np.fft.rfft(xn) #* dt
+            V = np.fft.fftfreq(len(xn), dt)
+
+            #V[len(X)-1] *= -1.
+            w = V * 2.*np.pi
+ 
+            # Just do a window
+            nf = 50 # 150 =  200 Hz window
+            ws = np.abs(w[0:len(X)])
+            vs = ws/(2.*np.pi)
+            iL =  vL / vs[1]
+
+            # Do complex fit 
+            [af, bf] = regressModulus(ws[iL-nf:iL+nf] , wL, dt*X[iL-nf:iL+nf] )
+            AM[it, it2] =  1e2*(af - 1.) # backwards extrapolate
+            RM[it, it2] = 1e2 * ((bf-t2)/t2)
+
+            try:
+                [af, bf, nb] = regressSpecComplex(ws[iL-nf:iL+nf], wL, dt*X[iL-nf:iL+nf], known=False)
+            except:
+                print("munged FD regression")
+                af = 0
+                bf=10.
+                nb = 0
+    
+            cr = Kw(af, nb, 1j*ws[iL-nf:iL+nf], bf, wL) 
+            
+            AFC[it, it2] =  1e2*(af - 1.) # backwards extrapolate
+            afe = af #  (af * np.exp(DT/bf)) #, af # backwards extrapolate
+            RFC[it, it2] = 1e2 * ((bf-t2)/t2)
+            """
+            # rotate phase
+            phi = np.arange(0, 2.*np.pi, .001)
+            best = 1e12
+            bestPhi = 0
+            for p in phi:
+                XNN = X * np.exp(1j*p)
+                if ( (np.linalg.norm( XNN.real[XNN.real < 0] )) < best):
+                    best = np.linalg.norm( XNN.real[XNN.real < 0])
+                    bestPhi = p
+            nb2 = bestPhi
+            nb3 = nb
+            """
+            #print ("nb", nb, "zeta", zeta*pi, "nb2", nb2, np.pi/2-zeta*pi)
+            Xc = X[iL-nf:iL+nf]
+            
+            #X = (X * np.exp(1j*(np.pi/2-zeta*pi) )).real # Correct
+            X = (X * np.exp(1j*(np.pi/2-nb) )).real
+            X = X[iL-nf:iL+nf]
+            #print (phase, bestPhi, phase-bestPhi) 
+            #plt.plot(ws, np.abs(X))
+            #plt.show()
+            #exit()           
+
+            #[a, b] = regressSpec(w[0:len(X)], wL, dt*X)
+            #[af, bf, nb] = regressSpecComplex(ws[iL-nf:iL+nf], wL, dt*X[iL-nf:iL+nf])
+            #[af, bf, nb] = regressSpec(ws[iL-nf:iL+nf], wL, dt*X[iL-nf:iL+nf])
+            [af, bf, nb] = regressSpec(ws[iL-nf:iL+nf], wL, dt*X)
+            #AF[it, it2] =  af  - 1.
+            #AF[it, it2] =  1e2*(af * np.exp(DT/bf)  - 1.) # backwards extrapolate
+            AF[it, it2] =  1e2*(af - 1.) # backwards extrapolate
+            afe = af #  (af * np.exp(DT/bf)) #, af # backwards extrapolate
+            RF[it, it2] = 1e2 * ((bf-t2)/t2)
+            
+#             print af, bf, nb
+# 
+#             plt.figure()
+#             plt.plot(xn)           
+# 
+#             plt.figure() 
+#             plt.plot(V[0:len(X)], dt * np.abs(X), label='mod')
+#             xp = af* np.abs( wL / (wL**2 + (-1j*ws[iL-nf:iL+nf]  + 1./bf)**2 ) )
+#             xpc =  np.abs( wL / (wL**2 + (-1j*ws[iL-nf:iL+nf]  + 1./t2)**2 ) )
+#             #plt.plot(vs[iL-50:iL+50], dt*np.real(X[iL-50:iL+50]))
+#             #plt.plot(vs[iL-50:iL+50], dt*np.imag(X[iL-50:iL+50]))
+#             plt.plot(vs[iL-nf:iL+nf], xp, label='predicted')
+#             plt.plot(vs[iL-nf:iL+nf], xpc, label='actual')
+#             plt.legend()
+
+        it2 += 1
+
+    # a little plot
+    if BLACK:
+        quadfig = plt.figure(0, facecolor='black', figsize=[pc2in(20), pc2in(32)])
+    else: 
+        quadfig = plt.figure(0, figsize=[ pc2in(20), pc2in(32) ])
+    qa = quadfig.add_axes([.1, .6, .8,  .375])
+
+    if BLACK:
+        qa.plot(1e3*t, xn, label = 'noisy signal', color='yellow')
+        invertColours(qa)
+    else:
+        qa.plot(1e3*t, xn, color='blue', alpha=.25)
+        #qa.plot(t, xn, label = 'noisy signal', color='blue')
+
+    #fa.plot(X, V)
+
+
+    #plt.plot(t[::irsamp], xn[::irsamp], '.-', marker = 'b', markersize=18, label='real envelope')
+    #plt.plot(t[iisamp::irsamp], xn[iisamp::irsamp], '.-', marker = 'imaginary envelope', markersize=18, label='imaginary envelope')
+    deSpine(plt.gca())
+
+    if BLACK:
+        l2 = plt.plot(1e3*times, he, color='red', label='CA')
+        l1 = plt.plot(1e3*tdec, abse, '.', color='green', markersize=12, label='time gates')
+        leg = plt.legend( frameon=False, scatterpoints=1, labelspacing=0.2, numpoints=1 )
+        invertLegend(leg)
+    else:
+        l2 = qa.plot(1e3*times, he, color='red') #, label='CA')
+        #l1 = qa.plot(1e3*tdec, abse, 'o', color='green', markersize=4, label='time gates')
+
+        #leg = plt.legend( frameon=True, scatterpoints=1, numpoints=1, labelspacing=0.25 )
+        #rect = leg.get_frame()
+        #rect.set_facecolor(light_grey)
+        #rect.set_linewidth(0.0)
+        #rect.set_alpha(0.5)
+
+    #qa.set_xlabel("time [s]")
+    #qa.set_title("time-domain")
+    
+    # regress curve using all times
+    re0 = b0 * np.exp(-times/rt20)
+
+    # regress curve based on decimated data
+    irsamp = 1
+    re = b * np.exp(-t[::irsamp]/rt2)   
+        
+    qa.plot(1e3*t, xe, label = 'true envelope', linewidth=2, color='blue')
+    #qa.plot(1e3*t[::irsamp],re, linewidth=2, label='gated regression', color='green')
+    qa.plot(1e3*t[::irsamp],re, linewidth=1, color='green')
+    qa.plot(1e3*times,re0, '--',linewidth=1, label='CA regression', color='black')
+    l1 = qa.errorbar( 1e3*tdec, abse, yerr=Stds, fmt='o', color='green', markersize=3, label='time gates (1 $\sigma$ EB)')
+    qa.set_xscale('log', basex=10)
+        
+ 
+    leg = qa.legend(frameon=True, scatterpoints=1, numpoints=1, labelspacing=0.2)
+    fixLeg(leg)
+
+
+#       Frequency-domain axis, did not bring much information. So removed. 
+    #ff = plt.figure()
+    #fa = quadfig.add_axes([.1, .05,  .8, .25])
+    fa = quadfig.add_axes([.1, .1, .8, .375])
+ 
+    #ax2 = plt.gca().twinx()
+    #l2 = ax2.plot(t[iisamp::irsamp], phase, '.-', marker = 'imaginary envelope', markersize=18, label='phase')
+    #plt.legend([l1,l2])
+    #invertColours(qa)
+    
+    #fa.plot(V[0:len(X)], dt * np.abs(X), label='mod')
+
+    #fmla = robjects.Formula('XX ~ a*(.5/rT2)  / ((1./rT2)^2 + (w-wL)^2 )')
+    #xp = af * np.abs( wL / (wL**2 + (-1j*ws[iL-nf:iL+nf]  + 1./bf)**2 ) )
+    #xpc =     np.abs( wL / (wL**2 + (-1j*ws[iL-nf:iL+nf]  + 1./t2)**2 ) )
+
+
+
+    xp = af * ( (.5/bf) / (  ((1./bf)**2 + (ws[iL-nf:iL+nf]-wL)**2 ) ) )
+    xpc =     ( (.5/t2) / (  ((1./t2)**2 + (ws[iL-nf:iL+nf]-wL)**2 ) ) )
+    #print ("af", af) 
+    #plt.plot(vs[iL-50:iL+50], dt*np.real(X[iL-50:iL+50]))
+    #plt.plot(vs[iL-50:iL+50], dt*np.imag(X[iL-50:iL+50]))
+    #fa.plot(np.abs(V[0:len(X)]), dt * np.abs(X), color='red', linewidth=2, label='FT modulus')
+    fa.plot(vs[iL-nf:iL+nf], dt*X, color='red', linewidth=2, label='phased')
+    fa.plot(vs[iL-nf:iL+nf], xp, '--',linewidth=1, label='regressions', color='black')
+    #fa.plot(vs[iL-nf:iL+nf], dt*Xc.real, color='red', '--', linewidth=2, label='real')
+    fa.plot(vs[iL-nf:iL+nf], dt*Xc.real, '-', color='blue', linewidth=2, label=r'$\mathrm{Re}$ FFT ')
+    fa.plot(vs[iL-nf:iL+nf], dt*Xc.imag, '--', color='blue', dashes=(1.5,.75), linewidth=2, label=r'$\mathrm{Im}$ FFT')
+    
+    fa.plot(vs[iL-nf:iL+nf], cr.real, '--', color='black', linewidth=1) #, label=r'reg')
+    fa.plot(vs[iL-nf:iL+nf], cr.imag, '--', color='black', dashes=(1.5,.75), linewidth=1) #, label=r'reg')
+    #ax.plot(dead_freqs[0:ni], np.imag(WSINDP2[0:ni]), "--", dashes=(1.5,.75),  color='blue', linewidth=1, label=r"$\mathrm{Im} ( \mathrm{DP} )$")
+    #fa.plot(vs[iL-nf:iL+nf], xpc, linewidth=2, label='actual', color='blue')
+
+    leg = fa.legend(frameon=True, scatterpoints=1, numpoints=1, labelspacing=0.2)
+    fixLeg(leg)
+
+    fa.set_xlabel("frequency [Hz]")
+    #fa.set_title("frequency-domain")
+    fa.set_xlim([1950,2050])
+    #leg = plt.legend()
+
+    #rect = leg.get_frame()
+    #rect.set_facecolor(light_grey)
+    #rect.set_linewidth(0.0)
+    #rect.set_alpha(0.5)
+    
+    #ra = quadfig.add_axes([.1, .1,  .8, .25])
+    #vs = .0125
+    #ra = quadfig.add_axes([.1, .1-vs, .8, .375])
+    #ra.set_title("decay envelope regressions")
+
+    #plt.savefig('quadri.png',dpi=200, facecolor='black', edgecolor='black')
+
+    # real imaginary plot
+    #rfig = plt.figure(facecolor='black')
+    #ra = rfig.add_axes([.1,.1,.8,.8])
+    #ra.plot(t, xn, label = 'noisy signal', color='yellow')
+    #ra.plot(t[::irsamp], xn[::irsamp], '.-', marker = 's', markersize=10, label='real signal')
+    #ra.plot(t[iisamp::irsamp], xn[iisamp::irsamp], '.-', marker = 'v', markersize=10, label='imaginary envelope')
+    #ra.plot(tdec, abse, '.-', color='green', markersize=18, label='decimated modulus')
+    #ra.plot(t[iisamp::irsamp], phase, '.-', color='green', markersize=18, label='decimated phase')
+    #leg = plt.legend()
+    #invertLegend(leg)
+    #invertColours(ra)
+    #plt.savefig("quad2.png", dpi=200, facecolor='black', edgecolor='black')
+
+
+
+    plt.figure(0) 
+    deSpine(plt.gca())
+    if BLACK:
+        ra.plot(t[iisamp::irsamp],re, linewidth=2, label='decimated regression', color='green')
+        ra.plot(times,re0, linewidth=2, label='all data regression', color='cyan')
+        ra.plot(t, xe, label = 'true', linewidth=4, color='magenta')
+        ra.set_xlabel("time", fontsize=16, color='white')
+        leg = plt.legend( labelspacing=0.2, scatterpoints=1,frameon=False )
+        fixLeg(leg)
+        invertLegend(leg)
+        plt.savefig('noisytime.pdf',dpi=600, facecolor='black', edgecolor='black')
+    else:
+
+        #ra.plot(1e3*times, afe*np.exp(-times/bf), '-', color='purple', linewidth=2, label='FD modulus')
+        qa.set_xlabel("time [ms]") #, fontsize=16)
+        
+
+        #rect = leg.get_frame()
+        #rect.set_facecolor(light_grey)
+        #rect.set_linewidth(0.0)
+        #rect.set_alpha(0.5)
+        qa.set_ylim([-1.25,3.25])
+        plt.savefig('noisytime_corr.pdf',dpi=600)
+        plt.savefig('noisytime_corr.eps',dpi=600)
+
+    #plt.show()
+    #exit()
+    
+    #plt.savefig('quadreg.png',dpi=200, facecolor='black', edgecolor='black')
+
+    # Just show envelopes
+    #efig = plt.figure(facecolor='black')
+    #ea = efig.add_axes([.1,.1,.8,.8])
+    #ea.plot(t[iisamp::irsamp],re, linewidth=2, label='decimated regression', color='yellow')
+    #ea.plot(times,re0, linewidth=2, label='all data regression', color='cyan')
+    #ea.plot(t, xe, label = 'clean envelope', linewidth=2, color='magenta')
+    #leg = plt.legend()
+    #invertLegend(leg)
+    #invertColours(ea)
+    #plt.savefig("envelopes.png", dpi=200, edgecolor='black', facecolor='black')    
+
+    # boxplot
+    if BLACK:
+        boxfig = plt.figure( facecolor='black', edgecolor='black')
+    else:
+        boxfig = plt.figure( figsize=[pc2in(20), pc2in(32)] )
+    ##############
+    #  b2    r2  #
+    #  b1    r1  #
+    #  b0    r0  #
+    ##############
+    vs =  0 #-3*.0125
+    vs2 = 0 #-2*.0125
+
+    # Time domain    
+    b1 = boxfig.add_axes([.15,.075, .35, .15]) # bottom we want labels 
+    r1 = boxfig.add_axes([ .6,.075, .35, .15])
+    
+    b0 = boxfig.add_axes([.15,.25, .35, .15])
+    r0 = boxfig.add_axes([ .6,.25, .35, .15])
+    
+    # Frequency domain
+    b2 = boxfig.add_axes([.15,.425, .35, .15])
+    r2 = boxfig.add_axes([ .6,.425, .35, .15])
+    
+    b4 = boxfig.add_axes([.15,.6, .35, .15])
+    r4 = boxfig.add_axes([ .6,.6, .35, .15])
+    
+    b3 = boxfig.add_axes([.15,.775,  .35, .15])
+    r3 = boxfig.add_axes([ .6,.775,  .35, .15])
+    
+    for ax in [b1,r1,b0,r0,b2,r2,b3,r3,b4,r4]:
+        deSpine(ax)
+    
+    B0 = b0.boxplot( BALL , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(b0, 'xticklabels', [])
+    
+    R0 = r0.boxplot( RALL , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(r0, 'xticklabels', []) 
+    
+    B1 = b1.boxplot( BDEC , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(b1, 'xticklabels', sT2) 
+    
+    R1 = r1.boxplot( RDEC , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(r1, 'xticklabels', sT2) 
+    
+    B2 = b2.boxplot( AF , sym='', bootstrap=5000)# , notch=True )
+    R2 = r2.boxplot( RF , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(r2, 'xticklabels', []) 
+    plt.setp(b2, 'xticklabels', []) 
+    
+    B3 = b3.boxplot( AFC , sym='', bootstrap=5000)# , notch=True )
+    R3 = r3.boxplot( RFC , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(r3, 'xticklabels', []) 
+    plt.setp(b3, 'xticklabels', []) 
+    
+    B4 = b4.boxplot( AM , sym='', bootstrap=5000)# , notch=True )
+    R4 = r4.boxplot( RM , sym='', bootstrap=5000)# , notch=True )
+    plt.setp(r4, 'xticklabels', []) 
+    plt.setp(b4, 'xticklabels', []) 
+    
+    b1.set_xlabel(r"true $T_2^*$ [ms]", color=labcol) #, fontsize=12) 
+    r1.set_xlabel(r"true $T_2^*$ [ms]", color=labcol) #, fontsize=12) 
+    
+    b2.set_ylabel(r"phased FD", color=labcol) #, fontsize=12) 
+    b3.set_ylabel(r"complex FD", color=labcol) #, fontsize=12) 
+    b4.set_ylabel(r"modulus FD", color=labcol) #, fontsize=12) 
+    b0.set_ylabel(r"CA", color=labcol) #, fontsize=12) 
+    b1.set_ylabel(r"gated CA", color=labcol) #, fontsize=12) 
+    
+    #r0.set_ylabel(r"parameter estimate error") 
+    #b1.set_xlabel(r"$T_2^*$ decay parameter [ms]") 
+
+    if BLACK:
+        for box in [B0, R0, B1, R1]: 
+            box['boxes'][0].set_color('w')
+            box['boxes'][0].set_linewidth(2)
+            box['medians'][0].set_color('y')
+            box['medians'][0].set_linewidth(2)
+            box['fliers'][0].set_color('w')
+            box['fliers'][1].set_color('w')
+            box['whiskers'][0].set_color('w')
+            box['whiskers'][1].set_color('w')
+#     else:
+    #it2 = 0
+    #for ax in B0, r0, b1, r1: 
+        #for line in ax.xaxis.get_ticklabels():
+        #        print  line.get_text()
+        #        line.set_text(str(T2[it2]))
+        #        print  line.get_text()
+        #setp(gca(), 'xticklabels', ['first', 'second', 'third']) 
+                #line.set_fontsize(16)   
+     #   it2 += 1 
+#             box['boxes'][0].set_color('red')
+#             box['boxes'][0].set_linewidth(3)
+#             box['medians'][0].set_color('y')
+#             box['medians'][0].set_linewidth(3)
+#             box['fliers'][0].set_color('w')
+#             box['fliers'][1].set_color('w')
+#             box['whiskers'][0].set_color('w')
+#             box['whiskers'][1].set_color('w')
+        
+
+    #r0.set_title(r"analytic signal $T_2^*$", color=labcol)
+    #b0.set_title(r"analytic signal $V_N^{(0)}$", color=labcol)
+    r3.set_title(r"$\tilde{T}_2^*$ relative error [\%]", color=labcol) #, fontsize=12)
+    b3.set_title(r"$\tilde{V}_N^{(0)}$ absolute error [\%]", color=labcol) #, fontsize=12)
+
+    if BLACK:
+        invertColours(b0)
+        invertColours(r0)
+        invertColours(b1)
+        invertColours(r1)
+        #plt.savefig("boxplot.png", dpi=200, facecolor='black', edgecolor='black')
+    #else:
+    #plt.figure()
+    #plt.boxplot( BDEC, bootstrap=1000 )
+    #plt.title("dec")    
+        #plt.savefig("boxplot.png", dpi=200)
+
+    bylow = min(b0.get_ylim()[0], b1.get_ylim()[0])
+    bylow = min(bylow, b2.get_ylim()[0])
+    bylow = min(bylow, b3.get_ylim()[0])
+    bylow = min(bylow, b4.get_ylim()[0])
+
+    byhi = max(b0.get_ylim()[1], b1.get_ylim()[1])
+    byhi = max(byhi, b2.get_ylim()[1])
+    byhi = max(byhi, b3.get_ylim()[1])
+    byhi = max(byhi, b4.get_ylim()[1])
+    
+    rylow = min(r0.get_ylim()[0], r1.get_ylim()[0])
+    rylow = min(rylow, r2.get_ylim()[0])
+    rylow = min(rylow, r3.get_ylim()[0])
+    rylow = min(rylow, r4.get_ylim()[0])
+
+    ryhi = max(r0.get_ylim()[1], r1.get_ylim()[1])
+    ryhi = max(ryhi, r2.get_ylim()[1])
+    ryhi = max(ryhi, r3.get_ylim()[1])
+    ryhi = max(ryhi, r4.get_ylim()[1])
+ 
+    b0.set_ylim((bylow, byhi))
+    b1.set_ylim((bylow, byhi))
+    b2.set_ylim((bylow, byhi))
+    b3.set_ylim((bylow, byhi))
+    b4.set_ylim((bylow, byhi))
+    
+    r0.set_ylim((rylow, ryhi))
+    r1.set_ylim((rylow, ryhi))
+    r2.set_ylim((rylow, ryhi))
+    r3.set_ylim((rylow, ryhi))
+    r4.set_ylim((rylow, ryhi))
+
+    
+    if BLACK:
+        #plt.savefig("boxplotlim2.pdf", dpi=600, facecolor='black', edgecolor='black')
+        plt.savefig("boxplotlim_2.pdf", dpi=600, facecolor='black', edgecolor='black')
+        plt.savefig("boxplotlim_2.eps", dpi=600, facecolor='black', edgecolor='black')
+    else:
+        #plt.savefig("boxplotlim2.pdf", dpi=600)
+        plt.savefig("boxplotlim_2_corr.pdf", dpi=600)
+        plt.savefig("boxplotlim_2_corr.eps", dpi=600)
+        #plt.savefig("boxplotlim2.tex", dpi=600)
+   
+    plt.show()
+    exit()
+
+#########################################################
+#########################################################
+
+# # fft figure
+# plt.figure()
+# XS = np.fft.rfft(xs)
+# freqs = np.fft.fftfreq(len(xs), dt)
+# freqs[len(XS)-1] *= -1 # nyquist returned for negative freq
+# freqs = freqs[0:len(XS)]
+# 
+# plt.plot(freqs[0:len(XS)], XS.real)
+# plt.plot(freqs[0:len(XS)], XS.imag)
+# 
+# # truncate by T X
+# plt.figure()
+# dv = freqs[1] - freqs[0]
+# iLw = vL / dv
+# tr = int(len(freqs) / 35.)
+# plt.plot(freqs[iLw-tr:iLw + tr], XS.real[iLw-tr:iLw+tr], '-x')
+# plt.plot(freqs[iLw-tr:iLw + tr], XS.imag[iLw-tr:iLw+tr], '-x')
+# plt.twinx()
+# plt.plot(freqs[iLw-tr:iLw + tr], np.angle(XS)[iLw-tr:iLw+tr], '-x')
+# 
+# print len(XS[iLw-tr:iLw+tr])
+# print len(t[iisamp::irsamp])
+# 
+# plt.show()

GUI/test.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+import sys
+import matplotlib
+matplotlib.use('Qt4Agg')
+matplotlib.rcParams['backend.qt4']='PySide'
+import pylab
+
+from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+
+from PySide import QtCore, QtGui
+
+if __name__ == '__main__':
+    app = QtGui.QApplication(sys.argv)
+
+    # generate the plot
+    fig = Figure(figsize=(600,600), dpi=72, facecolor=(1,1,1), edgecolor=(0,0,0))
+    ax = fig.add_subplot(111)
+    ax.plot([0,1])
+    # generate the canvas to display the plot
+    canvas = FigureCanvas(fig)
+
+    win = QtGui.QMainWindow()
+    # add the plot canvas to a window
+    win.setCentralWidget(canvas)
+
+    win.show()
+
+    sys.exit(app.exec_())

MRProc.py

@@ -0,0 +1,797 @@
+from __future__ import division # in case this is called from python2 
+from __future__ import print_function
+
+import numpy as np
+import matplotlib.pyplot as plt
+import sys, os
+import notch 
+from scipy import signal
+from scipy.interpolate import splprep, splev, spline # for smoothing spline FITPACK 
+from scipy.interpolate import UnivariateSpline
+from decay import *
+import scipy.stats as stats
+from pwctimeWhite import * 
+# for signal slot communication with GUI 
+#from PyQt4.QtCore import QObject, SIGNAL
+from PySide.QtCore import QObject, SIGNAL
+from pandas.io.parsers import read_csv #<<- faster than Numpy but not working right now
+from timeit import timeit 
+
+
+class MRProc(QObject):
+    """ Class to process read and invert ORS borehole data
+    """ 
+    def __init__(self):
+        QObject.__init__(self)
+        self.burst = False           # For Schlumberger or VC burst data 
+
+    #def __init__(self, filename):
+    #    # what do we need to know that isn't in new files?       
+    #    fileName, fileExtension = os.path.splitext(filename)
+    #    if fileExtension == ".ors":
+    #        self.loadORSFile(filename)
+        #self.DistRes = { } 
+        #self.DistRes = { 'env':np.array(0), 'mod':np.array(0), 'Time':np.array(0) } #[a0,b0,rt20] }
+        
+    def loadORSFile_OLD(self, filename):
+        """ Loads ORS files with minimal header info
+        """
+        f = open(filename)
+        header = f.readline().split() #np.loadtxt(filename, comment="#", )
+        ih = 1
+        while (header[0] == "#"):
+            ih += 1
+            header = f.readline().split() #np.loadtxt(filename, comment="#", )
+        self.NR = eval(header[0])    # number of records in an echo
+        self.NE = eval(header[1])    # number of echoes
+        self.DT = eval(header[2])    # in s
+        self.TAUE = eval(header[3])  # in s
+        self.RL = self.DT * self.NR  # in s
+
+        # pandas is about ~16 times faster than numpy for import (7 sec vs. .5 sec on tested example)  
+        # Parse in datafile, TODO update for newer format and remove hardcoded 3 in pandas
+        #DATA = np.loadtxt(filename, comments="#", skiprows=ih)
+        DATA = read_csv(filename, comment="#", sep='\t', skiprows=3, engine='c', header=None, names=('time','inphase','quadrature')).as_matrix() 
+
+        self.NS = int(np.shape(DATA)[0] / (self.NE * self.NR))
+
+        # reshape DATA
+        #self.DATA = np.reshape( DATA[:,1] + 1j*DATA[:,2], ( self.NS, self.NE, self.NR) )
+        self.DATA = np.reshape( self.A2D(DATA[:,1]) + 1j*self.A2D(DATA[:,2]), ( self.NS, self.NE, self.NR) )
+        self.WTIME = np.reshape( DATA[:,0], ( self.NS, self.NE, self.NR) )
+        self.TIMES = np.arange(self.DT, self.RL + 1e-8, self.DT)           # 1 ms record, 1 us dwell 
+
+        self.emit(SIGNAL("plotRAW()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+
+    def evaluate(self, value):
+        if len(value) == 1:
+            if value[0][-1].isdigit(): 
+                return eval(value[0])
+            else:
+                if value[0][-1] == "u":   # micro
+                    return eval(value[0][0:-1]) * 1e-6
+                elif value[0][-1] == "M": # mega
+                    return eval(value[0][0:-1]) * 1e6
+                elif value[0][-1] == "s": # second
+                    return eval(value[0][0:-1]) 
+                else:
+                    print("DOOM!")
+                    exit(1)
+        else:
+            # TODO
+            # logic here is a little lacking, but current tool does not do anything 
+            # sneaky with array values, could break in the future though 
+            vals = []
+            for val in value:
+                vals.append( eval(val) )
+            return vals
+
+    def loadORSFile(self, fname):
+        """ Loads ORS files with extensive header info
+        """
+        parameters = False
+        data = False
+        pars = {}
+        with open(fname) as f:
+            iline = 0
+            for line in f:
+                if len(line.split()) == 0:
+                    pass # empty do nothing
+                else:
+                    if line.split()[0] == "[ps]":
+                        parameters = False
+                        # these entries specify the chip programming 
+                    if parameters:
+                        # proc header info
+                        split,comment = line.split("#")
+                        var, val = split.split("=")
+                        val = val.split(";")[0].split()
+                        pars[var.strip()] = self.evaluate(val)
+                    if line.split()[0] == "[parameters]":
+                        parameters = True
+                    if data:
+                        if line[0] == "#":
+                            pass
+                        else:
+                            header = line.split()
+                            iline += 1
+                            break
+                    if line.split()[0] == "[data]":
+                        data = True
+                iline += 1
+
+        self.NR = eval(header[0])    # number of records in an echo
+        self.NE = eval(header[1])    # number of echoes
+        self.DT = eval(header[2])    # in s
+        self.TAUE = eval(header[3])  # in s
+        self.RL = self.DT * self.NR  # in s        
+        
+        # Pandas is much faster than numpy
+        DATA = read_csv(fname, comment="#", sep='\t', skiprows=iline, engine='c', header=None, names=('time','inphase','quadrature')).as_matrix() 
+        self.NS = int(np.shape(DATA)[0] / (self.NE * self.NR))
+
+        # reshape DATA
+        #self.DATA = np.reshape( DATA[:,1] + 1j*DATA[:,2], ( self.NS, self.NE, self.NR) )
+        self.DATA = np.reshape( self.A2D(DATA[:,1], pars) + 1j*self.A2D(DATA[:,2], pars), ( self.NS, self.NE, self.NR) )
+        self.WTIME = np.reshape( DATA[:,0], ( self.NS, self.NE, self.NR) )
+        self.TIMES = np.arange(self.DT, self.RL + 1e-8, self.DT)           # 1 ms record, 1 us dwell 
+
+        self.emit(SIGNAL("plotRAW()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+    
+    # analogue to digital conversion, 'don't quote me on this -- kevin'
+    def A2D(self, i, pars):
+            """ Actual voltage is not known. This routine will need to be expaned to account for 
+                calibration datasets. Or perhaps the inversion and fitting routines instead.
+                TODO, if prestacked data, we need to account for this. 
+            """ 
+            #return  (i/(.5 * (2.**16)))
+            #cal = 7.85 # TODO query for this
+            cal = 5.51 # 1/2 full
+            return i / ( pars['n'] * pars['cal'] )
+
+    def loadJavelinLog(self, filename):
+        """Loads processed Javelin data"""
+        #print("Javelin time")
+        import scipy.io as sio
+        Data =  sio.loadmat(filename)
+        self.T2T = Data['time'][:,0] 
+        self.TAUE =  self.T2T[3] - self.T2T[2]
+        # Better sigma estimate needed
+        self.sigma = 2.5 
+        self.T2N = np.random.normal( 0, self.sigma, len(self.T2T) )    
+        self.NS = 1
+        self.T2D = self.T2N + 1j*Data['se_vector_wc'][:,56]       # depth 0 
+        # What about each depth? How is modelling handled.
+
+    def loadVCMFile(self, filename):
+        #print("LOADING VCM file")
+        Data = np.loadtxt(filename, comments = "#")
+        self.T2T = Data[:,0]    
+        self.sigma = eval(open( filename, 'r' ).readline().split()[1])       
+        self.T2N = np.random.normal( 0, self.sigma, len(self.T2T) )    
+        self.T2D = self.T2N + 1j*Data[:,1]
+        self.NS = 1
+        self.TAUE =  self.T2T[3] - self.T2T[2]
+        
+        #self.emit(SIGNAL("plotLOG10ENV()"))   
+        #self.emit(SIGNAL("enableDSP()"))   
+        #self.emit(SIGNAL("enableINV()"))   
+        #self.emit(SIGNAL("doneStatus()"))  
+ 
+    def loadTextFile(self, filename, NS, NE, NR):
+        """ Loads older format files without header info """
+        print ("OLD TEXT FORMAT DETECTED, not SUPPORTED RIGHT NOW")
+        exit()
+        pass
+
+    def batchThread(self, pars, tag, bload=True, bwindow=True, benvelope=True, bphase=True, bgate=True):
+        
+        #print("batdacheing", load, window, envelope, phase, gate)
+        fileName, fileExtension = os.path.splitext( str(tag) )
+        if bload:
+            #print ("loading", tag)
+            if fileExtension == ".ors":
+                self.loadORSFile(str(tag)) 
+            elif fileExtension == ".vcm":
+                self.loadVCMFile(str(tag)) 
+        
+        if bwindow:
+            #print("windowing", pars['ftype'], pars['winWidth'])
+            self.WindowAndStack( pars['ftype'] , pars['winTrimLeft'], pars['winTrimRight'] )
+
+        if benvelope:
+            #print("enveloping", pars['offset'])
+            self.T2EnvelopeDetect( pars['offset'] ) 
+        
+        if bphase:
+            self.CorrectedAmplitude( 0,0 ) 
+        
+        if bgate:
+            #print("gating", pars['gpd'])
+            self.gateIntegrate( pars['gpd'], pars['stackEfficiency'] ) 
+
+        self.emit(SIGNAL("doneStatus()"))  
+        
+
+    def WindowAndStack(self, ftype="Blackman-Harris", triml=0, trimr=0):
+        # TODO, consider lowpass filter and interpolate to higher DT in order to minimize window amplitude effects
+        #       what would cost of such an operation be? 
+        # TODO, should record be overwritten? I don't think so. I think we should make a deep copy here and then you can always fall back.
+        
+        # Trim ends to centre echo, this many are REMOVED        
+        #triml = 18  
+        #trimr = 15   
+        self.TIMES = self.TIMES[triml:-(trimr)]
+        self.NR -= triml + trimr
+        if ftype == "Blackman-Harris":
+            window = signal.blackmanharris(self.NR)
+        elif ftype == "Blackman":
+            window = signal.blackman(self.NR)
+        elif ftype == "Hann":
+            window = signal.hann(self.NR)
+        elif ftype == "sinc":
+            window = np.ones( (self.NR) )
+
+        self.DATAP = self.DATA[:,:,triml:-trimr].copy()
+        for istk in range(0,self.NS):
+            for ie in range(0,self.NE,1):
+                self.DATAP[istk, ie,:] *= window #  signal.blackmanharris(self.NR)
+                #pass
+                #self.DATA[istk, ie, :] *= signal.hann(self.NR)
+                #self.DATA[istk, ie, :] *= signal.blackman(self.NR)
+                #DATA2[istk, ie, :] *= signal.blackmanharris(self.NR)
+            self.emit(SIGNAL("updateProgress(int)"), (int)(1e2*istk/self.NS))   
+    
+        self.DATASTACK = np.average(self.DATAP, axis=0)
+        if (self.NS > 1):
+            # for noise calculation, destructively average phase-cycled echoes
+            self.DATAP[1::2,:,:] *= -1.
+            self.NOISE = np.average(self.DATAP, axis=0)
+            self.NOISE -= np.mean(self.NOISE) # The noise can be biased? Don't understand why!!
+            #self.DATA[0::2,:,:] *= -1. 
+        self.emit(SIGNAL("plotWIN()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+
+    def ResampleEnvelopeData(self, Q, Mask=0, GatesPD=0):
+        """ Mirror the data and then apply window function and resample in Fourier domain at twice the number. 
+            Then take half. Should be better.
+            GatesPD is Gates Per Decade 
+        """
+        
+        tt = np.concatenate( [self.T2T[Mask::], self.T2T[Mask::][-1]+self.T2T[Mask::] ] )
+        xx = np.concatenate( [self.T2D[Mask::][::-1] , self.T2D[Mask::] ] )
+        
+        xx,tx = signal.resample( xx, 2*Q, t=tt)#, window='hanning')
+        self.T2D = xx[0:Q][::-1]
+        #self.T2D = self.T2D[::-1]
+        
+        xx = np.concatenate( [self.T2N[::-1] , self.T2N] )
+        xx,tx = signal.resample( xx, 2*Q, t=tt)#, window='hanning')
+        self.T2N = xx[0:Q][::-1]
+
+        # don't reverse times dummy!
+        self.T2T = tx[0:Q] #[::-1] ## <-- No! bad Trevor
+        self.NE = len(self.T2D)
+
+    def computeSTD(self):
+        if self.NS >= 2:
+            self.sigma = np.std( np.imag(self.T2N) )
+        else:
+            #N = np.real(self.T2D)
+            s0 = np.std( np.real(self.T2D) )
+            #sr = ( np.std( (np.exp(-1j*self.zeta)*N).real ))  
+            #si = ( np.std( (np.exp(-1j*self.zeta)*N).imag ))  
+            print("s0", s0)
+            self.sigma = s0 # np.array((.15)) #s0 #+ (sr+si-s0)/2.   
+            #self.phasegain =  (s0 + (sr+si-s0)/2) / s0
+            #print("ratio",  s0,  (s0+(sr+si-s0)/2.)/s0  )
+            #nr = (np.exp(-1j*self.zeta)*N).real
+            #ni = (np.exp(-1j*self.zeta)*N).imag
+            #print ("phasegain", self.phasegain)
+            #self.T2D.real *= self.phasegain 
+            #print("SIGMA CALCULATION HERE", s0, self.sigma)
+            
+    def computeSTDBurst(self):
+        if self.NS >= 2:
+            self.sigmaBurst = np.std( np.imag(self.T2Nb) )
+        else:
+            N = np.real(self.T2Db)
+            s0 = np.std( np.real(self.T2Db) )
+            sr = ( np.std( (np.exp(-1j*self.zeta)*N).real) )  
+            si = ( np.std( (np.exp(-1j*self.zeta)*N).imag) )  
+            self.sigmaBurst = s0 #+ (sr+si-s0)/2.   
+            #self.T2Db.real *= self.sigmaBurst/s0 #nr #(nr+ni)/2.          
+        #self.sigmaBurst = np.std( np.real(self.T2Db) ) 
+    
+    def gateIntegrateBurst(self, gpd, stackEfficiency):
+
+        self.computeSTDBurst()
+
+        # calculate total number of decades
+        nd = np.log10(self.T2Tb[-1]/self.T2Tb[0])   #np.log10(self.T2T[-1]) -  np.log10(self.T2T[-1])
+        tdd = np.logspace( np.log10(self.T2Tb[0]), np.log10(self.T2Tb[-1]), (int)(gpd*nd)+1, base=10, endpoint=True) 
+        tdl = tdd[0:-1]     # these are left edges
+        tdr = tdd[1::]      # these are left edges
+        td = (tdl+tdr) / 2. # window centres
+
+        htd = np.zeros( len(td), dtype=complex )
+        htn = np.zeros( len(td), dtype=complex )
+
+        isum = np.zeros( len(td), dtype=int )
+        
+        Vars = np.ones( len(td) ) * self.sigmaBurst**2 #* .15**2
+
+        ii = 0
+        for itd in range(len(self.T2Tb)):
+            if ( self.T2Tb[itd] > tdr[ii] ):
+                if (ii < len(td)-1):
+                    ii += 1
+                else:
+                    break
+            isum[ii] += 1
+            htd[ii]  += self.T2Db[ itd ]
+            #htn[ii] += self.T2N[ itd ]
+            Vars[ii] += self.sigmaBurst**2
+            #self.emit(SIGNAL("updateProgress(int)"), (int)(1e2*itd/len(self.T2T)))  
+        
+        # The 1.5 should be 2 in the theory, the 1.5 compensates for correlated noise, etc. Bascically 
+        #       we don't see noise reduce like ideal averaging. 
+        self.sigmaBurst = np.sqrt( Vars  * (1/isum)**stackEfficiency ) # Var (aX) = a^2 Var(x)
+
+        # Bootstrap
+        bootstrap = False
+        if bootstrap:
+            Means, isumbs = self.bootstrapWindows(np.real(self.T2Db), 300, isum)
+            ts,sm = self.smooth( isumbs, np.std(Means, axis=1) )
+            for it in range(ii):
+                self.sigmaBurst[it] = sm[isum[it]]
+
+        # RESET times where isum == 1
+        ii = 0
+        while (isum[ii] == 1):
+            td[ii] = self.T2Tb[ii]
+            ii += 1
+
+        htd /= isum
+        htn /= isum
+
+        self.T2Tb = td
+        self.T2Db = htd
+
+ 
+    def gateIntegrate(self, gpd, stackEfficiency):
+        """ 
+            Gate integrate the signal to gpd, gates per decade
+        """
+        self.computeSTD()
+        self.gpd = gpd
+
+        if self.burst:
+            self.gateIntegrateBurst(gpd, stackEfficiency)
+
+        # calculate total number of decades
+        nd = np.log10(self.T2T[-1]/self.T2T[0])   #np.log10(self.T2T[-1]) -  np.log10(self.T2T[-1])
+        tdd = np.logspace( np.log10(self.T2T[0]), np.log10(self.T2T[-1]), (int)(gpd*nd)+1, base=10, endpoint=True) 
+        tdl = tdd[0:-1]     # these are left edges
+        tdr = tdd[1::]      # these are left edges
+        td = (tdl+tdr) / 2. # window centres
+
+        htd = np.zeros( len(td), dtype=complex )
+        htn = np.zeros( len(td), dtype=complex )
+        isum = np.zeros( len(td), dtype=int )
+        Vars = np.zeros( len(td) ) 
+
+        ii = 0
+        for itd in range(len(self.T2T)):
+            if ( self.T2T[itd] > tdr[ii] ):
+                if (ii < len(td)-1):
+                    ii += 1
+                else:
+                    break
+            isum[ii] += 1
+            htd[ii]  += self.T2D[ itd ]
+            
+            #htn[ii] += self.T2N[ itd ]
+            Vars[ii] += self.sigma**2
+            self.emit(SIGNAL("updateProgress(int)"), (int)(1e2*itd/len(self.T2T)))  
+        
+        # Theoretical gates 
+        # The 1.5 should be 2 in the theory, the 1.5 compensates for correlated noise, etc. Bascically 
+        #       we don't see noise reduce like ideal averaging. 
+        self.sigma = np.sqrt(Vars  * (1./isum)**stackEfficiency ) # Var (aX) = a^2 Var(x)
+
+        # Bootstrap
+        bootstrap = False # False
+        bs = open("bootstrap.dat", "a")
+        if bootstrap:
+            nboot=10000
+            #Means, isumbs = self.bootstrapWindows(np.real(self.T2D), 100, isum[isum!=1])
+            Means, isumbs = self.bootstrapWindows(np.real(self.T2D), nboot, np.arange(1,isum[-1]+1))
+            #ts,sm = self.smooth(isumbs, np.std(Means - np.tile(np.mean(Means,axis=1),(nboot,1)).T  , axis=1, ddof=2)) # unbiased
+            # TODO use MAD instead of STD??
+            ts,sm = self.smooth(isumbs, np.std(Means, axis=1, ddof=1)) # unbiased
+            #scale = (1. + (nboot*isum)/(np.ones(ii+1)*len(self.T2D)))**.125
+            #print (scale) 
+            for item in (sm[isum[isum!=1]-1]-self.sigma[isum!=1]): #/self.sigma[isum!=1]:
+                bs.write( str(item) + " " )
+            bs.write("\n")
+            #ts,sm = self.smooth( isumbs, np.std(Means, axis=1))
+            #bias = np.average(Means,axis=1)
+            for it in range(len(self.sigma)):
+                self.sigma[it] = sm[isum[it]-1]
+            print('sigma boot', self.sigma)
+        # RESET times where isum == 1
+        ii = 0
+        while (isum[ii] == 1):
+            td[ii] = self.T2T[ii]
+            ii += 1
+
+        htd /= isum
+        htn /= isum
+
+        self.T2T = td
+        self.T2D = htd
+
+        self.emit(SIGNAL("plotLOG10ENV()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("enableINV()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+
+    def bootstrapWindows(self, N, nboot, isum):
+        """ Bootstraps noise as a function of gate width
+        """
+        nc = np.shape(N)[0]
+
+        Means = {}
+        Means = np.zeros( (len(isum), nboot)  )
+        for ii, nwin in enumerate(isum):  
+            for iboot in range(nboot):
+                cs = np.random.randint(0,nc-nwin)
+                #Means[ii,iboot] = np.mean( N[cs:cs+nwin] )
+                Means[ii,iboot] = np.mean( np.random.normal(0, self.sigma[0], nwin))
+        return Means, np.array(isum)
+
+    def smooth(self, x, y):
+        w = np.ones(len(x))
+        w[0] = 100. # force first time gate
+        xs = np.arange(1, x[-1]+1, .1) # resample
+        #s = UnivariateSpline( np.log(x), np.log(y), s=2.5, w=w)
+        s = UnivariateSpline( np.log(x), np.log(y), s=4.5, w=w)
+        #s = UnivariateSpline( x, y, s=2.5, w=w)
+        ys = s(np.log(xs))
+        #ys = s(xs)
+
+        # resample 
+        ys = ys[0::10]    
+        xs = xs[0::10]    
+   
+        return xs,np.exp(ys)
+
+    def T2EnvelopeDetect(self, offset=0):
+
+        self.NRS = (int)(2**12)  # Number of zeros to pad with, total record length
+        # Zero pad
+        DATASTACKZPF = np.append( self.DATASTACK, np.zeros( (self.NE, self.NRS - self.NR) ), axis=1  )
+        if (self.NS > 1):
+            NOISEZPF = np.append( self.NOISE, np.zeros( (self.NE, self.NRS - self.NR) ), axis=1  )
+    
+        # TODO check for proper split
+        SPLIT = self.NR//2 + offset  # 20 # 15 #2 
+
+        # containers for array
+        self.T2D = np.zeros( (self.NE), dtype='complex' ) 
+        self.T2N = np.zeros( (self.NE), dtype='complex' ) 
+        self.T2T = np.zeros( (self.NE) ) 
+        
+        # frequency-domain processing
+        for ie in range(0,self.NE):
+
+            COLOUR = np.array([ie/self.NE, 0., 1.-ie/self.NE]) # for plots
+            
+            ###############################################################
+            # fold data need to reverse some of these
+            #FOLD = ((DATASTACK[ie,0:NR/2] + DATASTACK[ie,:][::-1][0:NR/2])/2.)[::-1] 
+            #plt.figure(223)
+            #plt.plot( self.TAUE*(float)(ie) + self.TIMES, np.imag(self.DATASTACK[ie]),  color=COLOUR)
+            #plt.plot( self.TAUE*(float)(ie) + self.TIMES, np.imag(self.DATA[0,ie]),  color='green')
+            #plt.plot( self.TAUE*(float)(ie) + self.TIMES, np.imag(self.DATA[1,ie]),  color='black')
+            #plt.plot( self.TAUE*(float)(ie) + self.TIMES, np.imag(self.DATA[2,ie]),  color='cyan')
+            #plt.plot( self.TAUE*(float)(ie) + self.TIMES, np.imag(self.DATA[3,ie]),  color='purple')
+            #plt.plot( TAUE*(1e-6)*(float)(ie) + TIMES[SPLIT], np.imag(DATASTACK[ie])[SPLIT], 'o', markersize=6, color=COLOUR)
+            #plt.plot( TAUE*DT*ie + TIMES, np.real(DATASTACK[ie]),  color=COLOUR[::-1])
+
+            ##################################################################
+            # do frequency domain workflow 
+            # fold to DC
+            ND = np.append( DATASTACKZPF[ie,:][SPLIT::], DATASTACKZPF[ie,:][0:SPLIT] )
+            #X = 1e-2*((self.RL/2.)/self.NR) * np.fft.fft(ND, n=self.NRS) # Why 1e-2?
+            X = 1e4*(( (self.DT*self.NRS) /2.)/self.NRS) * np.fft.fft(ND, n=self.NRS) # Why 1e-2?
+            #X = (self.DT) * np.fft.fft(ND, n=self.NRS) # Why 1e-2?
+
+            if (self.NS > 1):
+                NND = np.append( NOISEZPF[ie,:][SPLIT::], NOISEZPF[ie,:][0:SPLIT] )
+                #XN = 1e-2*((self.RL/2.)/self.NR) * np.fft.fft(NND, n=self.NRS) # Why 1e-2?
+                XN = 1e4*(( (self.DT*self.NRS) /2.)/self.NRS) * np.fft.fft(NND, n=self.NRS) # Why 1e-2?
+                self.T2N[ie] = XN[0] #complex( np.real(X[0]),  np.imag(X[0]) )
+    
+            ##################################################################
+            # Save T2 records
+            self.T2D[ie] = X[0] #complex( np.real(X[0]),  np.imag(X[0]) )
+            self.T2T[ie] = (1.+ie)*(self.TAUE)
+            self.emit(SIGNAL("updateProgress(int)"), (int)(1e2*ie/self.NE))   
+       
+        self.computeSTD() 
+        
+        self.emit(SIGNAL("plotENV()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("enableINV()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+
+    def CorrectedAmplitude(self, joe=0, frank=0):
+        """ Phase corrects the record, joe and Frank are empty (ignored) and are workarounds for threading.
+        """
+        #[E0,df,phi,T2] = quadratureDetect(Q, I, tt)
+       
+        # mask first few echoes, just for detection 
+        NM = 2 
+        #[conv,E0,df,phi,T2] = quadratureDetect(np.imag(self.T2D[NM::]), np.real(self.T2D[NM::]), self.T2T[NM::], False, True)
+        #[conv,E0,df,phi,T2] = quadratureDetect(np.imag(self.T2D[NM::]), np.real(self.T2D[NM::]), self.T2T[NM::], False, False, True)
+        #                                                                              #CorrectFreq=False, BiExp=False, CorrectDC=False)
+        [conv,E0,df,phi,T2] = quadratureDetect2(np.imag(self.T2D[NM::]), np.real(self.T2D[NM::]), self.T2T[NM::])
+        self.zeta1 = phi
+
+        #if conv: # failed convergence
+        #    [conv,E0,df,phi,T2] = quadratureDetect(np.imag(self.T2D[NM::]), np.real(self.T2D[NM::]), self.T2T[NM::], False, False, False)
+        self.T2D = self.RotateAmplitude(np.real(self.T2D), np.imag(self.T2D), phi, df, self.T2T) 
+        self.computeSTD() 
+        #print(str(conv) + "\t" + str(phi)) #, file = "phase.dat")
+       
+        if self.burst:
+            #[conv,E0,df,phi,T2] = quadratureDetect(np.imag(self.T2Db), np.real(self.T2Db), self.T2Tb, False, False, False)
+            [conv,E0,df,phi,T2] = quadratureDetect2(np.imag(self.T2Db), np.real(self.T2Db), self.T2Tb) #, False, False, False)
+            #if conv: # failed convergence
+            #    [conv,E0,df,phi,T2] = quadratureDetect(np.imag(self.T2Db), np.real(self.T2Db), self.T2Tb, False, False, False)
+            env = E0*np.exp(-np.array(self.T2Tb)/T2)
+            self.T2Db = self.RotateAmplitude(np.real(self.T2Db), np.imag(self.T2Db), phi, df, self.T2Tb)
+            self.computeSTDBurst() 
+        
+        self.emit(SIGNAL("plotENV()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("enableINV()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+
+    def RotateAmplitude(self, X, Y, zeta, df, t):
+        self.zeta = zeta 
+        self.df = df 
+        V = X + 1j*Y
+        return np.abs(V) * np.exp(1j * (np.angle(V) - zeta - 2.*np.pi*df*t)) 
+
+    def MonoFit(self, mask=2, intercept="False"):
+        component='imag'
+        #print "MonoRes", component, mask, intercept
+        a0 = 0
+        if intercept=="True":
+            if component == "imag":
+                [a0,b0,rt20] =  regressCurve(np.imag(self.T2D[mask::]), self.T2T[mask::], intercept=True)  
+            if component == "real":
+                [a0,b0,rt20] =  regressCurve(np.real(self.T2D[mask::]), self.T2T[mask::], intercept=True)  
+            rfit =  r"$\tilde{T}_2$= %4d [ms]"%(1e3*rt20)
+
+        else:
+            if component == "imag":
+                [b0,rt20] =  regressCurve(np.imag(self.T2D[mask::]), self.T2T[mask::], intercept=False) #, intercept=True) # 
+            if component == "real":
+                [b0,rt20] =  regressCurve(np.real(self.T2D[mask::]), self.T2T[mask::], intercept=False) #, intercept=True) # 
+            rfit =  r"$\tilde{T}_2$= %4d [ms]"%(1e3*rt20)
+        
+
+        extrapolate = False #False #True #False 
+        if extrapolate:
+            Textr = 3
+            nede = np.log10(Textr/self.T2T[-1]) #np.log10(self.T2T[-1]) -  np.log10(self.T2T[-1])
+            tex = np.logspace( np.log10(self.T2T[-1]), np.log10(Textr), (int)(self.gpd*nede)+1, base=10, endpoint=True) 
+            dex = 1j*  (a0 + b0*np.exp(-np.array(tex)/rt20))
+            self.T2T = np.concatenate( (self.T2T, tex) )            
+            self.T2D = np.concatenate( (self.T2D, dex) )            
+            self.sigma = np.concatenate( (self.sigma, self.sigma[-1]*np.ones(len(dex)) ) )            
+            
+        #env = b0*np.exp(-np.array(self.T2T)/rt20)
+        #self.MonoRes = { 'env':env, 'rfit':rfit, 'b0':b0, 'rt20' :rt20 } #[a0,b0,rt20] }
+        env = a0 + b0*np.exp(-np.array(self.T2T)/rt20)
+        self.MonoRes = { 'env':env, 'rfit':rfit, 'a0':a0, 'b0':b0, 'rt20' :rt20, 't':self.T2T } #[a0,b0,rt20] }
+
+
+        self.emit(SIGNAL("plotMONO()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("enableINV()"))   
+        self.emit(SIGNAL("doneStatus()"))  
+
+    def BiFit(self, mask=2, intercept="False"):
+        component='imag'
+        #print "MonoRes", component, mask, intercept
+        a0 = 0
+        if intercept=="True":
+            if component == "imag":
+                [a0,b0,rt20,bb0,rrt20] =  regressCurve2(np.imag(self.T2D[mask::]), self.T2T[mask::], sigma2=self.sigma[mask::], intercept=True)  
+            if component == "real":
+                [a0,b0,rt20,bb0,rrt20] =  regressCurve2(np.real(self.T2D[mask::]), self.T2T[mask::], sigma2=self.sigma[mask::], intercept=True)  
+            rfit =  r"$\tilde{T}_2$= %4d [ms]"%(1e3*rt20)
+
+        else:
+            if component == "imag":
+                [b0,rt20,bb0,rrt20] =  regressCurve2(np.imag(self.T2D[mask::]), self.T2T[mask::], sigma2=self.sigma[mask::], intercept=False) #, intercept=True) # 
+            if component == "real":
+                [b0,rt20,bb0,rrt20] =  regressCurve2(np.real(self.T2D[mask::]), self.T2T[mask::], sigma2=self.sigma[mask::], intercept=False) #, intercept=True) # 
+            rfit =  r"$\tilde{T}_2$= %4d [ms]"%(1e3*rt20)
+        
+
+        extrapolate = True # True #True 
+        if extrapolate:
+            Textr = 3
+            nede = np.log10(Textr/self.T2T[-1]) #np.log10(self.T2T[-1]) -  np.log10(self.T2T[-1])
+            tex = np.logspace( np.log10(self.T2T[-1]), np.log10(Textr), (int)(self.gpd*nede)+1, base=10, endpoint=True) 
+            dex = 1j*  (a0 + b0*np.exp(-np.array(tex)/rt20) + bb0*np.exp(-np.array(tex)/rrt20) )
+            self.T2T = np.concatenate( (self.T2T, tex) )            
+            self.T2D = np.concatenate( (self.T2D, dex) )            
+            self.sigma = np.concatenate( (self.sigma, self.sigma[-1]*np.ones(len(dex)) ) )            
+            
+        #env = b0*np.exp(-np.array(self.T2T)/rt20)
+        #self.MonoRes = { 'env':env, 'rfit':rfit, 'b0':b0, 'rt20' :rt20 } #[a0,b0,rt20] }
+        env = a0 + b0*np.exp(-np.array(self.T2T)/rt20) + bb0*np.exp(-np.array(self.T2T)/rrt20)
+
+        #print ("bi fits", a0, b0, rt20, bb0, rrt20)
+
+        self.BiRes = { 'env':env, 'rfit':rfit, 'a0':a0, 'b0':b0, 'rt20' :rt20, 'bb0':bb0, 'rrt20':rrt20, 't':self.T2T } #[a0,b0,rt20] }
+
+        self.emit(SIGNAL("plotBI()"))   
+        self.emit(SIGNAL("enableDSP()"))   
+        self.emit(SIGNAL("enableINV()"))   
+        self.emit(SIGNAL("doneStatus()")) 
+        
+ 
+    def DistFit(self, dc=0, mask=0, nT2=30, lowT2=.005, hiT2=3.25, spacing="Log_10", Smooth="Smallest", betaScale=1):
+        
+        Time = pwcTime()
+        Time.setT2(lowT2, hiT2, nT2, spacing) 
+        Time.setSampling( self.T2T[mask:] ) 
+        Time.generateGenv()
+
+        #self.burst = False
+        #print ("MRProc.py ~~ DistFit self.burst override for publication ", self.burst)
+        if self.burst:
+            # fit burst data first
+            Timeb = pwcTime()
+            #Timeb.setT2(lowT2, hiT2, nT2, spacing) 
+            Timeb.T2Bins = np.copy(Time.T2Bins)
+            #if len(Timeb.T2Bins) > 20:
+            #    Timeb.T2Bins = Timeb.T2Bins[0:20] # Subset
+            Timeb.setSampling( self.T2Tb ) 
+            Timeb.generateGenv()
+
+            # invert burst data, always use smooth to encourage fast time inversion
+            modelb  = logBarrier(Timeb.Genv, np.imag(self.T2Db)-dc, Timeb.T2Bins, MAXITER=500, sigma=betaScale*self.sigmaBurst, alpha=1e10, smooth=Smooth) 
+            modelb2 = np.zeros(nT2)
+            modelb2[0:len(modelb)] += modelb 
+            #model = modelb2 # TODO remove 
+ 
+            # invert regular data independently, sum inversions 
+            #model  = logBarrier(Time.Genv, np.imag(self.T2D[mask:])-dc, MAXITER=500, x_0=modelb, sigma=betaScale*self.sigma[mask:], alpha=1e10, smooth=Smooth)
+            #model += modelb 
+            
+            # Pass burt result as reference model
+            model  = logBarrier(Time.Genv, np.imag(self.T2D[mask:])-dc, Time.T2Bins, MAXITER=500, xr=modelb2, sigma=betaScale*self.sigma[mask:], alpha=1e10, smooth=Smooth)
+
+        else:
+            model  = logBarrier(Time.Genv, np.imag(self.T2D[mask:])-dc, Time.T2Bins, MAXITER=500, sigma=betaScale*self.sigma[mask:], alpha=1e10, smooth=Smooth) #, smooth=True) #
+
+        # forward model
+        env = np.dot(Time.Genv, model) 
+        # NOTE this is not thread safe or even thread aware. Need to use MPI style message passing 
+        self.DistRes = { 'env':env, 'mod':model, 'Time':Time } #[a0,b0,rt20] } no dice
+    
+    def DistFitMP(self, q, tag, dc=0, mask=0, nT2=30, lowT2=.005, hiT2=3.25, spacing="Log_10", Smooth="Smallest", betaScale=1):
+        """ Multi-processor version of DistFit using Queue. Note that Queue doesn't 
+            tolerate large messages. So instead we write them to file, using pickle! 
+            It's semi-absurd. But seems to function fast enough. 
+        """
+        import pickle 
+        self.DistFit(dc, mask, nT2, lowT2, hiT2, spacing, Smooth, betaScale)
+        self.DistRes['tag'] = tag
+        pickle.dump( self.DistRes, open( str(tag)+".p", "wb" ) )
+        q.put( tag )
+    
+
+if __name__ == "__main__":
+
+    fileName, fileExtension = os.path.splitext(sys.argv[1])
+    if fileExtension == ".ors":
+
+        ORS = MRProc()
+        ORS.loadORSFile(sys.argv[1])
+        ORS.WindowAndStack()
+        ORS.T2EnvelopeDetect()
+        
+        #ORS.ResampleEnvelopeData(200, Mask=2, GatesPD=20)  # resample size 
+        
+        #print (len(ORS.T2D))
+        #exit()
+        #mono, rfit, [a0,b0,mt2] = ORS.MonoFit()
+        mono, rfit, [b0,mt2] = ORS.MonoFit()
+        #ca, caEnv, CAS = ORS.CorrectedAmplitude()
+        mymask = 2
+        env, mod, Time = ORS.DistFit(0, mymask) #a0)
+
+        # Subtract DC term before 2D fit? Kind of kludgy but I don't see a way around it right now. 
+        plt.figure()
+        #plt.plot(ORS.T2T, np.imag(ca), label='imag ca')
+        #plt.plot(ORS.T2T, np.real(ca), label='real ca')
+        #if ORS.NS < 2:
+        #    plt.plot(ORS.T2T, np.imag(ORS.T2D), label='imag')
+        #    plt.plot(ORS.T2T, np.real(ORS.T2D), label='real')
+        #else:
+        plt.errorbar(ORS.T2T, np.imag(ORS.T2D), fmt='o', yerr=ORS.sigma, label="data imag")
+        plt.errorbar(ORS.T2T, np.real(ORS.T2D), fmt='o', yerr=np.std(ORS.T2D.real), label="data real")
+        if ORS.NS > 2:
+            plt.errorbar(ORS.T2T, np.imag(ORS.T2N), fmt='o', yerr=ORS.sigma, label="noise imag")
+        
+        plt.plot(ORS.T2T, mono, color='cyan', linewidth=3, label=rfit)
+        #plt.plot(ORS.T2T, caEnv, label="car")
+        plt.plot(ORS.T2T[mymask::], env, color='magenta', linewidth=3, label="dist")
+        #plt.plot(ORS.T2T, a0+env)
+        plt.legend()
+        plt.savefig(sys.argv[1].strip(".ors")+"_caenv.pdf", facecolor='white', edgecolor='white', dpi=200)
+
+
+        # Report RMS error of two results 
+        print("RMS error mono-exponential ", np.linalg.norm(np.imag(ORS.T2D) - mono) )
+        print("RMS error dist-fit         ", np.linalg.norm(np.imag(ORS.T2D[mymask::]) - env) )
+        print("RMS error real  channel    ", np.linalg.norm(np.real(ORS.T2D) ) )
+        if ORS.NS > 2:
+            print("RMS error noise channel    ", np.linalg.norm(np.imag(ORS.T2N) ) )
+
+        plt.figure()
+        plt.plot( ORS.T2T[mymask::],  np.imag(ORS.T2D[mymask::]) - env )
+        plt.title("residuals")
+
+        #plt.show()
+        #exit()
+
+        plt.figure() 
+        plt.plot(Time.T2Bins, mod, color='purple', linewidth=2, label="recovered")
+        #plt.plot(Time.T2Bins, guess, color='red', linewidth=2, label="guess")
+
+        axmine = plt.gca()
+        axmine.set_xlabel(r"$T_2$ [s]", color='black')
+        axmine.set_ylabel(r"$A_0$ [rku]", color='black')
+        axmine2 = plt.twinx()
+        axmine2.set_ylabel(r"$A_0$ [rku]", color='black')
+
+        theta = np.sum(mod)
+        LogMeanT2 = np.exp(np.sum( mod * np.log(Time.T2Bins) ) / theta ) 
+
+        #axmine2.plot(mt2, a0+b0, 'o', markersize=8, label="mono")
+        axmine2.plot(mt2, b0, 'o', markersize=8, label="mono")
+        #axmine2.plot(Time.T2Bins, guess, '-',color=colour[ic], linewidth=2, label="total")
+        axmine2.plot(LogMeanT2, theta, 's', markersize=8, label="$T_{2ML}$")
+        axmine2.set_ylim([0, axmine2.get_ylim()[1]])
+        leg = plt.legend()
+
+        plt.savefig(sys.argv[1].strip(".ors")+"_2DT2.pdf", facecolor='white', edgecolor='white', dpi=200)
+
+   
+        plt.figure(23)
+        stats.probplot( np.imag(ORS.T2D) - mono , dist="norm", plot=plt) #, label="mono resid")
+        stats.probplot( np.imag(ORS.T2D[mymask::]) - env , dist="norm", plot=plt) #, label="dist resid")
+        if ORS.NS > 2:
+            stats.probplot( np.imag(ORS.T2N), dist="norm", plot=plt) #, label="noise" )
+
+        plt.savefig(sys.argv[1].strip(".ors")+"_qq.pdf")
+ 
+        plt.show()
+        exit()
+  

decay.py

@@ -0,0 +1,712 @@
+import numpy, array #,rpy2
+from matplotlib import pyplot as plt
+import numpy as np
+from scipy.optimize import least_squares
+from rpy2.robjects.packages import importr
+
+import rpy2.robjects as robjects
+import rpy2.robjects.numpy2ri
+
+#import notch
+from numpy.fft import fft, fftfreq
+
+# We know/can calculate frequency peak, use this to guess where picks will be.
+# maybe have a sliding window that reports peak values.
+def peakPicker(data, omega, dt):
+
+    # compute window based on omega and dt
+    # make sure you are not aliased, grab every other peak
+    window = (2*numpy.pi) / (omega*dt)
+
+    data = numpy.array(data) 
+    peaks = []
+    troughs = []
+    times = []
+    times2 = []
+    indices = []
+    ws = 0
+    we = window
+    ii = 0
+    for i in range((int)(len(data)/window)):
+        
+        # initially was just returning this I think avg is better
+        #times.append( (ws + numpy.abs(data[ws:we]).argmax()) * dt )
+    
+        peaks.append(numpy.max(data[ws:we]))
+        times.append( (ws + data[ws:we].argmax()) * dt )
+        indices.append( ii + data[ws:we].argmax() )        
+
+        troughs.append(numpy.min(data[ws:we]))
+        times2.append( (ws + (data[ws:we]).argmin()) * dt )
+        indices.append( ii + data[ws:we].argmin() )        
+
+        ws += window
+        we += window
+        ii += (int)(we-ws)
+    
+    #return numpy.array(peaks), numpy.array(times)
+    
+    # Averaging peaks does a good job of removing bias in noise
+    return (numpy.array(peaks)-numpy.array(troughs))/2., \
+        (numpy.array(times)+numpy.array(times2))/2., \
+        indices           
+
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressCurve(peaks,times,sigma2=1,intercept=True):
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    b1  = 0                  # Bias
+    b2  = 0                  # Linear 
+    rT2 = 0.3                # T2 regressed
+    r   = robjects.r         
+
+    # Variable shared between R and Python
+    robjects.globalenv['b1'] = b1
+    robjects.globalenv['b2'] = b2
+    robjects.globalenv['rT2'] = rT2
+    robjects.globalenv['sigma2'] = sigma2
+    value = robjects.FloatVector(peaks)
+    times = robjects.FloatVector(numpy.array(times))
+    
+#    my_weights = robjects.RVector(value/sigma2)
+#    robjects.globalenv['my_weigts'] = my_weights
+
+#    if sigma2 != 0:
+#        print "weighting"
+#        tw = numpy.array(peaks)/sigma2 
+#        my_weights = robjects.RVector( tw/numpy.max(tw) )
+#    else:
+#        my_weights = robjects.RVector(numpy.ones(len(peaks))) 
+
+#    robjects.globalenv['my_weights'] = my_weights
+    
+    if (intercept):
+        my_list = robjects.r('list(b1=50, b2=1e2, rT2=0.03)')
+        my_lower = robjects.r('list(b1=0, b2=0, rT2=.005)')
+        my_upper = robjects.r('list(b1=20000, b2=2000, rT2=.700)')
+    else:
+        my_list = robjects.r('list(b2=1e2, rT2=0.3)')
+        my_lower = robjects.r('list(b2=0, rT2=.005)')
+        my_upper = robjects.r('list(b2=2000, rT2=.700)')
+
+    my_cont = robjects.r('nls.control(maxiter=1000, warnOnly=TRUE, printEval=FALSE)')
+
+    
+    if (intercept):
+        #fmla = robjects.RFormula('value ~ b1 + exp(-times/rT2)')
+        fmla = robjects.Formula('value ~ b1 + b2*exp(-times/rT2)')
+        #fmla = robjects.RFormula('value ~ b1 + b2*times + exp(-times/rT2)')
+    else:
+        fmla = robjects.Formula('value ~ b2*exp(-times/rT2)')
+
+    env = fmla.getenvironment()
+    env['value'] = value
+    env['times'] = times
+    
+    # ugly, but I get errors with everything else I've tried
+    my_weights = robjects.r('rep(1,length(value))')
+    for ii in range(len(my_weights)):
+        my_weights[ii] *= peaks[ii]/sigma2
+    Error = False
+    #fit = robjects.r.nls(fmla,start=my_list,control=my_cont,weights=my_weights)
+    if (sigma2 != 1):
+        print("SIGMA 2")
+        #fit = robjects.r.tryCatch(robjects.r.suppressWarnings(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm="port", \
+        #                     weights=my_weights)), 'silent=TRUE')
+        fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list,control=my_cont))#, \
+                            # weights=my_weights))
+    else:
+        try:
+            fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm="port"))#,lower=my_lower,upper=my_upper))
+        except:
+            print("regression issue pass")
+            Error = True
+    # If failure fall back on zero regression values   
+    if not Error:
+        #Error = fit[3][0]
+        report =  r.summary(fit)
+    b1 = 0
+    b2 = 0 
+    rT2 = 1
+    if (intercept):
+        if not Error:
+            b1  =  r['$'](report,'par')[0]
+            b2  =  r['$'](report,'par')[1]
+            rT2 =  r['$'](report,'par')[2]
+            #print  report
+            #print  r['$'](report,'convergence')
+            #print  r['convergence'] #(report,'convergence')
+            #print  r['$'](report,'par')[13]
+            #print  r['$'](report,'par')[14]
+        else:
+            print("ERROR DETECTED, regressed values set to default")
+            b1 = 1e1
+            b2 = 1e-2
+            rT2 = 1e-2
+            #print r['$'](report,'par')[0]
+            #print r['$'](report,'par')[1]
+            #print r['$'](report,'par')[2]
+        return [b1,b2,rT2] 
+    else:
+        if not Error:
+            rT2 =  r['$'](report,'par')[1]
+            b2  =  r['$'](report,'par')[0]
+        else:
+            print("ERROR DETECTED, regressed values set to default")
+        return [b2, rT2] 
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressCurve2(peaks,times,sigma2=[None],intercept=True):
+
+    if sigma2[0] != None:
+        my_weights = robjects.FloatVector( sigma2 )
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    b1  = 0                  # Bias
+    b2  = 0                  # Linear 
+    bb2  = 0                 # Linear 
+    rT2 = 0.3                # T2 regressed
+    rrT2 = 1.3               # T2 regressed
+    r   = robjects.r         
+
+    # Variable shared between R and Python
+    robjects.globalenv['b1'] = b1
+    robjects.globalenv['b2'] = b2
+    robjects.globalenv['rT2'] = rT2
+    
+    robjects.globalenv['bb2'] = b2
+    robjects.globalenv['rrT2'] = rT2
+    
+    #robjects.globalenv['sigma2'] = sigma2
+    value = robjects.FloatVector(peaks)
+    times = robjects.FloatVector(numpy.array(times))
+    
+    
+    if (intercept):
+        my_list = robjects.r('list(b1=.50, b2=1e2, rT2=0.03, bb2=1e1, rrT2=1.3)')
+        my_lower = robjects.r('list(b1=0, b2=0, rT2=.005, bb2=0, rrT2=.005 )')
+        my_upper = robjects.r('list(b1=2000, b2=2000, rT2=.700, bb2=2000, rrT2=1.3 )')
+    else:
+        my_list  = robjects.r('list(b2=.5, rT2=0.3,  bb2=.5, rrT2=1.3)')
+        my_lower = robjects.r('list(b2=0,  rT2=.005, bb2=0,  rrT2=.005)')
+        my_upper = robjects.r('list(b2=1,  rT2=2.6,    bb2=1,  rrT2=2.6)')
+
+    my_cont = robjects.r('nls.control(maxiter=1000, warnOnly=TRUE, printEval=FALSE)')
+
+    
+    if (intercept):
+        #fmla = robjects.RFormula('value ~ b1 + exp(-times/rT2)')
+        fmla = robjects.Formula('value ~ b1 + b2*exp(-times/rT2) + bb2*exp(-times/rrT2)')
+        #fmla = robjects.RFormula('value ~ b1 + b2*times + exp(-times/rT2)')
+    else:
+        fmla = robjects.Formula('value ~ b2*exp(-times/rT2) + bb2*exp(-times/rrT2)')
+
+    env = fmla.getenvironment()
+    env['value'] = value
+    env['times'] = times
+    
+    # ugly, but I get errors with everything else I've tried
+    Error = False
+    #fit = robjects.r.nls(fmla,start=my_list,control=my_cont,weights=my_weights)
+    if (sigma2[0] != None):
+        #print("SIGMA 2")
+        #fit = robjects.r.tryCatch(robjects.r.suppressWarnings(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm="port", \
+        #                     weights=my_weights)), 'silent=TRUE')
+        fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm='port',weights=my_weights,lower=my_lower,upper=my_upper))#, \
+                            # weights=my_weights))
+    else:
+        try:
+            fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm="port"))#,lower=my_lower,upper=my_upper))
+        except:
+            print("regression issue pass")
+            Error = True
+    # If failure fall back on zero regression values   
+    if not Error:
+        #Error = fit[3][0]
+        report =  r.summary(fit)
+    b1 = 0
+    b2 = 0 
+    rT2 = 1
+    if (intercept):
+        if not Error:
+            b1  =  r['$'](report,'par')[0]
+            b2  =  r['$'](report,'par')[1]
+            rT2 =  r['$'](report,'par')[2]
+            #print  report
+            #print  r['$'](report,'convergence')
+            #print  r['convergence'] #(report,'convergence')
+            #print  r['$'](report,'par')[13]
+            #print  r['$'](report,'par')[14]
+        else:
+            print("ERROR DETECTED, regressed values set to default")
+            b1 = 1e1
+            b2 = 1e-2
+            rT2 = 1e-2
+            #print r['$'](report,'par')[0]
+            #print r['$'](report,'par')[1]
+            #print r['$'](report,'par')[2]
+        return [b1,b2,rT2, bb2, rrT2] 
+    else:
+        if not Error:
+            rT2 =  r['$'](report,'par')[1]
+            b2  =  r['$'](report,'par')[0]
+            rrT2 =  r['$'](report,'par')[3]
+            bb2  =  r['$'](report,'par')[2]
+        else:
+            print("ERROR DETECTED, regressed values set to default")
+        return [b2, rT2, bb2, rrT2] 
+
+def fun(x, t, y):
+    """ Cost function for regression, single exponential, no DC term 
+        x[0] = A0
+        x[1] = zeta 
+        x[2] = df
+        x[3] = T2
+    """
+    # concatenated real and imaginary parts  
+    pre =  np.concatenate((x[0]*np.cos(2.*np.pi*x[2]*t + x[1])*np.exp(-t/x[3]), \
+                       -1.*x[0]*np.sin(2.*np.pi*x[2]*t + x[1])*np.exp(-t/x[3])))  
+    return y-pre
+
+def fun2(x, t, y):
+    """ Cost function for regression, single exponential, no DC term 
+        x[0] = A0
+        x[1] = zeta 
+        x[2] = T2
+    """
+    # concatenated real and imaginary parts  
+    pre =  np.concatenate((x[0]*np.cos(x[1])*np.exp(-t/x[2]), \
+                       -1.*x[0]*np.sin(x[1])*np.exp(-t/x[2])))  
+    return y-pre
+
+
+def quadratureDetect2(X, Y, tt): 
+    """ Pure python quadrature detection using Scipy.  
+        X = real part of NMR signal 
+        Y = imaginary component of NMR signal 
+        tt = time 
+    """
+    # df 
+    x = np.array( [1., 0., 0., .2] )
+    res_lsq = least_squares(fun, x, args=(tt, np.concatenate((X, Y))), loss='soft_l1', f_scale=0.1,\
+        bounds=( [0., -np.pi, -10, .0] , [1., np.pi, 10, .6] ))
+    x = res_lsq.x 
+    return res_lsq.success, x[0], x[2], x[1], x[3]
+    
+    # no df
+    #x = np.array( [1., 0., 0.2] )
+    #res_lsq = least_squares(fun2, x, args=(tt, np.concatenate((X, Y))), loss='soft_l1', f_scale=0.1)
+    #x = res_lsq.x 
+    #return conv, E0,df,phi,T2
+    #return res_lsq.success, x[0], 0, x[1], x[2]
+
+def quadratureDetect(X, Y, tt, CorrectFreq=False, BiExp=False, CorrectDC=False):
+ 
+    r   = robjects.r        
+
+    if CorrectDC:
+        robjects.r(''' 
+             Xc1 <- function(E01, df, tt, phi, T2_1, DC) {
+	                DC + E01*cos(2*pi*df*tt + phi) * exp(-tt/T2_1)
+            }
+    
+            Yc1 <- function(E01, df, tt, phi, T2_1, DC) {
+	                DC - E01*sin(2*pi*df*tt + phi) * exp(-tt/T2_1)
+            } 
+            ''')
+    else:   
+        robjects.r(''' 
+             Xc1 <- function(E01, df, tt, phi, T2_1) {
+	                E01*cos(2*pi*df*tt + phi) * exp(-tt/T2_1)
+            }
+    
+            Yc1 <- function(E01, df, tt, phi, T2_1) {
+	                -E01*sin(2*pi*df*tt + phi) * exp(-tt/T2_1)
+            } 
+            ''')
+
+    # bi-exponential 
+    if CorrectDC:
+        robjects.r(''' 
+             Xc2 <- function(E01, E02, df, tt, phi, T2_1, T2_2, DC) {
+	               DC + E01*cos(2*pi*df*tt + phi) * exp(-tt/T2_1) + 
+	                DC + E02*cos(2*pi*df*tt + phi) * exp(-tt/T2_2)
+            }
+
+            Yc2 <- function(E01, E02, df, tt, phi, T2_1, T2_2, DC) {
+	                DC - E01*sin(2*pi*df*tt + phi) * exp(-tt/T2_1) + 
+	                DC - E02*sin(2*pi*df*tt + phi) * exp(-tt/T2_2)
+            } 
+            ''')
+    else:   
+        robjects.r(''' 
+             Xc2 <- function(E01, E02, df, tt, phi, T2_1, T2_2) {
+	               E01*cos(2*pi*df*tt + phi) * exp(-tt/T2_1) + 
+	               E02*cos(2*pi*df*tt + phi) * exp(-tt/T2_2)
+            }
+
+            Yc2 <- function(E01, E02, df, tt, phi, T2_1, T2_2) {
+	                -E01*sin(2*pi*df*tt + phi) * exp(-tt/T2_1) + 
+	                -E02*sin(2*pi*df*tt + phi) * exp(-tt/T2_2)
+            } 
+            ''')
+
+    # Make 0 vector 
+    Zero = robjects.FloatVector(numpy.zeros(len(X)))
+    
+    # Fitted Parameters
+    E01 = 0.
+    E02 = 0.
+    df = 0.
+    phi = 0.
+    T2_1 = 0.
+    T2_2 = 0.
+    DC = 0.
+    robjects.globalenv['DC'] = DC
+    robjects.globalenv['E01'] = E01
+    robjects.globalenv['E02'] = E02
+    robjects.globalenv['df'] = df
+    robjects.globalenv['phi'] = phi
+    robjects.globalenv['T2_1'] = T2_1
+    robjects.globalenv['T2_2'] = T2_2
+    XY = robjects.FloatVector(numpy.concatenate((X,Y)))
+    
+    # Arrays
+    tt = robjects.FloatVector(numpy.array(tt))
+    X = robjects.FloatVector(numpy.array(X))
+    Y = robjects.FloatVector(numpy.array(Y))
+    Zero = robjects.FloatVector(numpy.array(Zero))
+
+    
+
+    if BiExp:
+        if CorrectDC:
+            fmla = robjects.Formula('XY ~ c(Xc2( E01, E02, df, tt, phi, T2_1, T2_2, DC ), Yc2( E01, E02, df, tt, phi, T2_1, T2_2, DC ))')
+            if CorrectFreq:    
+                start = robjects.r('list(E01=.100, E02=.01,   df=0,    phi=0.    ,  T2_1=.100, T2_2=.01, DC=0.0)')
+                lower = robjects.r('list(E01=1e-6, E02=1e-6,  df=-50,  phi=-3.14 ,  T2_1=.001, T2_2=.001, DC=0.0)')
+                upper = robjects.r('list(E01=1.00, E02=1.0,   df=50,   phi=3.14  ,  T2_1=.800, T2_2=.8, DC=0.5)')
+            else:
+                start = robjects.r('list(E01=.100, E02=.01,   phi=0.9   ,  T2_1=.100, T2_2=.01,  DC=0.0)')
+                lower = robjects.r('list(E01=1e-6, E02=1e-6,  phi=-3.14 ,  T2_1=.001, T2_2=.001, DC=0.0)')
+                upper = robjects.r('list(E01=1.00, E02=1.0,   phi=3.14  ,  T2_1=.800, T2_2=.8,   DC=0.5)')
+        else:
+            fmla = robjects.Formula('XY ~ c(Xc2( E01, E02, df, tt, phi, T2_1, T2_2 ), Yc2( E01, E02, df, tt, phi, T2_1, T2_2))')
+            if CorrectFreq:    
+                start = robjects.r('list(E01=.100, E02=.01,   df=0,    phi=0.    ,  T2_1=.100, T2_2=.01)')
+                lower = robjects.r('list(E01=1e-6, E02=1e-6,  df=-50,  phi=-3.14 ,  T2_1=.001, T2_2=.001)')
+                upper = robjects.r('list(E01=1.00, E02=1.0,   df=50,   phi=3.14  ,  T2_1=.800, T2_2=.8)')
+            else:
+                start = robjects.r('list(E01=.100, E02=.01,   phi=0.9   ,  T2_1=.100, T2_2=.01)')
+                lower = robjects.r('list(E01=1e-6, E02=1e-6,  phi=-3.14 ,  T2_1=.001, T2_2=.001)')
+                upper = robjects.r('list(E01=1.00, E02=1.0,   phi=3.14  ,  T2_1=.800, T2_2=.8)')
+    else: 
+        if CorrectDC:
+            fmla = robjects.Formula('XY ~ c(Xc1( E01, df, tt, phi, T2_1, DC), Yc1( E01, df, tt, phi, T2_1,DC))')
+            if CorrectFreq:    
+                start = robjects.r('list(E01=.100, df=0   , phi=0.   , T2_1=.100, DC=0.0)')
+                lower = robjects.r('list(E01=1e-6, df=-50., phi=-3.14, T2_1=.001, DC=0.0)')
+                upper = robjects.r('list(E01=1.00, df=50. , phi=3.14 , T2_1=.800, DC=0.5)')
+            else:
+                start = robjects.r('list(E01=.100, phi= 0.  , T2_1=.100, DC=0.0)')
+                lower = robjects.r('list(E01=1e-6, phi=-3.13, T2_1=.001, DC=0.0)')
+                upper = robjects.r('list(E01=1.00, phi= 3.13, T2_1=.800, DC=0.5)')
+        else:
+            fmla = robjects.Formula('XY ~ c(Xc1( E01, df, tt, phi, T2_1), Yc1( E01, df, tt, phi, T2_1))')
+            if CorrectFreq:    
+                start = robjects.r('list(E01=.100, df=0     , phi=0.   ,  T2_1=.100)')
+                lower = robjects.r('list(E01=1e-6, df=-50. , phi=-3.14 ,  T2_1=.001)')
+                upper = robjects.r('list(E01=1.00, df=50.  , phi=3.14  ,  T2_1=.800)')
+            else:
+                start = robjects.r('list(E01=.100, phi= 0.  , T2_1=.100)')
+                lower = robjects.r('list(E01=1e-6, phi=-3.13, T2_1=.001)')
+                upper = robjects.r('list(E01=1.00, phi= 3.13, T2_1=.800)')
+
+    env = fmla.getenvironment()
+    env['Zero'] = Zero
+    env['X'] = X
+    env['Y'] = Y
+    env['XY'] = XY 
+    env['tt'] = tt
+
+    cont = robjects.r('nls.control(maxiter=10000, warnOnly=TRUE, printEval=FALSE)')
+    
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=start, control=cont, lower=lower, upper=upper, algorithm='port')) #, \
+    #fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=start, control=cont)) #, \
+    report =  r.summary(fit)
+
+    conv = r['$'](fit,'convergence')[0]
+    #if conv:
+    #    print (report)
+    #    print ("conv", conv)
+    print ("Conv",  r['$'](fit,'convergence'))  # T2
+    print (report)
+    
+    if BiExp:
+        if CorrectFreq:    
+            E0   =  r['$'](report,'par')[0]   # E01
+            E0  +=  r['$'](report,'par')[1]   # E02
+            df  =  r['$'](report,'par')[2]   # offset
+            phi =  r['$'](report,'par')[3]   # phase 
+            T2  =  r['$'](report,'par')[4]   # T2
+        else:
+            E0   =  r['$'](report,'par')[0]   # E01
+            E0  +=  r['$'](report,'par')[1]   # E02
+            phi =  r['$'](report,'par')[2]   # phase 
+            T2  =  r['$'](report,'par')[3]   # T2
+    else:
+        if CorrectFreq:    
+            E0   =  r['$'](report,'par')[0]   # E01
+            df  =  r['$'](report,'par')[1]   # offset
+            phi =  r['$'](report,'par')[2]   # phase 
+            T2  =  r['$'](report,'par')[3]   # T2
+        else:
+            E0   =  r['$'](report,'par')[0]   # E01
+            phi =  r['$'](report,'par')[1]   # phase 
+            T2  =  r['$'](report,'par')[2]   # T2
+    #phi = 0.907655876627
+    #phi = 0
+    #print ("df", df)# = 0
+    return conv, E0,df,phi,T2
+    
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressSpec(w, wL, X): #,sigma2=1,intercept=True):
+
+    # compute s
+    s = -1j*w
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    a   = 0                  # Linear 
+    rT2 = 0.1                # T2 regressed
+    r   = robjects.r         
+
+    # Variable shared between R and Python
+    robjects.globalenv['a'] = a
+    robjects.globalenv['rT2'] = rT2
+    robjects.globalenv['wL'] = wL
+    robjects.globalenv['nb'] = 0
+
+    s = robjects.ComplexVector(numpy.array(s))
+    XX = robjects.ComplexVector(X)
+    Xr = robjects.FloatVector(numpy.real(X))
+    Xi = robjects.FloatVector(numpy.imag(X))
+    Xa = robjects.FloatVector(numpy.abs(X))
+    Xri = robjects.FloatVector(numpy.concatenate((Xr,Xi)))
+    
+    #my_lower = robjects.r('list(a=.001, rT2=.001, nb=.0001)')
+    my_lower = robjects.r('list(a=.001, rT2=.001)')
+    #my_upper = robjects.r('list(a=1.5, rT2=.300, nb =100.)')
+    my_upper = robjects.r('list(a=1.5, rT2=.300)')
+     
+    #my_list = robjects.r('list(a=.2, rT2=0.03, nb=.1)')
+    my_list = robjects.r('list(a=.2, rT2=0.03)')
+    my_cont = robjects.r('nls.control(maxiter=5000, warnOnly=TRUE, printEval=FALSE)')
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    ##fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('XX ~ a*(wL) / (wL^2 + (s+1/rT2)^2 )') # complex
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 )) + nb') # complex
+    fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 ))') # complex
+ 
+    env = fmla.getenvironment()
+    env['s'] = s
+    env['Xr'] = Xr
+    env['Xa'] = Xa
+    env['Xi'] = Xi
+    env['Xri'] = Xri
+    env['XX'] = XX
+     
+    #fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list, control=my_cont)) #, lower=my_lower, algorithm='port')) #, \
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    report =  r.summary(fit)
+    #print report 
+    #print  r.warnings()
+ 
+    a  =  r['$'](report,'par')[0]
+    rT2 =  r['$'](report,'par')[1]
+    nb =  r['$'](report,'par')[2]
+    
+    return a, rT2, nb
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressSpecComplex(w, wL, X): #,sigma2=1,intercept=True):
+
+    # compute s
+    s = -1j*w
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    a   = 1                  # Linear 
+    rT2 = 0.1                # T2 regressed
+    r   = robjects.r         
+    phi2 = 0                 # phase
+    wL2 = wL
+
+    # Variable shared between R and Python
+    robjects.globalenv['a'] = a
+    robjects.globalenv['rT2'] = rT2
+    robjects.globalenv['wL'] = wL
+    robjects.globalenv['wL2'] = 0
+    robjects.globalenv['nb'] = 0
+    robjects.globalenv['phi2'] = phi2
+
+    s = robjects.ComplexVector(numpy.array(s))
+    XX = robjects.ComplexVector(X)
+    Xr = robjects.FloatVector(numpy.real(X))
+    Xi = robjects.FloatVector(numpy.imag(X))
+    Xa = robjects.FloatVector(numpy.abs(X))
+    Xri = robjects.FloatVector(numpy.concatenate((X.real,X.imag)))
+
+    robjects.r(''' 
+        source('kernel.r')
+    ''')   
+    #Kw = robjects.globalenv['Kwri']
+     
+    #print (numpy.shape(X))
+    
+    #my_lower = robjects.r('list(a=.001, rT2=.001, nb=.0001)')
+    #my_lower = robjects.r('list(a=.001, rT2=.001)') # Working
+    my_lower = robjects.r('list(a=.001, rT2=.001, phi2=-3.14, wL2=wL-5)')
+    #my_upper = robjects.r('list(a=1.5, rT2=.300, nb =100.)')
+    my_upper = robjects.r('list(a=3.5, rT2=.300, phi2=3.14, wL2=wL+5)')
+     
+    #my_list = robjects.r('list(a=.2, rT2=0.03, nb=.1)')
+    my_list = robjects.r('list(a=.2, rT2=0.03, phi2=0, wL2=wL)')
+    my_cont = robjects.r('nls.control(maxiter=5000, warnOnly=TRUE, printEval=FALSE)')
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('Xi   ~   Im(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 ))') # envelope
+    #fmla = robjects.Formula('Xri ~ c(Re(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 )), Im(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 )))') # envelope
+    
+    #fmlar = robjects.Formula('Xr ~ (Kwr(a, phi2, s, rT2, wL)) ') # envelope
+    #fmlai = robjects.Formula('Xi ~ (Kwi(a, phi2, s, rT2, wL)) ') # envelope
+    fmla = robjects.Formula('Xri ~ c(Kwr(a, phi2, s, rT2, wL2), Kwi(a, phi2, s, rT2, wL2) ) ') # envelope
+    #fmla = robjects.Formula('Xri ~ (Kwri(a, phi2, s, rT2, wL)) ') # envelope
+    
+    #fmla = robjects.Formula('Xa ~ (abs(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('XX ~ a*(wL) / (wL^2 + (s+1/rT2)^2 )') # complex
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 )) + nb') # complex
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    
+    #        self.Gw[iw, iT2] = ((np.sin(phi2) *  (alpha + 1j*self.w[iw]) + self.wL*np.cos(phi2)) / \
+    #                               (self.wL**2 + (alpha+1.j*self.w[iw])**2 ))
+    #        self.Gw[iw, iT2] = ds * self.sc*((np.sin(phi2)*( alpha + 1j*self.w[iw]) + self.wL*np.cos(phi2)) / \
+    #                               (self.wL**2 + (alpha+1.j*self.w[iw])**2 ))
+    
+    # Works Amplitude Only!
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 ))') # complex
+ 
+    env = fmla.getenvironment()
+    env['s'] = s
+    env['Xr'] = Xr
+    env['Xa'] = Xa
+    env['Xi'] = Xi
+    env['Xri'] = Xri
+    env['XX'] = XX
+     
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list, control=my_cont)) #, lower=my_lower, algorithm='port')) #, \
+    #fitr = robjects.r.tryCatch(robjects.r.nls(fmlar, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    
+    #env = fmlai.getenvironment()
+    #fiti = robjects.r.tryCatch(robjects.r.nls(fmlai, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    
+    #reportr =  r.summary(fitr)
+    #reporti =  r.summary(fiti)
+    report =  r.summary(fit)
+    #print( report )
+    #exit()
+    #print( reportr )
+    #print( reporti  )
+    #exit()
+    #print  r.warnings()
+ 
+    #a   =  (r['$'](reportr,'par')[0] + r['$'](reporti,'par')[0]) / 2.
+    #rT2 =  (r['$'](reportr,'par')[1] + r['$'](reporti,'par')[1]) / 2.
+    #nb  =  (r['$'](reportr,'par')[2] + r['$'](reporti,'par')[2]) / 2.
+    a   =  r['$'](report,'par')[0] 
+    rT2 =  r['$'](report,'par')[1] 
+    nb  =  r['$'](report,'par')[2] #phi2 
+
+    print ("Python wL2", r['$'](report,'par')[3] )   
+    print ("Python zeta", r['$'](report,'par')[2] )   
+ 
+    return a, rT2, nb
+
+
+
+###################################################################
+###################################################################
+###################################################################
+if __name__ == "__main__":
+
+    dt    = .0001
+    T2    = .1
+    omega = 2000.*2*numpy.pi
+    phi   = .0
+    T     = 8.*T2
+    
+    t = numpy.arange(0, T, dt)
+
+    # Synthetic data, simple single decaying sinusoid 
+    # with a single decay parameter and gaussian noise added 
+    data = numpy.exp(-t/T2) * numpy.sin(omega * t + phi) + numpy.random.normal(0,.05,len(t)) \
+                         + numpy.random.randint(-1,2,len(t))*numpy.random.exponential(.2,len(t)) 
+    cdata = numpy.exp(-t/T2) * numpy.sin(omega * t + phi) #+ numpy.random.normal(0,.25,len(t))
+    #data = numpy.random.normal(0,.25,len(t))
+
+    sigma2 = numpy.std(data[::-len(data)/4])
+    #sigma2 = numpy.var(data[::-len(data)/4])
+    print("sigma2", sigma2)    
+    
+    [peaks,times,indices] = peakPicker(data, omega, dt)
+    
+    [b1,b2,rT2] = regressCurve(peaks,times)
+    print("rT2 nonweighted", rT2)
+    
+    [b1,b2,rT2] = regressCurve(peaks,times,sigma2)
+    print("rT2 weighted", rT2)
+
+    envelope   =  numpy.exp(-t/T2)
+    renvelope  =  numpy.exp(-t/rT2)
+
+    #outf = file('regress.txt','w')
+    #for i in range(len(times)):
+    #    outf.write(str(times[i]) + "   " +  str(peaks[i]) + "\n")  
+    #outf.close()
+
+    plt.plot(t,data, 'b')
+    plt.plot(t,cdata, 'g', linewidth=1)
+    plt.plot(t,envelope, color='violet', linewidth=4)
+    plt.plot(t,renvelope, 'r', linewidth=4)
+    plt.plot(times, numpy.array(peaks), 'bo', markersize=8, alpha=.25)
+    plt.legend(['noisy data','clean data','real envelope','regressed env','picks'])
+    plt.savefig("regression.pdf")
+
+
+    # FFT check
+    fourier = fft(data)
+    plt.figure()
+    freq = fftfreq(len(data), d=dt)
+    plt.plot(freq, (fourier.real))
+    
+    plt.show()
+
+    # TODO do a bunch in batch mode to see if T2 estimate is better with or without 
+    # weighting and which model is best.
+
+    # TODO try with real data
+
+    # TODO test filters (median, FFT, notch)
+
+    # It looks like weighting is good for relatively low sigma, but for noisy data
+    # it hurts us. Check

logbarrier.py

@@ -0,0 +1,212 @@
+from __future__ import division
+import numpy as np
+from scipy.sparse.linalg import iterative  as iter
+import pylab 
+import pprint 
+from scipy.optimize import nnls 
+
+def PhiB(mux, muy, minVal, maxVal, x):
+    phib = mux * np.abs( np.sum(np.log( x-minVal)) )
+    #phib += np.abs( np.log(1. - maxVal / np.sum(x)) )
+    return phib
+    #phib += np.log std::log(maxVal - x.segment(ib*block, block).sum());
+    
+
+    #template < typename  Scalar >
+    #Scalar PhiB2 (const Scalar& minVal, const Scalar& maxVal, const VectorXr x,
+    #              const int& block, const int &nblocks) {
+    #    Scalar phib  = std::abs((x.array() - minVal).log().sum());
+    #    //phib      += std::abs((maxVal - x.array()).log().sum()*muy);
+    #    for (int ib=0; ib<nblocks; ++ib) {
+    #        //HiSegments(ib) = x.segment(ib*block, block).sum();
+    #        phib += Scalar(block)*std::log(maxVal - x.segment(ib*block, block).sum());
+    #    }
+    #    return phib;
+    #}
+
+def logBarrier(A, b, T2Bins, x_0=0, xr=0, alpha=10, mu1=10, mu2=10, smooth=False, MAXITER=70, fignum=1000, sigma=1, callback=None):
+    """Impliments a log barrier Tikhonov solution to a linear system of equations 
+        Ax = b  s.t.  x_min < x < x_max. A log-barrier term is used for the constraint
+    """
+    # TODO input
+    minVal = 0.0
+    maxVal = 1e8
+
+    Wd =    (np.eye(len(b)) / (sigma))        # Wd = eye( sigma )
+    WdTWd = (np.eye(len(b)) / (sigma**2))     # Wd = eye( sigma )
+
+    #print ("calculating AT WdT.Wd A ") # AT WdTWd A with known data matrix 
+    #print (" A.shape" , np.shape(A), np.shape(b))
+    ATWdTWdA = np.dot(A.conj().transpose(), np.dot( WdTWd, A ))     # TODO, implicit calculation instead?
+    N = np.shape(A)[1]                        # number of model
+    M = np.shape(A)[0]                        # number of data
+    SIGMA = .25  #.25 #.125 # .25 #.01#3e-1
+    EPSILON = 1e-35 # was 35 
+
+    # reference model
+    if np.size(xr) == 1:
+        xr =  np.zeros(N)     
+    
+    # initial guess
+    if np.size(x_0) == 1:
+        x = 1e-10 + np.zeros(N)     
+    else:
+        x = 1e-10 + x_0
+        
+    # Construct model constraint base   
+    #print ("constructing Phim")
+    Phim_base = np.zeros( [N , N] ) 
+    a1 = 1.0     # smallest
+    
+    # calculate largest term            
+    D1 = 1./abs(T2Bins[1]-T2Bins[0])
+    D2 = 1./abs(T2Bins[2]-T2Bins[1])
+    #a2 = 1. #(1./(2.*D1+D2))    # smooth
+    
+    if smooth == "Both":
+        #print ("SMOOTH")
+        # Smooth model
+        print ("Both small and smooth model")
+        for ip in range(N):
+            D1 = 0.
+            D2 = 0.
+            DMAX = 2./(T2Bins[1]-T2Bins[0])
+            if ip > 0:
+                D1 = 1./abs(T2Bins[ip]-T2Bins[ip-1])
+            if ip < N-1:
+                D2 = 1./abs(T2Bins[ip+1]-T2Bins[ip])
+            if ip > 0:
+                Phim_base[ip,ip-1] = -(D1)               # smooth in log space
+            if ip == 0:
+                Phim_base[ip,ip  ] =  (D1+D2) + a1       # Encourage a little low model, no a1
+            elif ip == N-1:
+                Phim_base[ip,ip  ] =  (D1+D2) + a1       # Penalize long decays
+            else:
+                Phim_base[ip,ip  ] =  (D1+D2) + a1       # Smooth and small
+            if ip < N-1:
+                Phim_base[ip,ip+1] = -(D2)               # smooth in log space
+
+        #Phim_base /= np.max(Phim_base)
+        #Phim_base += a1*np.eye(N)
+
+    elif smooth == "Smooth":
+        print ("Smooth model")
+        for ip in range(N):
+            if ip > 0:
+                Phim_base[ip,ip-1] = -1    # smooth in log space
+            if ip == 0:
+                Phim_base[ip,ip  ] = 1.0   # Encourage a little low model
+            elif ip == N-1:
+                Phim_base[ip,ip  ] = 8.0   # Penalize long decays
+            else:
+                Phim_base[ip,ip  ] = 2.0   # Smooth and small
+            if ip < N-1:
+                Phim_base[ip,ip+1] = -1    # smooth in log space
+        #print(Phim_base)    
+
+    else: 
+        print ("SMALLEST")
+        # Smallest model
+        for ip in range(N):
+            Phim_base[ip,ip  ] = 1.
+    
+    Phi_m =  alpha*Phim_base
+    WmTWm = Phim_base # np.dot(Phim_base, Phim_base.T)            
+    b_pre = np.dot(A, x)
+
+    phid = np.linalg.norm( np.dot(Wd, (b-b_pre)) )**2
+    phim = np.linalg.norm( np.dot(Phim_base, (x-xr)) )**2
+
+    mu2 = phim
+    phib = PhiB(mu1, mu2, 0, 1e8, x) 
+    mu1 = ((phid + alpha*phim) / phib)
+
+    #print ("iteration", -1, mu1, mu2, phib, phid, phim, len(b))
+    for i in range(MAXITER):
+            
+        b_pre = np.dot(A, x)
+        phid = np.linalg.norm(np.dot(Wd, (b-b_pre)))**2
+        # technically phim should not be on WmTWm matrix. So no need to square result. 
+        phim = np.linalg.norm(np.dot(Phim_base, (x-xr)))#**2
+        phib = PhiB(mu1, mu2, 0, 1e8, x) 
+        Phi_m =  alpha*Phim_base
+        
+        mu1 = ((phid + alpha*phim) / phib) 
+
+        WmTWm = Phim_base # np.dot(Phim_base, Phim_base.T)            
+        #ztilde = x
+        #print("ztilde", ztilde)
+        phid_old = phid
+        inner = 0
+        First = True
+
+        while ( (phib / (phid+alpha*phim)) > EPSILON  or First==True ):
+
+            First = False
+            # Log barrier, keep each element above minVal
+            X1 = np.eye(N) * (x-minVal)**-1           
+            X2 = np.eye(N) * (x-minVal)**-2         
+            
+            # Log barrier, keep sum below maxVal TODO normalize by component. Don't want to push all down  
+            Y1 = np.eye(N) * (maxVal - np.sum(x))**-1           
+            Y2 = np.eye(N) * (maxVal - np.sum(x))**-2         
+            
+            AA = ATWdTWdA + mu1*X2 + mu2*Y2 + Phi_m 
+            M = np.eye( N ) * (1./np.diag(ATWdTWdA + mu1*X2 + mu2*Y2 + Phi_m))
+        
+            # Solve system (newton step) 
+            b2 = np.dot(A.transpose(), np.dot(WdTWd, b-b_pre) ) + 2.*mu1*np.diag(X1) + 2.*mu2*np.diag(Y1) - alpha*np.dot(WmTWm,(x-xr))
+            ztilde = iter.cg(AA, b2, M=M) # tol=1e-3*phid, maxiter=200, callback=callback) #, tol=1e-2, maxiter) #, x0=x) #, tol=ttol) #, M=M, x0=x)        
+            h = (ztilde[0]) 
+            
+            # Solve system (direct solution) 
+            #b2 = np.dot(A.conj().transpose(), np.dot(WdTWd, b)) + 2.*mu1*np.diag(X1) + 2.*mu2*np.diag(Y1) - alpha*np.dot(WmTWm,(x-xr))
+            #ztilde = iter.cg(AA, b2, x0=x) #, tol=1e-2) #, x0=x) #, tol=ttol) #, M=M, x0=x)        
+            #h = (ztilde[0].real - x) 
+
+            # step size
+            d = np.min( (1, 0.95 * np.min(x/np.abs(h+1e-120))) )
+            
+            ##########################################################
+            # Update and fix any over/under stepping
+            x = x+d*h 
+            #x = np.max( ( (minVal+1e-120)*np.ones(N),  x+d*h), 0)
+        
+            # Determine mu steps to take
+            s1 = mu1 * (np.dot(X2, ztilde[0].real) - 2.*np.diag(X1))
+            s2 = mu2 * (np.dot(Y2, ztilde[0].real) - 2.*np.diag(Y1))
+
+            # determine mu for next step
+            mu1 = SIGMA/N * np.abs(np.dot(s1, x))
+            mu2 = SIGMA/N * np.abs(np.dot(s2, x))
+            
+            b_pre = np.dot(A, x)
+            phid = np.linalg.norm(np.dot(Wd, (b-b_pre)))**2
+            phim = np.linalg.norm(np.dot(Phim_base, (x-xr)))#**2
+            phib = PhiB(mu1, mu2, minVal, maxVal, x)
+            inner += 1
+        
+        # determine alpha
+        scale = (len(b)/phid)
+        alpha *= scale  #**(1/6) 
+
+        score = np.sqrt(phid/(len(b)+1.)) # unbiased  
+ 
+        # check stopping criteria 
+        if score < 1: 
+            print ("*overshot* optimal solution found") #, alpha, score)
+            break
+        if score < 1.1: # or np.linalg.norm(x_old-x) < 1e-5 or phid > phid_old:
+            #print ("overshoot")
+            #alpha *= 10
+            print ("optimal solution found") #, alpha, score)
+            break
+        if i > 10 and (np.sqrt(phid_old/(len(b)+1.)) - score) < 1e-2: # 1e-2
+            print ("slow convergence") #, alpha, score, i, scale, score-np.sqrt(phid_old/len(b)))
+            break
+            
+    print ( "alpha","phid", "iter", "search", "prior" )
+    print ( alpha, score, i, scale, np.sqrt(phid_old/(len(b)+1)))
+
+    return x
+

notch.py

@@ -0,0 +1,37 @@
+from numpy import pi, cos, zeros
+
+def notch(x, R, fn, dt, scale=True):
+    '''Simple Pole and Zero Notch Filter. Note that this filter 
+    is not zero phase, if you need a zero phase filter use 
+    zpnotch.
+    x                        # Input Sequence
+    fn                       # Frequency to Filter 
+    R                        # Pole and Zero locations
+    dt                       # Sampling rate
+    '''
+    wn = 2. * pi * fn * dt    
+    b0 = 1.
+    b1 = -2.*cos(wn)
+    b2 = 1.
+    a1 = -R*2.*cos(wn)
+    a2 = R*R
+
+    if scale == True:
+        sc = (1. + a1 + a2)/(b0 + b1 + b2)
+        b0 *= sc
+        b1 *= sc
+        b2 *= sc
+
+    xnm1 = 0.
+    xnm2 = 0.
+    ynm1 = 0.
+    ynm2 = 0.
+    y = zeros(len(x))
+    for i in range(len(x)):
+        y[i] = b0*x[i]+b1*xnm1+b2*xnm2-a1*ynm1-a2*ynm2
+        xnm2 = xnm1
+        xnm1 = x[i]
+        ynm2 = ynm1
+        ynm1 = y[i]
+
+    return y

plotHE.py

@@ -0,0 +1,67 @@
+from plotdata import *
+
+if __name__ == "__main__":
+    print sys.argv
+    colour = ['blue','red','green']
+    ic = 0
+        
+    #plt.figure(2) 
+    #axmine = plt.gca()
+    #axmine2 = plt.twinx()
+    
+    for f in sys.argv[1::]:
+        ORS = ORSProc(f)
+        ORS.WindowAndStack()
+        ORS.T2EnvelopeDetect()
+        
+        #mono, rfit, [a0,b0,mt2] = ORS.MonoFit()
+        #env, mod, Time = ORS.DistFit( a0 )
+        #env, mod, Time = ORS.DistFit(  )
+
+        # Subtract DC term before 2D fit? Kind of kludgy but I don't see a way around it right now. 
+
+        plt.figure(1)
+        print ORS.T2T, ORS.T2D
+        plt.plot((1e-6*ORS.T2T**3), np.log(np.imag(ORS.T2D)), 'o', markersize=8)
+        #plt.plot(ORS.T2T, np.real(ORS.T2D))
+        #plt.plot(ORS.T2T, mono, '--',label=rfit, color=colour[ic])
+        #plt.plot(ORS.T2T, a0+env, '-+', color=colour[ic], label='dist')
+        #plt.plot(ORS.T2T, env, '-+',color=colour[ic], label='dist')
+        #plt.legend()
+
+        #guess = np.zeros( len(Time.T2Bins ) )
+        #total = np.zeros( len(Time.T2Bins ) )
+        #ib = 0
+        #for bins in Time.T2Bins:
+        #    if bins > mt2:
+        #        guess[ib] = a0 + b0
+        #        total[ib] = np.sum( mod ) # TODO find log norm and plot there instead! 
+        #        break
+        #    ib += 1
+     
+        #LogMeanT2 = numpy.exp(numpy.sum(PWC*numpy.log(T2BINS), axis=1) / theta ) 
+        #theta = np.sum(mod)
+        #LogMeanT2 = np.exp(np.sum( mod * np.log(Time.T2Bins) ) / theta ) 
+
+        #plt.figure(2) 
+        #axmine.plot(Time.T2Bins, mod, linewidth=2, label=f, color=colour[ic])
+        #axmine2.plot(Time.T2Bins, guess, '--',color=colour[ic], linewidth=2, label="guess")
+        #axmine2.plot(mt2, a0+b0, 'o',color=colour[ic], markersize=8, label="guess")
+        #axmine2.plot(Time.T2Bins, guess, '-',color=colour[ic], linewidth=2, label="total")
+        #axmine2.plot(LogMeanT2, theta, 's',color=colour[ic], markersize=8, label="total")
+        ic += 1
+    #axmine2.set_ylim([0, axmine2.get_ylim()[1]])
+    #leg = axmine2.legend(numpoints=1)
+    plt.xlabel(r"$\tau_e^2$ [s]", color='black', fontsize=16)
+    #plt.ylabel(r"$T_2$ [s]", color='black')
+    plt.ylabel(r"signal [rku]", color='black', fontsize=16)
+    #axmine.set_ylabel(r"$A_0$ [i]", color='black')
+    
+    #plt.figure(1)
+    #plt.savefig(sys.argv[1].strip(".ors")+"_comp1DT2.pdf", facecolor='white', edgecolor='white', dpi=200)
+    
+    #plt.figure(2)
+    #plt.savefig(sys.argv[1].strip(".ors")+"_comp2DT2.pdf", facecolor='white', edgecolor='white', dpi=200)
+    plt.savefig("hahn.pdf")
+    plt.show()
+    exit() 

pwctimeWhite.py

@@ -0,0 +1,343 @@
+#import matplotlib
+#matplotlib.rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
+#matplotlib.rc('text', usetex = True)
+#matplotlib.rc('font', family='times')
+
+from matplotlib.colors import LogNorm
+from math import modf
+import matplotlib
+import numpy as np
+import pylab as plt
+from scipy.sparse.linalg import cg
+#from scipy.linalg.iterative import bicgstab
+from scipy.sparse.linalg import iterative  as iter # import bicgstab 
+#from iterative import bicgstab
+from matplotlib.ticker import FuncFormatter
+
+#from smooth import smooth
+from logbarrier import logBarrier
+from cmath import phase
+from decay import *
+
+class pwcTime:
+    """Simple class for evaluating pwc extimation in the time domain"""
+
+    def __init__(self):
+        self.T2Limits = np.zeros(2)
+        self.T2Bins   = np.zeros(1)
+        self.Larmor   = 0.
+        self.wL       = 0.
+        self.dt       = 1e-4
+        # TODO this is critical and strange in FD, maybe error in mapping
+        self.T        = 3. 
+        #self.dead     = 0.01327 # Wurks
+        self.dead     = 0.0  #15 #1e-3 #031415926 #.05# (np.pi*2)/(2000.)  #0.01 #13
+        self.phi      = 0.   # phase 
+        self.t        = np.arange(self.dead, self.T, self.dt)
+        self.nt       = len(self.t)
+        self.G        = np.zeros((2,2))
+        self.Gw       = np.zeros((2,2))
+
+    def setPhi(self, phiIn):
+        self.phi = phiIn
+
+    def setT2(self, low, high, number, spacing):
+        """ Sets the low and high limits of the T2 bins"""
+        # Log spaced
+        self.T2Limits[0] = low
+        self.T2Limits[1] = high
+        #self.T2Bins = np.arange(np.log(low), np.log(high), (np.log(high)-np.log(low))/number, endpoint=True)
+        #self.T2Bins = np.linspace(np.log(low), np.log(high), (np.log(high)-np.log(low))/number, endpoint=True)
+        #self.T2Bins = np.exp( self.T2Bins )
+        #print ("T2Bins", self.T2Bins)
+        if spacing == "Log_10":
+            self.T2Bins = np.logspace( np.log10(low), np.log10(high), num=number, endpoint=True, base=10 ) # base=10
+        elif spacing == "Log_2":
+            self.T2Bins = np.logspace( np.log2(low), np.log2(high), num=number, endpoint=True, base=2 ) # base=10
+        elif spacing == "Log_e":
+            self.T2Bins = np.logspace( np.log(low), np.log(high), num=number, endpoint=True, base=np.e ) # base=10
+        elif spacing == "Linear":
+            self.T2Bins = np.linspace( low, high, num=number, endpoint=True ) # base=10
+        else:
+            print("In setT2, spacing not recognized")
+            exit(1)
+        #print ("T2Bins", self.T2Bins)
+        #exit()
+
+
+
+    def setLarmor(self, freq):
+        """ Set the Larmor frequency, in Hz"""
+        self.Larmor = freq
+        self.wL = np.pi * 2. * freq
+
+    #def setSampling (self, dtin, Tin):
+    #    self.T = Tin
+    #    self.dt = dtin
+    #    self.t  = np.arange(self.dead, self.T, self.dt)
+    #    self.nt       = len(self.t)
+    
+    def setSampling (self, times):
+        self.T  = times[-1]
+        self.dt = times[1] - times[0]
+        self.t  = times 
+        self.nt = len(self.t)
+
+    def getSampling(self):
+        return self.dt
+
+    def getNumT2(self):
+        """Returns the number of T2Bins"""
+        return len(self.T2Bins)
+
+    def getNumTime(self):
+        """ Returns the number of times """
+        return self.nt
+        
+    def generateGenv(self):
+        """ Fills in the matrix G, this is for spin-spin decay only """
+        #nt = (int) ( (self.T-self.dead) / self.dt)
+        nT2 = len(self.T2Bins)
+        
+        # rows are times, cols are T2 bins
+        self.Genv = np.zeros((self.nt, nT2))
+
+        # could do this w/o loops but who cares for this
+        for iT2 in range(len(self.T2Bins)):
+            for it in range(len(self.t)):
+                self.Genv[it, iT2] = np.exp(-self.t[it]/self.T2Bins[iT2]) 
+    
+    def generateJGKernel(self, TauE, Times, D_w, G , DTau):
+        gamma_H = 26752. #/ (2*np.pi)     # rad G^-1 s^-1 (wL = 2 pi gamma B0) TODO be aware of 2 pi term.
+
+        #print( "TauE", TauE )
+        #print( "D_w", D_w )
+        #print( "G", G )
+        #print( "Times", Times )
+
+        ntt = 0
+        for time in TauE:
+            ntt += len(Times[time])
+
+        self.JG = np.zeros( (ntt, len(G)) )
+
+        #print ("JG", self.JG)               
+        
+        for gg in range(len(G)):
+            it = 0 
+            for TE in TauE:
+                #print("TE", TE) NOTE in Dunn, this should be \tau == TE/2
+                tau = TE/2. 
+                #T2D =  ( 3. * (gamma_H**2) * (G[gg]**2) * D_w * ((tau)**2) ) # Dunn
+                #T2D = (D_w/3.) * tau * gamma_H**2 * G[gg]**2 # Keating 2009 
+                
+                T2D = (D_w * (tau**DTau) * (gamma_H**2) * (G[gg]**2) ) / 3. # Keating 2009 
+                for t in Times[TE]:
+                    self.JG[it, gg] = np.exp( -t * T2D ) 
+                    it += 1
+
+        #plt.matshow(self.JG)
+        #plt.colorbar()
+        #plt.show()
+
+    def generateGDenv(self, TauE, Times, D, Gbins, Jg, DTau):
+        """ Generates a diffusion sensitivity matrix
+            TauE is an array of the TE echo times 
+            Times is a Dictionary of the Times so that Times[TauE[0]]...Times[TauE[-1]] are all 1D arrays of times
+            D is an array of the D times.
+        """
+        #G = 10.                  # G/cm ORS Tool 
+        #G =  6.                  # G/cm VC Mid field 
+        #G =  .6                   # G/cm VC Mid field ?
+
+        ##################################################
+        # Vista Clara with water 
+        # G = 100 Iteration 10 5.05285635664        
+        # G = 60  Iteration 10 4.75446648427
+        # G = 10  Iteration 10 1.8  
+        # G =  6  Iteration 10 1.1 
+        # G =  3  Iteration 10 0.870649020301 
+        #print( "TauE", TauE )
+        #print( "D", D )
+        #print( "Gbins", Gbins )
+        #print( "Times", Times )
+
+        #G =   .8                   # G/cm VC Mid field 
+        eta = 1                   # unitless
+                                  # TODO check units of gamma, and D. Are they both in si or cgs? 
+        gamma_H = 26752.          # rad G^-1 s^-1 (wL = 2 pi gamma B0) TODO be aware of 2 pi term.
+        #D_w = 1e-6 #2.3e-9       # diffusion of bulk water (Hurlimann 1995) diffusion limit
+        # 2.34e-9 #  [m^2/s]      # Spyrou.pdf   
+        # 2.34e-5 #  [cm^2/s]     # Spyrou.pdf   
+        # 
+        # D_w = .140 m^2/s        # Hayden --> .0000140   in cgs 
+
+        # So D *T_2 in cgs yields cm^2 -- which is the same as permeability ?? 
+  
+        # D_0
+        # Hurliman1995         D_0 = 2.3e-9   [m^2/s]  
+        # Hayden 2004          D_0 = .140     [m^2/s]
+        
+        # extrude Genv --> len(Tau_E) times more data and len(D) times more model
+        #self.GD = np.tile(self.Genv, (len(TauE)-1, len(D) ))
+        ntt = 0
+        nT2 = len(self.T2Bins)
+        #print (Times)
+        #print (np.concatenate(Times))
+        for time in TauE:
+            ntt += len(Times[time])
+
+        self.GD = np.zeros( (ntt , nT2*len(D)) )
+        #print (np.shape(self.GD))        
+      
+        """      
+                 [  {T2[0]D[0]}  {T2[1]D[0]} ... {T2[nt]D[nd]}  
+            G =  [  {T[0]TE[0]}
+                 [  {T[1]TE[0]}
+                        ...
+                 [  {T[0]TE[1]}
+                 [  {T[nt]TE[nTE]}
+        """ 
+        for d in range(len(D)):
+            for iT2 in range(len(self.T2Bins)):
+                #for it in range(len(self.t)):
+                #print ( "T2bins", self.T2Bins[iT2] )
+                it = 0 
+                for TE in TauE:
+                    tau = TE#/2.
+                    for t in Times[TE]:
+                        ig = 0
+                        for gg in Gbins:
+                            #print ( "Gradient info, gg=", gg, "J(g)", Jg[ig])
+                            #T2D =  (3* (gamma_H**2) * (gg**2) * D[d] * (tau**2) ) # (D[d]/12.) * ((gamma_H*G*(TE/2.))**2) # inverse
+                            tau = TE/2.
+                            #T2D =  ( 3. * (gamma_H**2) * (G[gg]**2) * D_w * ((tau)**2) ) # Dunn
+                            #T2D = (D[d]/3.) * tau * gamma_H**2 * gg**2 # Keating 2009 
+                            T2D = (D[d] * tau**DTau * gamma_H**2 * gg**2) / 3. # Keating 2009 
+                            self.GD[it, d*nT2+iT2] +=  Jg[ig] * np.exp(-t/self.T2Bins[iT2]) *  np.exp( -t * T2D ) 
+                            ig += 1
+                        it += 1
+        
+        # now scale this bastard
+        #TEs = np.ones( len(TauE) *  )    
+        #plt.figure() 
+        #plt.matshow(self.GD)
+        #plt.colorbar()
+        #plt.show()
+        
+    def plotGenv(self):
+        # Make plot for SEG 
+        def tformatter(x, pos):
+            return '%1.2f' %(x*self.dt)
+        def t2formatter(x, pos):
+            return '%0.3f' %(self.T2Bins[0] + x*(self.T2Bins[1]-self.T2Bins[0]))
+        fig = plt.figure(997, facecolor='white')
+        #self.G += 1. + 1e-3
+        plt.imshow(np.abs(self.Genv), aspect='auto', cmap='jet', norm=LogNorm(vmin=1e-4, vmax = 1.)  )
+        cb = plt.colorbar()
+        ax = plt.gca()
+        for t in cb.ax.get_yticklabels():
+            t.set_color("black")
+            t.set_fontsize(16) 
+        for t in cb.ax.get_yticklines():
+            t.set_color("black")
+        cb.ax.spines['top'].set_color('black')
+        cb.ax.spines['bottom'].set_color('black')
+        cb.ax.spines['left'].set_color('black')
+        cb.ax.spines['right'].set_color('black')
+        cb.set_label(r"amplitude", color=('black'))
+        formatter = FuncFormatter(tformatter)
+        ax.yaxis.set_major_formatter(formatter)
+        wformatter = FuncFormatter(t2formatter)
+        ax.xaxis.set_major_formatter(wformatter)
+        ax.set_xlabel(r"$T_2$ [s]", color = 'black')
+        ax.set_ylabel(r"time [s]", color = 'black')
+        ax.spines['top'].set_color('black')
+        ax.spines['bottom'].set_color('black')
+        ax.spines['left'].set_color('black')
+        ax.spines['right'].set_color('black')
+        for line in ax.yaxis.get_ticklines():
+            line.set_color('black')
+        for line in ax.yaxis.get_ticklabels():
+            line.set_color('black')
+            line.set_fontsize(16)
+        for line in ax.xaxis.get_ticklines():
+            line.set_color('black')
+        for line in ax.xaxis.get_minorticklines():
+            line.set_color('black')
+        for line in ax.xaxis.get_ticklabels():
+            line.set_color('black')
+            line.set_fontsize(16)
+        plt.savefig('timeenvmatrix.png', dpi=200, facecolor='white', edgecolor='white')
+
+ 
+if __name__ == "__main__":
+
+    Time = pwcTime()
+    Time.setT2(.01, .6, 60)
+    Time.setSampling(1e-3, 2)
+    Time.generateGenv()
+
+    # Generate some noisy data
+    model = np.zeros(Time.getNumT2())
+   
+    #model[5]  = .05
+    model[16]  = .1
+    model[17]  = .15
+    model[18]  = .15
+    model[19]  = .1
+    #model[10] = .05
+ 
+    model[52] = .1
+    model[53] = .2
+    model[54] = .1
+
+   
+    sigma = .02 * .4 
+    noise = np.random.normal(0, sigma, Time.getNumTime())
+ 
+    dataenv = np.dot(Time.Genv, model) + noise
+    cleanenv = np.dot(Time.Genv, model) #+ noise)
+    
+    # monoexponential fit
+    [a0,b0,rt20] =  regressCurve(dataenv, Time.t, intercept=True) #
+    print(a0, b0, rt20)
+    T2R =  a0 + b0*np.exp(-np.array(Time.t)/rt20)
+    guess = np.zeros( len(Time.T2Bins ) )
+    ib = 0
+    for bins in Time.T2Bins:
+        if bins > rt20:
+            guess[ib] = a0 + b0
+            break
+        ib += 1 
+    #exit()   
+
+    #timemodenv  = logBarrier(Time.Genv, dataenv, x_0=guess, xr=guess, MAXITER=500, sigma=sigma, alpha=1e8) #, smooth=True)
+    timemodenv  = logBarrier(Time.Genv, dataenv, MAXITER=500, sigma=sigma, alpha=1e10, smooth=True) #, smooth=True)
+    preenv = np.dot(Time.Genv, timemodenv) #+ noise)
+   
+    # Data plot 
+    fig = plt.figure(facecolor='white')
+    axmine = fig.add_axes([.125,.1,.8,.8])
+    axmine.plot(Time.t, dataenv, color='red', alpha=.5, label='noisy data')
+    axmine.plot(Time.t, cleanenv, color='blue', linewidth=4, label='true')
+    axmine.plot(Time.t, preenv, color='green', linewidth=2, label='multi')
+    axmine.plot(Time.t, T2R, color='black', linewidth=2, label='mono')
+    #axmine.plot(Time.t, noise, color='purple', linewidth=1, label='noise')
+    #axmine.set_xscale("log", nonposx='clip')
+    plt.savefig("data2Dfits.pdf", facecolor='white', edgecolor='white', dpi=200)
+    plt.legend()
+
+    # Model plot 
+    plt.figure(1000)
+    plt.plot(Time.T2Bins, model, linewidth=3, color='green', label='true')
+    axmine = plt.gca() 
+    plt.semilogx(Time.T2Bins, timemodenv, color='purple', linewidth=2, label="multi-recovered")
+    plt.semilogx(Time.T2Bins, guess, color='red', linewidth=2, label="mono-recovered")
+    leg = plt.legend()
+    axmine.set_xlabel(r"$T_2$ [s]", color='black')
+    axmine.set_ylabel(r"$A_0$ [i]", color='black')
+    plt.savefig("modelreconstruct.pdf", facecolor='white', edgecolor='white', dpi=200)
+
+    plt.show()
+

smooth.py

@@ -0,0 +1,102 @@
+import numpy
+
+def smooth(x,window_len=11,window='hanning'):
+    """smooth the data using a window with requested size.
+    
+    This method is based on the convolution of a scaled window with the signal.
+    The signal is prepared by introducing reflected copies of the signal 
+    (with the window size) in both ends so that transient parts are minimized
+    in the begining and end part of the output signal.
+    
+    input:
+        x: the input signal 
+        window_len: the dimension of the smoothing window; should be an odd integer
+        window: the type of window from 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'
+            flat window will produce a moving average smoothing.
+
+    output:
+        the smoothed signal
+        
+    example:
+
+    t=linspace(-2,2,0.1)
+    x=sin(t)+randn(len(t))*0.1
+    y=smooth(x)
+    
+    see also: 
+    
+    numpy.hanning, numpy.hamming, numpy.bartlett, numpy.blackman, numpy.convolve
+    scipy.signal.lfilter
+ 
+    TODO: the window parameter could be the window itself if an array instead of a string   
+    """
+
+    if x.ndim != 1:
+        raise ValueError, "smooth only accepts 1 dimension arrays."
+
+    if x.size < window_len:
+        raise ValueError, "Input vector needs to be bigger than window size."
+
+
+    if window_len<3:
+        return x
+
+
+    if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']:
+        raise ValueError, "Window is on of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'"
+
+
+    s=numpy.r_[2*x[0]-x[window_len:1:-1],x,2*x[-1]-x[-1:-window_len:-1]]
+    #print(len(s))
+    if window == 'flat': #moving average
+        w=ones(window_len,'d')
+    else:
+        w=eval('numpy.'+window+'(window_len)')
+
+    y=numpy.convolve(w/w.sum(),s,mode='same')
+    return y[window_len-1:-window_len+1]
+
+
+
+
+from numpy import *
+from pylab import *
+
+def smooth_demo():
+
+    t=linspace(-4,4,100)
+    x=sin(t)
+    xn=x+randn(len(t))*0.1
+    y=smooth(x)
+
+    ws=31
+
+    subplot(211)
+    plot(ones(ws))
+
+    windows=['flat', 'hanning', 'hamming', 'bartlett', 'blackman']
+
+    hold(True)
+    for w in windows[1:]:
+        eval('plot('+w+'(ws) )')
+
+    axis([0,30,0,1.1])
+
+    legend(windows)
+    title("The smoothing windows")
+    subplot(212)
+    plot(x)
+    plot(xn)
+    for w in windows:
+        plot(smooth(xn,10,w))
+    l=['original signal', 'signal with noise']
+    l.extend(windows)
+
+    legend(l)
+    title("Smoothing a noisy signal")
+    show()
+
+
+if __name__=='__main__':
+    smooth_demo()
+