Inversion within the GUI is functional.

akvo/gui/akvoGUI.py

@@ -164,6 +164,8 @@ class ApplicationWindow(QtWidgets.QMainWindow):
         # Kernel         
         self.ui.calcK0.pressed.connect( self.calcK0 )       
 
+        # Inversion
+        self.ui.invertButton.pressed.connect( self.QTInv )
 
         # META 
         self.ui.locEdit.editingFinished.connect( self.logSite )
@@ -316,6 +318,49 @@ class ApplicationWindow(QtWidgets.QMainWindow):
             self.ui.ProcTabs.removeTab(0)    
             self.ui.ProcTabs.removeTab(0)    
     
+    def QTInv(self):
+        print("Big RED INVERT BUTTON")
+        
+        try:
+            with open('.akvo.last.path') as f: 
+                fpath = f.readline()  
+                pass
+        except IOError as e:
+            fpath = '.'
+        
+        akvoDatafile = QtWidgets.QFileDialog.getOpenFileName(self, 'Select Datafile File', fpath, r"Akvo datafiles (*.yaml)")[0]
+        K0file = QtWidgets.QFileDialog.getOpenFileName(self, 'Select Kernel File', fpath, r"Akvo kernels (*.yml)")[0]
+
+        T2lo = self.ui.T2low.value()
+        T2hi = self.ui.T2hi.value()
+        NT2 = self.ui.NT2.value()
+        dataChan = self.ui.invChan.currentText()
+       
+        invDict = dict()
+        invDict["data"] = dict()
+        invDict["data"] = dict() 
+        invDict["data"][akvoDatafile] = dict()
+        invDict["data"][akvoDatafile]["channels"] = [dataChan,]
+        invDict["K0"] = [K0file,]
+        invDict["T2Bins"] = dict()
+        invDict["T2Bins"]["low"] = T2lo
+        invDict["T2Bins"]["high"] = T2hi
+        invDict["T2Bins"]["number"] = NT2
+        
+        node = yaml.YAML()
+        kpo = open( "invert.yml", 'w' )
+        node.dump(invDict, kpo)
+ 
+        callBox = callScript(  ) #QtWidgets.QDialog() 
+        
+        callBox.ui = Ui_callScript()
+        callBox.ui.setupUi( callBox )
+        callBox.setupQTInv( "invert.yml" )
+        
+        callBox.exec_()
+        callBox.show()
+            
+
     def calcK0(self):
         
         try:

akvo/gui/callScript.py

@@ -26,6 +26,22 @@ class callScript(QDialog):
         #self.process.start('python', ['calcAkvoKernel.py', akvoData, TxCoil, SaveStr])
         self.process.start('akvoK0', [ akvoData, TxCoil, kernelParams, SaveStr])
 
+    def setupQTInv(self, params):
+
+        #QtGui.QWidget.__init__(self)
+        #uic.loadUi('redirect.ui', self)
+
+        #print ('Connecting process')
+        self.process = QtCore.QProcess(self)
+        self.process.readyReadStandardOutput.connect(self.stdoutReady)
+        self.process.readyReadStandardError.connect(self.stderrReady)
+        self.process.started.connect(lambda: p('Started!'))
+        self.process.finished.connect(lambda: p('Finished!'))
+
+        #print ('Starting process')
+        #self.process.start('python', ['calcAkvoKernel.py', akvoData, TxCoil, SaveStr])
+        self.process.start('akvoQT', [params])
+
     def append(self, text):
         cursor = self.ui.textEdit.textCursor()
         cursor.movePosition(cursor.End)

akvo/gui/main.ui

@@ -3759,10 +3759,10 @@ background: dark grey;
                   <number>1</number>
                  </property>
                  <property name="maximum">
-                  <number>14</number>
+                  <number>18</number>
                  </property>
                  <property name="value">
-                  <number>3</number>
+                  <number>8</number>
                  </property>
                 </widget>
                </item>
@@ -4008,8 +4008,8 @@ background: dark grey;
               <rect>
                <x>0</x>
                <y>0</y>
-               <width>100</width>
-               <height>30</height>
+               <width>96</width>
+               <height>26</height>
               </rect>
              </property>
              <attribute name="label">
@@ -4021,8 +4021,8 @@ background: dark grey;
               <rect>
                <x>0</x>
                <y>0</y>
-               <width>411</width>
-               <height>67</height>
+               <width>96</width>
+               <height>26</height>
               </rect>
              </property>
              <attribute name="label">
@@ -4033,29 +4033,137 @@ background: dark grey;
           </widget>
           <widget class="QWidget" name="InvertTab">
            <attribute name="title">
-            <string>INV</string>
+            <string>QT Inversion</string>
            </attribute>
-           <widget class="QPushButton" name="invertButton">
-            <property name="geometry">
-             <rect>
-              <x>130</x>
-              <y>140</y>
-              <width>311</width>
-              <height>141</height>
-             </rect>
-            </property>
-            <property name="styleSheet">
-             <string notr="true">#invertButton {
+           <layout class="QVBoxLayout" name="verticalLayout_12">
+            <item>
+             <widget class="QGroupBox" name="groupBox_2">
+              <property name="maximumSize">
+               <size>
+                <width>16777215</width>
+                <height>200</height>
+               </size>
+              </property>
+              <property name="title">
+               <string>QT T2* distribution</string>
+              </property>
+              <layout class="QGridLayout" name="gridLayout_18">
+               <item row="0" column="0">
+                <widget class="QLabel" name="label_76">
+                 <property name="text">
+                  <string>T2* Low (ms)</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="0" column="1">
+                <widget class="QDoubleSpinBox" name="T2low">
+                 <property name="minimum">
+                  <double>1.000000000000000</double>
+                 </property>
+                 <property name="maximum">
+                  <double>30.000000000000000</double>
+                 </property>
+                 <property name="value">
+                  <double>10.000000000000000</double>
+                 </property>
+                </widget>
+               </item>
+               <item row="1" column="0">
+                <widget class="QLabel" name="label_77">
+                 <property name="text">
+                  <string>T2* High (ms)</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="1" column="1">
+                <widget class="QDoubleSpinBox" name="T2hi">
+                 <property name="minimum">
+                  <double>10.000000000000000</double>
+                 </property>
+                 <property name="maximum">
+                  <double>2000.000000000000000</double>
+                 </property>
+                 <property name="value">
+                  <double>1000.000000000000000</double>
+                 </property>
+                </widget>
+               </item>
+               <item row="2" column="0">
+                <widget class="QLabel" name="label_78">
+                 <property name="text">
+                  <string>N T2*</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="2" column="1">
+                <widget class="QSpinBox" name="NT2">
+                 <property name="minimum">
+                  <number>10</number>
+                 </property>
+                 <property name="value">
+                  <number>35</number>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </widget>
+            </item>
+            <item>
+             <widget class="QGroupBox" name="groupBox_6">
+              <property name="title">
+               <string>QT Inversion</string>
+              </property>
+              <layout class="QGridLayout" name="gridLayout_19">
+               <item row="1" column="0">
+                <widget class="QLabel" name="label_79">
+                 <property name="text">
+                  <string>Data channel</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="1" column="1">
+                <widget class="QComboBox" name="invChan">
+                 <item>
+                  <property name="text">
+                   <string>Chan. 1</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>Chan. 2</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>Chan. 3</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>Chan. 4</string>
+                  </property>
+                 </item>
+                </widget>
+               </item>
+               <item row="2" column="0" colspan="2">
+                <widget class="QPushButton" name="invertButton">
+                 <property name="styleSheet">
+                  <string notr="true">#invertButton {
 font-size:29pt;
 font-weight: bold;
 color: white;
 background: red;
 }</string>
-            </property>
-            <property name="text">
-             <string>Invert</string>
-            </property>
-           </widget>
+                 </property>
+                 <property name="text">
+                  <string>Invert</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </widget>
+            </item>
+           </layout>
           </widget>
           <widget class="QWidget" name="AppraiseTab">
            <attribute name="title">

akvo/terminal/plotKernel.py

@@ -19,6 +19,7 @@ def catLayers(K0):
         #print(K0["layer-"+str(lay)].data) #    print (lay)
         K[lay] = K0["layer-"+str(lay)].data #    print (lay)
     return K
+
 if __name__ == "__main__":
 
     with open(sys.argv[1]) as f:

akvo/tressel/SlidesPlot.py

@@ -0,0 +1,34 @@
+#################################################################################
+# GJI final pub specs                                                           #
+import matplotlib                                                               #
+from matplotlib import rc                                                           #
+matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath,amssymb}"]  #
+rc('font',**{'family':'sans-serif','serif':['timet']})                                   #
+rc('font',**{'size':11})                                                             #
+rc('text', usetex=True)                                                             #
+# converts pc that GJI is defined in to inches                                      # 
+# In GEOPHYSICS \textwidth = 42pc                                               #
+#        \columnwidth = 20pc                                                    #
+#        one column widthe figures are 20 picas                                 #
+#        one and one third column figures are 26 picas                          #
+def pc2in(pc):                                                                  #
+    return pc*12/72.27                                                          #
+#################################################################################
+import numpy as np
+light_grey = np.array([float(248)/float(255)]*3)
+
+def fixLeg(legend):
+    rect = legend.get_frame()
+    #rect.set_color('None')
+    rect.set_facecolor(light_grey)
+    rect.set_linewidth(0.0)
+    rect.set_alpha(0.5)
+
+def deSpine(ax1):
+    spines_to_remove = ['top', 'right']
+    for spine in spines_to_remove:
+        ax1.spines[spine].set_visible(False)
+    #ax1.xaxis.set_ticks_position('none')
+    #ax1.yaxis.set_ticks_position('none')
+    ax1.get_xaxis().tick_bottom()
+    ax1.get_yaxis().tick_left()

akvo/tressel/calcAkvoKernel.py

@@ -147,6 +147,7 @@ def main():
     yml = open( sys.argv[4], 'w' )
     print(Kern, file=yml)
 
+    # 
     K0 = Kern.GetKernel()
     plt.matshow(np.abs(K0))
     plt.show()

akvo/tressel/invertTA.py

@@ -0,0 +1,218 @@
+from akvo.tressel.SlidesPlot import *
+import numpy as np
+import sys
+import matplotlib.pyplot as plt
+import cmocean
+from pylab import meshgrid 
+from akvo.tressel.logbarrier import *
+import yaml,os
+
+from matplotlib.colors import LogNorm
+from matplotlib.colors import LightSource
+from matplotlib.ticker import ScalarFormatter
+from matplotlib.ticker import MaxNLocator
+from matplotlib.ticker import AutoMinorLocator
+from matplotlib.ticker import LogLocator
+from matplotlib.ticker import FormatStrFormatter
+import cmocean
+from akvo.tressel.lemma_yaml import * 
+
+def buildKQT(K0,tg,T2Bins):
+    """ 
+        Constructs a QT inversion kernel from an initial amplitude one.  
+    """
+    nlay, nq = np.shape(K0)
+    nt2 = len(T2Bins)
+    nt = len(tg)
+    KQT = np.zeros( ( nq*nt,nt2*nlay) )
+    for iq in range(nq):
+        for it in range(nt):
+            for ilay in range(nlay):
+                for it2 in range(nt2):
+                    #KQT[iq*nt + it,ilay*nt2+it2] = K0[ilay,iq]*np.exp(-((10+tg[it])*1e-3)/(1e-3*T2Bins[it2]))
+                    KQT[iq*nt + it,ilay*nt2+it2] = K0[ilay,iq]*np.exp(-((10+tg[it])*1e-3)/(1e-3*T2Bins[it2]))
+    return KQT
+
+def loadAkvoData(fnamein, chan):
+    """ Loads data from an Akvo YAML file. The 0.02 is hard coded as the pulse length. This needs to be 
+        corrected in future kernel calculations. The current was reported but not the pulse length. 
+    """
+    fname = (os.path.splitext(fnamein)[0])
+    with open(fnamein, 'r') as stream:
+        try:
+            AKVO = (yaml.load(stream, Loader=yaml.Loader))
+        except yaml.YAMLError as exc:
+            print(exc)
+            exit()
+
+    Z = np.zeros( (AKVO.nPulseMoments, AKVO.Gated["Pulse 1"]["abscissa"].size ) )
+    ZS = np.zeros( (AKVO.nPulseMoments, AKVO.Gated["Pulse 1"]["abscissa"].size ) )
+    for q in range(AKVO.nPulseMoments):
+        Z[q] = AKVO.Gated["Pulse 1"][chan]["Q-"+str(q) + " CA"].data
+        if chan == "Chan. 1":
+            ZS[q] = AKVO.Gated["Pulse 1"][chan]["STD"].data
+        elif chan == "Chan. 2":
+            ZS[q] = AKVO.Gated["Pulse 1"][chan]["STD"].data
+        elif chan == "Chan. 3":
+            ZS[q] = AKVO.Gated["Pulse 1"][chan]["STD"].data
+        elif chan == "Chan. 4":
+            ZS[q] = AKVO.Gated["Pulse 1"][chan]["STD"].data
+        else:
+            print("DOOM!!!")
+            exit()
+    #Z *= 1e-9 
+    #ZS *= 1e-9 
+
+    J = AKVO.Pulses["Pulse 1"]["current"].data 
+    J = np.append(J,J[-1]+(J[-1]-J[-2]))
+    Q = AKVO.pulseLength[0]*J
+    return Z, ZS, AKVO.Gated["Pulse 1"]["abscissa"].data  #, Q
+
+def catLayers(K0):
+    K = np.zeros( (len(K0.keys()), len(K0["layer-0"].data)) , dtype=complex )
+    for lay in range(len(K0.keys())):
+        #print(K0["layer-"+str(lay)].data) #    print (lay)
+        K[lay] =K0["layer-"+str(lay)].data #    print (lay)
+    return 1e9*K                           # invert in nV
+
+def loadK0(fname):
+    """ Loads in initial amplitude kernel
+    """
+    print("loading K0", fname)
+    with open(fname) as f:
+        K0 = yaml.load(f, Loader=yaml.Loader)
+    K = catLayers(K0.K0)
+    ifaces = np.array(K0.Interfaces.data)
+    return ifaces, np.abs(K)
+
+
+
+def main():
+
+    if (len (sys.argv) < 3):
+        print ("python invertTA.py  K0.dat  Data.yaml")
+    print (sys.argv[1])
+    with open(sys.argv[1], 'r') as stream:
+        try:
+            cont = (yaml.load(stream, Loader=yaml.Loader))
+        except yaml.YAMLError as exc:
+            print(exc)
+    ###############################################
+    # Load in data
+    ###############################################
+    V = []
+    VS = []
+    tg = 0
+    for dat in cont['data']:
+        for ch in cont['data'][dat]['channels']:
+            print("dat", dat, "ch", ch)
+            v,vs,tg = loadAkvoData(dat, ch)
+            V.append(v)
+            VS.append(vs)
+    for iv in range(1, len(V)):
+        V[0] = np.concatenate( (V[0], V[iv]) )
+        VS[0] = np.concatenate( (VS[0], VS[iv]) )
+    V = V[0]
+    VS = VS[0]
+    
+    #plt.matshow(V, cmap='RdBu', vmin=-np.max(np.abs(V)), vmax=np.max(np.abs(V)))
+    #plt.title("data")
+    #plt.colorbar()
+    #plt.show()
+    #exit()    
+
+    #plt.matshow(VS, cmap='inferno', vmin=-np.max(np.abs(VS)), vmax=np.max(np.abs(VS)))
+    #plt.title("error")
+    #plt.colorbar()
+
+    ###############################################
+    # Load in kernels
+    ###############################################
+    K0 = []
+    for kern in cont["K0"]:
+        ifaces,k0 = loadK0( kern )
+        K0.append(k0)
+    for ik in range(1, len(K0)):
+        K0[0] = np.concatenate( (K0[0].T, K0[ik].T) ).T
+    K0 = K0[0]
+    #plt.matshow(K0)
+    
+    ###############################################
+    # Build full kernel
+    ############################################### 
+    T2Bins = np.logspace( np.log10(cont["T2Bins"]["low"]), np.log10(cont["T2Bins"]["high"]), cont["T2Bins"]["number"], endpoint=True, base=10)  
+    KQT = buildKQT(K0,tg,T2Bins)
+    #plt.matshow(KQT)
+
+    # Chan. 1    reg = 1.5   
+    # Chan. 2    reg = 1.35
+    # Chan. 4    reg = 1.95  
+ 
+    ###############################################
+    # Invert
+    ############################################### 
+    print("Calling inversion", flush=True)
+    inv, ibreak, errn, phim, phid, mkappa = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e6, smooth="Smallest" ) #, smooth=True) # 
+                     #logBarrier(A, b, T2Bins, lambdastar, x_0=0, xr=0, alpha=10, mu1=10, mu2=10, smooth=False, MAXITER=70, fignum=1000, sigma=1, callback=None):
+    #return x, ibreak, np.sqrt(phid/len(b)), PHIM, PHID/len(b), np.argmax(kappa)
+
+
+    ###############################################
+    # Appraise
+    ############################################### 
+    pre = np.dot(KQT,inv) 
+    PRE = np.reshape( pre, np.shape(V)  )
+    plt.matshow(PRE, cmap='Blues')
+    plt.gca().set_title("predicted")
+    plt.colorbar()
+
+    DIFF = (PRE-V) / VS
+    md = np.max(np.abs(DIFF))
+    plt.matshow(DIFF, cmap=cmocean.cm.balance, vmin=-md, vmax=md)
+    plt.gca().set_title("misfit / $\widehat{\sigma}$")
+    plt.colorbar()
+    
+    plt.matshow(V, cmap='Blues')
+    plt.gca().set_title("observed")
+    plt.colorbar()
+
+    T2Bins = np.append( T2Bins, T2Bins[-1] + (T2Bins[-1]-T2Bins[-2]) )
+    
+    print( np.shape(inv), len(ifaces)-1,cont["T2Bins"]["number"] )
+    INV = np.reshape(inv, (len(ifaces)-1,cont["T2Bins"]["number"]) )
+    Y,X = meshgrid( ifaces, T2Bins )
+    fig = plt.figure( figsize=(pc2in(17.0),pc2in(18.)) )
+    ax1 = fig.add_axes( [.2,.15,.6,.7] )
+    im = ax1.pcolor(X, Y, INV.T, cmap=cmocean.cm.tempo) #cmap='viridis')
+    im.set_edgecolor('face')
+    ax1.set_xlim( T2Bins[0], T2Bins[-1] )
+    ax1.set_ylim( ifaces[-1], ifaces[0] )
+    cb = plt.colorbar(im, label = u"PWC (m$^3$/m$^3$)") #, format='%1.1f')
+    cb.locator = MaxNLocator( nbins = 4)
+    cb.ax.yaxis.set_offset_position('left')                         
+    cb.update_ticks()
+ 
+    #ax1.set_xlabel(u"$T_2^*$ (ms)")
+    #ax1.set_ylabel(u"depth (m)$")
+    
+    ax1.get_xaxis().set_major_formatter(FormatStrFormatter('%1.0f'))
+    ax1.get_yaxis().set_major_formatter(FormatStrFormatter('%1.0f'))
+    ax1.xaxis.set_major_locator( MaxNLocator(nbins = 4) )   
+
+    #ax1.xaxis.set_label_position('top') 
+
+    ax2 = ax1.twiny()
+    ax2.plot( np.sum(INV, axis=1), (ifaces[1:]+ifaces[0:-1])/2 ,  color='red' )
+    ax2.set_xlabel(u"total water (m$^3$/m$^3$)")
+    ax2.set_ylim( ifaces[-1], ifaces[0] )
+    ax2.xaxis.set_major_locator( MaxNLocator(nbins = 3) )   
+    ax2.get_xaxis().set_major_formatter(FormatStrFormatter('%0.2f'))
+    #ax2.xaxis.set_label_position('bottom') 
+
+    plt.savefig("akvoInversion.pdf")
+    
+    plt.show()
+
+if __name__ == "__main__":
+    main() 
+

akvo/tressel/lemma_yaml.py

@@ -0,0 +1,121 @@
+import yaml
+    
+def Complex_ctor(loader, node):
+    re = eval(node.value[0][1].value)
+    im = eval(node.value[1][1].value)
+    return re + 1j*im 
+
+yaml.add_constructor(r'Complex', Complex_ctor)
+
+class MatrixXr(yaml.YAMLObject):
+    yaml_tag = u'MatrixXr'
+    def __init__(self, rows, cols, data):
+        self.rows = rows
+        self.cols = cols
+        self.data = np.zeros((rows,cols))
+    def __repr__(self):
+        return "%s(rows=%r, cols=%r, data=%r)" % (self.__class__.__name__, self.rows, self.cols, self.data) 
+
+class VectorXr(yaml.YAMLObject):
+    yaml_tag = r'VectorXr'
+    def __init__(self, array):
+        self.size = np.shape(array)[0]
+        self.data = array.tolist()
+    def __repr__(self):
+        # Converts to numpy array on import 
+        return "np.array(%r)" % (self.data)
+
+class VectorXcr(yaml.YAMLObject):
+    yaml_tag = r'VectorXcr'
+    def __init__(self, array):
+        self.size = np.shape(array)[0]
+        self.datar = array.tolist()
+    def __repr__(self):
+        # Converts to numpy array on import 
+        #return "np.array(%r)" % (self.data)
+        return "np.array(%r)" % (3)
+
+class Vector3r(yaml.YAMLObject):
+    yaml_tag = r'Vector3r'
+    def __init__(self, array):
+        self.size = 3 #np.shape(array)[0]
+        self.data = array.tolist()
+    def __repr__(self):
+        # Converts to numpy array on import 
+        return "np.array(%r)" % (self.data)
+
+class Vector3Xcr(yaml.YAMLObject):
+    yaml_tag = r'Vector3Xcr'
+    def __init__(self, array):
+        self.size = 3 #np.shape(array)[0]
+        self.data = array.tolist()
+    def __repr__(self):
+        # Converts to numpy array on import 
+        return "np.array(%r)" % (self.data)
+
+class Vector3Xr(yaml.YAMLObject):
+    yaml_tag = r'Vector3Xr'
+    def __init__(self, array):
+        self.size = 3 #np.shape(array)[0]
+        self.data = array.tolist()
+    def __repr__(self):
+        # Converts to numpy array on import 
+        return "np.array(%r)" % (self.data)
+
+#class KernelV0( ):
+    #yaml_tag = r'KernelV0'
+#    def __init__(self):
+#        self.name = "hello"
+
+#def KernelV0_constructor(loader, node):
+    #...     value = loader.construct_scalar(node)
+    #...     a, b = map(int, value.split('d'))
+#    return KernelV0( )
+
+
+# class KervnelV0(yaml.YAMLObject):
+#     yaml_loader = yaml.Loader
+#     yaml_dumper = yaml.Dumper
+# 
+#     yaml_tag = u'!KernelV0'
+#     #yaml_flow_style = ...
+# 
+#     def __init__(self):
+#         self.val = 7
+# 
+#     @classmethod
+#     def from_yaml(cls, loader, node):
+#         # ...
+#         data = 0
+#         return data
+# 
+#     @classmethod
+#     def to_yaml(cls, dumper, data):
+#         # ...
+#         return node
+
+class KervnelV0(yaml.YAMLObject):
+    yaml_tag = u'KernelV0'
+    def __init__(self, val):
+        self.val = val
+
+class LayeredEarthEM(yaml.YAMLObject):
+    yaml_tag = u'LayeredEarthEM'
+    def __init__(self, val):
+        self.val = val
+
+class PolygonalWireAntenna(yaml.YAMLObject):
+    yaml_tag = u'PolygonalWireAntenna'
+    def __init__(self, val):
+        self.val = val
+
+class AkvoData(yaml.YAMLObject):
+    yaml_tag = u'AkvoData'
+    def __init__(self, obj): #nPulseMoments, pulseLength):
+    #def __init__(self, rows, cols, data):
+        #self.nPulseMoments = nPulseMoments
+        #self.pulseLength = pulseLength 
+        #for key in obj.keys:
+        #    self[key] = obj.key
+        pass
+

akvo/tressel/logbarrier.py

@@ -0,0 +1,283 @@
+from __future__ import division
+import numpy as np
+from scipy.sparse.linalg import iterative  as iter
+from scipy.sparse import eye as seye
+import pylab 
+import pprint 
+from scipy.optimize import nnls 
+
+import matplotlib.pyplot as plt
+
+def PhiB(mux, minVal, x):
+    phib = mux * np.abs( np.sum(np.log( x-minVal)) )
+    return phib
+
+def curvaturefd(x, y, t):
+    x1 = np.gradient(x,t) 
+    x2 = np.gradient(x1,t) 
+    y1 = np.gradient(y,t) 
+    y2 = np.gradient(y1,t) 
+    return np.abs(x1*y2 - y1*x2) / np.power(x1**2 + y1**2, 3./2)
+
+def curvatureg(x, y):
+    from scipy.ndimage import gaussian_filter1d
+    #first and second derivative
+    x1 = gaussian_filter1d(x, sigma=1, order=1)#, mode='constant', cval=x[-1])
+    x2 = gaussian_filter1d(x1, sigma=1, order=1)#, mode='constant', cval=y[-1])
+    y1 = gaussian_filter1d(y, sigma=1, order=1)#, mode='constant', cval=x1[-1])
+    y2 = gaussian_filter1d(y1, sigma=1, order=1)#, mode='constant', cval=y1[-1])
+    return np.abs(x1*y2 - y1*x2) / np.power(x1**2 + y1**2, 3./2)
+
+def logBarrier(A, b, T2Bins, lambdastar, 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 )
+
+    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 # lower is more aggresive relaxation of log barrier  
+    EPSILON = 1e-25 #1e-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   
+    Phim_base = np.zeros( [N , N] ) 
+    a1 = .05     # smallest too
+    
+    # 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 ("Both small and smooth model")
+        for ip in range(N):
+            D1 = 0.
+            D2 = 0.
+            if ip > 0:
+                #D1 = np.sqrt(1./abs(T2Bins[ip]-T2Bins[ip-1]))**.5
+                D1 = (1./abs(T2Bins[ip]-T2Bins[ip-1])) #**2
+            if ip < N-1:
+                #D2 = np.sqrt(1./abs(T2Bins[ip+1]-T2Bins[ip]))**.5
+                D2 = (1./abs(T2Bins[ip+1]-T2Bins[ip])) #**2
+            if ip > 0:
+                Phim_base[ip,ip-1] =   -(D1)      
+            if ip == 0:
+                Phim_base[ip,ip  ] = 2.*(D1+D2)  
+            elif ip == N-1:
+                Phim_base[ip,ip  ] = 2.*(D1+D2) 
+            else:
+                Phim_base[ip,ip  ] = 2.*(D1+D2)
+            if ip < N-1:
+                Phim_base[ip,ip+1] =   -(D2)  
+        Phim_base /= np.max(Phim_base)            # normalize 
+        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  ] = 2.05   # Encourage a little low model
+            elif ip == N-1:
+                Phim_base[ip,ip  ] = 2.5   # Penalize long decays
+            else:
+                Phim_base[ip,ip  ] = 2.1   # Smooth and small
+            if ip < N-1:
+                Phim_base[ip,ip+1] = -1    # smooth in log space
+
+    elif smooth == "Smallest":
+        for ip in range(N):
+            Phim_base[ip,ip  ] = 1.
+    else: 
+        print("non valid model constraint:", smooth)
+        exit()
+    
+    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, 0, x) 
+    mu1 = ((phid + alpha*phim) / phib)
+
+    PHIM = []
+    PHID = []
+    MOD = []
+
+    ALPHA = []
+    ALPHA.append(alpha)
+    #ALPHA = np.linspace( alpha, 1, MAXITER  )
+    for i in range(MAXITER):
+        #alpha = ALPHA[i]
+
+        Phi_m =  alpha*Phim_base
+        
+        # reset mu1 at each iteration 
+        # Calvetti -> No ; Li -> Yes   
+        # without this, non monotonic convergence occurs...which is OK if you really trust your noise 
+        mu1 = ((phid + alpha*phim) / phib) 
+
+        WmTWm = Phim_base # np.dot(Phim_base, Phim_base.T)            
+        phid_old = phid
+        inner = 0
+
+        First = True # guarantee entry 
+
+        xp = np.copy(x) # prior step x 
+
+        while ( (phib / (phid+alpha*phim)) > EPSILON  or First==True ):
+        #while ( 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 + Phi_m 
+            M = np.eye( N ) * (1./np.diag(ATWdTWdA + mu1*X2 + Phi_m))
+            #M = seye( N ).dot(1./np.diag(ATWdTWdA + mu1*X2 + Phi_m))
+        
+            # Solve system (newton step) (Li)
+            b2 = np.dot(A.conj().transpose(), np.dot(WdTWd, b-b_pre) ) + 2.*mu1*np.diag(X1) - alpha*np.dot(WmTWm,(x-xr))
+            ztilde = iter.cg(AA, b2, M = M) 
+            h = (ztilde[0].real) 
+            
+            # Solve system (direct solution) (Calvetti) 
+            #b2 = np.dot(A.conj().transpose(), np.dot(WdTWd, b)) + 2.*mu1*np.diag(X1) - alpha*np.dot(WmTWm,(x-xr))
+            #ztilde = iter.cg(AA, b2, 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 += d*h
+        
+            # 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, minVal, x)
+            inner += 1
+ 
+        PHIM.append(phim)      
+        PHID.append(phid)      
+        MOD.append(np.copy(x))  
+
+        # determine alpha
+        scale = 1.5*(len(b)/phid)
+        #alpha *= np.sqrt(scale)
+        alpha *= min(scale, .95) # was .85...
+        #print("alpha", min(scale, 0.99))
+        #alpha *= .99 # was .85...
+        ALPHA.append(alpha)
+        #alpha = ALPHA[i+1]
+            
+        print("inversion progress", i, alpha, np.sqrt(phid/len(b)), phim, flush=True)       
+        
+
+#         if np.sqrt(phid/len(b)) < 0.97: 
+#             ibreak = -1
+#             print ("------------overshot--------------------", alpha, np.sqrt(phid/len(b)), ibreak)
+#             alpha *= 2. #0
+#             x -= d*h
+#             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
+#             mu1 = ((phid + alpha*phim) / phib)
+        if lambdastar == "discrepency": 
+            if np.sqrt(phid/len(b)) < 1.00 or alpha < 1e-5: 
+                ibreak = 1
+                print ("optimal solution found", alpha, np.sqrt(phid/len(b)), ibreak)
+                break
+        # slow convergence, bail and use L-curve 
+        # TI- only use L-curve. Otherwise results for perlin noise are too spurious for paper.  
+        if lambdastar == "lcurve":
+            if i > 4: 
+                kappa = curvaturefd(np.log(np.array(PHIM)), np.log(np.array(PHID)), ALPHA[0:i+1])#ALPHA[0:-1])
+                #kappa = curvatureg(np.log(np.array(PHIM)), np.log(np.array(PHID)))
+                print("max kappa", np.argmax(kappa), "distance from", i-np.argmax(kappa)) 
+            if i > 4 and (i-np.argmax(kappa)) > 4: # ((np.sqrt(phid_old/len(b))-np.sqrt(phid/len(b))) < 1e-4) : 
+            #if np.sqrt(phid/len(b)) < 3.0 and ((np.sqrt(phid_old/len(b))-np.sqrt(phid/len(b))) < 1e-3): 
+                ibreak = 1
+                MOD = np.array(MOD)
+                print ("###########################") #slow convergence", alpha, "phid_old", np.sqrt(phid_old/len(b)), "phid", np.sqrt(phid/len(b)), ibreak)
+                print ("Using L-curve criteria") 
+                #kappa = curvaturefd(np.log(np.array(PHIM)), np.log(np.array(PHID)), ALPHA[0:-1])
+                #kappa2 = curvatureg(np.log(np.array(PHIM)), np.log(np.array(PHID)))
+                #kappa = curvature( np.array(PHIM), np.array(PHID))
+                x = MOD[ np.argmax(kappa) ]
+                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
+                mu1 = ((phid + alpha*phim) / phib) 
+                print ("L-curve selected", alpha, "phid_old", np.sqrt(phid_old/len(b)), "phid", np.sqrt(phid/len(b)), ibreak)
+                print ("###########################")
+                if np.sqrt(phid/len(b)) <= 1:
+                    ibreak=0
+
+                plt.figure()
+                #plt.plot( (np.array(PHIM)),  np.log(np.array(PHID)/len(b)), '.-')
+                #plt.plot(  ((np.array(PHIM))[np.argmax(kappa)]) , np.log( (np.array(PHID)/len(b))[np.argmax(kappa)] ), '.', markersize=12)
+                #plt.axhline()
+                plt.plot( np.log(np.array(PHIM)),  np.log(np.sqrt(np.array(PHID)/len(b))), '.-')
+                plt.plot( np.log(np.array(PHIM))[np.argmax(kappa)], np.log(np.sqrt(np.array(PHID)/len(b))[np.argmax(kappa)]), '.', markersize=12)
+                ax2 = plt.twinx()
+                ax2.plot( np.log(np.array(PHIM)), kappa, color='green', label="lcurve" )
+                plt.legend()
+                plt.savefig('lcurve.pdf')
+                break
+
+    PHIM = np.array(PHIM)
+    PHID = np.array(PHID)
+
+    if (i == MAXITER-1 ):
+        ibreak = 2
+        print("Reached max iterations!!", alpha, np.sqrt(phid/len(b)), ibreak)
+        kappa = curvaturefd(np.log(np.array(PHIM)), np.log(np.array(PHID)), ALPHA[0:-1])
+        x = MOD[ np.argmax(kappa) ]
+        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
+        mu1 = ((phid + alpha*phim) / phib) 
+
+    if lambdastar == "lcurve":
+        return x, ibreak, np.sqrt(phid/len(b)), PHIM, PHID/len(b), np.argmax(kappa)
+    else:
+        return x, ibreak, np.sqrt(phid/len(b))
+
+
+
+if __name__ == "__main__":
+    print("Test")

setup.py

@@ -21,7 +21,7 @@ with open("README.md", "r") as fh:
     long_description = fh.read()
 
 setup(name='Akvo',
-      version='1.3.5',
+      version='1.3.6',
       python_requires='>3.7.0', # due to pyLemma
       description='Surface nuclear magnetic resonance workbench',
       long_description=long_description,
@@ -61,6 +61,7 @@ setup(name='Akvo',
               'console_scripts': [
                   'akvo = akvo.gui.akvoGUI:main',                  
                   'akvoK0 = akvo.tressel.calcAkvoKernel:main',                  
+                  'akvoQT = akvo.tressel.invertTA:main',                  
               ],              
           },
       #cmdclass = cmdclass,