only add passive to menu if it exists

Author: mayofaulkner

atlaselectrophysiology/ephys_atlas_gui.py

@@ -1117,13 +1117,14 @@ def data_button_pressed(self):
                 'LF')
             self.img_lfp_data, self.probe_lfp_data = self.plotdata.get_lfp_spectrum_data()
             self.line_fr_data, self.line_amp_data = self.plotdata.get_fr_amp_data_line()
-            (self.probe_rfmap_on_data, self.probe_rfmap_off_data,
-             self.rfmap_boundaries) = self.plotdata.get_rfmap_data()
+            self.probe_rfmap, self.rfmap_boundaries = self.plotdata.get_rfmap_data()
             self.img_stim_data = self.plotdata.get_passive_events()
             self.slice_data = self.loaddata.get_slice_images(self.ephysalign.xyz_samples)
 
             self.data_status = True
 
+            self.init_menubar()
+
         # Initialise checked plots
         self.img_init.setChecked(True)
         self.line_init.setChecked(True)

atlaselectrophysiology/ephys_gui_setup.py

@@ -16,7 +16,7 @@ def init_layout(self, main_window, offline=False):
         main_widget = QtWidgets.QWidget()
         self.setCentralWidget(main_widget)
 
-        self.init_menubar()
+        #self.init_menubar()
         self.init_interaction_features()
         self.init_figures()
 
@@ -103,7 +103,7 @@ def init_menubar(self):
         img_options.addAction(scatter_amp)
         self.img_options_group.addAction(scatter_amp)
 
-        stim_type = ['valveOn', 'toneOn', 'noiseOn', 'leftGabor', 'rightGabor']
+        stim_type = list(self.img_stim_data.keys())
         for stim in stim_type:
             img = QtGui.QAction(stim, self, checkable=True, checked=False)
             img.triggered.connect(lambda checked, item=stim: self.plot_image(
@@ -137,12 +137,15 @@ def init_menubar(self):
         probe_rmsAP.triggered.connect(lambda: self.plot_probe(self.probe_rms_APdata))
         probe_rmsLFP = QtGui.QAction('rms LFP', self, checkable=True, checked=False)
         probe_rmsLFP.triggered.connect(lambda: self.plot_probe(self.probe_rms_LFPdata))
-        probe_on_rfmap = QtGui.QAction('RF Map - On', self, checkable=True, checked=False)
-        probe_on_rfmap.triggered.connect(lambda: self.plot_probe(self.probe_rfmap_on_data,
-                                                                 bounds=self.rfmap_boundaries))
-        probe_off_rfmap = QtGui.QAction('RF Map - Off', self, checkable=True, checked=False)
-        probe_off_rfmap.triggered.connect(lambda: self.plot_probe(self.probe_rfmap_off_data,
-                                                                  bounds=self.rfmap_boundaries))
+
+
+
+        #probe_on_rfmap = QtGui.QAction('RF Map - On', self, checkable=True, checked=False)
+        #probe_on_rfmap.triggered.connect(lambda: self.plot_probe(self.probe_rfmap_on_data,
+        #                                                         bounds=self.rfmap_boundaries))
+        #probe_off_rfmap = QtGui.QAction('RF Map - Off', self, checkable=True, checked=False)
+        #probe_off_rfmap.triggered.connect(lambda: self.plot_probe(self.probe_rfmap_off_data,
+        #                                                          bounds=self.rfmap_boundaries))
         # Initialise with rms of AP probe plot
         self.probe_init = probe_rmsAP
 
@@ -167,10 +170,14 @@ def init_menubar(self):
             probe_options.addAction(probe)
             self.probe_options_group.addAction(probe)
 
-        probe_options.addAction(probe_on_rfmap)
-        self.probe_options_group.addAction(probe_on_rfmap)
-        probe_options.addAction(probe_off_rfmap)
-        self.probe_options_group.addAction(probe_off_rfmap)
+        sub_types = list(self.probe_rfmap.keys())
+        for sub in sub_types:
+            probe = QtGui.QAction(f'RF Map - {sub}', self, checkable=True, checked=False)
+            probe.triggered.connect(lambda checked, item=sub: self.plot_probe(
+                                    self.probe_rfmap[item], bounds=self.rfmap_boundaries))
+            probe_options.addAction(probe)
+            self.probe_options_group.addAction(probe)
+
 
         # SLICE PLOTS MENU BAR
         # Define all coronal slice plot options

atlaselectrophysiology/load_data.py

@@ -417,6 +417,7 @@ def upload_dj(self, align_qc, ephys_qc, ephys_desc):
 
     def update_qc(self, upload_alyx=True, upload_flatiron=True):
         # if resolved just update the alignment_number
+        upload_flatiron=False
         align_qc = AlignmentQC(self.probe_id, one=self.one, brain_atlas=self.brain_atlas)
         align_qc.load_data(prev_alignments=self.alignments, xyz_picks=self.xyz_picks,
                            depths=self.chn_depths, cluster_chns=self.cluster_chns)

atlaselectrophysiology/plot_data.py

@@ -451,10 +451,9 @@ def avg_chn_depth(a):
             return data_img, data_probe
 
     def get_rfmap_data(self):
+        data_img = dict()
         if not self.rfmap_data_status:
-            data_img_on = None
-            data_img_off = None
-            return data_img_on, data_img_off, None
+            return data_img, None
         else:
 
             (rf_map_times, rf_map_pos,
@@ -466,43 +465,35 @@ def get_rfmap_data(self):
                                               self.spikes['depths'][self.spike_idx][self.kp_idx],
                                               D_BIN=160)
             rfs_svd = passive.get_svd_map(rf_map)
-
-            img_on = np.vstack(rfs_svd['on'])
-            img_off = np.vstack(rfs_svd['off'])
+            img = dict()
+            img['on'] = np.vstack(rfs_svd['on'])
+            img['off'] = np.vstack(rfs_svd['off'])
             yscale = ((np.max(self.chn_coords[:, 1]) - np.min(self.chn_coords[:, 1]))
-                      / img_on.shape[0])
+                      / img['on'].shape[0])
             xscale = 1
-            levels = np.quantile(np.c_[img_on, img_off], [0, 1])
-
-            data_img_on = {
-                'img': [img_on.T],
-                'scale': [np.array([xscale, yscale])],
-                'levels': levels,
-                'offset': [np.array([0, 0])],
-                'cmap': 'viridis',
-                'xrange': np.array([0, 15]),
-                'xaxis': 'Position',
-                'title': 'rfmap (dB)'
-            }
-
-            data_img_off = {
-                'img': [img_off.T],
-                'scale': [np.array([xscale, yscale])],
-                'levels': levels,
-                'offset': [np.array([0, 0])],
-                'cmap': 'viridis',
-                'xrange': np.array([0, 15]),
-                'xaxis': 'Position',
-                'title': 'rfmap (dB)'
-            }
+            levels = np.quantile(np.c_[img['on'], img['off']], [0, 1])
+
+            sub_type = ['on', 'off']
+            for sub in sub_type:
+                sub_data = {sub: {
+                    'img': [img[sub].T],
+                    'scale': [np.array([xscale, yscale])],
+                    'levels': levels,
+                    'offset': [np.array([0, 0])],
+                    'cmap': 'viridis',
+                    'xrange': np.array([0, 15]),
+                    'xaxis': 'Position',
+                    'title': 'rfmap (dB)'}
+                }
+                data_img.update(sub_data)
 
-            return data_img_on, data_img_off, depths
+            return data_img, depths
 
     def get_passive_events(self):
         stim_keys = ['valveOn', 'toneOn', 'noiseOn', 'leftGabor', 'rightGabor']
-        data_img = {stim: None for stim in stim_keys}
+        data_img = dict()
         if not self.passive_data_status and not self.gabor_data_status:
-            return data_img
+            return  data_img
         elif not self.passive_data_status and self.gabor_data_status:
             stim_types = ['leftGabor', 'rightGabor']
             stims = self.vis_stim