From: W. Trevor King Date: Sat, 7 Aug 2010 22:46:22 +0000 (-0400) Subject: Update DifferenceCommand to use flexible column names. X-Git-Url: http://git.tremily.us/?p=hooke.git;a=commitdiff_plain;h=767155aa19ecc4d07b91daa7e5e8cf456030e29e Update DifferenceCommand to use flexible column names. --- diff --git a/hooke/plugin/curve.py b/hooke/plugin/curve.py index 5c13ba7..86ea7d8 100644 --- 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 and `). """.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 with respect to `). +Name of the new column for storing the derivative (without units, defaults to +`derivative of with respect to `). """.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 `) for storing the power spectrum. +Name of the new data block for storing the power spectrum (defaults to +`power spectrum of `). """.strip()), ], help=self.__doc__, plugin=plugin)