- Arc integration

- xy-offset
- normalization

Author: aglavic

bash_completion.d/plotpy

@@ -10,8 +10,8 @@ _plot() {
       "dns") COMPREPLY=($(compgen -G "$curw*.d_dat") $(compgen -G "$curw*.d_dat.gz") $(compgen -S/ -d -- $curw));;
       "mbe") COMPREPLY=($(compgen -G "$curw*.dat") $(compgen -G "$curw*.png") $(compgen -G "$curw*.log") $(compgen -S/ -d -- $curw));;
       "4circle") COMPREPLY=($(compgen -G "$curw*.spec") $(compgen -G "$curw*.spec.gz") $(compgen -G "$curw*.[0-9][0-9][0-9][0-9]") $(compgen -G "$curw*.fio") $(compgen -G "$curw*.fio.gz") $(compgen -S/ -d -- $curw));;
-      "kws2") COMPREPLY=($(compgen -G "$curw*.DAT") $(compgen -G "$curw*.edf") $(compgen -G "$curw*.cmb") $(compgen -G "$curw*.bin") $(compgen -G "$curw*.gz") $(compgen -S/ -d -- $curw));;
-      "gisas") COMPREPLY=($(compgen -G "$curw*.DAT") $(compgen -G "$curw*.edf") $(compgen -G "$curw*.cmb") $(compgen -G "$curw*.bin") $(compgen -G "$curw*.gz") $(compgen -S/ -d -- $curw));;
+      "kws2") COMPREPLY=($(compgen -G "$curw*.DAT") $(compgen -G "$curw*.edf") $(compgen -G "$curw*.cmb") $(compgen -G "$curw*.bin") $(compgen -G "$curw*.gz") $(compgen -G "$curw*.mat") $(compgen -S/ -d -- $curw));;
+      "gisas") COMPREPLY=($(compgen -G "$curw*.DAT") $(compgen -G "$curw*.edf") $(compgen -G "$curw*.cmb") $(compgen -G "$curw*.bin") $(compgen -G "$curw*.gz") $(compgen -G "$curw*.mat") $(compgen -S/ -d -- $curw));;
       "in12") COMPREPLY=($(compgen -o default));;
       "refl") COMPREPLY=($(compgen -G "$curw*.[Uu][Xx][Dd]") $(compgen -G "$curw*.raw") $(compgen -G "$curw*.xrdml") $(compgen -G "$curw*.txt") $(compgen -G "$curw*.gz") $(compgen -S/ -d -- $curw));;
       "sas") COMPREPLY=($(compgen -G "$curw*.dat") $(compgen -G "$curw*.txt") $(compgen -G "$curw*.gz") $(compgen -S/ -d -- $curw));;

mime_types/gisas.xml

@@ -6,5 +6,6 @@
      <glob pattern="*.edf.gz"/>
      <glob pattern="*.cmb"/>
      <glob pattern="*.cmb.gz"/>
+     <glob pattern="*.mat"/>
    </mime-type>
 </mime-info>

plot_script/gtkgui/file_actions.py

@@ -169,7 +169,9 @@ def cross_section(self, x, x_0, y, y_0, w, binning,
     except ValueError:
       return False
 
-  def radial_integration(self, x_0, y_0, dr, max_r, at_end=False):
+  def radial_integration(self, x_0, y_0, dr, max_r,
+                                  phi_0=0., dphi=180., symmetric=True,
+                                  at_end=False):
     '''
       Create a radial integration around one point of a dataset
       
@@ -182,11 +184,17 @@ def radial_integration(self, x_0, y_0, dr, max_r, at_end=False):
     '''
     data=self.window.measurement[self.window.index_mess]
     try:
-      cs_object=self.create_radial_integration(x_0, y_0, dr, max_r)
+      cs_object=self.create_radial_integration(x_0, y_0, dr, max_r,
+                                               phi_0, dphi, symmetric)
       if cs_object is None:
         return False
       cs_object.number=data.number
-      cs_object.short_info='%s - Radial integration around (%g,%g)'%(
+      if dphi<180.:
+        cs_object.short_info='%s - Arc integration with φ=%g±%g from (%g,%g)'%(
+                           data.short_info, phi_0, dphi,
+                           x_0, y_0)
+      else:
+        cs_object.short_info='%s - Radial integration around (%g,%g)'%(
                            data.short_info, x_0, y_0)
       cs_object.sample_name=data.sample_name
       cs_object.info=data.info
@@ -608,16 +616,19 @@ def create_cross_section(self, x, x_0, y, y_0, w, binning, gauss_weighting=False
     out_dataset.append_column(PhysicalProperty(dataset.y.dimension, dataset.y.unit, data[2]))
     return out_dataset
 
-  def create_radial_integration(self, x_0, y_0, dr, max_r):
+  def create_radial_integration(self, x_0, y_0, dr, max_r,
+                                    phi_0=0., dphi=180., symmetric=True):
     '''
       Create a radial integration around one point (x_0,y_0)
       
       :param x_0: x-position of the center point
       :param y_0: y-position of the center point
       :param dr: Step size in radius for the created plot
       :param max_r: Maximal radius to integrate to
+      :param phi: Direction of radian
+      :param dphi: Width of arc
+      :param symmetric: Join negative and positive directions
     '''
-    from numpy import sqrt
     data=self.window.measurement[self.window.index_mess].get_filtered_data_matrix()
     dims=self.window.measurement[self.window.index_mess].dimensions()
     units=self.window.measurement[self.window.index_mess].units()
@@ -627,13 +638,15 @@ def create_radial_integration(self, x_0, y_0, dr, max_r):
           self.window.measurement[self.window.index_mess].yerror)
     # new_cols=[(dims[col], units[col]) for col in cols]
     # Distances to the point
-    dist_r=sqrt((data[cols[0]]-x_0)**2+(data[cols[1]]-y_0)**2)
-    max_r=min(dist_r.max(), max_r)
+    r=numpy.sqrt((data[cols[0]]-x_0)**2+(data[cols[1]]-y_0)**2)
     values=data[cols[2]]
     errors=data[cols[3]]
+    max_r=min(r.max(), max_r)
     first_dim="r"
     first_unit=units[cols[0]]
-    new_cols=[(first_dim, first_unit), (dims[cols[2]], units[cols[2]]), (dims[cols[3]], units[cols[3]])]
+    new_cols=[(first_dim, first_unit),
+              (dims[cols[2]], units[cols[2]]),
+              (dims[cols[3]], units[cols[3]])]
     output=MeasurementData([],
                            [],
                            0,
@@ -644,15 +657,28 @@ def create_radial_integration(self, x_0, y_0, dr, max_r):
     # the result is than calculated as hist(intensity)/hist(1)
     # and sqrt(hist(error²))/hist(1)
     points=int(max_r/dr)+1
-    hy, ignore=numpy.histogram(dist_r, points, weights=values)
-    hdy, ignore=numpy.histogram(dist_r, points, weights=errors**2)
+    if dphi<180.:
+      # take out just one arc region for the integration
+      phi=numpy.arctan2(data[cols[1]]-y_0, data[cols[0]]-x_0)/numpy.pi*180.
+      phi_region=numpy.where(((phi-phi_0)%180.)<=dphi)
+      r=r[phi_region]
+      values=values[phi_region]
+      errors=errors[phi_region]
+      if not symmetric:
+        phi=phi[phi_region]
+        r[((phi-phi_0)%360.)>180]*=-1.
+        points=int(max_r/dr)*2+1
+    hy, ignore=numpy.histogram(r, points, weights=values)
+    hdy, ignore=numpy.histogram(r, points, weights=errors**2)
     hdy=numpy.sqrt(hdy)
-    count, hx=numpy.histogram(dist_r, points)
+    count, hx=numpy.histogram(r, points)
     hy/=count
     hdy/=count
     hx=(hx[:-1]+hx[1:])/2.
     output.data.append(PhysicalProperty(new_cols[0][0], new_cols[0][1], hx))
     output.data.append(PhysicalProperty(new_cols[1][0], new_cols[1][1], hy, hdy))
+    if self.window.measurement[self.window.index_mess].logz:
+      output.logy=True
     if len(output)==0:
       return None
     else:

plot_script/gtkgui/main_window_data_treatment.py

@@ -671,6 +671,58 @@ def extract_cross_section(self, action):
       self.replot()
     return gotit
 
+  def correct_offset(self, action):
+    '''
+      Simple xy-offset correction.
+    '''
+    data=self.active_dataset
+    dimension_names=[]
+    dims=data.dimensions()
+    dimension_names.append(dims[data.xdata])
+    dimension_names.append(dims[data.ydata])
+    dialog=SimpleEntryDialog('Correct xy-Offset:',
+                                [
+                                ('x-offset', 0., float),
+                                ('y-offset', 0., float),
+                                ],
+                                description='Click to select the xy-origin'
+                                )
+    dialog.register_mouse_callback(self, [[('x-offset', 0), ('y-offset', 1)]])
+    values, result=dialog.run()
+    dialog.destroy()
+    if result:
+      data.x-=values['x-offset']
+      data.y-=values['y-offset']
+      self.replot()
+
+  def normalize_data(self, action):
+    '''
+      Simple xy-offset correction.
+    '''
+    data=self.active_dataset
+    dimension_names=[]
+    dims=data.dimensions()
+    dimension_names.append(dims[data.xdata])
+    dimension_names.append(dims[data.ydata])
+    dialog=SimpleEntryDialog('Normalize Data:',
+                                [
+                                ('Normalization', 1., float),
+                                ],
+                                description='Click to select value'
+                                )
+    dialog.register_mouse_callback(self, [[('Normalization', 1)]])
+    values, result=dialog.run()
+    dialog.destroy()
+    if result:
+      norm=values['Normalization']
+      ynorm=data.y/norm
+      ynorm.unit='a.u.'
+      ynorm.dimension=ynorm.dimension+'_{Norm}'
+      data.data.append(ynorm)
+      data.ydata=len(data.data)-1
+      self.rebuild_menus()
+      self.replot()
+
   def extract_radial_integration(self, action):
     '''
       Open a dialog to select point as center of a radial integration.
@@ -688,6 +740,9 @@ def extract_radial_integration(self, action):
                                 ('y0', 0, float),
                                 ('Δr', 0.001, float),
                                 ('r_max', 1e10, float),
+                                ('φ (x-axis)', 0., float),
+                                ('Δφ', 180., float),
+                                ('Symmetric', True),
                                 ],
                                 description='Click on the graph to select a xy-position.'
                                 )
@@ -699,8 +754,12 @@ def extract_radial_integration(self, action):
       x0=values['x0']
       y0=values['y0']
       mr=values['r_max']
+      phi=values['φ (x-axis)']
+      dphi=values['Δφ']
+      symmetric=values['Symmetric']
       gotit=self.file_actions.activate_action('radial_integration',
-                                        x0, y0, dr, mr, False
+                                        x0, y0, dr, mr,
+                                        phi, dphi, symmetric, False
                                         )
       if not gotit:
         message=gtk.MessageDialog(parent=self,

plot_script/gtkgui/main_window_ui.py

@@ -73,7 +73,7 @@ def build_menu(self):
         None, # tooltip
         self.change),
     ("FilesMenu", None, # name, stock id
-        "_Change", None, # label, accelerator
+        "Change", None, # label, accelerator
         None, # tooltip
         None),)
   # Menus allways present
@@ -265,6 +265,10 @@ def build_menu(self):
           <placeholder name='z-actions'/>
           <placeholder name='y-actions'>
           <menuitem action='CombinePoints'/>
+          <menu action='SimpleCorrections'>
+            <menuitem action='XYOffset'/>
+            <menuitem action='Normalize'/>
+          </menu>
           <menuitem action='Integrate'/>
           <menuitem action='Derivate'/>
           <menuitem action='PeakInfo'/>
@@ -378,7 +382,7 @@ def create_action_group(self):
       ("ViewMenu", None, "_View"), # name, stock id, label
       ("AxesMenu", None, "_Axes"), # name, stock id, label
       ("TreatmentMenu", None, "_Data treatment"), # name, stock id, label
-      ("ExtrasMenu", None, "E_xtras"), # name, stock id, label
+      ("ExtrasMenu", None, "Extras"), # name, stock id, label
       ("HelpMenu", None, "_Help"), # name, stock id, label
       ("ToolBar", None, "Toolbar"), # name, stock id, label
       ("Navigate", None, "Navigate"), # name, stock id, label
@@ -522,7 +526,7 @@ def create_action_group(self):
         None, # tooltip
         self.unit_transformation),
       ("CrossSection", None, # name, stock id
-        "Cross-Section...", None, #'s',                     # label, accelerator
+        "Cross-Section...", '<alt>C', #'s',                     # label, accelerator
         None, # tooltip
         self.extract_cross_section),
       ("InterpolateSmooth", None, # name, stock id
@@ -534,17 +538,29 @@ def create_action_group(self):
         None, # tooltip
         self.rebin_3d_data_dialog),
       ("RadialIntegration", None, # name, stock id
-        "Calculate Radial Integration...", None, # label, accelerator
+        "Calculate Radial/Arc Integration...", "<alt>R", # label, accelerator
         None, # tooltip
         self.extract_radial_integration),
       ("IntegrateIntensities", None, # name, stock id
         "Integrat Intensities...", None, # label, accelerator
         None, # tooltip
         self.extract_integrated_intensities),
       ("CombinePoints", None, # name, stock id
-        "Combine points", None, # label, accelerator
+        "Combine points", '<alt>C', # label, accelerator
         None, # tooltip
         self.combine_data_points),
+      ("SimpleCorrections", None, # name, stock id
+        "Correct the Dataset", None, # label, accelerator
+        None, # tooltip
+        None),
+      ("XYOffset", None, # name, stock id
+        "xy-Offset", '<alt>X', # label, accelerator
+        None, # tooltip
+        self.correct_offset),
+      ("Normalize", None, # name, stock id
+        "Normalization", '<alt>N', # label, accelerator
+        None, # tooltip
+        self.normalize_data),
       ("Derivate", None, # name, stock id
         "Derivate or Smoothe", '<control>D', # label, accelerator
         None, # tooltip

plot_script/plotpy_info.py

@@ -2,6 +2,6 @@
 
 __copyright__="Copyright 2008-2012"
 __license__="GPL v3"
-__version__="0.7.13.10"
+__version__="0.7.14"
 __maintainer__="Artur Glavic"
 __email__="[email protected]"

plot_script/read_data/circle.py

@@ -150,6 +150,9 @@ def read_scan(scan_lines, last_comments):
     output.scan_line=1
     output.filters=[(9,-1.0, 0.5, False)]
     output=MeasurementData4D.from_md(output, y2=2)
+  if scan_header['type'].split()[0]=='circle_mesh':
+    output.scan_line_constant=0
+    output.scan_line=1
   data=numpy.array(map(lambda line: numpy.fromstring(line, sep=" "), scan_data)).transpose()
   for i, col in enumerate(columns):
     output.data.append(PhysicalProperty(col[0], col[1], data[i]))
@@ -228,6 +231,9 @@ def get_type_columns(type_line, columns):
     first_index=columns.index(first_angle)
     second_index=columns.index(second_angle)
     return first_index, second_index, intensity_error, intensity
+  elif type_=='circle_mesh':
+    items=options.strip().split()
+    return columns.index(items[0].lower()), columns.index(items[1].lower()), intensity_error, intensity
   elif type_=='mesh3d':
     items=options.strip().split()
     first_angle='Theta' #items[0]

plot_script/read_data/qtiplot.py

@@ -43,10 +43,12 @@ def process_tables(name, table, index):
     Read the data of one table using the header to define column names.
   '''
   header, data=table.split('<data>')
-  data=data.split('</data>')[0].strip()
+  data=data.strip().split('</data>')[0]
   header_info=process_header(header)
+  # split data by lines and columns
   data_lines=data.splitlines()
-  data_items=map(str.split, data_lines)
+  data_items=map(lambda line: line.split('\t'), data_lines)
+  # convert to numbers
   data=[map(float_convert, line) for line in data_items]
   data=numpy.array(data).transpose()
   column_names=header_info['columns']
@@ -88,5 +90,12 @@ def float_convert(item):
   try:
     return float(item)
   except ValueError:
-    return 0.
+    if ':' in item:
+      try:
+        h, m, s=item.split(':')
+        return 3600.*float(h)+60.*float(m)+float(s)
+      except:
+        return 0.
+    else:
+      return 0.
 

plot_script/sessions/kws2.py

@@ -47,8 +47,9 @@ class KWS2Session(GUI, GenericSession):
   #------------------ help text strings ---------------
 
   #++++++++++++++++++ local variables +++++++++++++++++
-  FILE_WILDCARDS=[('GISAS', '*.DAT', '*.DAT.gz', '*.cmb', '*.cmb.gz', '*.edf', '*.edf.gz', '*.tif', '*.bin', '*.bin.gz',
-                   '*.bmp'), ]
+  FILE_WILDCARDS=[('GISAS', '*.DAT', '*.DAT.gz', '*.cmb', '*.cmb.gz',
+                   '*.edf', '*.edf.gz', '*.tif', '*.bin', '*.bin.gz',
+                   '*.mat', '*.bmp'), ]
   mds_create=False
   read_directly=True
 
@@ -134,4 +135,4 @@ def autosubtract_background(self, dataset, fraction=5.):
     dataset.plot_options.zrange=(1., None)
     return fine_background
 
-  #++++++++++++++++++++++++++ data treatment functions ++++++++++++++++++++++++++++++++
+  #++++++++++++++++++++++++++ data treatment functions ++++++++++++++++++++++++++++++++