Update DifferenceCommand to use flexible column names.

diff --git a/hooke/plugin/curve.py b/hooke/plugin/curve.py
index 5c13ba741a4e325720bbaa9641c555b7a64cf325..86ea7d8099203e6c2428f5ad565a7442fbd43abf 100644 (file)
--- a/hooke/plugin/curve.py
+++ b/hooke/plugin/curve.py
@@ -194,7 +194,7 @@ class ExportCommand (Command):
             name='export block',
             arguments=[
                 CurveArgument,
-                Argument(name='block', aliases=['set'], type='int', default=0,
+                Argument(name='block', type='int', default=0,
                          help="""
 Data block to save.  For an approach/retract force curve, `0` selects
 the approaching curve and `1` selects the retracting curve.
@@ -220,41 +220,75 @@ True if you want the column-naming header line.
         f.close()
 
 class DifferenceCommand (Command):
-    """Calculate the difference between two blocks of data.
+    """Calculate the difference between two columns of data.
+
+    The difference is added to block A as a new column.
+
+    Note that the command will fail if the columns have different
+    lengths, so be careful when differencing columns from different
+    blocks.
     """
     def __init__(self, plugin):
         super(DifferenceCommand, self).__init__(
-            name='block difference',
+            name='difference',
             arguments=[
                 CurveArgument,
-                Argument(name='block one', aliases=['set one'], type='int',
-                         default=1,
+                Argument(name='block A', type='int',
                          help="""
 Block A in A-B.  For an approach/retract force curve, `0` selects the
-approaching curve and `1` selects the retracting curve.
+approaching curve and `1` selects the retracting curve.  Defaults to
+the first block.
+""".strip()),
+                Argument(name='block B', type='int',
+                         help="""
+Block B in A-B.  Defaults to matching `block A`.
+""".strip()),
+                Argument(name='column A', type='string',
+                         help="""
+Column of data from block A to difference.  Defaults to the first column.
 """.strip()),
-                Argument(name='block two', aliases=['set two'], type='int',
-                         default=0,
-                         help='Block B in A-B.'),
-                Argument(name='x column', type='int', default=0,
+                Argument(name='column B', type='string', default=1,
                          help="""
-Column of data to return as x values.
+Column of data from block B to difference.  Defaults to matching `column A`.
 """.strip()),
-                Argument(name='y column', type='int', default=1,
+                Argument(name='output column name', type='string',
                          help="""
-Column of data block to difference.
+Name of the new column for storing the difference (without units, defaults to
+`difference of <block A> <column A> and <block B> <column B>`).
 """.strip()),
                 ],
             help=self.__doc__, plugin=plugin)
 
     def _run(self, hooke, inqueue, outqueue, params):
-        a = params['curve'].data[params['block one']]
-        b = params['curve'].data[params['block two']]
-        assert a[:,params['x column']] == b[:,params['x column']]
-        out = Data((a.shape[0],2), dtype=a.dtype)
-        out[:,0] = a[:,params['x column']]
-        out[:,1] = a[:,params['y column']] - b[:,params['y column']]
-        outqueue.put(out)
+        data_A = params['curve'].data[params['block A']]
+        data_B = params['curve'].data[params['block B']]
+        # HACK? rely on params['curve'] being bound to the local hooke
+        # playlist (i.e. not a copy, as you would get by passing a
+        # curve through the queue).  Ugh.  Stupid queues.  As an
+        # alternative, we could pass lookup information through the
+        # queue...
+        new = Data((data_A.shape[0], data_A.shape[1]+1), dtype=data_A.dtype)
+        new.info = copy.deepcopy(data.info)
+        new[:,:-1] = data_A
+
+        a_col = data_A.info['columns'].index(params['column A'])
+        b_col = data_A.info['columns'].index(params['column A'])
+        out = data_A[:,a_col] - data_B[:,b_col]
+
+        a_name,a_units = split_data_label(params['column A'])
+        b_name,b_units = split_data_label(params['column B'])
+        assert a_units == b_units, (
+            'Unit missmatch: %s != %s' % (a_units, b_units))
+        if params['output column name'] == None:
+            params['output column name'] = (
+                'difference of %s %s and %s %s' % (
+                    block_A.info['name'], params['column A'],
+                    block_B.info['name'], params['column B']))
+        new.info['columns'].append(
+            join_data_label(params['output distance column'], a_units)
+        new[:,-1] = out
+        params['curve'].data[params['block A']] = new
+
 
 class DerivativeCommand (Command):
     """Calculate the derivative (actually, the discrete differentiation)
@@ -265,10 +299,10 @@ class DerivativeCommand (Command):
     """
     def __init__(self, plugin):
         super(DerivativeCommand, self).__init__(
-            name='block derivative',
+            name='derivative',
             arguments=[
                 CurveArgument,
-                Argument(name='block', aliases=['set'], type='int', default=0,
+                Argument(name='block', type='int', default=0,
                          help="""
 Data block to differentiate.  For an approach/retract force curve, `0`
 selects the approaching curve and `1` selects the retracting curve.
@@ -288,7 +322,8 @@ central differencing.
 """.strip()),
                 Argument(name='output column name', type='string',
                          help="""
-Name of the new column for storing the derivative (without units, defaults to `derivative of <f column name> with respect to <x column name>`).
+Name of the new column for storing the derivative (without units, defaults to
+`derivative of <f column name> with respect to <x column name>`).
 """.strip()),
                 ],
             help=self.__doc__, plugin=plugin)
@@ -328,10 +363,10 @@ class PowerSpectrumCommand (Command):
     """
     def __init__(self, plugin):
         super(PowerSpectrumCommand, self).__init__(
-            name='block power spectrum',
+            name='power spectrum',
             arguments=[
                 CurveArgument,
-                Argument(name='block', aliases=['set'], type='int', default=0,
+                Argument(name='block', type='int', default=0,
                          help="""
 Data block to act on.  For an approach/retract force curve, `0`
 selects the approaching curve and `1` selects the retracting curve.
@@ -363,7 +398,8 @@ Otherwise, the chunks are end-to-end, and not overlapping.
 """.strip()),
                 Argument(name='output block name', type='string',
                          help="""
-Name of the new data block (defaults to `power spectrum of <source block name> <source column name>`) for storing the power spectrum.
+Name of the new data block for storing the power spectrum (defaults to
+`power spectrum of <source block name> <source column name>`).
 """.strip()),
                 ],
             help=self.__doc__, plugin=plugin)