Improvements to reload of dmp files

akvo/gui/akvoGUI.py

             #self.ui.logTextBrowser.append( yaml.dump(self.YamlNode)) #, default_flow_style=False)  )
         #except KeyError:
         #    pass
-       
         # Remove "Saved" and "Loaded" from processing flow 
         #if "Loaded" not in self.YamlNode.Processing.keys():
         #    self.YamlNode.Processing["Loaded"] = []
         self.ui.lcdNumberNQ.setEnabled(True)
 
         self.ui.headerFileBox.setEnabled(True)
-        self.ui.headerFileBox.setChecked( False )
+        self.ui.headerFileBox.setChecked( True )
+        self.headerBoxShrink() 
         #self.ui.headerBox2.setVisible(True) 
-        self.ui.inputRAWParametersBox.setEnabled(True)
+        self.ui.inputRAWParametersBox.setEnabled(False)
         self.ui.loadDataPushButton.setEnabled(True)
         
-        # make plots as you import the dataset
+        # make plots as you import the datasetmost
         self.ui.plotImportCheckBox.setEnabled(True)
         self.ui.plotImportCheckBox.setChecked(True)
+
+        # enable the LCDs
+        self.ui.lcdNumberFID1Length.setEnabled(1)
+        self.ui.lcdNumberFID2Length.setEnabled(1)
+        self.ui.lcdNumberResampFreq.setEnabled(1)
+        self.ui.lcdTotalDeadTime.setEnabled(1)
+        
+        self.ui.lcdTotalDeadTime.display( 1e3*self.RAWDataProc.DATADICT["INFO"]["deadTime"] )
+        self.ui.headerFileTextBrowser.clear( ) 
+        self.ui.headerFileTextBrowser.append( self.RAWDataProc.DATADICT["INFO"]["headerstr"] )
+            
+        self.ui.lcdNumberFID1Length.display(self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][-1]- self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][0])
  
         # Update info from the header into the GUI
         self.ui.pulseTypeTextBrowser.clear()
         self.ui.lcdNumberNuTx.display(self.RAWDataProc.transFreq)
         self.ui.lcdNumberTauPulse1.display(1e3*self.RAWDataProc.pulseLength[0])
         self.ui.lcdNumberTuneuF.display(self.RAWDataProc.TuneCapacitance)
-        self.ui.lcdNumberSampFreq.display(self.RAWDataProc.samp)
+        self.ui.lcdNumberResampFreq.display(self.RAWDataProc.samp)
+        self.ui.lcdNumberSampFreq.display(50000) # TODO, if non GMR is supported, query
         self.ui.lcdNumberNQ.display(self.RAWDataProc.nPulseMoments)
         self.ui.DeadTimeSpinBox.setValue(1e3*self.RAWDataProc.deadTime)
         self.ui.CentralVSpinBox.setValue( self.RAWDataProc.transFreq )
         self.ui.logTextBrowser.append( yaml.dump(self.YamlNode)) #, default_flow_style=False)  )
 
     def disable(self):
+        self.ui.inputRAWParametersBox.setEnabled(False)
         self.ui.BandPassBox.setEnabled(False)
         self.ui.downSampleGroupBox.setEnabled(False)
         self.ui.windowFilterGroupBox.setEnabled(False)
         
         # FD Adaptive filtering 
         self.ui.adaptFDBox.setEnabled(True)
-        self.ui.adaptFDBox.setChecked(True)
+        self.ui.adaptFDBox.setChecked(False)
+        
+        # Harmonic
+        self.ui.harmonicBox.setEnabled(True)
+        self.ui.harmonicBox.setChecked(True)
 
         # sum group box
         try:
     def harmonicModel(self):
         self.lock("harmonic noise modelling")
         thread.start_new_thread(self.RAWDataProc.harmonicModel, \
-                (self.ui.f0Spin.value(), \
-                self.ui.mplwidget))
+                ( \
+                 self.ui.NHarmonicsFreqsSpin.value(), \
+                 self.ui.NKHarmonicsSpin.value(), \
+                 self.ui.f0Spin.value(), \
+                 self.ui.f1Spin.value(), \
+                 self.ui.plotHarmonic.isChecked(), \
+                 self.ui.mplwidget) \
+        )
 
     def FDSmartStack(self):
 
         
         thread.start_new_thread(self.RAWDataProc.downsample, \
                 (self.ui.truncateSpinBox.value(), \
-                self.ui.downSampleSpinBox.value(),
+                self.ui.downSampleSpinBox.value(), \
+                self.ui.dsPlot.isChecked(), \
                 self.ui.mplwidget))
 
     def quadDet(self):

akvo/tressel/harmonic.py

         t = time samples 
     """
     
-    A = np.exp(1j* np.tile( np.arange(1,nK+1),(len(t), 1)) * 2*np.pi* (f0/fs) * np.tile(np.arange(len(t)),(nK,1)).T  )
+    A = np.exp(1j* np.tile( np.arange(1,nK+1),(len(t), 1)) * 2*np.pi* (f0/fs) * np.tile( np.arange(1, len(t)+1, 1),(nK,1)).T  )
 
     v = np.linalg.lstsq(A, sN, rcond=None) 
     alpha = np.real(v[0]) 
 
     h = np.zeros(len(t))
     for ik in range(nK):
-        h +=  2*amp[ik] * np.cos( 2.*np.pi*(ik+1) * (f0/fs) * np.arange(0, len(t), 1 )  + phase[ik] )
+        h +=  2*amp[ik] * np.cos( 2.*np.pi*(ik+1) * (f0/fs) * np.arange(1, len(t)+1, 1 )  + phase[ik] )
     
     return sN-h
     
         nK = number of harmonics to calculate 
         t = time samples 
     """
-    A1 = np.exp(1j* np.tile( np.arange(1,nK+1),(len(t), 1)) * 2*np.pi* (f0/fs) * np.tile(np.arange(len(t)),(nK,1)).T  )
-    A2 = np.exp(1j* np.tile( np.arange(1,nK+1),(len(t), 1)) * 2*np.pi* (f1/fs) * np.tile(np.arange(len(t)),(nK,1)).T  )
+    A1 = np.exp(1j* np.tile( np.arange(1,nK+1),(len(t), 1)) * 2*np.pi* (f0/fs) * np.tile(np.arange(1, len(t)+1, 1),(nK,1)).T  )
+    A2 = np.exp(1j* np.tile( np.arange(1,nK+1),(len(t), 1)) * 2*np.pi* (f1/fs) * np.tile(np.arange(1, len(t)+1, 1),(nK,1)).T  )
     A = np.concatenate( (A1, A2), axis=1 )
 
 
 
     h = np.zeros(len(t))
     for ik in range(nK):
-        h +=  2*amp[ik]  * np.cos( 2.*np.pi*(ik+1) * (f0/fs) * np.arange(0, len(t), 1 )  + phase[ik] ) + \
-              2*amp1[ik] * np.cos( 2.*np.pi*(ik+1) * (f1/fs) * np.arange(0, len(t), 1 )  + phase1[ik] )
+        h +=  2*amp[ik]  * np.cos( 2.*np.pi*(ik+1) * (f0/fs) * np.arange(1, len(t)+1, 1 )  + phase[ik] ) + \
+              2*amp1[ik] * np.cos( 2.*np.pi*(ik+1) * (f1/fs) * np.arange(1, len(t)+1, 1 )  + phase1[ik] )
 
     return sN-h
 
     f02 = guessf0(sN, fs)
     print("minHarmonic", f0, fs, nK, " guess=", f02)
     # CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg, trust-krylov, trust-exact and trust-constr
-    res = minimize(harmonicNorm, np.array((f02)), args=(sN, fs, nK, t), jac='2-point', method='BFGS') #, jac=jacEuler) #, hess=None, bounds=None )
+    res = minimize(harmonicNorm, np.array((f0)), args=(sN, fs, nK, t), jac='2-point', method='BFGS') #, jac=jacEuler) #, hess=None, bounds=None )
     print(res)
     return harmonicEuler(res.x[0], sN, fs, nK, t)#[0]
 
     phi2 = 2.*np.pi*np.random.rand() - np.pi
     print("phi", phi, phi2)
     A =  1.0
-    A2 = 1.0 
+    A2 = 0.0 
     A3 = 1.0 
     nK = 10
     T2 = .200
 
     # single freq
     #h = harmonicEuler( f0, sN, fs, nK, t) 
-    #h = minHarmonic( f0, sN, fs, nK, t) 
+    h = minHarmonic( f0, sN, fs, nK, t) 
     
     # two freqs 
-    h = minHarmonic2( f0+1e-2, f1-1e-2, sN, fs, nK, t) 
+    #h = minHarmonic2( f0+1e-2, f1-1e-2, sN, fs, nK, t) 
     #h = harmonicEuler2( f0, f1, sN, fs, nK, t) 
 
     plt.figure()

akvo/tressel/mrsurvey.py

         canvas.draw()
         self.doneTrigger.emit() 
 
-    def harmonicModel(self, f0, canvas):
-        print("harmonic modelling...", f0)
-        plot = True
+    def harmonicModel(self, nF, nK, f0, f1, plot, canvas):
+        #print("harmonic modelling...", f0)
+        #plot = True
         if plot:
             canvas.reAx2()
             canvas.ax1.tick_params(axis='both', which='major', labelsize=8)
                             canvas.ax1.plot( self.DATADICT[pulse]["TIMES"], 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
                                 label = "orig " +  pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " rchan="  + str(ichan))
 
-                        self.DATADICT[pulse][ichan][ipm][istack] = harmonic.minHarmonic( f0, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 20, self.DATADICT[pulse]["TIMES"] ) 
+                        self.DATADICT[pulse][ichan][ipm][istack] = harmonic.minHarmonic( f0, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 45, self.DATADICT[pulse]["TIMES"] ) 
                         #self.DATADICT[pulse][ichan][ipm][istack] = harmonic.minHarmonic2( f0-1e-2, f0+1e-2, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 30, self.DATADICT[pulse]["TIMES"] ) 
 
                         # plot
                             canvas.ax2.plot( self.DATADICT[pulse]["TIMES"], 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
                                 label = "orig " +  pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " chan="  + str(ichan))
                         
-                        self.DATADICT[pulse][ichan][ipm][istack] = harmonic.minHarmonic( f0, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 20, self.DATADICT[pulse]["TIMES"] ) 
+                        self.DATADICT[pulse][ichan][ipm][istack] = harmonic.minHarmonic( f0, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 45, self.DATADICT[pulse]["TIMES"] ) 
                         #self.DATADICT[pulse][ichan][ipm][istack] = harmonic.minHarmonic2( f0-1e-2, f0+1e-2, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 30, self.DATADICT[pulse]["TIMES"] ) 
                         #self.DATADICT[pulse][ichan][ipm][istack] = harmonic.harmonicEuler( f0, self.DATADICT[pulse][ichan][ipm][istack], self.samp, 20, self.DATADICT[pulse]["TIMES"] ) 
                
            
         return [bord, self.fe] 
 
-    def downsample(self, truncate, dec, canvas):
+    def downsample(self, truncate, dec, plot, canvas):
         """ Downsamples and truncates the raw signal. 
         """
         canvas.reAx2()
                             self.DATADICT[pulse][ichan][ipm][istack] = self.DATADICT[pulse][ichan][ipm][istack][0:itrunc]
                             RSTIMES = RSTIMES[0:itrunc]
 
-
-                    for ichan in self.DATADICT[pulse]["chan"]:
-                        canvas.ax2.plot( RSTIMES, 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
-                            label = pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " ichan="  + str(ichan))
-                    for ichan in self.DATADICT[pulse]["rchan"]:
-                        canvas.ax1.plot( RSTIMES, 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
-                            label = pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " ichan="  + str(ichan))
+                    if plot:
+                        for ichan in self.DATADICT[pulse]["chan"]:
+                            canvas.ax2.plot( RSTIMES, 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
+                                label = pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " ichan="  + str(ichan))
+                        for ichan in self.DATADICT[pulse]["rchan"]:
+                            canvas.ax1.plot( RSTIMES, 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
+                                label = pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " ichan="  + str(ichan))
                     
-                    canvas.ax1.set_xlabel(r"time [s]", fontsize=8)
-                    canvas.ax1.set_ylabel(r"signal [nV]", fontsize=8)
-                    canvas.ax2.set_xlabel(r"time [s]", fontsize=8)
-                    canvas.ax2.set_ylabel(r"signal [nV]", fontsize=8)
+                        canvas.ax1.set_xlabel(r"time [s]", fontsize=8)
+                        canvas.ax1.set_ylabel(r"signal [nV]", fontsize=8)
+                        canvas.ax2.set_xlabel(r"time [s]", fontsize=8)
+                        canvas.ax2.set_ylabel(r"signal [nV]", fontsize=8)
                     
-                    canvas.ax1.legend(prop={'size':6})
-                    canvas.ax2.legend(prop={'size':6})
-                    canvas.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 
-                    canvas.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 
-                    canvas.draw() 
+                        canvas.ax1.legend(prop={'size':6})
+                        canvas.ax2.legend(prop={'size':6})
+                        canvas.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 
+                        canvas.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 
+                        canvas.draw() 
                 percent = (int)(1e2*((float)(iFID*self.DATADICT["nPulseMoments"]+(ipm))/( len(self.DATADICT["PULSES"])*self.nPulseMoments)))
                 self.progressTrigger.emit(percent)
             iFID += 1