-# Copyright (C) 2008-2011 Alberto Gomez-Casado
-# Fabrizio Benedetti
-# Massimo Sandal <devicerandom@gmail.com>
-# W. Trevor King <wking@drexel.edu>
+# Copyright (C) 2010-2012 W. Trevor King <wking@tremily.us>
#
# This file is part of Hooke.
#
-# Hooke is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
+# Hooke is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
#
-# Hooke is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
-# Public License for more details.
+# Hooke is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
#
-# You should have received a copy of the GNU Lesser General Public
-# License along with Hooke. If not, see
-# <http://www.gnu.org/licenses/>.
+# You should have received a copy of the GNU Lesser General Public License
+# along with Hooke. If not, see <http://www.gnu.org/licenses/>.
"""The ``curve`` module provides :class:`CurvePlugin` and several
associated :class:`hooke.command.Command`\s for handling
import os.path
import re
+from FFT_tools import unitary_avg_power_spectrum
import numpy
import yaml
from ..curve import Data
from ..engine import CommandMessage
from ..util.calculus import derivative
-from ..util.fft import unitary_avg_power_spectrum
from ..util.si import ppSI, join_data_label, split_data_label
from . import Builtin
from .playlist import current_playlist_callback
if column_name == None:
column_name = self._column_arguments[0].name
column_name = params[column_name]
+ if column_name is None:
+ return None
block = self._block(hooke, params, block_name)
columns = block.info['columns']
try:
GetCommand(self), InfoCommand(self), BlockInfoCommand(self),
DeltaCommand(self), ExportCommand(self), DifferenceCommand(self),
DerivativeCommand(self), PowerSpectrumCommand(self),
- ClearStackCommand(self)]
+ ScaledColumnAdditionCommand(self), ClearStackCommand(self)]
# Define commands
return params
+class ScaledColumnAdditionCommand (ColumnAddingCommand):
+ """Add one affine transformed column to another: `o=A*i1+B*i2+C`.
+ """
+ def __init__(self, plugin):
+ super(ScaledColumnAdditionCommand, self).__init__(
+ name='scaled column addition',
+ columns=[
+ ('input column 1', 'input column (m)', """
+Name of the first column to use as the transform input.
+""".strip()),
+ ('input column 2', None, """
+Name of the second column to use as the transform input.
+""".strip()),
+ ],
+ new_columns=[
+ ('output column', 'output column (m)', """
+Name of the column to use as the transform output.
+""".strip()),
+ ],
+ arguments=[
+ Argument(name='scale 1', type='float', default=None,
+ help="""
+A float value for the first scale constant.
+""".strip()),
+ Argument(name='scale 1 name', type='string', default=None,
+ help="""
+The name of the first scale constant in the `.info` dictionary.
+""".strip()),
+ Argument(name='scale 2', type='float', default=None,
+ help="""
+A float value for the second scale constant.
+""".strip()),
+ Argument(name='scale 2 name', type='string', default=None,
+ help="""
+The name of the second scale constant in the `.info` dictionary.
+""".strip()),
+ Argument(name='constant', type='float', default=None,
+ help="""
+A float value for the offset constant.
+""".strip()),
+ Argument(name='constant name', type='string', default=None,
+ help="""
+The name of the offset constant in the `.info` dictionary.
+""".strip()),
+ ],
+ help=self.__doc__, plugin=plugin)
+
+ def _run(self, hooke, inqueue, outqueue, params):
+ self._add_to_command_stack(params)
+ i1 = self._get_column(hooke=hooke, params=params,
+ column_name='input column 1')
+ i2 = self._get_column(hooke=hooke, params=params,
+ column_name='input column 2')
+ if i1 is None:
+ i1 = 0
+ if i2 is None:
+ i2 = 0
+ # what if both i1 and i2 are None?
+ a = self._get_constant(params, i1.info, 'scale 1')
+ b = self._get_constant(params, i2.info, 'scale 2')
+ c = self._get_constant(params, i1.info, 'constant')
+ out = a*i1 + b*i2 + c
+ self._set_column(hooke=hooke, params=params,
+ column_name='output column', values=out)
+
+ def _get_constant(self, params, info, name):
+ a = params[name]
+ pname = params[name + ' name']
+ b = None
+ if pname is not None:
+ pname_entries = pname.split('|')
+ b = info
+ for entry in pname_entries:
+ b = b[entry]
+ if a is None and b is None:
+ return 0
+ if a is None:
+ a = 1
+ if b is None:
+ b = 1
+ return a*b
+
+
class ClearStackCommand (CurveCommand):
"""Empty a curve's command stack.
"""
maxpoint=True
if rebase:
- print 'Select baseline'
+ print('Select baseline')
self.basepoints=self._measure_N_points(N=2, whatset=whatset)
self.basecurrent=self.current.path
if maxpoint:
- print 'Select two points'
+ print('Select two points')
points=self._measure_N_points(N=2, whatset=whatset)
boundpoints=[points[0].index, points[1].index]
boundpoints.sort()
try:
y=min(plot.vectors[whatset][1][boundpoints[0]:boundpoints[1]])
except ValueError:
- print 'Chosen interval not valid. Try picking it again. Did you pick the same point as begin and end of interval?'
+ print('Chosen interval not valid. Try picking it again. Did '
+ 'you pick the same point as begin and end of interval?')
else:
- print 'Select point to measure'
+ print('Select point to measure')
points=self._measure_N_points(N=1, whatset=whatset)
#whatplot=points[0].dest
y=points[0].graph_coords[1]
avg=np.mean(to_average)
forcebase=abs(y-avg)
- print str(forcebase*(10**12))+' pN'
+ print('{} pN'.format(forcebase * 10**12))
to_dump='forcebase '+self.current.path+' '+str(forcebase*(10**12))+' pN'
self.outlet.push(to_dump)
# Decides between the two forms of user input, as per (args)
if fitspan == 0:
# Gets the Xs of two clicked points as indexes on the current curve vector
- print 'Click twice to delimit chunk'
+ print('Click twice to delimit chunk')
points=self._measure_N_points(N=2,whatset=1)
else:
- print 'Click once on the leftmost point of the chunk (i.e.usually the peak)'
+ print('Click once on the leftmost point of the chunk (i.e.usually the peak)')
points=self._measure_N_points(N=1,whatset=1)
slope=self._slope(points,fitspan)
# Outputs the relevant slope parameter
- print 'Slope:'
- print str(slope)
+ print('Slope:')
+ print(str(slope))
to_dump='slope '+self.current.path+' '+str(slope)
self.outlet.push(to_dump)
try:
parameters=self.linefit_between(clickedpoints[0],clickedpoints[1])
except:
- print 'Cannot fit. Did you click twice the same point?'
+ print('Cannot fit. Did you click twice the same point?')
return
# Outputs the relevant slope parameter
- print 'Slope:'
- print str(parameters[0])
+ print('Slope:')
+ print(str(parameters[0]))
to_dump='slope '+self.curve.path+' '+str(parameters[0])
self.outlet.push(to_dump)