Changeset 441 for sans/utils


Ignore:
Timestamp:
Nov 11, 2008 1:49:10 PM (14 years ago)
Author:
ajj
Message:

updates

Location:
sans/utils/bt5
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • sans/utils/bt5/bt5plot2/bt5plot2

    r439 r441  
    1313 
    1414try: 
    15         import pygtk 
    16         pygtk.require("2.0") 
    17          
     15    import pygtk 
     16    pygtk.require("2.0") 
     17     
    1818except: 
    19         pass 
     19    pass 
    2020 
    2121try: 
    22         import gtk 
    23         import gtk.glade 
     22    import gtk 
     23    import gtk.glade 
    2424except: 
    25         sys.exit(1) 
     25    sys.exit(1) 
    2626 
    2727 
    2828 
    2929class appGui: 
    30          
    31         TARGETS = [('STRING', gtk.TARGET_SAME_APP, 0)] 
    32          
    33         def __init__(self): 
    34                  
    35                 gladefile = "bt5plot2.glade" 
    36                 self.windowname = "win_Main" 
    37                 self.wTree = gtk.glade.XML(gladefile, self.windowname) 
    38  
    39                 event_dic = {"on_win_Main_destroy" : gtk.main_quit, 
    40                                          "on_quit1_activate" : gtk.main_quit, 
    41                                          "on_set_data_dir1_activate" : self.setdatadir, 
    42                                          "on_xaxis_loglin_activate" : self.handle_xaxis_loglin, 
    43                                          "on_yaxis_loglin_activate" : self.handle_yaxis_loglin} 
    44         #                                "on_tv_plotlist_key_press_event" : self.handle_plotlist_keypress} 
    45  
    46                  
    47                 self.wTree.signal_autoconnect(event_dic) 
    48  
    49                 # Set up file list 
    50                 self.filelistview = self.wTree.get_widget("tv_filelist") 
    51                  
    52                 self.filelist = gtk.ListStore(str,'gboolean',object,object,object) 
    53                 self.filelist.set_sort_column_id(0,gtk.SORT_ASCENDING) 
    54                 self.filelistview.set_model(self.filelist) 
    55  
    56                 self.cellrenderertoggle = gtk.CellRendererToggle() 
    57                 self.cellrenderertoggle.set_property('activatable', True) 
    58                 self.cellrenderertoggle.connect("toggled", self.handle_plot_toggle, self.filelist) 
    59          
    60                 self.AddFileListColumns() 
    61  
    62                 #fill the file list 
    63                 self.FillFileList(self.GetDirList()) 
    64  
    65                 # Set up graphing widget to display xpeek data 
    66                 self.figure = Figure(figsize=(4,4), dpi=72) 
    67                 self.axis = self.figure.add_subplot(111) 
    68                 self.axis.set_xlabel('Motor position') 
    69                 self.axis.set_ylabel('Counts') 
    70                 #self.axis.set_title('XPeek') 
    71                 self.axis.grid(True) 
    72                  
    73                 self.canvas = FigureCanvasGTK(self.figure) 
    74                 self.canvas.show() 
    75                  
    76                 self.plotView = self.wTree.get_widget("hbox1") 
    77                 self.plotView.pack_start(self.canvas, True, True)        
    78                  
    79                 #self.filelistview.enable_model_drag_source( gtk.gdk.BUTTON1_MASK, 
     30     
     31    TARGETS = [('STRING', gtk.TARGET_SAME_APP, 0)] 
     32     
     33    def __init__(self): 
     34         
     35        gladefile = "bt5plot2.glade" 
     36        self.windowname = "win_Main" 
     37        self.wTree = gtk.glade.XML(gladefile, self.windowname) 
     38 
     39        event_dic = {"on_win_Main_destroy" : gtk.main_quit, 
     40                     "on_quit1_activate" : gtk.main_quit, 
     41                     "on_set_data_dir1_activate" : self.setdatadir, 
     42                     "on_xaxis_loglin_activate" : self.handle_xaxis_loglin, 
     43                     "on_yaxis_loglin_activate" : self.handle_yaxis_loglin, 
     44                     "on_plot_type_activate" : self.handle_plot_type_change} 
     45    #                 "on_tv_plotlist_key_press_event" : self.handle_plotlist_keypress} 
     46 
     47        #This is a bit clunky, but never mind. 
     48        #Set default plottype to rate. Glade definition sets that as default active button in menu 
     49        self.plottype = 'rate' 
     50         
     51        self.wTree.signal_autoconnect(event_dic) 
     52 
     53        # Set up file list 
     54        self.filelistview = self.wTree.get_widget("tv_filelist") 
     55         
     56        self.filelist = gtk.ListStore(str, 'gboolean', object, object, object) 
     57        self.filelist.set_sort_column_id(0, gtk.SORT_ASCENDING) 
     58        self.filelistview.set_model(self.filelist) 
     59 
     60        self.cellrenderertoggle = gtk.CellRendererToggle() 
     61        self.cellrenderertoggle.set_property('activatable', True) 
     62        self.cellrenderertoggle.connect("toggled", self.handle_plot_toggle, self.filelist) 
     63     
     64        self.AddFileListColumns() 
     65 
     66        #fill the file list 
     67        self.FillFileList(self.GetDirList()) 
     68 
     69        # Set up graphing widget to display xpeek data 
     70        self.figure = Figure(figsize=(4, 4), dpi=72) 
     71        self.axis = self.figure.add_subplot(111) 
     72        self.axis.set_yscale('log') 
     73        self.axis.set_aspect('auto') 
     74        self.axis.set_autoscale_on('True') 
     75        self.axis.set_xlabel('Motor position') 
     76        self.axis.set_ylabel('Counts') 
     77        self.axis.grid(True) 
     78         
     79        self.canvas = FigureCanvasGTK(self.figure) 
     80        self.canvas.show() 
     81         
     82        self.plotView = self.wTree.get_widget("hbox1") 
     83        self.plotView.pack_start(self.canvas, True, True)     
     84         
     85        #self.filelistview.enable_model_drag_source( gtk.gdk.BUTTON1_MASK, 
    8086                #                                  self.TARGETS, 
    8187                #                                   gtk.gdk.ACTION_COPY) 
    8288 
    83                 #self.filelistview.connect("drag_data_get", self.dnd_data_getdata) 
    84                  
    85                  
    86         def AddFileListColumns(self): 
    87                 """This function adds a column to the list view. 
    88                 First it create the gtk.TreeViewColumn and then set 
    89                 some needed properties""" 
    90                                                  
    91                 column = gtk.TreeViewColumn('Filename', gtk.CellRendererText() 
    92                         , text=0) 
    93                 column.set_resizable(True)               
    94                 column.set_sort_column_id(0) 
    95                 self.filelistview.append_column(column) 
    96  
    97                 column = gtk.TreeViewColumn('', self.cellrenderertoggle, active=1) 
    98                 self.filelistview.append_column(column) 
    99                 return 
    100                  
    101         def GetDirList(self): 
    102                 dirlist = os.listdir(os.getcwd()) 
    103                  
    104                 bt5list = [ x for x in dirlist if x.find('.bt5') > 0] 
    105                  
    106                 return bt5list 
    107                  
    108          
    109         def FillFileList(self,filenames): 
    110                 self.filelist.clear() 
    111                 for filename in filenames: 
    112                         data = usans.getBT5DataFromFile(filename) 
    113                         self.filelist.append([filename,0,data,0,0]) 
    114                 return 
    115                          
    116  
    117         def setdatadir(self, widget): 
    118                 chooser = gtk.FileChooserDialog(title="Select Data Directory",action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, 
    119                                   buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK)) 
    120                 chooser.set_default_response(gtk.RESPONSE_OK) 
    121                 chooser.set_current_folder(os.getcwd()) 
    122                 response = chooser.run() 
    123                 if response == gtk.RESPONSE_OK: 
    124                         os.chdir(chooser.get_filename()) 
    125                         self.FillFileList(self.GetDirList()) 
    126                 chooser.destroy() 
    127  
    128         def handle_plot_toggle(self, cell, path, model): 
    129                 model[path][1] = not model[path][1] 
    130  
    131                 if model[path][1]: 
    132                         #add plot 
    133                         self.add_plot(model, path) 
    134                 else: 
    135                         #remove plot 
    136                         self.remove_plot(model, path) 
    137                 return 
    138  
    139         def add_plot(self, model, path): 
    140                  
    141                 xdata = [] 
    142                 ydata = [] 
    143  
    144                 data =  model[path][2] 
    145                 mvals =  data.keys() 
    146                 mvals.sort(usans.numeric_compare) 
    147                 for mval in mvals: 
    148                         xdata.append(mval) 
    149                         ydata.append(data[mval][1]+data[mval][2]+data[mval][4]+data[mval][5]+data[mval][6]) 
    150                          
    151                 model[path][3] = (xdata,ydata) 
    152  
    153                 model[path][4], = self.axis.plot(xdata,ydata) 
    154                 self.canvas.draw() 
    155                 return 
    156  
    157         def remove_plot(self, model, path): 
    158  
    159                 self.axis.lines.remove(model[path][4]) 
    160                 self.canvas.draw() 
    161                 return 
    162  
    163         def handle_xaxis_loglin(self,widget): 
    164  
    165  
    166                 if (self.axis.get_xscale() == "log"): 
    167                         self.axis.set_xscale('linear') 
    168                 else: 
    169                         self.axis.set_xscale('log')              
    170  
    171                 self.canvas.draw() 
    172                 return   
    173  
    174         def handle_yaxis_loglin(self,widget): 
    175  
    176  
    177                 if (self.axis.get_yscale() == "log"): 
    178                         self.axis.set_yscale('linear') 
    179                 else: 
    180                         self.axis.set_yscale('log')              
    181  
    182                 self.canvas.draw() 
    183                 return 
    184  
    185         #def handle_plotlist_keypress(self,widget,event): 
    186         #       keyname = gtk.gdk.keyval_name(event.keyval) 
    187         #       print keyname 
    188         #       if keyname in ["Delete", "BackSpace"]: 
    189         #               self.deleteplotlistentry(widget) 
    190         #                
    191         #       return True 
    192                  
    193         #def deleteplotlistentry(self, treeview): 
    194         #       treeselection = treeview.get_selection() 
    195         #       model, iter = treeselection.get_selected() 
    196         #       model.remove(iter) 
    197         #       return 
    198                          
     89        #self.filelistview.connect("drag_data_get", self.dnd_data_getdata) 
     90         
     91         
     92    def AddFileListColumns(self): 
     93        """This function adds a column to the list view. 
     94        First it create the gtk.TreeViewColumn and then set 
     95        some needed properties""" 
     96                         
     97        column = gtk.TreeViewColumn('Filename', gtk.CellRendererText() 
     98            , text=0) 
     99        column.set_resizable(True)         
     100        column.set_sort_column_id(0) 
     101        self.filelistview.append_column(column) 
     102 
     103        column = gtk.TreeViewColumn('', self.cellrenderertoggle, active=1) 
     104        self.filelistview.append_column(column) 
     105        return 
     106         
     107    def GetDirList(self): 
     108        dirlist = os.listdir(os.getcwd()) 
     109         
     110        bt5list = [ x for x in dirlist if x.find('.bt5') > 0] 
     111         
     112        return bt5list 
     113         
     114     
     115    def FillFileList(self, filenames): 
     116        self.filelist.clear() 
     117        for filename in filenames: 
     118            data,metadata = usans.getBT5DataFromFile(filename) 
     119            self.filelist.append([filename, 0, (data,metadata), 0, 0]) 
     120        return 
     121             
     122 
     123    def setdatadir(self, widget): 
     124        chooser = gtk.FileChooserDialog(title="Select Data Directory", action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, 
     125                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) 
     126        chooser.set_default_response(gtk.RESPONSE_OK) 
     127        chooser.set_current_folder(os.getcwd()) 
     128        response = chooser.run() 
     129        if response == gtk.RESPONSE_OK: 
     130            os.chdir(chooser.get_filename()) 
     131            self.FillFileList(self.GetDirList()) 
     132        chooser.destroy() 
     133 
     134    def handle_plot_toggle(self, cell, path, model): 
     135        model[path][1] = not model[path][1] 
     136 
     137        if model[path][1]: 
     138            #add plot 
     139            self.add_plot(model, path) 
     140        else: 
     141            #remove plot 
     142            self.remove_plot(model, path) 
     143        return 
     144 
     145    def add_plot(self, model, path): 
     146         
     147        self.make_plottable_dataset(model, path, self.plottype) 
     148 
     149        if self.plottype == 'split': 
     150                model[path][4] = self.axis.plot(model[path][3][0],model[path][3][1], 'o', 
     151                                                                                         model[path][3][0],model[path][3][2], 'o', 
     152                                                                                         model[path][3][0],model[path][3][3], 'o', 
     153                                                                                         model[path][3][0],model[path][3][4], 'o', 
     154                                                                                         model[path][3][0],model[path][3][5], 'o') 
     155        else: 
     156            model[path][4] = self.axis.plot(model[path][3][0],model[path][3][1], 'bo') 
     157         
     158        self.axis.autoscale_view() 
     159        self.canvas.draw() 
     160        return 
     161 
     162    def make_plottable_dataset(self, model, path, type): 
     163          
     164         data,metadata = model[path][2] 
     165          
     166         if type == 'total': 
     167             #generate totals 
     168             xdata = [] 
     169             ydata = []      
     170              
     171             mvals = data.keys() 
     172             mvals.sort(usans.numeric_compare) 
     173             for mval in mvals: 
     174                 xdata.append(mval) 
     175                 ydata.append(data[mval][1] + data[mval][2] + data[mval][4] + data[mval][5] + data[mval][6]) 
     176              
     177             model[path][3] = [xdata, ydata] 
     178              
     179         elif type == 'rate': 
     180             # generate countrate 
     181             xdata = [] 
     182             ydata = [] 
     183              
     184             mvals = data.keys() 
     185             mvals.sort(usans.numeric_compare) 
     186             for mval in mvals: 
     187                 xdata.append(mval) 
     188              
     189             if metadata['base'] == 'TIME': 
     190                #Counting in TIME base, so normalize by seconds 
     191                cnttime = metadata['mon'] 
     192                for mval in mvals: 
     193                        ydata.append((data[mval][1] + data[mval][2] + data[mval][4] + data[mval][5] + data[mval][6])/cnttime) 
     194             else: 
     195                #Must be counting in monitor base so normalize by monitor 
     196                moncts = metadata['mon'] 
     197                for mval in mvals: 
     198                        ydata.append((data[mval][1] + data[mval][2] + data[mval][4] + data[mval][5] + data[mval][6])/cnttime) 
     199              
     200             model[path][3] = [xdata, ydata] 
     201              
     202         elif type == 'trans': 
     203             xdata = [] 
     204             ydata = [] 
     205              
     206             mvals = data.keys() 
     207             mvals.sort(usans.numeric_compare) 
     208             for mval in mvals: 
     209                 xdata.append(mval) 
     210                 ydata.append(data[mval][3]) 
     211              
     212             model[path][3] = [xdata, ydata]              
     213          
     214         elif type == 'mon': 
     215             xdata = [] 
     216             ydata = [] 
     217              
     218             mvals = data.keys() 
     219             mvals.sort(usans.numeric_compare) 
     220             for mval in mvals: 
     221                 xdata.append(mval) 
     222                 ydata.append(data[mval][0]) 
     223              
     224             model[path][3] = [xdata, ydata]              
     225              
     226         elif type == 'split': 
     227             xdata = [] 
     228             ydata1 = [] 
     229             ydata2 = [] 
     230             ydata3 = [] 
     231             ydata4 = [] 
     232             ydata5 = [] 
     233              
     234             mvals = data.keys() 
     235             mvals.sort(usans.numeric_compare) 
     236             for mval in mvals: 
     237                 xdata.append(mval) 
     238                 ydata1.append(data[mval][1])    
     239                 ydata2.append(data[mval][2])    
     240                 ydata3.append(data[mval][4])    
     241                 ydata4.append(data[mval][5])    
     242                 ydata5.append(data[mval][6])    
     243 
     244             model[path][3] = [xdata,ydata1,ydata2,ydata3,ydata4,ydata5] 
     245         else: 
     246                pass 
     247              
     248         return 
     249 
     250    def remove_plot(self, model, path): 
     251 
     252        for line in model[path][4]: 
     253                self.axis.lines.remove(line) 
     254                 
     255        self.axis.autoscale_view() 
     256        self.canvas.draw()         
     257        return 
     258 
     259    def handle_xaxis_loglin(self, widget): 
     260 
     261 
     262        if (self.axis.get_xscale() == "log"): 
     263            self.axis.set_xscale('linear') 
     264        else: 
     265            self.axis.set_xscale('log')         
     266 
     267        self.axis.autoscale_view() 
     268 
     269        self.canvas.draw() 
     270         
     271        return     
     272 
     273    def handle_yaxis_loglin(self, widget): 
     274 
     275 
     276        if (self.axis.get_yscale() == "log"): 
     277            self.axis.set_yscale('linear') 
     278        else: 
     279            self.axis.set_yscale('log')         
     280 
     281        self.axis.autoscale_view() 
     282        self.canvas.draw() 
     283        return 
     284        
     285    def handle_plot_type_change(self,widget): 
     286                 
     287        if widget.get_active(): 
     288                self.plottype = widget.get_name().split('_')[1] 
     289                print self.plottype 
     290                 
     291        return 
     292         
    199293 
    200294app = appGui() 
  • sans/utils/bt5/bt5plot2/bt5plot2.glade

    r438 r441  
    129129              <child> 
    130130                <widget class="GtkMenu" id="menuitem3_menu"> 
    131                    <child> 
    132                      <widget class="GtkMenuItem" id="xaxis1"> 
    133                         <property name="visible">True</property> 
    134                         <property name="label" translatable="yes">_X-axis</property> 
    135                         <property name="use_underline">True</property> 
    136                         <child> 
    137                           <widget class="GtkMenu" id="xaxis1_menu"> 
    138                                 <child> 
    139                                   <widget class="GtkMenuItem" id="loglin1"> 
    140                                         <property name="visible">True</property> 
    141                                         <property name="label" translatable="yes">_Log/Lin</property> 
    142                                         <property name="use_underline">True</property> 
    143                                         <signal name="activate" handler="on_xaxis_loglin_activate"/> 
    144                                   </widget> 
    145                                 </child>         
    146                           </widget> 
    147                         </child> 
    148                      </widget> 
    149                    </child> 
    150                    <child> 
    151                      <widget class="GtkMenuItem" id="yaxis1"> 
    152                         <property name="visible">True</property> 
    153                         <property name="label" translatable="yes">_Y-axis</property> 
    154                         <property name="use_underline">True</property> 
    155                         <child> 
    156                           <widget class="GtkMenu" id="yaxis1_menu"> 
    157                                 <child> 
    158                                   <widget class="GtkMenuItem" id="loglin2"> 
    159                                         <property name="visible">True</property> 
    160                                         <property name="label" translatable="yes">_Log/Lin</property> 
    161                                         <property name="use_underline">True</property> 
    162                                         <signal name="activate" handler="on_yaxis_loglin_activate"/> 
    163                                   </widget> 
    164                                 </child>         
    165                           </widget> 
    166                         </child> 
    167                      </widget> 
    168                    </child> 
    169  
    170  
    171  
     131 
     132                  <child> 
     133                    <widget class="GtkMenuItem" id="plot_type1"> 
     134                      <property name="visible">True</property> 
     135                      <property name="label" translatable="yes">_Plot Type</property> 
     136                      <property name="use_underline">True</property> 
     137                      <signal name="activate" handler="on_plot_type1_activate" last_modification_time="Tue, 11 Nov 2008 15:45:10 GMT"/> 
     138 
     139                      <child> 
     140                        <widget class="GtkMenu" id="plot_type1_menu"> 
     141 
     142                          <child> 
     143                            <widget class="GtkRadioMenuItem" id="rmi_total"> 
     144                              <property name="visible">True</property> 
     145                              <property name="label" translatable="yes">Total Counts</property> 
     146                              <property name="use_underline">True</property> 
     147                              <property name="active">False</property> 
     148                              <signal name="activate" handler="on_plot_type_activate" last_modification_time="Tue, 11 Nov 2008 15:48:27 GMT"/> 
     149                            </widget> 
     150                          </child> 
     151 
     152                          <child> 
     153                            <widget class="GtkRadioMenuItem" id="rmi_rate"> 
     154                              <property name="visible">True</property> 
     155                              <property name="label" translatable="yes">Count Rate</property> 
     156                              <property name="use_underline">True</property> 
     157                              <property name="active">True</property> 
     158                              <property name="group">rmi_total</property> 
     159                              <signal name="activate" handler="on_plot_type_activate" last_modification_time="Tue, 11 Nov 2008 15:48:27 GMT"/> 
     160                            </widget> 
     161                          </child> 
     162 
     163                          <child> 
     164                            <widget class="GtkRadioMenuItem" id="rmi_trans"> 
     165                              <property name="visible">True</property> 
     166                              <property name="label" translatable="yes">Transmission</property> 
     167                              <property name="use_underline">True</property> 
     168                              <property name="active">False</property> 
     169                              <property name="group">rmi_total</property> 
     170                              <signal name="activate" handler="on_plot_type_activate" last_modification_time="Tue, 11 Nov 2008 15:48:27 GMT"/> 
     171                            </widget> 
     172                          </child> 
     173 
     174                          <child> 
     175                            <widget class="GtkRadioMenuItem" id="rmi_mon"> 
     176                              <property name="visible">True</property> 
     177                              <property name="label" translatable="yes">Monitor</property> 
     178                              <property name="use_underline">True</property> 
     179                              <property name="active">False</property> 
     180                              <property name="group">rmi_total</property> 
     181                              <signal name="activate" handler="on_plot_type_activate" last_modification_time="Tue, 11 Nov 2008 15:48:27 GMT"/> 
     182                            </widget> 
     183                          </child> 
     184 
     185                          <child> 
     186                            <widget class="GtkRadioMenuItem" id="rmi_split"> 
     187                              <property name="visible">True</property> 
     188                              <property name="label" translatable="yes">Split Detectors</property> 
     189                              <property name="use_underline">True</property> 
     190                              <property name="active">False</property> 
     191                              <property name="group">rmi_total</property> 
     192                              <signal name="activate" handler="on_plot_type_activate" last_modification_time="Tue, 11 Nov 2008 15:48:27 GMT"/> 
     193                            </widget> 
     194                          </child> 
     195                        </widget> 
     196                      </child> 
     197                    </widget> 
     198                  </child> 
     199 
     200                  <child> 
     201                    <widget class="GtkMenuItem" id="xaxis1"> 
     202                      <property name="visible">True</property> 
     203                      <property name="label" translatable="yes">_X-axis</property> 
     204                      <property name="use_underline">True</property> 
     205 
     206                      <child> 
     207                        <widget class="GtkMenu" id="xaxis1_menu"> 
     208 
     209                          <child> 
     210                            <widget class="GtkMenuItem" id="loglin1"> 
     211                              <property name="visible">True</property> 
     212                              <property name="label" translatable="yes">_Log/Lin</property> 
     213                              <property name="use_underline">True</property> 
     214                              <signal name="activate" handler="on_xaxis_loglin_activate"/> 
     215                            </widget> 
     216                          </child> 
     217                        </widget> 
     218                      </child> 
     219                    </widget> 
     220                  </child> 
     221 
     222                  <child> 
     223                    <widget class="GtkMenuItem" id="yaxis1"> 
     224                      <property name="visible">True</property> 
     225                      <property name="label" translatable="yes">_Y-axis</property> 
     226                      <property name="use_underline">True</property> 
     227 
     228                      <child> 
     229                        <widget class="GtkMenu" id="yaxis1_menu"> 
     230 
     231                          <child> 
     232                            <widget class="GtkMenuItem" id="loglin2"> 
     233                              <property name="visible">True</property> 
     234                              <property name="label" translatable="yes">_Log/Lin</property> 
     235                              <property name="use_underline">True</property> 
     236                              <signal name="activate" handler="on_yaxis_loglin_activate"/> 
     237                            </widget> 
     238                          </child> 
     239                        </widget> 
     240                      </child> 
     241                    </widget> 
     242                  </child> 
    172243                </widget> 
    173244              </child> 
  • sans/utils/bt5/bt5plot2/usans.py

    r438 r441  
    33#import Tkinter as Tk 
    44 
    5 def numeric_compare(x,y): 
    6         x = float(x) 
    7         y = float(y)     
     5def numeric_compare(x, y): 
     6    x = float(x) 
     7    y = float(y)     
    88 
    9         if x < y: 
    10                 return -1 
    11         elif x==y: 
    12                 return 0 
    13         else: # x>y 
    14                 return 1  
     9    if x < y: 
     10        return - 1 
     11    elif x == y: 
     12        return 0 
     13    else: # x>y 
     14        return 1  
    1515 
    1616def getBT5DataFromFile(fileName): 
    17         ''' 
    18         Takes a filename and returns a dictionary of the detector values 
    19         keyed by varying value (ususally A2 or A5) 
    20         ''' 
    21         detdata = {} 
     17    ''' 
     18    Takes a filename and returns a dictionary of the detector values 
     19    keyed by varying value (ususally A2 or A5) 
     20    ''' 
     21    detdata = {} 
     22    metadata = {} 
     23    motlist = [] 
     24     
     25    inputfile = open(fileName, "r") 
    2226 
    23         inputfile = open(fileName, "r") 
     27    inputdata = inputfile.readlines() 
    2428 
    25         inputdata = inputfile.readlines() 
     29    mdtmp = inputdata[0].replace("'","") 
     30    mdtmp = mdtmp.split() 
     31     
     32    #Sundry metadata about run settings 
     33    (metadata['filename'], metadata['datetime'], 
     34    metadata['mon'],metadata['prefactor'], 
     35    metadata['base'],metadata['numpnts'], 
     36    metadata['type']) = (mdtmp[0],' '.join(mdtmp[1:5]),mdtmp[6],mdtmp[7],mdtmp[8],mdtmp[9],mdtmp[10]) 
     37     
     38    #Comment string 
     39    metadata['title'] = inputdata[2].strip() 
     40     
     41    #Start, step and end values for motors 1-6 
     42    motlist.append(inputdata[5].split()[1:]) 
     43    motlist.append(inputdata[6].split()[1:]) 
     44    motlist.append(inputdata[7].split()[1:]) 
     45    motlist.append(inputdata[8].split()[1:]) 
     46    motlist.append(inputdata[9].split()[1:]) 
     47    motlist.append(inputdata[10].split()[1:])  
     48    metadata['motorvals'] = motlist 
     49     
     50    for index in range(13, len(inputdata), 2): 
     51        detdata[inputdata[index].split()[0]] = inputdata[index + 1].split(',')     
    2652 
    27         for index in range(13,len(inputdata),2): 
    28                 detdata[inputdata[index].split()[0]] = inputdata[index+1].split(',')     
     53    for key in detdata.keys(): 
     54        for val in range(0, len(detdata[key])): 
     55            detdata[key][val] = int(detdata[key][val]) 
    2956 
    30         for key in detdata.keys(): 
    31                 for val in range(0,len(detdata[key])): 
    32                         detdata[key][val] = int(detdata[key][val]) 
    33  
    34         inputfile.close() 
    35         return detdata 
     57    inputfile.close() 
     58    return detdata,metadata 
    3659 
    3760def printBT5DetData(detdata): 
    38         ''' 
    39         Print the contents of the file in a formatted fashion 
     61    ''' 
     62    Print the contents of the file in a formatted fashion 
    4063 
    41         Takes a dictionary of data as provided by getBT5DataFromFile() and prints out the contents 
    42         in a formatted fashion 
    43         ''' 
    44         motorvals = detdata.keys() 
    45         motorvals.sort(cmp=numeric_compare) 
     64    Takes a dictionary of data as provided by getBT5DataFromFile() and prints out the contents 
     65    in a formatted fashion 
     66    ''' 
     67    motorvals = detdata.keys() 
     68    motorvals.sort(cmp=numeric_compare) 
    4669 
    47         for motorval in motorvals: 
    48                 str = motorval+":" 
    49                 str += "\tMon: "+repr(detdata[motorval][0]) 
    50                 str += "\tDet 1-5: "+repr(detdata[motorval][2]) 
    51                 str += "\t"+repr(detdata[motorval][1]) 
    52                 str += "\t"+repr(detdata[motorval][4]) 
    53                 str += "\t"+repr(detdata[motorval][5]) 
    54                 str += "\t"+repr(detdata[motorval][6]) 
    55                 str += "\tTrans: "+repr(detdata[motorval][3]) 
    56                 print str 
     70    for motorval in motorvals: 
     71        str = motorval + ":" 
     72        str += "\tMon: " + repr(detdata[motorval][0]) 
     73        str += "\tDet 1-5: " + repr(detdata[motorval][2]) 
     74        str += "\t" + repr(detdata[motorval][1]) 
     75        str += "\t" + repr(detdata[motorval][4]) 
     76        str += "\t" + repr(detdata[motorval][5]) 
     77        str += "\t" + repr(detdata[motorval][6]) 
     78        str += "\tTrans: " + repr(detdata[motorval][3]) 
     79        print str 
    5780 
    58         return 0 
     81    return 0 
    5982 
    60 def getAlignVals(data,motorval): 
    61         ''' 
    62         Return the values we record in the logbook for a given motor position 
     83def getAlignVals(data, motorval): 
     84    ''' 
     85    Return the values we record in the logbook for a given motor position 
    6386 
    64         Takes a dictionary as provided by getBT5DataFromFile and returns a dictionary with  
    65         keys Central, Trans and Sum 
    66         ''' 
    67         alignvals = {} 
     87    Takes a dictionary as provided by getBT5DataFromFile and returns a dictionary with  
     88    keys Central, Trans and Sum 
     89    ''' 
     90    alignvals = {} 
    6891 
    69         alignvals['Central'] = data[motorval][1] 
    70         alignvals['Trans'] = data[motorval][3] 
    71         alignvals['Sum'] = data[motorval][1]+data[motorval][2]+data[motorval][4]+data[motorval][5]+data[motorval][6]     
    72         return alignvals 
     92    alignvals['Central'] = data[motorval][1] 
     93    alignvals['Trans'] = data[motorval][3] 
     94    alignvals['Sum'] = data[motorval][1] + data[motorval][2] + data[motorval][4] + data[motorval][5] + data[motorval][6]      
     95    return alignvals 
    7396 
    74 def maxDetCount(data,detector): 
    75         ''' 
    76         Return the maximum value and corresponding motor position for a given detector 
    77          
    78         Takes a dictionary as provided by getBT5DataFromFile() and returns a dictionary with 
    79         keys Position and Value 
    80         '''      
    81         maxpos = '' 
    82         maxval = 0 
    83         result = {} 
     97def maxDetCount(data, detector): 
     98    ''' 
     99    Return the maximum value and corresponding motor position for a given detector 
     100     
     101    Takes a dictionary as provided by getBT5DataFromFile() and returns a dictionary with 
     102    keys Position and Value 
     103    '''     
     104    maxpos = '' 
     105    maxval = 0 
     106    result = {} 
    84107 
    85         mvals = data.keys() 
    86         det = {'1':2, '2':1, '3':4, '4':5, '5':6}[repr(detector)] 
     108    mvals = data.keys() 
     109    det = {'1':2, '2':1, '3':4, '4':5, '5':6}[repr(detector)] 
    87110 
    88         for mval in mvals: 
    89                 if data[mval][det] > maxval: 
    90                         maxval = data[mval][det]                 
    91                         maxpos = mval 
    92          
    93         result['Position'] = maxpos 
    94         result['Value'] = maxval 
     111    for mval in mvals: 
     112        if data[mval][det] > maxval: 
     113            maxval = data[mval][det]         
     114            maxpos = mval 
     115     
     116    result['Position'] = maxpos 
     117    result['Value'] = maxval 
    95118 
    96         return result    
     119    return result     
    97120 
    98          
    99          
     121     
     122     
    100123 
    101124if __name__ == '__main__': 
    102         import sys 
    103         data = getBT5DataFromFile(sys.argv[1]) 
    104         printBT5DetData(data) 
     125    import sys 
     126    data,metadata = getBT5DataFromFile(sys.argv[1]) 
     127    printBT5DetData(data) 
    105128 
    106         maxinfo =  maxDetCount(data,2) 
    107         print maxinfo 
    108         avals = getAlignVals(data,maxinfo['Position']) 
    109         print avals 
     129    maxinfo = maxDetCount(data, 2) 
     130    print maxinfo 
     131    avals = getAlignVals(data, maxinfo['Position']) 
     132    print avals 
  • sans/utils/bt5/bt5view/bt5view

    r440 r441  
    1414 
    1515try: 
    16         import pygtk 
    17         pygtk.require("2.0") 
    18          
     16    import pygtk 
     17    pygtk.require("2.0") 
     18     
    1919except: 
    20         pass 
     20    pass 
    2121 
    2222try: 
    23         import gtk 
    24         import gtk.glade 
     23    import gtk 
     24    import gtk.glade 
    2525except: 
    26         sys.exit(1) 
     26    sys.exit(1) 
    2727 
    2828 
    2929 
    3030class appGui: 
    31          
    32         TARGETS = [('STRING', gtk.TARGET_SAME_APP, 0)] 
    33          
    34         def __init__(self): 
    35                  
    36                 gladefile = "bt5view.glade" 
    37                 self.windowname = "win_Main" 
    38                 self.wTree = gtk.glade.XML(gladefile, self.windowname) 
    39  
    40                 event_dic = {"on_win_Main_destroy" : gtk.main_quit, 
    41                                         "on_quit1_activate" : gtk.main_quit, 
    42                                         "on_set_data_dir1_activate" : self.setdatadir, 
    43                                         "on_tv_plotlist_key_press_event" : self.handle_plotlist_keypress} 
    44  
    45                  
    46                 self.wTree.signal_autoconnect(event_dic) 
    47  
    48                 # Set up file list 
    49                 self.filelistview = self.wTree.get_widget("tv_filelist") 
    50                 self.AddFileListColumn("Filename",0) 
    51                  
    52                 self.filelist = gtk.ListStore(str) 
    53                 self.filelistview.set_model(self.filelist) 
    54                 self.filelist.set_sort_column_id(0,gtk.SORT_ASCENDING) 
    55  
    56                 # Set up plot group list 
    57                 self.plotlistview = self.wTree.get_widget("tv_plotlist") 
    58                 #self.AddPlotListColumn("Dataset",0) 
    59                 #self.AddPlotListColumn("Plot",1) 
    60                 self.cellrendertoggle = gtk.CellRendererToggle() 
    61                 self.cellrendertoggle.set_property('activatable', True) 
    62                 self.AddPlotListColumns("Dataset") 
    63  
    64                 #Create TreeStore model - Name of dataset, is it plotted, loaded data for children, plottable data for parent 
    65                 self.plotlist = gtk.TreeStore(str,'gboolean',object,object) 
    66                 self.plotlistview.set_model(self.plotlist) 
    67                 self.plotlist.set_sort_column_id(0,gtk.SORT_ASCENDING) 
    68          
    69                 #fill the file list 
    70                 self.FillFileList(self.GetDirList()) 
    71                 #self.plotlist.append(None,None) 
    72                  
    73                 # Set up graphing widget to display xpeek data 
    74                 self.figure = Figure(figsize=(4,4), dpi=72) 
    75                 self.axis = self.figure.add_subplot(111) 
    76                 self.axis.set_xlabel('Motor position') 
    77                 self.axis.set_ylabel('Counts') 
    78                 #self.axis.set_title('XPeek') 
    79                 self.axis.grid(True) 
    80                  
    81                 self.canvas = FigureCanvasGTK(self.figure) 
    82                 self.canvas.show() 
    83                  
    84                 self.plotView = self.wTree.get_widget("hbox1") 
    85                 self.plotView.pack_start(self.canvas, True, True)        
    86                  
    87                 self.filelistview.enable_model_drag_source( gtk.gdk.BUTTON1_MASK, 
     31     
     32    TARGETS = [('STRING', gtk.TARGET_SAME_APP, 0)] 
     33     
     34    def __init__(self): 
     35         
     36        gladefile = "bt5view.glade" 
     37        self.windowname = "win_Main" 
     38        self.wTree = gtk.glade.XML(gladefile, self.windowname) 
     39 
     40        event_dic = {"on_win_Main_destroy" : gtk.main_quit, 
     41                    "on_quit1_activate" : gtk.main_quit, 
     42                    "on_set_data_dir1_activate" : self.setdatadir, 
     43                    "on_tv_plotlist_key_press_event" : self.handle_plotlist_keypress} 
     44 
     45         
     46        self.wTree.signal_autoconnect(event_dic) 
     47 
     48        # Set up file list 
     49        self.filelistview = self.wTree.get_widget("tv_filelist") 
     50        self.AddFileListColumn("Filename", 0) 
     51         
     52        self.filelist = gtk.ListStore(str) 
     53        self.filelistview.set_model(self.filelist) 
     54        self.filelist.set_sort_column_id(0, gtk.SORT_ASCENDING) 
     55 
     56        # Set up plot group list 
     57        self.plotlistview = self.wTree.get_widget("tv_plotlist") 
     58        #self.AddPlotListColumn("Dataset",0) 
     59        #self.AddPlotListColumn("Plot",1) 
     60        self.cellrendertoggle = gtk.CellRendererToggle() 
     61        self.cellrendertoggle.set_property('activatable', True) 
     62        self.AddPlotListColumns("Dataset") 
     63 
     64        #Create TreeStore model - Name of dataset, is it plotted, loaded data for children, plottable data for parent 
     65        self.plotlist = gtk.TreeStore(str, 'gboolean', object, object) 
     66        self.plotlistview.set_model(self.plotlist) 
     67        self.plotlist.set_sort_column_id(0, gtk.SORT_ASCENDING) 
     68     
     69        #fill the file list 
     70        self.FillFileList(self.GetDirList()) 
     71        #self.plotlist.append(None,None) 
     72         
     73        # Set up graphing widget to display xpeek data 
     74        self.figure = Figure(figsize=(4, 4), dpi=72) 
     75        self.axis = self.figure.add_subplot(111) 
     76        self.axis.set_xlabel('Motor position') 
     77        self.axis.set_ylabel('Counts') 
     78        #self.axis.set_title('XPeek') 
     79        self.axis.grid(True) 
     80         
     81        self.canvas = FigureCanvasGTK(self.figure) 
     82        self.canvas.show() 
     83         
     84        self.plotView = self.wTree.get_widget("hbox1") 
     85        self.plotView.pack_start(self.canvas, True, True)     
     86         
     87        self.filelistview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, 
    8888                                                  self.TARGETS, 
    8989                                                   gtk.gdk.ACTION_COPY) 
    90                 self.plotlistview.enable_model_drag_dest(self.TARGETS, 
     90        self.plotlistview.enable_model_drag_dest(self.TARGETS, 
    9191                                               gtk.gdk.ACTION_COPY) 
    9292 
    93                 self.filelistview.connect("drag_data_get", self.dnd_data_getdata) 
    94                 self.plotlistview.connect("drag_data_received",self.dnd_data_received) 
    95                  
    96                 #Handle toggling of checkboxes in plot list 
    97                 self.cellrendertoggle.connect("toggled", self.handle_toggled, (self.plotlistview.get_model(), 1)) 
    98          
    99                  
    100         def AddFileListColumn(self, title, columnId): 
    101                 """This function adds a column to the list view. 
    102                 First it create the gtk.TreeViewColumn and then set 
    103                 some needed properties""" 
    104                                                  
    105                 column = gtk.TreeViewColumn(title, gtk.CellRendererText() 
    106                         , text=columnId) 
    107                 column.set_resizable(True)               
    108                 column.set_sort_column_id(columnId) 
    109                 self.filelistview.append_column(column) 
    110                 return 
    111                  
    112         def AddPlotListColumns(self, title): 
    113                 column = gtk.TreeViewColumn(title, gtk.CellRendererText() 
    114                         , text=0) 
    115                 #column.set_resizable(True)              
    116                 column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) 
    117                 column.set_fixed_width(230) 
    118                 column.set_sort_column_id(0) 
    119                 #column.set_min_width(200) 
    120                 self.plotlistview.append_column(column) 
    121  
    122                 column = gtk.TreeViewColumn('',self.cellrendertoggle, active=1) 
    123                 column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) 
    124                 #column.set_min_width(20) 
    125                 #column.set_max_width(20) 
    126                 #column.set_fixed_width(20) 
    127                 #column.set_resizable(False) 
    128                 self.plotlistview.append_column(column) 
    129                 return 
    130  
    131         def handle_toggled(self, cell, path, user_data): 
    132                 model, column = user_data 
    133                 model[path][column] = not model[path][column] 
    134  
    135                 return 
    136          
    137         def GetDirList(self): 
    138                 dirlist = os.listdir(os.getcwd()) 
    139                  
    140                 return dirlist 
    141                  
    142          
    143         def FillFileList(self,filenames): 
    144                 self.filelist.clear() 
    145                 for filename in filenames: 
    146                         self.filelist.append([filename]) 
    147                 return 
    148                          
    149  
    150         def dnd_data_received(self, treeview, context, x, y, selection, info, etime): 
    151                 model = treeview.get_model() 
    152                 data = selection.data 
    153                 #Get USANS data from file 
    154                 detdata = usans.getBT5DataFromFile(data) 
    155                 drop_info = treeview.get_dest_row_at_pos(x, y) 
    156                 if drop_info: 
    157                         #Other entries exist already 
    158                         path, position = drop_info 
    159                         iter = model.get_iter(path) 
    160                         if model.iter_depth(iter) > 0: 
    161                                 #Adding to exisiting dataset 
    162                                 parent = model.iter_parent(iter) 
    163                                 if position == gtk.TREE_VIEW_DROP_INTO_OR_AFTER or position == gtk.TREE_VIEW_DROP_AFTER: 
    164                                         titer = model.insert_after(parent,iter,[data,0,detdata,0]) 
    165                                 elif position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE or position == gtk.TREE_VIEW_DROP_BEFORE: 
    166                                         titer = model.insert_before(parent,iter,[data,0,detdata,0]) 
    167                         else: 
    168                                 #New top level entry 
    169                                 if position == gtk.TREE_VIEW_DROP_INTO_OR_AFTER or position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE: 
    170                                         titer = model.insert_after(iter, None, [data,0,detdata,0]) 
    171                                 else: 
    172                                 #Not sure that this should ever get called.... 
    173                                         iter = model.append(None,[data,0,0,0]) 
    174                                         titer = model.append(iter,[data,0,detdata,0]) 
    175                 else: 
    176                         #First entry 
    177                         iter = model.append(None,[data[:5],0,0,0]) 
    178                         titer = model.append(iter,[data,0,detdata,0]) 
    179                  
    180                 print titer 
    181                                          
    182                 self.do_plot(model,titer, "total") 
    183  
    184                 return 
    185          
    186         def do_plot(self, model, iter, type): 
    187                 #Handle plotting - ignore type for the moment, only plot total counts 
    188                 path = model.get_path(iter) 
    189                 #Always passing a child, but let's check anyway  
    190                 if model.iter_depth(iter) > 0: 
    191                         parent = model.iter_parent(iter)         
    192                         ppath = model.get_path(parent) 
    193                         #Check to see if parent is already plotted 
    194                         if (model[ppath][1]): 
    195                                 print "Parent plotted"   
    196                                 #If plotted, add new data to existing plotted dataset and set checkbox 
    197                                 self.make_plottable_dataset(model, ppath, type) 
    198                                 model[path][1] = 1 
    199                         else: 
    200                                 print "Parent not plotted" 
    201                                 if(model.iter_n_children(iter) > 1):  
    202                                         print "has siblings" 
    203                                         #If not plotted and there are siblings, add new data to dataset and set checkbox but do not plot 
    204                                         self.make_plottable_dataset(model, ppath, type) 
    205                                         model[path][1] = 1 
    206                                 else: 
    207                                         #If parent not plotted and there are no siblings, create plottable dataset, plot and set checkbox 
    208                                         self.make_plottable_dataset(model, ppath, type) 
    209                                         print model[ppath][3] 
    210                                         self.axis.plot(model[ppath][3][0], model[ppath][3][1]) 
    211                                         self.figure.draw() 
    212                                         model[path][1] = 1 
    213  
    214  
    215                 return 
    216  
    217         def make_plottable_dataset(self,model,path,type): 
    218                 #Will use select here, but for now ignore type and just do total                 
    219                 piter = model.get_iter(path) 
    220                 xdata = [] 
    221                 ydata = [] 
    222  
    223                 for iter in range(0,model.iter_n_children(piter)):  
    224                         #for each child that has the plot flag set add keys to xdata and summed values to ydata 
    225                         cpath = model.get_path(model.iter_nth_child(piter,iter)) 
    226                         data = model[cpath][2] 
    227                         mvals = data.keys() 
    228                         mvals.sort() 
    229                         for mval in mvals: 
    230                                 xdata.append(mval) 
    231                                 ydata.append(data[mval][1]+data[mval][2]+data[mval][4]+data[mval][5]+data[mval][6]) 
    232  
    233                 print xdata 
    234                 print ydata 
    235  
    236                 model[path][3] = [xdata,ydata]   
    237                 return  
    238  
    239         def dnd_data_getdata(self, treeview, context, selection, target_id, etime): 
    240                 treeselection = treeview.get_selection() 
    241                 model, iter = treeselection.get_selected() 
    242                 data = model.get_value(iter, 0) 
    243                 selection.set('STRING', 8, data) 
    244                 return 
    245          
    246         def setdatadir(self, widget): 
    247                 chooser = gtk.FileChooserDialog(title="Select Data Directory",action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, 
    248                                   buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK)) 
    249                 chooser.set_default_response(gtk.RESPONSE_OK) 
    250                 chooser.set_current_folder(os.getcwd()) 
    251                 response = chooser.run() 
    252                 if response == gtk.RESPONSE_OK: 
    253                         os.chdir(chooser.get_filename()) 
    254                         self.FillFileList(self.GetDirList()) 
    255                 chooser.destroy() 
    256  
    257         def handle_plotlist_keypress(self,widget,event): 
    258                 keyname = gtk.gdk.keyval_name(event.keyval) 
    259                 print keyname 
    260                 if keyname in ["Delete", "BackSpace"]: 
    261                         self.deleteplotlistentry(widget) 
    262                 if keyname in ["Down"]: 
    263                         (path,),focus = widget.get_cursor() 
    264                         widget.set_cursor(path+1) 
    265                 if keyname in ["Up"]: 
    266                         (path,),focus = widget.get_cursor() 
    267                         widget.set_cursor(path-1) 
    268                 return True 
    269                  
    270         def deleteplotlistentry(self, treeview): 
    271                 treeselection = treeview.get_selection() 
    272                 model, iter = treeselection.get_selected() 
    273                 model.remove(iter) 
    274                 return 
    275                  
     93        self.filelistview.connect("drag_data_get", self.dnd_data_getdata) 
     94        self.plotlistview.connect("drag_data_received", self.dnd_data_received) 
     95         
     96        #Handle toggling of checkboxes in plot list 
     97        self.cellrendertoggle.connect("toggled", self.handle_toggled, (self.plotlistview.get_model(), 1)) 
     98     
     99         
     100    def AddFileListColumn(self, title, columnId): 
     101        """This function adds a column to the list view. 
     102        First it create the gtk.TreeViewColumn and then set 
     103        some needed properties""" 
     104                         
     105        column = gtk.TreeViewColumn(title, gtk.CellRendererText() 
     106            , text=columnId) 
     107        column.set_resizable(True)         
     108        column.set_sort_column_id(columnId) 
     109        self.filelistview.append_column(column) 
     110        return 
     111         
     112    def AddPlotListColumns(self, title): 
     113        column = gtk.TreeViewColumn(title, gtk.CellRendererText() 
     114            , text=0) 
     115        #column.set_resizable(True)         
     116        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) 
     117        column.set_fixed_width(230) 
     118        column.set_sort_column_id(0) 
     119        #column.set_min_width(200) 
     120        self.plotlistview.append_column(column) 
     121 
     122        column = gtk.TreeViewColumn('', self.cellrendertoggle, active=1) 
     123        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) 
     124        #column.set_min_width(20) 
     125        #column.set_max_width(20) 
     126        #column.set_fixed_width(20) 
     127        #column.set_resizable(False) 
     128        self.plotlistview.append_column(column) 
     129        return 
     130 
     131    def handle_toggled(self, cell, path, user_data): 
     132        model, column = user_data 
     133        model[path][column] = not model[path][column] 
     134 
     135        return 
     136     
     137    def GetDirList(self): 
     138        dirlist = os.listdir(os.getcwd()) 
     139         
     140        return dirlist 
     141         
     142     
     143    def FillFileList(self, filenames): 
     144        self.filelist.clear() 
     145        for filename in filenames: 
     146            self.filelist.append([filename]) 
     147        return 
     148             
     149 
     150    def dnd_data_received(self, treeview, context, x, y, selection, info, etime): 
     151        model = treeview.get_model() 
     152        data = selection.data 
     153        #Get USANS data from file 
     154        detdata = usans.getBT5DataFromFile(data) 
     155        drop_info = treeview.get_dest_row_at_pos(x, y) 
     156        if drop_info: 
     157            #Other entries exist already 
     158            path, position = drop_info 
     159            iter = model.get_iter(path) 
     160            if model.iter_depth(iter) > 0: 
     161                #Adding to exisiting dataset 
     162                parent = model.iter_parent(iter) 
     163                if position == gtk.TREE_VIEW_DROP_INTO_OR_AFTER or position == gtk.TREE_VIEW_DROP_AFTER: 
     164                    titer = model.insert_after(parent, iter, [data, 0, detdata, 0]) 
     165                elif position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE or position == gtk.TREE_VIEW_DROP_BEFORE: 
     166                    titer = model.insert_before(parent, iter, [data, 0, detdata, 0]) 
     167            else: 
     168                #New top level entry 
     169                if position == gtk.TREE_VIEW_DROP_INTO_OR_AFTER or position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE: 
     170                    titer = model.insert_after(iter, None, [data, 0, detdata, 0]) 
     171                else: 
     172                #Not sure that this should ever get called.... 
     173                    iter = model.append(None, [data, 0, 0, 0]) 
     174                    titer = model.append(iter, [data, 0, detdata, 0]) 
     175        else: 
     176            #First entry 
     177            iter = model.append(None, [data[:5], 0, 0, 0]) 
     178            titer = model.append(iter, [data, 0, detdata, 0]) 
     179         
     180        print titer 
     181                     
     182        self.do_plot(model, titer, "total") 
     183 
     184        return 
     185     
     186    def do_plot(self, model, iter, type): 
     187        #Handle plotting - ignore type for the moment, only plot total counts 
     188        path = model.get_path(iter) 
     189        #Always passing a child, but let's check anyway     
     190        if model.iter_depth(iter) > 0: 
     191            parent = model.iter_parent(iter)     
     192            ppath = model.get_path(parent) 
     193            #Check to see if parent is already plotted 
     194            if (model[ppath][1]): 
     195                print "Parent plotted"     
     196                #If plotted, add new data to existing plotted dataset and set checkbox 
     197                self.make_plottable_dataset(model, ppath, type) 
     198                model[path][1] = 1 
     199            else: 
     200                print "Parent not plotted" 
     201                if(model.iter_n_children(iter) > 1):  
     202                    print "has siblings" 
     203                    #If not plotted and there are siblings, add new data to dataset and set checkbox but do not plot 
     204                    self.make_plottable_dataset(model, ppath, type) 
     205                    model[path][1] = 1 
     206                else: 
     207                    #If parent not plotted and there are no siblings, create plottable dataset, plot and set checkbox 
     208                    self.make_plottable_dataset(model, ppath, type) 
     209                    print model[ppath][3] 
     210                    self.axis.plot(model[ppath][3][0], model[ppath][3][1]) 
     211                    self.figure.draw() 
     212                    model[path][1] = 1 
     213 
     214 
     215        return 
     216 
     217    def make_plottable_dataset(self, model, path, type): 
     218        #Will use select here, but for now ignore type and just do total         
     219        piter = model.get_iter(path) 
     220        xdata = [] 
     221        ydata = [] 
     222 
     223        for iter in range(0, model.iter_n_children(piter)):  
     224            #for each child that has the plot flag set add keys to xdata and summed values to ydata 
     225            cpath = model.get_path(model.iter_nth_child(piter, iter)) 
     226            data = model[cpath][2] 
     227            mvals = data.keys() 
     228            mvals.sort() 
     229            for mval in mvals: 
     230                xdata.append(mval) 
     231                ydata.append(data[mval][1] + data[mval][2] + data[mval][4] + data[mval][5] + data[mval][6]) 
     232 
     233        print xdata 
     234        print ydata 
     235 
     236        model[path][3] = [xdata, ydata]     
     237        return  
     238 
     239    def dnd_data_getdata(self, treeview, context, selection, target_id, etime): 
     240        treeselection = treeview.get_selection() 
     241        model, iter = treeselection.get_selected() 
     242        data = model.get_value(iter, 0) 
     243        selection.set('STRING', 8, data) 
     244        return 
     245     
     246    def setdatadir(self, widget): 
     247        chooser = gtk.FileChooserDialog(title="Select Data Directory", action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, 
     248                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) 
     249        chooser.set_default_response(gtk.RESPONSE_OK) 
     250        chooser.set_current_folder(os.getcwd()) 
     251        response = chooser.run() 
     252        if response == gtk.RESPONSE_OK: 
     253            os.chdir(chooser.get_filename()) 
     254            self.FillFileList(self.GetDirList()) 
     255        chooser.destroy() 
     256 
     257    def handle_plotlist_keypress(self, widget, event): 
     258        keyname = gtk.gdk.keyval_name(event.keyval) 
     259        print keyname 
     260        if keyname in ["Delete", "BackSpace"]: 
     261            self.deleteplotlistentry(widget) 
     262        if keyname in ["Down"]: 
     263            (path,), focus = widget.get_cursor() 
     264            widget.set_cursor(path + 1) 
     265        if keyname in ["Up"]: 
     266            (path,), focus = widget.get_cursor() 
     267            widget.set_cursor(path - 1) 
     268        return True 
     269         
     270    def deleteplotlistentry(self, treeview): 
     271        treeselection = treeview.get_selection() 
     272        model, iter = treeselection.get_selected() 
     273        model.remove(iter) 
     274        return 
     275         
    276276app = appGui() 
    277277gtk.main() 
  • sans/utils/bt5/bt5view/usans.py

    r440 r441  
    33#import Tkinter as Tk 
    44 
    5 def numeric_compare(x,y): 
    6         x = float(x) 
    7         y = float(y)     
     5def numeric_compare(x, y): 
     6    x = float(x) 
     7    y = float(y)     
    88 
    9         if x < y: 
    10                 return -1 
    11         elif x==y: 
    12                 return 0 
    13         else: # x>y 
    14                 return 1  
     9    if x < y: 
     10        return - 1 
     11    elif x == y: 
     12        return 0 
     13    else: # x>y 
     14        return 1  
    1515 
    1616def getBT5DataFromFile(fileName): 
    17         ''' 
    18         Takes a filename and returns a dictionary of the detector values 
    19         keyed by varying value (ususally A2 or A5) 
    20         ''' 
    21         detdata = {} 
     17    ''' 
     18    Takes a filename and returns a dictionary of the detector values 
     19    keyed by varying value (ususally A2 or A5) 
     20    ''' 
     21    detdata = {} 
     22    metadata = {} 
    2223 
    23         inputfile = open(fileName, "r") 
     24    inputfile = open(fileName, "r") 
    2425 
    25         inputdata = inputfile.readlines() 
     26    inputdata = inputfile.readlines() 
    2627 
    27         for index in range(13,len(inputdata),2): 
    28                 detdata[inputdata[index].split()[0]] = inputdata[index+1].split(',')     
     28    mdtmp = inputdata[0].split(' ') 
     29     
     30    print mdtmp 
    2931 
    30         for key in detdata.keys(): 
    31                 for val in range(0,len(detdata[key])): 
    32                         detdata[key][val] = int(detdata[key][val]) 
     32    for index in range(13, len(inputdata), 2): 
     33        detdata[inputdata[index].split()[0]] = inputdata[index + 1].split(',')     
    3334 
    34         inputfile.close() 
    35         return detdata 
     35    for key in detdata.keys(): 
     36        for val in range(0, len(detdata[key])): 
     37            detdata[key][val] = int(detdata[key][val]) 
     38 
     39    inputfile.close() 
     40    return detdata 
    3641 
    3742def printBT5DetData(detdata): 
    38         ''' 
    39         Print the contents of the file in a formatted fashion 
     43    ''' 
     44    Print the contents of the file in a formatted fashion 
    4045 
    41         Takes a dictionary of data as provided by getBT5DataFromFile() and prints out the contents 
    42         in a formatted fashion 
    43         ''' 
    44         motorvals = detdata.keys() 
    45         motorvals.sort(cmp=numeric_compare) 
     46    Takes a dictionary of data as provided by getBT5DataFromFile() and prints out the contents 
     47    in a formatted fashion 
     48    ''' 
     49    motorvals = detdata.keys() 
     50    motorvals.sort(cmp=numeric_compare) 
    4651 
    47         for motorval in motorvals: 
    48                 str = motorval+":" 
    49                 str += "\tMon: "+repr(detdata[motorval][0]) 
    50                 str += "\tDet 1-5: "+repr(detdata[motorval][2]) 
    51                 str += "\t"+repr(detdata[motorval][1]) 
    52                 str += "\t"+repr(detdata[motorval][4]) 
    53                 str += "\t"+repr(detdata[motorval][5]) 
    54                 str += "\t"+repr(detdata[motorval][6]) 
    55                 str += "\tTrans: "+repr(detdata[motorval][3]) 
    56                 print str 
     52    for motorval in motorvals: 
     53        str = motorval + ":" 
     54        str += "\tMon: " + repr(detdata[motorval][0]) 
     55        str += "\tDet 1-5: " + repr(detdata[motorval][2]) 
     56        str += "\t" + repr(detdata[motorval][1]) 
     57        str += "\t" + repr(detdata[motorval][4]) 
     58        str += "\t" + repr(detdata[motorval][5]) 
     59        str += "\t" + repr(detdata[motorval][6]) 
     60        str += "\tTrans: " + repr(detdata[motorval][3]) 
     61        print str 
    5762 
    58         return 0 
     63    return 0 
    5964 
    60 def getAlignVals(data,motorval): 
    61         ''' 
    62         Return the values we record in the logbook for a given motor position 
     65def getAlignVals(data, motorval): 
     66    ''' 
     67    Return the values we record in the logbook for a given motor position 
    6368 
    64         Takes a dictionary as provided by getBT5DataFromFile and returns a dictionary with  
    65         keys Central, Trans and Sum 
    66         ''' 
    67         alignvals = {} 
     69    Takes a dictionary as provided by getBT5DataFromFile and returns a dictionary with  
     70    keys Central, Trans and Sum 
     71    ''' 
     72    alignvals = {} 
    6873 
    69         alignvals['Central'] = data[motorval][1] 
    70         alignvals['Trans'] = data[motorval][3] 
    71         alignvals['Sum'] = data[motorval][1]+data[motorval][2]+data[motorval][4]+data[motorval][5]+data[motorval][6]     
    72         return alignvals 
     74    alignvals['Central'] = data[motorval][1] 
     75    alignvals['Trans'] = data[motorval][3] 
     76    alignvals['Sum'] = data[motorval][1] + data[motorval][2] + data[motorval][4] + data[motorval][5] + data[motorval][6]      
     77    return alignvals 
    7378 
    74 def maxDetCount(data,detector): 
    75         ''' 
    76         Return the maximum value and corresponding motor position for a given detector 
    77          
    78         Takes a dictionary as provided by getBT5DataFromFile() and returns a dictionary with 
    79         keys Position and Value 
    80         '''      
    81         maxpos = '' 
    82         maxval = 0 
    83         result = {} 
     79def maxDetCount(data, detector): 
     80    ''' 
     81    Return the maximum value and corresponding motor position for a given detector 
     82     
     83    Takes a dictionary as provided by getBT5DataFromFile() and returns a dictionary with 
     84    keys Position and Value 
     85    '''     
     86    maxpos = '' 
     87    maxval = 0 
     88    result = {} 
    8489 
    85         mvals = data.keys() 
    86         det = {'1':2, '2':1, '3':4, '4':5, '5':6}[repr(detector)] 
     90    mvals = data.keys() 
     91    det = {'1':2, '2':1, '3':4, '4':5, '5':6}[repr(detector)] 
    8792 
    88         for mval in mvals: 
    89                 if data[mval][det] > maxval: 
    90                         maxval = data[mval][det]                 
    91                         maxpos = mval 
    92          
    93         result['Position'] = maxpos 
    94         result['Value'] = maxval 
     93    for mval in mvals: 
     94        if data[mval][det] > maxval: 
     95            maxval = data[mval][det]         
     96            maxpos = mval 
     97     
     98    result['Position'] = maxpos 
     99    result['Value'] = maxval 
    95100 
    96         return result    
     101    return result     
    97102 
    98          
    99          
     103     
     104     
    100105 
    101106if __name__ == '__main__': 
    102         import sys 
    103         data = getBT5DataFromFile(sys.argv[1]) 
    104         printBT5DetData(data) 
     107    import sys 
     108    data = getBT5DataFromFile(sys.argv[1]) 
     109    printBT5DetData(data) 
    105110 
    106         maxinfo =  maxDetCount(data,2) 
    107         print maxinfo 
    108         avals = getAlignVals(data,maxinfo['Position']) 
    109         print avals 
     111    maxinfo = maxDetCount(data, 2) 
     112    print maxinfo 
     113    avals = getAlignVals(data, maxinfo['Position']) 
     114    print avals 
Note: See TracChangeset for help on using the changeset viewer.