hooke/plugin/curve.py

   1 # Copyright (C) 2008-2010 Alberto Gomez-Casado
   2 #                         Fabrizio Benedetti
   3 #                         Massimo Sandal <devicerandom@gmail.com>
   4 #                         W. Trevor King <wking@drexel.edu>
   5 #
   6 # This file is part of Hooke.
   7 #
   8 # Hooke is free software: you can redistribute it and/or modify it
   9 # under the terms of the GNU Lesser General Public License as
  10 # published by the Free Software Foundation, either version 3 of the
  11 # License, or (at your option) any later version.
  12 #
  13 # Hooke is distributed in the hope that it will be useful, but WITHOUT
  14 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  16 # Public License for more details.
  17 #
  18 # You should have received a copy of the GNU Lesser General Public
  19 # License along with Hooke.  If not, see
  20 # <http://www.gnu.org/licenses/>.
  21
  22 """The ``curve`` module provides :class:`CurvePlugin` and several
  23 associated :class:`hooke.command.Command`\s for handling
  24 :mod:`hooke.curve` classes.
  25 """
  26
  27 import copy
  28
  29 import numpy
  30
  31 from ..command import Command, Argument, Failure
  32 from ..command_stack import CommandStack
  33 from ..curve import Data
  34 from ..engine import CommandMessage
  35 from ..util.calculus import derivative
  36 from ..util.fft import unitary_avg_power_spectrum
  37 from ..util.si import ppSI, join_data_label, split_data_label
  38 from . import Builtin
  39 from .playlist import current_playlist_callback
  40
  41
  42 # Define common or complicated arguments
  43
  44 def current_curve_callback(hooke, command, argument, value):
  45     if value != None:
  46         return value
  47     playlist = current_playlist_callback(hooke, command, argument, value)
  48     curve = playlist.current()
  49     if curve == None:
  50         raise Failure('No curves in %s' % playlist)
  51     return curve
  52
  53 CurveArgument = Argument(
  54     name='curve', type='curve', callback=current_curve_callback,
  55     help="""
  56 :class:`hooke.curve.Curve` to act on.  Defaults to the current curve
  57 of the current playlist.
  58 """.strip())
  59
  60 def _name_argument(name, default, help):
  61     """TODO
  62     """
  63     return Argument(name=name, type='string', default=default, help=help)
  64
  65 def block_argument(*args, **kwargs):
  66     """TODO
  67     """
  68     return _name_argument(*args, **kwargs)
  69
  70 def column_argument(*args, **kwargs):
  71     """TODO
  72     """
  73     return _name_argument(*args, **kwargs)
  74
  75
  76 # Define useful command subclasses
  77
  78 class CurveCommand (Command):
  79     """A :class:`~hooke.command.Command` operating on a
  80     :class:`~hooke.curve.Curve`.
  81     """
  82     def __init__(self, **kwargs):
  83         if 'arguments' in kwargs:
  84             kwargs['arguments'].insert(0, CurveArgument)
  85         else:
  86             kwargs['arguments'] = [CurveArgument]
  87         super(CurveCommand, self).__init__(**kwargs)
  88
  89     def _curve(self, hooke, params):
  90         """Get the selected curve.
  91
  92         Notes
  93         -----
  94         `hooke` is intended to attach the selected curve to the local
  95         playlist; the returned curve should not be effected by the
  96         state of `hooke`.  This is important for reliable
  97         :class:`~hooke.command_stack.CommandStack`\s.
  98         """
  99         # HACK? rely on params['curve'] being bound to the local hooke
 100         # playlist (i.e. not a copy, as you would get by passing a
 101         # curve through the queue).  Ugh.  Stupid queues.  As an
 102         # alternative, we could pass lookup information through the
 103         # queue...
 104         return params['curve']
 105
 106     def _add_to_command_stack(self, params):
 107         """Store the command name and current `params` values in the
 108         curve's `.command_stack`.
 109
 110         If this would duplicate the command currently on top of the
 111         stack, no action is taken.  Call early on, or watch out for
 112         repeated param processing.
 113
 114         Recommended practice is to *not* lock in argument values that
 115         are loaded from the plugin's :attr:`.config`.
 116
 117         Notes
 118         -----
 119         Perhaps we should subclass :meth:`_run` and use :func:`super`,
 120         or embed this in :meth:`run` to avoid subclasses calling this
 121         method explicitly, with all the tedium and brittality that
 122         implies.  On the other hand, the current implemtnation allows
 123         CurveCommands that don't effect the curve itself
 124         (e.g. :class:`GetCommand`) to avoid adding themselves to the
 125         stack entirely.
 126         """
 127         if params['stack'] == True:
 128             curve = self._curve(hooke=None, params=params)
 129             if (len(curve.command_stack) > 0
 130                 and curve.command_stack[-1].command == self.name
 131                 and curve.command_stack[-1].arguments == params):
 132                 pass  # no need to place duplicate calls on the stack.
 133             else:
 134                 curve.command_stack.append(CommandMessage(
 135                         self.name, params))
 136
 137
 138 class BlockCommand (CurveCommand):
 139     """A :class:`CurveCommand` operating on a :class:`~hooke.curve.Data` block.
 140     """
 141     def __init__(self, blocks=None, **kwargs):
 142         if blocks == None:
 143             blocks = [('block', None, 'Name of the data block to act on.')]
 144         block_args = []
 145         for name,default,help in blocks:
 146             block_args.append(block_argument(name, default, help))
 147         self._block_arguments = block_args
 148         if 'arguments' not in kwargs:
 149             kwargs['arguments'] = []
 150         kwargs['arguments'] = block_args + kwargs['arguments']
 151         super(BlockCommand, self).__init__(**kwargs)
 152
 153     def _block_names(self, hooke, params):
 154         curve = self._curve(hooke, params)
 155         return [b.info['name'] for b in curve.data]
 156
 157     def _block_index(self, hooke, params, name=None):
 158         if name == None:
 159             name = self._block_arguments[0].name
 160         block_name = params[name]
 161         if block_name == None:
 162             curve = self._curve(hooke=hooke, params=params)
 163             if len(curve.data) == 0:
 164                 raise Failure('no blocks in %s' % curve)
 165             block_name = curve.data[0].info['name']
 166         names = self._block_names(hooke=hooke, params=params)
 167         try:
 168             return names.index(block_name)
 169         except ValueError, e:
 170             curve = self._curve(hooke, params)
 171             raise Failure('no block named %s in %s (%s): %s'
 172                           % (block_name, curve, names, e))
 173
 174     def _block(self, hooke, params, name=None):
 175         # HACK? rely on params['block'] being bound to the local hooke
 176         # playlist (i.e. not a copy, as you would get by passing a
 177         # block through the queue).  Ugh.  Stupid queues.  As an
 178         # alternative, we could pass lookup information through the
 179         # queue...
 180         curve = self._curve(hooke, params)
 181         index = self._block_index(hooke, params, name)
 182         return curve.data[index]
 183
 184
 185 class ColumnAccessCommand (BlockCommand):
 186     """A :class:`BlockCommand` accessing a :class:`~hooke.curve.Data`
 187     block column.
 188     """
 189     def __init__(self, columns=None, **kwargs):
 190         if columns == None:
 191             columns = [('column', None, 'Name of the data column to act on.')]
 192         column_args = []
 193         for name,default,help in columns:
 194             column_args.append(column_argument(name, default, help))
 195         self._column_arguments = column_args
 196         if 'arguments' not in kwargs:
 197             kwargs['arguments'] = []
 198         kwargs['arguments'] = column_args + kwargs['arguments']
 199         super(ColumnAccessCommand, self).__init__(**kwargs)
 200
 201     def _get_column(self, hooke, params, block_name=None, column_name=None):
 202         if column_name == None:
 203             column_name = self._column_arguments[0].name
 204         column_name = params[column_name]
 205         block = self._block(hooke, params, block_name)
 206         columns = block.info['columns']
 207         try:
 208             column_index = columns.index(column_name)
 209         except ValueError, e:
 210             raise Failure('%s not in %s (%s): %s'
 211                           % (column_name, block.info['name'], columns, e))
 212         return block[:,column_index]
 213
 214
 215 class ColumnAddingCommand (ColumnAccessCommand):
 216     """A :class:`ColumnAccessCommand` that also adds columns.
 217     """
 218     def __init__(self, new_columns=None, **kwargs):
 219         if new_columns == None:
 220             new_columns = []
 221         column_args = []
 222         for name,default,help in new_columns:
 223             column_args.append(column_argument(name, default, help))
 224         self._new_column_arguments = column_args
 225         if 'arguments' not in kwargs:
 226             kwargs['arguments'] = []
 227         kwargs['arguments'] = column_args + kwargs['arguments']
 228         super(ColumnAddingCommand, self).__init__(**kwargs)
 229
 230     def _get_column(self, hooke, params, block_name=None, column_name=None):
 231         if column_name == None and len(self._column_arguments) == 0:
 232             column_name = self._new_column_arguments[0].name
 233         return super(ColumnAddingCommand, self)._get_column(
 234             hooke=hooke, params=params, block_name=block_name,
 235             column_name=column_name)
 236
 237     def _set_column(self, hooke, params, block_name=None, column_name=None,
 238                     values=None):
 239         if column_name == None:
 240             column_name = self._column_arguments[0].name
 241         column_name = params[column_name]
 242         block = self._block(hooke=hooke, params=params, name=block_name)
 243         if column_name not in block.info['columns']:
 244             new = Data((block.shape[0], block.shape[1]+1), dtype=block.dtype)
 245             new.info = copy.deepcopy(block.info)
 246             new[:,:-1] = block
 247             new.info['columns'].append(column_name)
 248             block = new
 249             block_index = self._block_index(hooke, params, name=block_name)
 250             self._curve(hooke, params).data[block_index] = block
 251         column_index = block.info['columns'].index(column_name)
 252         block[:,column_index] = values
 253
 254
 255 # The plugin itself
 256
 257 class CurvePlugin (Builtin):
 258     def __init__(self):
 259         super(CurvePlugin, self).__init__(name='curve')
 260         self._commands = [
 261             GetCommand(self), InfoCommand(self), DeltaCommand(self),
 262             ExportCommand(self), DifferenceCommand(self),
 263             DerivativeCommand(self), PowerSpectrumCommand(self),
 264             ClearStackCommand(self)]
 265
 266
 267 # Define commands
 268
 269 class GetCommand (CurveCommand):
 270     """Return a :class:`hooke.curve.Curve`.
 271     """
 272     def __init__(self, plugin):
 273         super(GetCommand, self).__init__(
 274             name='get curve', help=self.__doc__, plugin=plugin)
 275
 276     def _run(self, hooke, inqueue, outqueue, params):
 277         outqueue.put(self._curve(hooke, params))
 278
 279
 280 class InfoCommand (CurveCommand):
 281     """Get selected information about a :class:`hooke.curve.Curve`.
 282     """
 283     def __init__(self, plugin):
 284         args = [
 285             Argument(name='all', type='bool', default=False, count=1,
 286                      help='Get all curve information.'),
 287             ]
 288         self.fields = ['name', 'path', 'experiment', 'driver', 'filetype', 'note',
 289                        'blocks', 'block sizes']
 290         for field in self.fields:
 291             args.append(Argument(
 292                     name=field, type='bool', default=False, count=1,
 293                     help='Get curve %s' % field))
 294         super(InfoCommand, self).__init__(
 295             name='curve info', arguments=args,
 296             help=self.__doc__, plugin=plugin)
 297
 298     def _run(self, hooke, inqueue, outqueue, params):
 299         curve = self._curve(hooke, params)
 300         fields = {}
 301         for key in self.fields:
 302             fields[key] = params[key]
 303         if reduce(lambda x,y: x and y, fields.values()) == False:
 304             params['all'] = True # No specific fields set, default to 'all'
 305         if params['all'] == True:
 306             for key in self.fields:
 307                 fields[key] = True
 308         lines = []
 309         for key in self.fields:
 310             if fields[key] == True:
 311                 get = getattr(self, '_get_%s' % key.replace(' ', '_'))
 312                 lines.append('%s: %s' % (key, get(curve)))
 313         outqueue.put('\n'.join(lines))
 314
 315     def _get_name(self, curve):
 316         return curve.name
 317
 318     def _get_path(self, curve):
 319         return curve.path
 320
 321     def _get_experiment(self, curve):
 322         return curve.info.get('experiment', None)
 323
 324     def _get_driver(self, curve):
 325         return curve.driver
 326
 327     def _get_filetype(self, curve):
 328         return curve.info.get('filetype', None)
 329
 330     def _get_note(self, curve):
 331         return curve.info.get('note', None)
 332
 333     def _get_blocks(self, curve):
 334         return len(curve.data)
 335
 336     def _get_block_sizes(self, curve):
 337         return [block.shape for block in curve.data]
 338
 339
 340 class DeltaCommand (BlockCommand):
 341     """Get distance information between two points.
 342
 343     With two points A and B, the returned distances are A-B.
 344     """
 345     def __init__(self, plugin):
 346         super(DeltaCommand, self).__init__(
 347             name='delta',
 348             arguments=[
 349                 Argument(name='point', type='point', optional=False, count=2,
 350                          help="""
 351 Indicies of points bounding the selected data.
 352 """.strip()),
 353                 Argument(name='SI', type='bool', default=False,
 354                          help="""
 355 Return distances in SI notation.
 356 """.strip())
 357                 ],
 358             help=self.__doc__, plugin=plugin)
 359
 360     def _run(self, hooke, inqueue, outqueue, params):
 361         data = self._block(hooke, params)
 362         As = data[params['point'][0],:]
 363         Bs = data[params['point'][1],:]
 364         ds = [A-B for A,B in zip(As, Bs)]
 365         if params['SI'] == False:
 366             out = [(name, d) for name,d in zip(data.info['columns'], ds)]
 367         else:
 368             out = []
 369             for name,d in zip(data.info['columns'], ds):
 370                 n,units = split_data_label(name)
 371                 out.append(
 372                   (n, ppSI(value=d, unit=units, decimals=2)))
 373         outqueue.put(out)
 374
 375
 376 class ExportCommand (BlockCommand):
 377     """Export a :class:`hooke.curve.Curve` data block as TAB-delimeted
 378     ASCII text.
 379
 380     A "#" prefixed header will optionally appear at the beginning of
 381     the file naming the columns.
 382     """
 383     def __init__(self, plugin):
 384         super(ExportCommand, self).__init__(
 385             name='export block',
 386             arguments=[
 387                 Argument(name='output', type='file', default='curve.dat',
 388                          help="""
 389 File name for the output data.  Defaults to 'curve.dat'
 390 """.strip()),
 391                 Argument(name='header', type='bool', default=True,
 392                          help="""
 393 True if you want the column-naming header line.
 394 """.strip()),
 395                 ],
 396             help=self.__doc__, plugin=plugin)
 397
 398     def _run(self, hooke, inqueue, outqueue, params):
 399         data = self._block(hooke, params)
 400
 401         with open(params['output'], 'w') as f:
 402             if params['header'] == True:
 403                 f.write('# %s \n' % ('\t'.join(data.info['columns'])))
 404             numpy.savetxt(f, data, delimiter='\t')
 405
 406
 407 class DifferenceCommand (ColumnAddingCommand):
 408     """Calculate the difference between two columns of data.
 409
 410     The difference is added to block A as a new column.
 411
 412     Note that the command will fail if the columns have different
 413     lengths, so be careful when differencing columns from different
 414     blocks.
 415     """
 416     def __init__(self, plugin):
 417         super(DifferenceCommand, self).__init__(
 418             name='difference',
 419             blocks=[
 420                 ('block A', None,
 421                  'Name of block A in A-B.  Defaults to the first block'),
 422                 ('block B', None,
 423                  'Name of block B in A-B.  Defaults to matching `block A`.'),
 424                 ],
 425             columns=[
 426                 ('column A', None,
 427                  """
 428 Column of data from block A to difference.  Defaults to the first column.
 429 """.strip()),
 430                 ('column B', None,
 431                  """
 432 Column of data from block B to difference.  Defaults to matching `column A`.
 433 """.strip()),
 434                 ],
 435             new_columns=[
 436                 ('output column', None,
 437                  """
 438 Name of the new column for storing the difference (without units, defaults to
 439 `difference of <block A> <column A> and <block B> <column B>`).
 440 """.strip()),
 441                 ],
 442             help=self.__doc__, plugin=plugin)
 443
 444     def _run(self, hooke, inqueue, outqueue, params):
 445         self._add_to_command_stack(params)
 446         params = self.__setup_params(hooke=hooke, params=params)
 447         data_A = self._get_column(hooke=hooke, params=params,
 448                                   block_name='block A',
 449                                   column_name='column A')
 450         data_B = self._get_column(hooke=hooke, params=params,
 451                                   block_name='block B',
 452                                   column_name='column B')
 453         out = data_A - data_B
 454         self._set_column(hooke=hooke, params=params,
 455                          block_name='block A',
 456                          column_name='output column',
 457                          values=out)
 458
 459     def __setup_params(self, hooke, params):
 460         curve = self._curve(hooke, params)
 461         if params['block A'] == None:
 462             params['block A'] = curve.data[0].info['name']
 463         if params['block B'] == None:
 464             params['block B'] = params['block A']
 465         block_A = self._block(hooke, params=params, name='block A')
 466         block_B = self._block(hooke, params=params, name='block B')
 467         if params['column A'] == None:
 468             params['column A'] = block.info['columns'][0]
 469         if params['column B'] == None:
 470             params['column B'] = params['column A']
 471         a_name,a_unit = split_data_label(params['column A'])
 472         b_name,b_unit = split_data_label(params['column B'])
 473         if a_unit != b_unit:
 474             raise Failure('Unit missmatch: %s != %s' % (a_unit, b_unit))
 475         if params['output column'] == None:
 476             params['output column'] = join_data_label(
 477                 'difference of %s %s and %s %s' % (
 478                     block_A.info['name'], a_name,
 479                     block_B.info['name'], b_name),
 480                 a_unit)
 481         else:
 482             params['output column'] = join_data_label(
 483                 params['output column'], a_unit)
 484         return params
 485
 486
 487 class DerivativeCommand (ColumnAddingCommand):
 488     """Calculate the derivative (actually, the discrete differentiation)
 489     of a data column.
 490
 491     See :func:`hooke.util.calculus.derivative` for implementation
 492     details.
 493     """
 494     def __init__(self, plugin):
 495         super(DerivativeCommand, self).__init__(
 496             name='derivative',
 497             columns=[
 498                 ('x column', None,
 499                  'Column of data block to differentiate with respect to.'),
 500                 ('f column', None,
 501                  'Column of data block to differentiate.'),
 502                 ],
 503             new_columns=[
 504                 ('output column', None,
 505                  """
 506 Name of the new column for storing the derivative (without units, defaults to
 507 `derivative of <f column> with respect to <x column>`).
 508 """.strip()),
 509                 ],
 510             arguments=[
 511                 Argument(name='weights', type='dict', default={-1:-0.5, 1:0.5},
 512                          help="""
 513 Weighting scheme dictionary for finite differencing.  Defaults to
 514 central differencing.
 515 """.strip()),
 516                 ],
 517             help=self.__doc__, plugin=plugin)
 518
 519     def _run(self, hooke, inqueue, outqueue, params):
 520         self._add_to_command_stack(params)
 521         params = self.__setup_params(hooke=hooke, params=params)
 522         x_data = self._get_column(hooke=hooke, params=params,
 523                                   column_name='x column')
 524         f_data = self._get_column(hooke=hooke, params=params,
 525                                   column_name='f column')
 526         d = derivative(
 527             x_data=x_data, f_data=f_data, weights=params['weights'])
 528         self._set_column(hooke=hooke, params=params,
 529                          column_name='output column',
 530                          values=d)
 531
 532     def __setup_params(self, hooke, params):
 533         curve = self._curve(hooke, params)
 534         x_name,x_unit = split_data_label(params['x column'])
 535         f_name,f_unit = split_data_label(params['f column'])
 536         d_unit = '%s/%s' % (f_unit, x_unit)
 537         if params['output column'] == None:
 538             params['output column'] = join_data_label(
 539                 'derivative of %s with respect to %s' % (
 540                     f_name, x_name),
 541                 d_unit)
 542         else:
 543             params['output column'] = join_data_label(
 544                 params['output column'], d_unit)
 545         return params
 546
 547
 548 class PowerSpectrumCommand (ColumnAddingCommand):
 549     """Calculate the power spectrum of a data column.
 550     """
 551     def __init__(self, plugin):
 552         super(PowerSpectrumCommand, self).__init__(
 553             name='power spectrum',
 554             arguments=[
 555                 Argument(name='output block', type='string',
 556                          help="""
 557 Name of the new data block for storing the power spectrum (defaults to
 558 `power spectrum of <source block name> <source column name>`).
 559 """.strip()),
 560                 Argument(name='bounds', type='point', optional=True, count=2,
 561                          help="""
 562 Indicies of points bounding the selected data.
 563 """.strip()),
 564                 Argument(name='freq', type='float', default=1.0,
 565                          help="""
 566 Sampling frequency.
 567 """.strip()),
 568                 Argument(name='freq units', type='string', default='Hz',
 569                          help="""
 570 Units for the sampling frequency.
 571 """.strip()),
 572                 Argument(name='chunk size', type='int', default=2048,
 573                          help="""
 574 Number of samples per chunk.  Use a power of two.
 575 """.strip()),
 576                 Argument(name='overlap', type='bool', default=False,
 577                          help="""
 578 If `True`, each chunk overlaps the previous chunk by half its length.
 579 Otherwise, the chunks are end-to-end, and not overlapping.
 580 """.strip()),
 581                 ],
 582             help=self.__doc__, plugin=plugin)
 583
 584     def _run(self, hooke, inqueue, outqueue, params):
 585         self._add_to_command_stack(params)
 586         params = self.__setup_params(hooke=hooke, params=params)
 587         data = self._get_column(hooke=hooke, params=params)
 588         bounds = params['bounds']
 589         if bounds != None:
 590             data = data[bounds[0]:bounds[1]]
 591         freq_axis,power = unitary_avg_power_spectrum(
 592             data, freq=params['freq'],
 593             chunk_size=params['chunk size'],
 594             overlap=params['overlap'])
 595         b = Data((len(freq_axis),2), dtype=data.dtype)
 596         b.info['name'] = params['output block']
 597         b.info['columns'] = [
 598             params['output freq column'],
 599             params['output power column'],
 600             ]
 601         self._curve(hooke, params).data.append(b)
 602         self._set_column(hooke, params, block_name='output block',
 603                          column_name='output freq column',
 604                          values=freq_axis)
 605         self._set_column(hooke, params, block_name='output block',
 606                          column_name='output power column',
 607                          values=power)
 608         outqueue.put(b)
 609
 610     def __setup_params(self, hooke, params):
 611         if params['output block'] in self._block_names(hooke, params):
 612             raise Failure('output block %s already exists in %s.'
 613                           % (params['output block'],
 614                              self._curve(hooke, params)))
 615         data = self._get_column(hooke=hooke, params=params)
 616         d_name,d_unit = split_data_label(data.info['name'])
 617         if params['output block'] == None:
 618             params['output block'] = 'power spectrum of %s %s' % (
 619                 data.info['name'], params['column'])
 620         self.params['output freq column'] = join_data_label(
 621             'frequency axis', params['freq units'])
 622         self.params['output power column'] = join_data_label(
 623             'power density', '%s^2/%s' % (data_units, params['freq units']))
 624         return params
 625
 626
 627 class ClearStackCommand (CurveCommand):
 628     """Empty a curve's command stack.
 629     """
 630     def __init__(self, plugin):
 631         super(ClearStackCommand, self).__init__(
 632             name='clear curve command stack',
 633             help=self.__doc__, plugin=plugin)
 634
 635     def _run(self, hooke, inqueue, outqueue, params):
 636         curve = self._curve(hooke, params)
 637         curve.command_stack = CommandStack()
 638
 639
 640 class OldCruft (object):
 641
 642     def do_forcebase(self,args):
 643         '''
 644         FORCEBASE
 645         (generalvclamp.py)
 646         Measures the difference in force (in pN) between a point and a baseline
 647         took as the average between two points.
 648
 649         The baseline is fixed once for a given curve and different force measurements,
 650         unless the user wants it to be recalculated
 651         ------------
 652         Syntax: forcebase [rebase]
 653                 rebase: Forces forcebase to ask again the baseline
 654                 max: Instead of asking for a point to measure, asks for two points and use
 655                      the maximum peak in between
 656         '''
 657         rebase=False #if true=we select rebase
 658         maxpoint=False #if true=we measure the maximum peak
 659
 660         plot=self._get_displayed_plot()
 661         whatset=1 #fixme: for all sets
 662         if 'rebase' in args or (self.basecurrent != self.current.path):
 663             rebase=True
 664         if 'max' in args:
 665             maxpoint=True
 666
 667         if rebase:
 668             print 'Select baseline'
 669             self.basepoints=self._measure_N_points(N=2, whatset=whatset)
 670             self.basecurrent=self.current.path
 671
 672         if maxpoint:
 673             print 'Select two points'
 674             points=self._measure_N_points(N=2, whatset=whatset)
 675             boundpoints=[points[0].index, points[1].index]
 676             boundpoints.sort()
 677             try:
 678                 y=min(plot.vectors[whatset][1][boundpoints[0]:boundpoints[1]])
 679             except ValueError:
 680                 print 'Chosen interval not valid. Try picking it again. Did you pick the same point as begin and end of interval?'
 681         else:
 682             print 'Select point to measure'
 683             points=self._measure_N_points(N=1, whatset=whatset)
 684             #whatplot=points[0].dest
 685             y=points[0].graph_coords[1]
 686
 687         #fixme: code duplication
 688         boundaries=[self.basepoints[0].index, self.basepoints[1].index]
 689         boundaries.sort()
 690         to_average=plot.vectors[whatset][1][boundaries[0]:boundaries[1]] #y points to average
 691
 692         avg=np.mean(to_average)
 693         forcebase=abs(y-avg)
 694         print str(forcebase*(10**12))+' pN'
 695         to_dump='forcebase '+self.current.path+' '+str(forcebase*(10**12))+' pN'
 696         self.outlet.push(to_dump)
 697
 698     #---SLOPE---
 699     def do_slope(self,args):
 700         '''
 701         SLOPE
 702         (generalvclamp.py)
 703         Measures the slope of a delimited chunk on the return trace.
 704         The chunk can be delimited either by two manual clicks, or have
 705         a fixed width, given as an argument.
 706         ---------------
 707         Syntax: slope [width]
 708                 The facultative [width] parameter specifies how many
 709                 points will be considered for the fit. If [width] is
 710                 specified, only one click will be required.
 711         (c) Marco Brucale, Massimo Sandal 2008
 712         '''
 713
 714         # Reads the facultative width argument
 715         try:
 716             fitspan=int(args)
 717         except:
 718             fitspan=0
 719
 720         # Decides between the two forms of user input, as per (args)
 721         if fitspan == 0:
 722             # Gets the Xs of two clicked points as indexes on the current curve vector
 723             print 'Click twice to delimit chunk'
 724             points=self._measure_N_points(N=2,whatset=1)
 725         else:
 726             print 'Click once on the leftmost point of the chunk (i.e.usually the peak)'
 727             points=self._measure_N_points(N=1,whatset=1)
 728
 729         slope=self._slope(points,fitspan)
 730
 731         # Outputs the relevant slope parameter
 732         print 'Slope:'
 733         print str(slope)
 734         to_dump='slope '+self.current.path+' '+str(slope)
 735         self.outlet.push(to_dump)
 736
 737     def _slope(self,points,fitspan):
 738         # Calls the function linefit_between
 739         parameters=[0,0,[],[]]
 740         try:
 741             clickedpoints=[points[0].index,points[1].index]
 742             clickedpoints.sort()
 743         except:
 744             clickedpoints=[points[0].index-fitspan,points[0].index]
 745
 746         try:
 747             parameters=self.linefit_between(clickedpoints[0],clickedpoints[1])
 748         except:
 749             print 'Cannot fit. Did you click twice the same point?'
 750             return
 751
 752         # Outputs the relevant slope parameter
 753         print 'Slope:'
 754         print str(parameters[0])
 755         to_dump='slope '+self.curve.path+' '+str(parameters[0])
 756         self.outlet.push(to_dump)
 757
 758         # Makes a vector with the fitted parameters and sends it to the GUI
 759         xtoplot=parameters[2]
 760         ytoplot=[]
 761         x=0
 762         for x in xtoplot:
 763             ytoplot.append((x*parameters[0])+parameters[1])
 764
 765         clickvector_x, clickvector_y=[], []
 766         for item in points:
 767             clickvector_x.append(item.graph_coords[0])
 768             clickvector_y.append(item.graph_coords[1])
 769
 770         lineplot=self._get_displayed_plot(0) #get topmost displayed plot
 771
 772         lineplot.add_set(xtoplot,ytoplot)
 773         lineplot.add_set(clickvector_x, clickvector_y)
 774
 775
 776         if lineplot.styles==[]:
 777             lineplot.styles=[None,None,None,'scatter']
 778         else:
 779             lineplot.styles+=[None,'scatter']
 780         if lineplot.colors==[]:
 781             lineplot.colors=[None,None,'black',None]
 782         else:
 783             lineplot.colors+=['black',None]
 784
 785
 786         self._send_plot([lineplot])
 787
 788         return parameters[0]
 789
 790
 791     def linefit_between(self,index1,index2,whatset=1):
 792         '''
 793         Creates two vectors (xtofit,ytofit) slicing out from the
 794         current return trace a portion delimited by the two indexes
 795         given as arguments.
 796         Then does a least squares linear fit on that slice.
 797         Finally returns [0]=the slope, [1]=the intercept of the
 798         fitted 1st grade polynomial, and [2,3]=the actual (x,y) vectors
 799         used for the fit.
 800         (c) Marco Brucale, Massimo Sandal 2008
 801         '''
 802         # Translates the indexes into two vectors containing the x,y data to fit
 803         xtofit=self.plots[0].vectors[whatset][0][index1:index2]
 804         ytofit=self.plots[0].vectors[whatset][1][index1:index2]
 805
 806         # Does the actual linear fitting (simple least squares with numpy.polyfit)
 807         linefit=[]
 808         linefit=np.polyfit(xtofit,ytofit,1)
 809
 810         return (linefit[0],linefit[1],xtofit,ytofit)