From 21d40554082f1c88f94206f8d8131c3889d093c7 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Tue, 27 Oct 2015 23:17:53 +0100 Subject: [PATCH 01/33] make SweepValues.parameter public --- qcodes/sweep_values.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/qcodes/sweep_values.py b/qcodes/sweep_values.py index 9c3e8b6022e..afae320b868 100644 --- a/qcodes/sweep_values.py +++ b/qcodes/sweep_values.py @@ -23,7 +23,7 @@ class SweepValues(object): example usage: for i, value in eumerate(sv): sv.set(value) # or (await / yield from) sv.set_async(value) - # set(_async) just shortcuts sv._parameter.set + # set(_async) just shortcuts sv.parameter.set sleep(delay) vals = measure() sv.feedback((i, ), vals) # optional - sweep should not assume @@ -36,7 +36,7 @@ class SweepValues(object): how many there are. ''' def __init__(self, parameter): - self._parameter = parameter + self.parameter = parameter self.name = parameter.name self._values = [] @@ -52,9 +52,9 @@ def __init__(self, parameter): self.set_async = mock_async(parameter.set) def validate(self, values): - if hasattr(self._parameter, 'validate'): + if hasattr(self.parameter, 'validate'): for value in values: - self._parameter.validate(value) + self.parameter.validate(value) def __iter__(self): raise NotImplementedError @@ -122,7 +122,7 @@ def append(self, value): def extend(self, new_values): if isinstance(new_values, SweepFixedValues): - if new_values._parameter is not self._parameter: + if new_values.parameter is not self.parameter: raise TypeError( 'can only extend SweepFixedValues of the same parameters') # these values are already validated @@ -135,7 +135,7 @@ def extend(self, new_values): 'cannot extend SweepFixedValues with {}'.format(new_values)) def copy(self): - new_sv = SweepFixedValues(self._parameter, []) + new_sv = SweepFixedValues(self.parameter, []) # skip validation by adding values separately instead of on init new_sv._values = self._values[:] return new_sv From dd3ffe6652a7a1bbbc85b18c26082e24181a7973 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:26:27 +0100 Subject: [PATCH 02/33] move sweep_values into instruments (with parameters) --- qcodes/{ => instrument}/sweep_values.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename qcodes/{ => instrument}/sweep_values.py (100%) diff --git a/qcodes/sweep_values.py b/qcodes/instrument/sweep_values.py similarity index 100% rename from qcodes/sweep_values.py rename to qcodes/instrument/sweep_values.py From e23b82a01bcce2d90e2bf9dd526f9016904e7b49 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:34:49 +0100 Subject: [PATCH 03/33] split out Parameter base class and allow multi-dimensional and multi-returns --- qcodes/instrument/parameter.py | 164 ++++++++++++++++++++++++++++----- 1 file changed, 139 insertions(+), 25 deletions(-) diff --git a/qcodes/instrument/parameter.py b/qcodes/instrument/parameter.py index 68d3175df3c..d4a79a0c553 100644 --- a/qcodes/instrument/parameter.py +++ b/qcodes/instrument/parameter.py @@ -1,3 +1,38 @@ +''' +Measured and/or controlled parameters + +the Parameter class is meant for direct parameters of instruments (ie +subclasses of Instrument) but elsewhere in Qcodes we can use anything +as a parameter if it has the right attributes: + +To use Parameters in data acquisition loops, they should have: + .name - like a variable name, ie no spaces or weird characters + .label - string to use as an axis label (optional, defaults to .name) + (except for composite measurements, see below) + +Controlled parameters should have a .set(value) (and/or .set_async(value)) +method, which takes a single value to apply to this parameter. +To use this parameter for sweeping, also connect its __getitem__ to +SweepFixedValues as below. + +Measured parameters should have .get() (and/or .get_async()) which can return: +- a single value: + parameter should have .name and optional .label as above +- several values of different meaning (raw and measured, I and Q, + a set of fit parameters, that sort of thing, that all get measured/calculated + at once): + parameter should have .names and optional .labels, each a sequence with + the same length as returned by .get() +- an array of values of one type: + parameter should have .name and optional .label as above, but also + .size attribute, which is an integer (or tuple of integers) describing + the size of the returned array (which must be fixed) + optionally also .setpoints, array(s) of setpoint values for this data + otherwise we will use integers from 0 in each direction as the setpoints +- several arrays of values (all the same size): + define .names (and .labels) AND .size (and .setpoints) +''' + from datetime import datetime, timedelta import time import asyncio @@ -7,7 +42,7 @@ from qcodes.utils.metadata import Metadatable from qcodes.utils.sync_async import syncable_command, NoCommandError from qcodes.utils.validators import Validator, Numbers, Ints -from qcodes.sweep_values import SweepFixedValues +from qcodes.instrument.sweep_values import SweepFixedValues def no_func(*args, **kwargs): @@ -15,9 +50,110 @@ def no_func(*args, **kwargs): class Parameter(Metadatable): + def __init__(self, + name=None, names=None, + label=None, labels=None, + size=None, setpoints=None, + setpoint_names=None, setpoint_labels=None, + vals=None, **kwargs): + ''' + defines one generic parameter, not necessarily part of + an instrument. can be settable and/or gettable. + + A settable Parameter has a .set and/or a .set_async method, + and supports only a single value at a time (see below) + + A gettable Parameter has a .get and/or a .get_async method, + which may return: + 1. a single value + 2. a sequence of values with different names (for example, + raw and interpreted, I and Q, several fit parameters...) + 3. an array of values all with the same name, but at different + setpoints (for example, a time trace or fourier transform that + was acquired in the hardware and all sent to the computer at once) + 4. 2 & 3 together: a sequence of arrays. All arrays should be the same + size. + + Because .set only supports a single value, if a Parameter is both + gettable AND settable, .get should return a single value too (case 1) + + The constructor arguments change somewhat between these cases: + + name: (1&3) the local name of this parameter, should be a valid + identifier, ie no spaces or special characters + names: (2&4) a tuple of names + + label: (1&3) string to use as an axis label for this parameter + defaults to name + labels: (2&4) a tuple of labels + + size: (3&4) an integer or tuple of integers for the size of array + returned by .get(). Can be an integer only if the array is 1D, but + as a tuple it can describe any dimensionality (including 1D) + If size is an integer then setpoints, setpoint_names, + and setpoint_labels should also not be wrapped in tuples. + setpoints: (3&4) the setpoints for the returned array of values. + The first array should be 1D, the second 2D, etc. + Defaults to integers from zero in each respective direction + Each may be either a DataArray, a numpy array, or a sequence + (sequences will be converted to numpy arrays) + NOTE: if the setpoints will be different each measurement, leave + this out and return the setpoints (with extra names) in the get. + setpoint_names: (3&4) one identifier (like name) per setpoint array. + Ignored if setpoints are DataArrays, which already have names. + setpoint_labels: (3&4) one label (like label above) per setpoint array. + + vals: allowed values for setting this parameter (only relevant + if it has a setter) + defaults to Numbers() + ''' + super().__init__(**kwargs) + + if name is not None: + self.name = name + self.label = name if label is None else label + + # vals / validate only applies to simple single-value parameters + self._set_vals(vals) + + elif names is not None: + self.names = names + self.labels = names if labels is None else names + + else: + raise ValueError('either name or names is required') + + if size is not None: + self.size = size + self.setpoints = setpoints + self.setpoint_names = setpoint_names + self.setpoint_labels = setpoint_labels + + def _set_vals(self, vals): + if vals is None: + self._vals = Numbers() + elif isinstance(vals, Validator): + self._vals = vals + else: + raise TypeError('vals must be a Validator') + + def validate(self, value): + if not self._vals.is_valid(value): + raise ValueError( + '{} is not a valid value for {}'.format(value, self.name)) + + def __getitem__(self, keys): + ''' + slice a Parameter to get a SweepValues object + to iterate over during a sweep + ''' + return SweepFixedValues(self, keys) + + +class InstrumentParameter(Parameter): def __init__(self, instrument, name, get_cmd=None, async_get_cmd=None, parse_function=None, - set_cmd=None, async_set_cmd=None, vals=None, + set_cmd=None, async_set_cmd=None, sweep_step=None, sweep_delay=None, max_val_age=3600, **kwargs): ''' @@ -44,10 +180,9 @@ def __init__(self, instrument, name, max_val_age: max time (in seconds) to trust a saved value from this parameter as the starting point of a sweep ''' - super().__init__(**kwargs) + super().__init__(name=name, **kwargs) self._instrument = instrument - self.name = name # stored value from last .set() or .get() # normally only used by set with a sweep, to avoid @@ -60,7 +195,6 @@ def __init__(self, instrument, name, self.has_set = False self._set_get(get_cmd, async_get_cmd, parse_function) - self._set_vals(vals) self._set_set(set_cmd, async_set_cmd) self.set_sweep(sweep_step, sweep_delay, max_val_age) @@ -98,14 +232,6 @@ def _set_get(self, get_cmd, async_get_cmd, parse_function): if self._get is not no_func: self.has_get = True - def _set_vals(self, vals): - if vals is None: - self._vals = Numbers() - elif isinstance(vals, Validator): - self._vals = vals - else: - raise TypeError('vals must be a Validator') - def _set_set(self, set_cmd, async_set_cmd): # note: this does not set the final setter functions. that's handled # in self.set_sweep, when we choose a swept or non-swept setter. @@ -116,11 +242,6 @@ def _set_set(self, set_cmd, async_set_cmd): if self._set is not no_func: self.has_set = True - def validate(self, value): - if not self._vals.is_valid(value): - raise ValueError( - '{} is not a valid value for {}'.format(value, self.name)) - def _validate_and_set(self, value): self.validate(value) self._set(value) @@ -216,10 +337,3 @@ def set_sweep(self, sweep_step, sweep_delay, max_val_age=None): if max_val_age < 0: raise ValueError('max_val_age must be non-negative') self._max_val_age = max_val_age - - def __getitem__(self, keys): - ''' - slice a Parameter to get a SweepValues object - to iterate over during a sweep - ''' - return SweepFixedValues(self, keys) From 20cb4b11fc236b561eb89d4ee86f7212047af322 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:38:35 +0100 Subject: [PATCH 04/33] BaseInstrument -> Instrument, and clean it up a little --- qcodes/instrument/base.py | 28 +++++++++++++++++----------- qcodes/instrument/ip.py | 4 ++-- qcodes/instrument/mock.py | 4 ++-- qcodes/instrument/visa.py | 4 ++-- qcodes/tests/test_instrument.py | 4 ++-- 5 files changed, 25 insertions(+), 19 deletions(-) diff --git a/qcodes/instrument/base.py b/qcodes/instrument/base.py index 393d939dd6f..c5af7678e9e 100644 --- a/qcodes/instrument/base.py +++ b/qcodes/instrument/base.py @@ -2,11 +2,12 @@ from qcodes.utils.metadata import Metadatable from qcodes.utils.sync_async import wait_for_async -from qcodes.instrument.parameter import Parameter -from qcodes.instrument.function import Function +from qcodes.utils.helpers import safe_getattr +from .parameter import InstrumentParameter +from .function import Function -class BaseInstrument(Metadatable): +class Instrument(Metadatable): def __init__(self, name, **kwargs): super().__init__(**kwargs) self.functions = {} @@ -21,7 +22,7 @@ def __init__(self, name, **kwargs): def add_parameter(self, name, **kwargs): ''' - binds one Parameter to this instrument. + binds one InstrumentParameter to this instrument. instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument. @@ -29,15 +30,16 @@ def add_parameter(self, name, **kwargs): In this sense, parameters are the state variables of the instrument, anything the user can set and/or get - `name` is how the Parameter will be stored within instrument.parameters - and also how you address it using the shortcut methods: + `name` is how the InstrumentParameter will be stored within + instrument.parameters and also how you address it using the + shortcut methods: instrument.set(param_name, value) etc. - see Parameter for the list of kwargs + see InstrumentParameter for the list of kwargs ''' if name in self.parameters: raise KeyError('Duplicate parameter name {}'.format(name)) - self.parameters[name] = Parameter(self, name, **kwargs) + self.parameters[name] = InstrumentParameter(self, name, **kwargs) def add_function(self, name, **kwargs): ''' @@ -83,7 +85,7 @@ def write_async(self, cmd): # check if the paired function is still from the base class (so we'd # have a recursion loop) notice that we only have to do this in one # of the pair, because the other will call this one. - if self.write.__func__ is BaseInstrument.write: + if self.write.__func__ is Instrument.write: raise NotImplementedError( 'instrument {} has no write method defined'.format(self.name)) self.write(cmd) @@ -93,7 +95,7 @@ def read(self): @asyncio.coroutine def read_async(self): - if self.read.__func__ is BaseInstrument.read: + if self.read.__func__ is Instrument.read: raise NotImplementedError( 'instrument {} has no read method defined'.format(self.name)) return self.read() @@ -103,7 +105,7 @@ def ask(self, cmd): @asyncio.coroutine def ask_async(self, cmd): - if self.ask.__func__ is BaseInstrument.ask: + if self.ask.__func__ is Instrument.ask: raise NotImplementedError( 'instrument {} has no ask method defined'.format(self.name)) return self.ask(cmd) @@ -112,6 +114,7 @@ def ask_async(self, cmd): # shortcuts to parameters & setters & getters # # # # instrument['someparam'] === instrument.parameters['someparam'] # + # instrument.someparam === instrument.parameters['someparam'] # # instrument.get('someparam') === instrument['someparam'].get() # # etc... # ########################################################################## @@ -119,6 +122,9 @@ def ask_async(self, cmd): def __getitem__(self, key): return self.parameters[key] + def __getattr__(self, key): + return safe_getattr(self, key, 'parameters') + def set(self, param_name, value): self.parameters[param_name].set(value) diff --git a/qcodes/instrument/ip.py b/qcodes/instrument/ip.py index 600ce7ea4d2..6e2d7d7091e 100644 --- a/qcodes/instrument/ip.py +++ b/qcodes/instrument/ip.py @@ -1,10 +1,10 @@ import socket import asyncio -from qcodes.instrument.base import BaseInstrument +from .base import Instrument -class IPInstrument(BaseInstrument): +class IPInstrument(Instrument): def __init__(self, name, address=None, port=None, timeout=5, terminator='\n', **kwargs): super().__init__(name, **kwargs) diff --git a/qcodes/instrument/mock.py b/qcodes/instrument/mock.py index 3b825aaef05..c870a6ec339 100644 --- a/qcodes/instrument/mock.py +++ b/qcodes/instrument/mock.py @@ -2,10 +2,10 @@ import time from datetime import datetime -from qcodes.instrument.base import BaseInstrument +from .base import Instrument -class MockInstrument(BaseInstrument): +class MockInstrument(Instrument): def __init__(self, name, delay=0, model=None, keep_history=True, use_async=False, read_response=None, **kwargs): ''' diff --git a/qcodes/instrument/visa.py b/qcodes/instrument/visa.py index 7d359eacf69..e1ff1a9d082 100644 --- a/qcodes/instrument/visa.py +++ b/qcodes/instrument/visa.py @@ -1,10 +1,10 @@ import visa import asyncio -from qcodes.instrument.base import BaseInstrument +from .base import Instrument -class VisaInstrument(BaseInstrument): +class VisaInstrument(Instrument): def __init__(self, name, address=None, timeout=5, terminator='', **kwargs): super().__init__(name, **kwargs) diff --git a/qcodes/tests/test_instrument.py b/qcodes/tests/test_instrument.py index 4bee3ce2d8f..1db5bd7dfb7 100644 --- a/qcodes/tests/test_instrument.py +++ b/qcodes/tests/test_instrument.py @@ -2,7 +2,7 @@ from unittest import TestCase from datetime import datetime, timedelta -from qcodes.instrument.base import BaseInstrument +from qcodes.instrument.base import Instrument from qcodes.instrument.mock import MockInstrument from qcodes.utils.validators import Numbers, Ints, Strings, MultiType from qcodes.utils.sync_async import wait_for_async, NoCommandError @@ -313,7 +313,7 @@ def test_mock_read(self): self.read_response) def test_base_instrument_errors(self): - b = BaseInstrument('silent') + b = Instrument('silent') with self.assertRaises(NotImplementedError): b.read() From b6fc01ba566042c72d5b7e0190c8e922f919e8ab Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:43:21 +0100 Subject: [PATCH 05/33] some new helper functions - set_mp_method: idempotent way to set multiprocessing method ie to mimic windows on a mac - PrintableProcess: wrapper for multiprocessing Process for nicer repr - safe_getattr: avoid recursion when delegating attributes to a dict --- qcodes/utils/helpers.py | 80 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 77 insertions(+), 3 deletions(-) diff --git a/qcodes/utils/helpers.py b/qcodes/utils/helpers.py index bed0089d69f..b34db07a517 100644 --- a/qcodes/utils/helpers.py +++ b/qcodes/utils/helpers.py @@ -1,9 +1,10 @@ from asyncio import iscoroutinefunction -from inspect import getargspec, ismethod from collections import Iterable -import math -import logging from datetime import datetime +from inspect import getargspec, ismethod +import logging +import math +import multiprocessing as mp def is_sequence(obj): @@ -84,3 +85,76 @@ def make_unique(s, existing): s_out = '{}_{}'.format(s, n) return s_out + + +def set_mp_method(method, force=False): + ''' + an idempotent wrapper for multiprocessing.set_start_method + args are the same: + + method: one of: + 'fork' (default on unix/mac) + 'spawn' (default, and only option, on windows) + 'forkserver' + force: allow changing context? default False + in the original function, even calling the function again + with the *same* method raises an error, but here we only + raise the error if you *don't* force *and* the context changes + ''' + try: + # force windows multiprocessing behavior on mac + mp.set_start_method(method) + except RuntimeError as err: + if err.args != ('context has already been set', ): + raise + + mp_method = mp.get_start_method() + if mp_method != method: + raise RuntimeError( + 'unexpected multiprocessing method ' + '\'{}\' when trying to set \'{}\''.format(mp_method, method)) + + +class PrintableProcess(mp.Process): + ''' + controls repr printing of the process + subclasses should provide a `name` attribute to go in repr() + if subclass.name = 'DataServer', + repr results in eg '<DataServer-1, started daemon>' + otherwise would be '<DataServerProcess(DataServerProcess...)>' + ''' + def __repr__(self): + cname = self.__class__.__name__ + out = super().__repr__().replace(cname + '(' + cname, self.name) + return out.replace(')>', '>') + + +def safe_getattr(obj, key, attr_dict): + ''' + __getattr__ delegation to avoid infinite recursion + + obj: the instance being queried + key: the attribute name (string) + attr_dict: the name (string) of the dict within obj that + holds the attributes being delegated + ''' + # TODO: is there a way to automatically combine this with __dir__? + # because we're always just saying: + # def __getattr__(self, key): + # return safe_getattr(self, key, 'some_dict') + # but then we should add self.some_dict's keys to dir() as well. + # or should we set all these attributes up front, instead of using + # __getattr__? + try: + if key == attr_dict: + # we got here looking for the dict itself, but it doesn't exist + msg = "'{}' object has no attribute '{}'".format( + obj.__class__.__name__, key) + raise AttributeError(msg) + + return getattr(obj, attr_dict)[key] + + except KeyError: + msg = "'{}' object has no attribute or {} item '{}'".format( + obj.__class__.__name__, attr_dict, key) + raise AttributeError(msg) from None From 2b9da45e6f5b10b65d66c07c0e79d7e49d06256f Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:46:55 +0100 Subject: [PATCH 06/33] new loop syntax and data model --- qcodes/data/data_array.py | 178 ++++++++ qcodes/data/data_set.py | 239 +++++++++++ qcodes/data/format.py | 413 +++++++++++++++++++ qcodes/data/io.py | 155 +++++++ qcodes/{storage.py => data/manager.py} | 143 ++++--- qcodes/loops.py | 549 +++++++++++++++++++++++++ qcodes/station.py | 320 ++------------ qcodes/sweep_storage.py | 329 --------------- 8 files changed, 1639 insertions(+), 687 deletions(-) create mode 100644 qcodes/data/data_array.py create mode 100644 qcodes/data/data_set.py create mode 100644 qcodes/data/format.py create mode 100644 qcodes/data/io.py rename qcodes/{storage.py => data/manager.py} (54%) create mode 100644 qcodes/loops.py delete mode 100644 qcodes/sweep_storage.py diff --git a/qcodes/data/data_array.py b/qcodes/data/data_array.py new file mode 100644 index 00000000000..f3c2de689fa --- /dev/null +++ b/qcodes/data/data_array.py @@ -0,0 +1,178 @@ +import numpy as np + + +class DataArray(object): + ''' + A container for one parameter in a measurement loop + + If this is a measured parameter, This object doesn't contain + the data of the setpoints it was measured at, but it references + the DataArray objects of these parameters. Those objects only have + the dimensionality at which they were set - ie the inner loop setpoint + the same dimensionality as the measured parameter, but the outer + loop setpoint(s) have lower dimensionality + + when it's first created, a DataArray has no dimensionality, you must call + .nest for each dimension. + + if preset_data is provided (a numpy array matching size) it is used to + initialize the data, and the array can still be nested around it. + Otherwise it is an error to nest an array that already has data. + ''' + def __init__(self, parameter=None, name=None, label=None, array_id=None, + set_arrays=(), size=(), action_indices=(), preset_data=None): + if parameter is not None: + self.name = parameter.name + self.label = getattr(parameter, 'label', self.name) + else: + self.name = name + self.label = name if label is None else label + + self.array_id = array_id + self.set_arrays = set_arrays + self.size = size + self._preset = False + + self.data = None + if size: + self.init_data(preset_data) + + self.action_indices = action_indices + self.last_saved_index = None + self.modified_range = None + + def nest(self, size, action_index=None, set_array=None): + ''' + nest this array inside a new outer loop + + size: length of the new loop + action_index: within the outer loop, which action is this in? + set_array: a DataArray listing the setpoints of the outer loop + if this DataArray *is* a setpoint array, you should omit both + action_index and set_array, and it will reference itself as the + set_array + ''' + if self.data is not None and not self._preset: + raise RuntimeError('Only preset arrays can be nested after data ' + 'is initialized.') + + if set_array is None: + if self.set_arrays: + raise TypeError('a setpoint array must be its own inner loop') + set_array = self + + self.size = (size, ) + self.size + + if action_index is not None: + self.action_indices = (action_index, ) + self.action_indices + + self.set_arrays = (set_array, ) + self.set_arrays + + if self._preset: + inner_data = self.data + self.data = np.ndarray(self.size) + # existing preset array copied to every index of the nested array. + for i in range(size): + self.data[i] = inner_data + + self._set_index_bounds() + + return self + + def init_data(self, data=None): + ''' + create a data array (if one doesn't exist) + if data is provided, this array is marked as a preset + meaning it can still be nested around this data. + ''' + if data is not None: + if data.shape != self.size: + raise ValueError('preset data must be a numpy array ' + 'with size matching the array size') + self.data = data + self._preset = True + elif self.data is not None: + if self.data.shape != self.size: + raise ValueError('data has already been initialized, ' + 'but its size doesn\'t match self.size') + return + else: + self.data = np.ndarray(self.size) + self.clear() + self._set_index_bounds() + + def _set_index_bounds(self): + self._min_indices = tuple(0 for d in self.size) + self._max_indices = tuple(d - 1 for d in self.size) + + def clear(self): + self.data.fill(float('nan')) + + def __setitem__(self, loop_indices, value): + ''' + set data values. Follows numpy syntax, allowing indices of lower + dimensionality than the array, if value makes up the extra dimension(s) + + Also updates the record of modifications to the array. If you don't + want this overhead, you can access self.data directly. + ''' + min_li = self._flat_index(loop_indices, self._min_indices) + max_li = self._flat_index(loop_indices, self._max_indices) + self._update_modified_range(min_li, max_li) + + self.data[loop_indices] = value + + def __getitem__(self, loop_indices): + return self.data[loop_indices] + + def __getattr__(self, key): + ''' + pass all other attributes through to the numpy array + + perhaps it would be cleaner to do this by making DataArray + actually a subclass of ndarray, but because things can happen + before init_data (before we know how big the array will be) + it seems better this way. + ''' + # note that this is similar to safe_getattr, but we're passing + # through attributes of an attribute, not dict items, so it's + # simpler. But the same TODO applies, we need to augment __dir__ + if key == 'data' or self.data is None: + raise AttributeError('no data array has been created') + + return getattr(self.data, key) + + def _flat_index(self, indices, index_fill): + indices = indices + index_fill[len(indices):] + return np.ravel_multi_index(tuple(zip(indices)), self.size)[0] + + def _update_modified_range(self, low, high): + if self.modified_range: + self.modified_range = (min(self.modified_range[0], low), + max(self.modified_range[1], high)) + else: + self.modified_range = (low, high) + + def mark_saved(self): + ''' + after saving data, mark any outstanding modifications as saved + ''' + if self.modified_range: + self.last_saved_index = max(self.last_saved_index or 0, + self.modified_range[1]) + + self.modified_range = None + + def clear_save(self): + ''' + make this array look unsaved, so we can force overwrite + or rewrite, like if we're moving or copying the DataSet + ''' + if self.last_saved_index is not None: + self._update_modified_range(0, self.last_saved_index) + + self.last_saved_index = None + + def __repr__(self): + return '{}: {}\n{}'.format(self.__class__.__name__, self.name, + repr(self.data)) diff --git a/qcodes/data/data_set.py b/qcodes/data/data_set.py new file mode 100644 index 00000000000..f5bcf1cfaff --- /dev/null +++ b/qcodes/data/data_set.py @@ -0,0 +1,239 @@ +from enum import Enum + +from .manager import get_data_manager +from .format import GNUPlotFormat +from .io import DiskIO +from qcodes.utils.helpers import safe_getattr + + +class DataMode(Enum): + LOCAL = 1 + PUSH_TO_SERVER = 2 + PULL_FROM_SERVER = 3 + + +class DataSet(object): + ''' + A container for one complete measurement loop + May contain many individual arrays with potentially different + sizes and dimensionalities. + + location: where this data set is stored, also its identifier. + what exactly this means depends on io and formatter + if you omit *everything*, will try to pull location (and mode) + from the live measurement + + arrays: a dict of array_id: DataArray's contained in this DataSet + + mode: sets whether and how this instance connects to a DataServer + DataMode.LOCAL: this DataSet doesn't communicate across processes, + ie it lives entirely either in the main proc, or in the DataServer + DataMode.PUSH_TO_SERVER: no local copy of data, just pushes each + measurement to a DataServer + DataMode.PULL_FROM_SERVER: pulls changes from the DataServer + on calling sync(). Reverts to local if and when this + DataSet stops being the live measurement + + formatter: knows how to read and write the file format + + io: knows how to connect to the storage (disk vs cloud etc) + ''' + + default_io = DiskIO('.') + default_formatter = GNUPlotFormat() + SERVER_MODES = set((DataMode.PULL_FROM_SERVER, DataMode.PUSH_TO_SERVER)) + + def __init__(self, location=None, mode=None, arrays=None, + data_manager=None, formatter=None, io=None): + self.location = location + self.formatter = formatter or self.default_formatter + self.io = io or self.default_io + self.mode = mode + + if mode is None: + if arrays: + # no mode but arrays provided - assume the user is doing + # local analysis and making a new local DataSet + mode = DataMode.LOCAL + else: + # check if this is the live measurement, make it sync if it is + mode = DataMode.PULL_FROM_SERVER + + self.arrays = {} + if arrays: + self.action_id_map = self._clean_array_ids(arrays) + for array in arrays: + self.add_array(array) + + if not data_manager: + data_manager = get_data_manager() + + if mode == DataMode.LOCAL: + self._init_local() + elif mode == DataMode.PUSH_TO_SERVER: + self._init_push_to_server(data_manager) + elif mode == DataMode.PULL_FROM_SERVER: + self._init_live(data_manager) + else: + raise ValueError('unrecognized DataSet mode', mode) + + def _init_local(self): + self.mode = DataMode.LOCAL + + if self.arrays: + for array in self.arrays.values(): + array.init_data() + else: + self.read() + + def _init_push_to_server(self, data_manager): + # If some code was not available when data_manager was started, + # we can't unpickle it on the other end. + # So we'll try, then restart if this error occurs, then try again. + # + # This still has a pitfall, if code has been *changed* since + # starting the server, it will still have the old version and + # everything will look fine but it won't have the new behavior. + # If the user does that, they need to manually restart the server, + # using: + # data_manager.restart() + try: + data_manager.ask('new_data', self) + except AttributeError: + data_manager.restart() + data_manager.ask('new_data', self) + + # need to set data_manager *after* _init_new_data because + # we can't (and shouldn't) send data_manager through a queue + self.data_manager = data_manager + + def init_on_server(self): + if not self.arrays: + raise RuntimeError('A server-side DataSet needs DataArrays.') + + self._init_local() + + def _init_live(self, data_manager): + self.data_manager = data_manager + with self.data_manager.query_lock: + if self.check_live_data(): + live_obj = data_manager.ask('get_data') + self.arrays = live_obj.arrays + return + + self._init_local() + + def check_live_data(self): + if self.mode in self.SERVER_MODES and self.data_manager: + live_location = self.data_manager.ask('get_data', 'location') + + if self.location is None: + # no location given yet, pull it from the live data + self.location = live_location + + if self.location == live_location: + return True + + if self.mode != DataMode.LOCAL: + # just stopped being the live data - drop the data and reload it, + # in case more arrived after the live measurement ended + self.arrays = {} + self._init_local() + + return False + + def sync(self): + # TODO: anything we can do to reduce the amount of data to send? + # seems like in the most general case this would need to remember + # each client DataSet on the server, and what has changed since + # that particular client last synced (at least first and last pt) + if self.mode not in self.SERVER_MODES: + return + with self.data_manager.query_lock: + if not self.check_live_data(): + # note that check_live_data switches us to LOCAL + # and reads the data set back from storage, + # if the server says the data isn't there anymore + # (ie the measurement is done) + return + live_data = self.data_manager.ask('get_data').arrays + + for array_id in self.arrays: + self.arrays[array_id].data = live_data[array_id].data + + def add_array(self, data_array): + self.arrays[data_array.array_id] = data_array + + def _clean_array_ids(self, arrays): + ''' + replace action_indices tuple with compact string array_ids + stripping off as much extraneous info as possible + ''' + action_indices = [array.action_indices for array in arrays] + array_names = set(array.name for array in arrays) + for name in array_names: + param_arrays = [array for array in arrays + if array.name == name] + if len(param_arrays) == 1: + # simple case, only one param with this name, id = name + param_arrays[0].array_id = name + continue + + # otherwise, strip off as many leading equal indices as possible + # and append the rest to the back of the name with underscores + param_action_indices = [list(array.action_indices) + for array in param_arrays] + while all(len(ai) for ai in param_action_indices): + if len(set(ai[0] for ai in param_action_indices)) == 1: + for ai in param_action_indices: + ai[:1] = [] + else: + break + for array, ai in zip(param_arrays, param_action_indices): + array.array_id = name + '_' + '_'.join(str(i) for i in ai) + + array_ids = [array.array_id for array in arrays] + return dict(zip(action_indices, array_ids)) + + def store(self, loop_indices, ids_values): + ''' + set some collection of data points + loop_indices: the indices within whatever loops we are inside + values: a dict of action_index:value or array_id:value + where value may be an arbitrarily nested list, to record + many values at once into one array + ''' + if self.mode == DataMode.PUSH_TO_SERVER: + self.data_manager.write('store_data', loop_indices, ids_values) + else: + for array_id, value in ids_values.items(): + self.arrays[array_id][loop_indices] = value + + def read(self): + self.formatter.read(self) + + def write(self): + if self.mode != DataMode.LOCAL: + raise RuntimeError('This object is connected to a DataServer ' + 'and should be saved from there.') + + self.formatter.write(self) + + def close(self): + if self.mode == DataMode.PUSH_TO_SERVER: + self.data_manager.ask('end_data') + + def __getattr__(self, key): + ''' + alias arrays items as attributes + ie data_array.arrays['vsd'] === data_array.vsd + ''' + return safe_getattr(self, key, 'arrays') + + def __repr__(self): + out = '{}: {}, location=\'{}\''.format(self.__class__.__name__, + self.mode, self.location) + for array_id, array in self.arrays.items(): + out += '\n {}: {}'.format(array_id, array.name) + + return out diff --git a/qcodes/data/format.py b/qcodes/data/format.py new file mode 100644 index 00000000000..aaabefa93e1 --- /dev/null +++ b/qcodes/data/format.py @@ -0,0 +1,413 @@ +''' +Data file formatters + +Formatters translate between DataSets and data files. + +Each Formatter is expected to implement a write method: + write(self, data_set) + +and either read or read_one_file: + read(self, data_set) + read_one_file(data_set, f, ids_read) + f: a file-like object supporting .readline() and for ... in + ids_read: a set of array_id's we've already encountered, so + read_one_file can check for duplication and consistency + +data_set is a DataSet object, which is expected to have attributes: + io: an IO manager (see qcodes.io) + location: a string, like a file path, that identifies the DataSet and + tells the IO manager where to store it + arrays: a dict of {array_id:DataArray} to read into. + - read will create DataArrays that don't yet exist. + - write will write ALL DataArrays in the DataSet, using + last_saved_index and modified_range, as well as whether or not + it found the specified file, to determine how much to write. +''' + +from collections import namedtuple +import numpy as np +import re +import math + +from .data_array import DataArray + + +class Formatter(object): + ArrayGroup = namedtuple('ArrayGroup', 'size set_arrays data name') + + def find_changes(self, arrays): + new_data = {} + can_append = True + + for array in arrays.values(): + if array.modified_range: + if array.modified_range[0] <= array.last_saved_index: + can_append = False + new_data[array.array_id] = 'overwrite' + else: + new_data[array.array_id] = 'append' + + return new_data, can_append + + def mark_saved(self, arrays): + for array in arrays.values(): + array.mark_saved() + + def write(self, data_set): + raise NotImplementedError + + def read(self, data_set): + io_manager = data_set.io + location = data_set.location + + data_files = io_manager.list(location) + if not data_files: + raise IOError('no data found at ' + location) + + # in case the DataArrays exist but haven't been initialized + for array in data_set.arrays.values(): + if array.data is None: + array.init_data() + + ids_read = set() + for fn in data_files: + with io_manager.open(fn, 'r') as f: + try: + self.read_one_file(data_set, f, ids_read) + except ValueError: + print('error reading file ' + fn) + + def read_one_file(self, data_set, f, ids_read): + raise NotImplementedError + + def match_save_range(self, group, file_exists): + # match all full-sized arrays, which are the data arrays plus + # the inner loop setpoint array + + # note: if an outer loop has changed values (without the inner + # loop or measured data changing) we won't notice it here + + # use the inner setpoint as a base and look for differences + # in last_saved_index and modified_range in the data arrays + inner_setpoint = group.set_arrays[-1] + last_saved_index = (inner_setpoint.last_saved_index if file_exists + else None) + modified_range = inner_setpoint.modified_range + for array in group.data: + # force overwrite if inconsistent last_saved_index + if array.last_saved_index != last_saved_index: + last_saved_index = None + + # find the modified_range that encompasses all modifications + amr = array.modified_range + if amr: + if modified_range: + modified_range = (min(modified_range[0], amr[0]), + max(modified_range[1], amr[1])) + else: + modified_range = amr + + # update all sources with the new matching values + for array in group.data + (inner_setpoint, ): + array.modified_range = modified_range + array.last_saved_index = last_saved_index + + # calculate the range to save + if not modified_range: + # nothing to save + return None + if last_saved_index is None or last_saved_index >= modified_range[0]: + # need to overwrite - start save from 0 + return (0, modified_range[1]) + else: + # we can append! save only from last save to end of mods + return (last_saved_index + 1, modified_range[1]) + + return last_saved_index, modified_range + + def group_arrays(self, arrays): + ''' + find the sets of arrays which share all the same setpoint arrays + so each set can be grouped together into one file + returns dimension list, set_array list, and data_array list + ''' + + all_set_arrays = tuple(set(array.set_arrays + for array in arrays.values())) + grouped_data = [[] for _ in all_set_arrays] + + for array in arrays.values(): + i = all_set_arrays.index(array.set_arrays) + if array.set_arrays[-1] != array: + # don't include the setpoint array itself in the data + grouped_data[i].append(array) + + out = [] + for set_arrays, data in zip(all_set_arrays, grouped_data): + leni = len(set_arrays) + if not data and any(1 for other_set_arrays in all_set_arrays if + len(other_set_arrays) > leni and + other_set_arrays[:leni] == set_arrays): + # this is an outer loop that doesn't have any data of its own, + # so skip it. + # Inner-loop setpoints with no data is weird (we set values + # but didn't measure anything there?) but we should keep it. + continue + + group_name = '_'.join(sai.array_id for sai in set_arrays) + out.append(self.ArrayGroup(size=set_arrays[-1].size, + set_arrays=set_arrays, + data=tuple(data), + name=group_name)) + return out + + +class GNUPlotFormat(Formatter): + ''' + Saves data in one or more gnuplot-format files. We make one file for + each set of matching dependent variables in the loop. + + These files are basically tab-separated values, but any quantity of + any whitespace characters is accepted. + + Each row represents one setting of the setpoint variable(s) + the setpoint variable(s) are in the first column(s) + measured variable(s) come after. + + The data is preceded by comment lines (starting with #). + We use three: + - one for the variable name + - the (longer) axis label, in quotes so a label can contain whitespace. + - for each dependent var, the (max) number of points in that dimension + (this also tells us how many dependent vars we have in this file) + + # id1\tid2\t\id3... + # "label1"\t"label2"\t"label3"... + # 100\t250 + 1\t2\t3... + 2\t3\t4... + + For data of 2 dependent variables, gnuplot puts each inner loop into one + block, then increments the outer loop in the next block, separated by a + blank line. + + We extend this to an arbitrary quantity of dependent variables by using + one blank line for each loop level that resets. (gnuplot *does* seem to + use 2 blank lines sometimes, to denote a whole new dataset, which sort + of corresponds to our situation.) + ''' + def __init__(self, extension='dat', terminator='\n', separator='\t', + comment='# ', number_format='g'): + # file extension: accept either with or without leading dot + self.extension = '.' + extension.lstrip('.') + + # line terminator (only used for writing; will read any \r\n combo) + if terminator not in ('\r', '\n', '\r\n'): + raise ValueError( + r'GNUPlotFormat terminator must be \r, \n, or \r\n') + self.terminator = terminator + + # field separator (only used for writing; will read any whitespace) + if not re.fullmatch(r'\s+', separator): + raise ValueError('GNUPlotFormat separator must be whitespace') + self.separator = separator + + # beginning of a comment line. (when reading, just checks the + # non-whitespace character(s) of comment + self.comment = comment + self.comment_chars = comment.rstrip() + if not self.comment_chars: + raise ValueError('comment must have some non-whitespace') + self.comment_len = len(self.comment_chars) + + # number format (only used for writing; will read any number) + self.number_format = '{:' + number_format + '}' + + def read_one_file(self, data_set, f, ids_read): + arrays = data_set.arrays + ids = self._read_comment_line(f).split() + labels = self._get_labels(self._read_comment_line(f)) + size = tuple(map(int, self._read_comment_line(f).split())) + ndim = len(size) + + set_arrays = () + data_arrays = [] + indexed_ids = list(enumerate(ids)) + + for i, array_id in indexed_ids[:ndim]: + # setpoint arrays + set_size = size[: i + 1] + if array_id in arrays: + set_array = arrays[array_id] + if set_array.size != set_size: + raise ValueError( + 'sizes do not match for set array: ' + array_id) + if array_id not in ids_read: + # it's OK for setpoints to be duplicated across + # multiple files, but we should only empty the + # array out the first time we see it, so subsequent + # reads can check for consistency + set_array.clear() + else: + set_array = DataArray(label=labels[i], array_id=array_id, + set_arrays=set_arrays, size=set_size) + set_array.init_data() + set_arrays = set_arrays + (set_array, ) + arrays[array_id] = set_array + set_arrays = set_arrays + (set_array, ) + ids_read.add(array_id) + + for i, array_id in indexed_ids[ndim:]: + # data arrays + if array_id in ids_read: + raise ValueError('duplicate data id found: ' + array_id) + + if array_id in arrays: + data_array = arrays[array_id] + data_array.clear() + else: + data_array = DataArray(label=labels[i], array_id=array_id, + set_arrays=set_arrays, size=size) + data_array.init_data() + arrays[array_id] = data_array + data_arrays.append(data_array) + ids_read.add(array_id) + + indices = [0] * ndim + first_point = True + resetting = 0 + for line in f: + if self._is_comment(line): + continue + + # ignore leading or trailing whitespace (including in blank lines) + line = line.strip() + + if not line and not first_point: + # each consecutive blank line implies one more loop to reset + # when we read the next data point. Don't depend on the number + # of setpoints that change, as there could be weird cases, like + # bidirectional sweeps, or highly diagonal sweeps, where this + # is incorrect. Anyway this really only matters for >2D sweeps. + resetting += 1 + continue + + values = tuple(map(float, line.split())) + + if resetting: + indices[-resetting - 1] += 1 + indices[-resetting:] = [0] * resetting + resetting = 0 + + for value, set_array in zip(values[:ndim], set_arrays): + nparray = set_array.data + myindices = tuple(indices[:nparray.ndim]) + stored_value = nparray[myindices] + if math.isnan(stored_value): + nparray[myindices] = value + elif stored_value != value: + raise ValueError('inconsistent setpoint values') + + for value, data_array in zip(values[ndim:], data_arrays): + data_array.data[myindices] = value + + indices[-1] += 1 + + def _is_comment(self, line): + return line[:self.comment_len] == self.comment_chars + + def _read_comment_line(self, f): + s = f.readline() + if not self._is_comment(s): + raise ValueError('expected a comment line, found:\n' + s) + return s[self.comment_len:] + + def _get_labels(self, labelstr): + labelstr = labelstr.strip() + if labelstr[0] != '"' or labelstr[-1] != '"': + # fields are *not* quoted + return labelstr.split() + else: + # fields *are* quoted (and escaped) + parts = re.split('"\s+"', labelstr[1:-1]) + return [l.replace('\\"', '"').replace('\\\\', '\\') for l in parts] + + def write(self, data_set): + io_manager = data_set.io + location = data_set.location + arrays = data_set.arrays + + groups = self.group_arrays(arrays) + existing_files = set(io_manager.list(location)) + written_files = set() + + for group in groups: + if len(groups) == 1: + fn = location + self.extension + else: + fn = io_manager.join(location, group.name + self.extension) + + written_files.add(fn) + + file_exists = fn in existing_files + save_range = self.match_save_range(group, file_exists) + + if save_range is None: + continue + + overwrite = save_range[0] == 0 + open_mode = 'w' if overwrite else 'a' + shape = group.set_arrays[-1].shape + + with io_manager.open(fn, open_mode) as f: + if overwrite: + f.write(self._make_header(group)) + + for i in range(save_range[0], save_range[1] + 1): + indices = np.unravel_index(i, shape) + + # insert a blank line for each loop that reset (to index 0) + # note that if *all* indices are zero (the first point) + # we won't put any blanks + for j, index in enumerate(reversed(indices)): + if index != 0: + if j: + f.write(self.terminator * j) + break + + one_point = self._data_point(group, indices) + f.write(self.separator.join(one_point) + self.terminator) + + extra_files = existing_files - written_files + if extra_files: + # TODO log this? Doesn't seem like it should raise, but we want + # to know about it somehow. If this data set is read back in, it + # will get the extra files included. + pass + + def _make_header(self, group): + ids, labels = [], [] + for array in group.set_arrays + group.data: + ids.append(array.array_id) + label = getattr(array, 'label', array.array_id) + label = label.replace('\\', '\\\\').replace('"', '\\"') + labels.append('"' + label + '"') + + sizes = [str(size) for size in group.set_arrays[-1].shape] + if len(sizes) != len(group.set_arrays): + raise ValueError('array dimensionality does not match setpoints') + + out = (self._comment_line(ids) + self._comment_line(labels) + + self._comment_line(sizes)) + + return out + + def _comment_line(self, items): + return self.comment + self.separator.join(items) + self.terminator + + def _data_point(self, group, indices): + for array in group.set_arrays: + yield self.number_format.format(array[indices[:array.ndim]]) + + for array in group.data: + yield self.number_format.format(array[indices]) diff --git a/qcodes/data/io.py b/qcodes/data/io.py new file mode 100644 index 00000000000..4aa99ec087c --- /dev/null +++ b/qcodes/data/io.py @@ -0,0 +1,155 @@ +''' +IO managers for QCodes + +IO managers wrap whatever physical storage layer the user wants to use +in an interface mimicking the built-in <open> context manager, with +some restrictions to minimize the overhead in creating new IO managers. + +The main thing these managers need to implement is the open context manager: +- Only the context manager needs to be implemented, not separate + open function and close methods. + +- open takes the standard parameters: + filename: (string) + mode: (string) only 'r' (read), 'w' (write), and 'a' (append) are + expected to be implemented. As with normal file objects, the only + difference between write and append is that write empties the file + before adding new data, and append leaves the existing contents in + place but starts writing at the end. + +- the file-like object returned should implement a minimal set of operations. + + In read mode: + read([size]): read to the end or at most size bytes into a string + readline([size]): read until a newline or up to size bytes, into a string + iter(): usually return self, but can be any iterator over lines + next(): assuming iter() returns self, this yields the next line. + (note: iter and next can be constructed automatically by FileWrapper + if you implement readline.) + + In write or append mode: + write(s): add string s to the end of the file. + writelines(seq): add a sequence of strings (can be constructed + automatically if you use FileWrapper) + +IO managers should also implement: +- a join method, ala os.path.join(*args). +- a list method, that returns all objects matching location +''' + +from contextlib import contextmanager +import os + +ALLOWED_OPEN_MODES = ('r', 'w', 'a') + + +class DiskIO(object): + ''' + simple IO object to wrap disk operations with a custom base location + Other IO managers (ie cloud) should replicate at least this behavior: + + with io_instance.open(filename, mode) as f: + s = f.read() # allowed for mode 'r' + f.write(s) # allowed for modes 'w' and 'a' + ''' + def __init__(self, base_location): + self.base_location = os.path.abspath(base_location) + + @contextmanager + def open(self, filename, mode): + ''' + mimics the interface of the built in open context manager + filename: string, relative to base_location + mode: 'r' (read), 'w' (write), or 'a' (append) + other open modes are not supported because we don't want + to force all IO managers to support others. + ''' + if mode not in ALLOWED_OPEN_MODES: + raise ValueError('mode {} not allowed in IO managers'.format(mode)) + + filepath = self._add_base(filename) + + # make directories if needed + dirpath = os.path.dirname(filepath) + if not os.path.exists(dirpath): + os.makedirs(dirpath) + + # normally we'd construct this context manager with try/finally, but + # here we already have a context manager for open so we just wrap it + with open(filepath, mode) as f: + yield f + + def _add_base(self, location): + return os.path.join(self.base_location, location) + + def _strip_base(self, path): + return os.path.relpath(path, self.base_location) + + def __repr__(self): + return '<DiskIO, base_location={}>'.format(self.base_location) + + def join(self, *args): + return os.path.join(*args) + + def isfile(self, location): + path = self._add_base(location) + return os.path.isfile(path) + + def list(self, location, maxdepth=1): + ''' + return all files that match location, either files + whose names match up to an arbitrary extension + or any files within an exactly matching directory name, + nested as far as maxdepth (default 1) levels + ''' + base_location, pattern = os.path.split(location) + path = self._add_base(base_location) + + matches = [fn for fn in os.listdir(path) if fn.startswith(pattern)] + out = [] + + for match in matches: + matchpath = self.join(path, match) + if os.path.isdir(matchpath) and match == pattern and maxdepth > 0: + # exact directory match - walk down to maxdepth + for root, dirs, files in os.walk(matchpath, topdown=True): + depth = root[len(path):].count(os.path.sep) + if depth == maxdepth: + dirs[:] = [] # don't recurse any further + for fn in files: + out.append(self._strip_base(self.join(root, fn))) + + elif (os.path.isfile(matchpath) and + (match == pattern or os.path.splitext(match)[0] == pattern)): + # exact filename match, or match up to an extension + # note that we need match == pattern in addition to the + # splitext test to cover the case of the base filename itself + # containing a dot. + out.append(self.join(base_location, match)) + + return out + + +class FileWrapper(object): + def read(self, size=None): + raise NotImplementedError + + def readline(self, size=None): + raise NotImplementedError + + def __iter__(self): + return self + + def __next__(self): + line = self.readline() + if line: + return line + else: + raise StopIteration + + def write(self, s): + raise NotImplementedError + + def writelines(self, seq): + for s in seq: + self.write(s) diff --git a/qcodes/storage.py b/qcodes/data/manager.py similarity index 54% rename from qcodes/storage.py rename to qcodes/data/manager.py index ee713831b6f..541b12ea62f 100644 --- a/qcodes/storage.py +++ b/qcodes/data/manager.py @@ -1,100 +1,109 @@ +from datetime import datetime, timedelta import multiprocessing as mp from queue import Empty from traceback import format_exc -from datetime import datetime, timedelta +from sys import stderr -from qcodes.sweep_storage import NoSweep +from qcodes.utils.helpers import PrintableProcess -def get_storage_manager(): +def get_data_manager(): ''' create or retrieve the storage manager - makes sure we don't accidentally create multiple StorageManager processes + makes sure we don't accidentally create multiple DataManager processes ''' - sm = StorageManager.default - if sm and sm._server.is_alive(): - return sm - return StorageManager() + dm = DataManager.default + if dm and dm._server.is_alive(): + return dm + return DataManager() + + +class NoData(object): + def store(self, *args, **kwargs): + raise RuntimeError('no DataSet to add to') + def write(self, *args, **kwargs): + pass -class StorageManager(object): + +class DataManager(object): default = None ''' - creates a separate process (StorageServer) that holds running sweeps + creates a separate process (DataServer) that holds running measurement and monitor data, and manages writing these to disk or other storage - To talk to the server, get a client with StorageManager.new_client() - - StorageServer communicates with other processes through messages - I'll write this using multiprocessing Queue's, but should be easily + DataServer communicates with other processes through messages + Written using multiprocessing Queue's, but should be easily extensible to other messaging systems ''' def __init__(self, query_timeout=2): - StorageManager.default = self + DataManager.default = self self._query_queue = mp.Queue() self._response_queue = mp.Queue() self._error_queue = mp.Queue() - # lock is only used with queries that get responses + # query_lock is only used with queries that get responses # to make sure the process that asked the question is the one # that gets the response. - self._query_lock = mp.RLock() + # Any query that does NOT expect a response can just dump it in + # and more on. + self.query_lock = mp.RLock() self.query_timeout = query_timeout self._start_server() def _start_server(self): - self._server = mp.Process(target=self._run_server, daemon=True) + self._server = DataServerProcess(target=self._run_server, daemon=True) self._server.start() def _run_server(self): - StorageServer(self._query_queue, self._response_queue, - self._error_queue) + DataServer(self._query_queue, self._response_queue, self._error_queue) def write(self, *query): self._query_queue.put(query) - self.check_for_errors() + self._check_for_errors() - def check_for_errors(self): + def _check_for_errors(self): if not self._error_queue.empty(): - raise self._error_queue.get() + errstr = self._error_queue.get() + errhead = '*** error on DataServer ***' + print(errhead + '\n\n' + errstr, file=stderr) + raise RuntimeError(errhead) def ask(self, *query, timeout=None): timeout = timeout or self.query_timeout - with self._query_lock: + with self.query_lock: self._query_queue.put(query) try: res = self._response_queue.get(timeout=timeout) except Empty as e: if self._error_queue.empty(): # only raise if we're not about to find a deeper error - # I do it this way rather than just checking for errors - # now) because ipython obfuscates the real error - # by noting that it occurred while processing this one raise e - self.check_for_errors() + self._check_for_errors() return res def halt(self): if self._server.is_alive(): - self.write('halt') + self.ask('halt') self._server.join() - def restart(self): + def restart(self, force=False): + if (not force) and self.ask('get_data', 'location'): + raise RuntimeError('A measurement is running. Use ' + 'restart(force=True) to override.') self.halt() self._start_server() - def set(self, key, value): - self.write('set', key, value) - def get(self, key, timeout=None): - return self.ask('get', key, timeout=timeout) +class DataServerProcess(PrintableProcess): + name = 'DataServer' -class StorageServer(object): +class DataServer(object): default_storage_period = 1 # seconds between data storage calls queries_per_store = 5 default_monitor_period = 60 # seconds between monitoring storage calls @@ -106,12 +115,8 @@ def __init__(self, query_queue, response_queue, error_queue): self._storage_period = self.default_storage_period self._monitor_period = self.default_monitor_period - # flexible storage, for testing purposes - # but we can adapt this when we get to monitoring - self._dict = {} - - self._sweep = NoSweep() - self._sweeping = False + self._data = NoData() + self._measuring = False self._run() @@ -133,10 +138,10 @@ def _run(self): try: now = datetime.now() - if now > next_store_ts: + if self._measuring and now > next_store_ts: td = timedelta(seconds=self._storage_period) next_store_ts = now + td - self._sweep.update_storage_wrapper() + self._data.write() if now > next_monitor_ts: td = timedelta(seconds=self._monitor_period) @@ -150,48 +155,42 @@ def _reply(self, response): self._response_queue.put(response) def _post_error(self, e): - e.args = e.args + (format_exc(), ) - self._error_queue.put(e) + self._error_queue.put(format_exc()) ###################################################################### # query handlers # # # # method: handle_<type>(self, arg1, arg2, ...) # # will capture queries ('<type>', arg1, arg2, ...) # + # # + # All except store_data return something, so should be used with ask # + # rather than write. That way they wait for the queue to flush and # + # will receive errors right anyway # ###################################################################### - # _dict, set, get, and call are all just for testing/debugging - def handle_set(self, key, value): - self._dict[key] = value - - def handle_get(self, key): - self._reply(self._dict[key]) - - def handle_call(self, key, method_name, args): - self._reply(getattr(self._dict[key], method_name)(*args)) - def handle_halt(self): self._running = False + self._reply(True) + + def handle_new_data(self, data_set): + if self._measuring: + raise RuntimeError('Already executing a measurement') - def handle_new_sweep(self, sweep_storage_obj): - if self._sweeping: - raise RuntimeError('Already executing a sweep') - self._sweep = sweep_storage_obj - self._sweep.init_on_server() - self._sweeping = True - # send a reply, just so the client expects a response - # and therefore can listen for errors + self._data = data_set + self._data.init_on_server() + self._measuring = True self._reply(True) - def handle_end_sweep(self): - self._sweep.update_storage_wrapper() - self._sweeping = False + def handle_end_data(self): + self._data.write() + self._measuring = False + self._reply(True) - def handle_set_sweep_point(self, indices, values): - self._sweep.set_point(indices, values) + def handle_store_data(self, *args): + self._data.store(*args) - def handle_get_sweeping(self): - self._reply(self._sweeping) + def handle_get_measuring(self): + self._reply(self._measuring) - def handle_get_sweep(self, attr=None): - self._reply(self._sweep.get(attr)) + def handle_get_data(self, attr=None): + self._reply(getattr(self._data, attr) if attr else self._data) diff --git a/qcodes/loops.py b/qcodes/loops.py new file mode 100644 index 00000000000..11fd94cd46a --- /dev/null +++ b/qcodes/loops.py @@ -0,0 +1,549 @@ +''' +Data acquisition loops + +The general scheme is: + +1. create a (potentially nested) Loop, which defines the sweep + setpoints and delays +2. activate the loop (which changes it to an ActiveLoop object), + or omit this step to use the default measurement as given by the + Loop.set_measurement class method. +3. run it with the .run method, which creates a DataSet to hold the data, + and defines how and where to save the data. + +Some examples: + + # set default measurements for later Loop's to use + Loop.set_measurement(param1, param2, param3) + + # 1D sweep, using the default measurement set + Loop(sweep_values, delay).run() + + # 2D sweep, using the default measurement set + # sv1 is the outer loop, sv2 is the inner. + Loop(sv1, delay1).loop(sv2, delay2).run() + + # 1D sweep with specific measurements to take at each point + Loop(sv, delay).each(param4, param5).run() + + # Multidimensional sweep: 1D measurement of param6 on the outer loop, + # and the default measurements in a 2D loop + Loop(sv1, delay).each(param6, Loop(sv2, delay)).run() + +Supported actions (args to .set_measurement or .each) are: + Parameter: anything with a .get method and .name or .names + see parameter.py for options + ActiveLoop (or Loop, will be activated with default measurement) + Task: any callable that does not generate data + Wait: a delay +''' +from datetime import datetime, timedelta +import multiprocessing as mp +import time +import numpy as np + +from qcodes.station import Station +from qcodes.data.data_set import DataSet, DataMode +from qcodes.data.data_array import DataArray +from qcodes.utils.helpers import wait_secs, PrintableProcess +from qcodes.utils.sync_async import mock_sync + + +def get_bg(): + processes = mp.active_children() + loops = [p for p in processes if isinstance(p, MeasurementProcess)] + + if len(loops) == 1: + return loops[0] + + if len(loops): + raise RuntimeError('Oops, multiple loops are running???') + + return None + + +def halt_bg(self, timeout=5): + loop = get_bg() + if not loop: + print('No loop running') + return + + loop.signal_queue.put(ActiveLoop.HALT) + loop.join(timeout) + + if loop.is_alive(): + loop.terminate() + print('Background loop did not respond to halt signal, terminated') + + +# def measure(*actions): +# # measure has been moved into Station +# # TODO - for all-at-once parameters we want to be able to +# # store the output into a DataSet without making a Loop. +# pass + + +class Loop(object): + def __init__(self, sweep_values, delay): + self.sweep_values = sweep_values + self.delay = delay + self.nested_loop = None + + def loop(self, sweep_values, delay): + ''' + Nest another loop inside this one + + Loop(sv1, d1).loop(sv2, d2).each(*a) is equivalent to: + Loop(sv1, d1).each(Loop(sv2, d2).each(*a)) + + returns a new Loop object - the original is untouched + ''' + out = Loop(self.sweep_values, self.delay) + + if self.nested_loop: + # nest this new loop inside the deepest level + out.nested_loop = self.nested_loop.loop(sweep_values, delay) + else: + out.nested_loop = Loop(sweep_values, delay) + + return out + + def each(self, *actions): + ''' + Perform a set of actions at each setting of this loop + + Each action can be: + - a Parameter to measure + - a Task to execute + - a Wait + - another Loop or ActiveLoop + ''' + actions = list(actions) + + # check for nested Loops, and activate them with default measurement + for i, action in enumerate(actions): + if isinstance(action, Loop): + default = Station.default.default_measurement + actions[i] = action.each(*default) + + if self.nested_loop: + # recurse into the innermost loop and apply these actions there + actions = [self.nested_loop.each(*actions)] + + return ActiveLoop(self.sweep_values, self.delay, *actions) + + def run(self, *args, **kwargs): + ''' + shortcut to run a loop with the default measurement set + stored by Station.set_measurement + ''' + default = Station.default.default_measurement + return self.each(*default).run(*args, **kwargs) + + +class ActiveLoop(object): + HALT = 'HALT LOOP' + + def __init__(self, sweep_values, delay, *actions): + self.sweep_values = sweep_values + self.delay = delay + self.actions = actions + + # compile now, but don't save the results + # just used for preemptive error checking + # if we saved the results, we wouldn't capture nesting + # nor would we be able to reuse an ActiveLoop multiple times + # within one outer Loop. + # TODO: this doesn't work, because _Measure needs the data_set, + # which doesn't exist yet - do we want to make a special "dry run" + # mode, or is it sufficient to let errors wait until .run()? + # self._compile_actions(actions) + + # if the first action is another loop, it changes how delays + # happen - the outer delay happens *after* the inner var gets + # set to its initial value + self._nest_first = hasattr(actions[0], 'containers') + + self._monitor = None # TODO: how to specify this? + + def containers(self): + loop_size = len(self.sweep_values) + loop_array = DataArray(parameter=self.sweep_values.parameter) + loop_array.nest(size=loop_size) + + data_arrays = [loop_array] + + for i, action in enumerate(self.actions): + if hasattr(action, 'containers'): + action_arrays = action.containers() + + elif hasattr(action, 'get'): + # this action is a parameter to measure + # note that this supports lists (separate output arrays) + # and arrays (nested in one/each output array) of return values + action_arrays = self._parameter_arrays(action) + + else: + continue + + for array in action_arrays: + array.nest(size=loop_size, action_index=i, + set_array=loop_array) + data_arrays.extend(action_arrays) + + return data_arrays + + def _parameter_arrays(self, action): + out = [] + + size = getattr(action, 'size', ()) + if isinstance(size, int): + size = (size,) + sp_blank = None + else: + size = tuple(size) + sp_blank = (None,) * len(size) + + ndim = len(size) + if ndim: + for dim in self.size: + if not isinstance(dim, int) or dim <= 0: + raise ValueError('size must consist of positive ' + 'integers, not ' + repr(dim)) + sp_vals = getattr(action, 'setpoints', sp_blank) + sp_names = getattr(action, 'sp_names', sp_blank) + sp_labels = getattr(action, 'sp_labels', sp_blank) + + if sp_blank is None: + sp_vals = (sp_vals,) + sp_names = (sp_names,) + sp_labels = (sp_labels,) + + if (len(sp_vals) != ndim or len(sp_names) != ndim or + len(sp_labels) != ndim): + raise ValueError('Wrong number of setpoint, setpoint names, ' + 'or setpoint labels provided') + + for i, sp in enumerate(zip(sp_vals, sp_names, sp_labels)): + out.append(self._make_setpoint_array(size, i, tuple(out), *sp)) + else: + setpoints = () + + if hasattr(action, 'names'): + names = action.names + labels = getattr(action, 'labels', names) + for i, (name, label) in enumerate(zip(names, labels)): + out.append(DataArray(name=name, label=label, size=size, + action_indices=(i,), set_arrays=setpoints)) + + elif hasattr(action, 'name'): + name = action.name + label = getattr(action, 'label', name) + out.append(DataArray(name=name, label=label, size=size, + action_indices=(), set_arrays=setpoints)) + + else: + raise ValueError('a gettable parameter must have .name or .names') + + return out + + def _make_setpoint_array(self, size, i, prev_setpoints, vals, name, label): + this_size = size[: i + 1] + + if vals is None: + vals = self._default_setpoints(this_size) + elif isinstance(vals, DataArray): + # can't simply use the DataArray, even though that's + # what we're going to return here, because it will + # get nested (don't want to alter the original) + # DataArrays do have the advantage though of already including + # name and label, so take these if they exist + if vals.name is not None: + name = vals.name + if vals.label is not None: + label = vals.label + + # extract a copy of the numpy array + vals = np.array(vals.data) + else: + # turn any sequence into a (new) numpy array + vals = np.array(vals) + + if vals.shape != this_size: + raise ValueError('nth setpoint array should have size matching ' + 'the first n dimensions of size.') + + if name is None: + if len(size) > 1: + name = 'index{}'.format(i + 1) + else: + name = 'index' + + return DataArray(name=name, label=label, set_arrays=prev_setpoints, + size=this_size, preset_data=vals) + + def _default_setpoints(self, size): + if len(size) == 1: + return np.arange(0, size[0], 1) + + sp = np.ndarray(size) + sp_inner = self._default_setpoints(self, size[1:]) + for i in range(len(sp)): + sp[i] = sp_inner + + return sp + + def set_common_attrs(self, data_set, signal_queue): + ''' + set a couple of common attributes that the main and nested loops + all need to have: + - the DataSet collecting all our measurements + - a queue for communicating with the main process + ''' + self.data_set = data_set + self.signal_queue = signal_queue + for action in self.actions: + if hasattr(action, 'set_common_attrs'): + action.set_common_attrs(data_set, signal_queue) + + def _check_signal(self): + while not self.signal_queue.empty(): + signal = self.signal_queue.get() + if signal == self.HALT: + raise KeyboardInterrupt('sweep was halted') + + def run(self, location=None, formatter=None, io=None, data_manager=None, + background=True, use_async=False, enqueue=False, quiet=False): + ''' + execute this loop + + location: the location of the DataSet, a string whose meaning + depends on formatter and io + formatter: knows how to read and write the file format + io: knows how to connect to the storage (disk vs cloud etc) + data_manager: a DataManager instance (omit to use default) + background: (default True) run this sweep in a separate process + so we can have live plotting and other analysis in the main process + use_async: (default True): execute the sweep asynchronously as much + as possible + enqueue: (default False): wait for a previous background sweep to + finish? If false, will raise an error if another sweep is running + + returns: + a DataSet object that we can use to plot + ''' + + prev_loop = get_bg() + if prev_loop: + if enqueue: + prev_loop.join() # wait until previous loop finishes + else: + raise RuntimeError( + 'a loop is already running in the background') + + data_set = DataSet(arrays=self.containers(), + mode=DataMode.PUSH_TO_SERVER, + data_manager=data_manager, location=location, + formatter=formatter, io=io) + signal_queue = mp.Queue() + self.set_common_attrs(data_set=data_set, signal_queue=signal_queue) + + if use_async: + raise NotImplementedError # TODO + loop_fn = mock_sync(self._async_loop) if use_async else self._run_loop + + if background: + # TODO: in notebooks, errors in a background sweep will just appear + # the next time a command is run. Do something better? + # (like log them somewhere, show in monitoring window)? + p = MeasurementProcess(target=loop_fn, daemon=True) + p.is_sweep = True + p.signal_queue = self.signal_queue + p.start() + self.data_set.sync() + self.data_set.mode = DataMode.PULL_FROM_SERVER + else: + loop_fn() + self.data_set.read() + + if not quiet: + print(repr(self.data_set)) + print(datetime.now().strftime('started at %Y-%m-%d %H:%M:%S')) + return self.data_set + + def _compile_actions(self, actions, action_indices=()): + callables = [] + measurement_group = [] + for i, action in enumerate(actions): + new_action_indices = action_indices + (i,) + if hasattr(action, 'get'): + measurement_group.append((action, new_action_indices)) + continue + elif measurement_group: + callables.append(_Measure(measurement_group, self.data_set)) + measurement_group[:] = [] + + callables.append(self._compile_one(action, new_action_indices)) + + if measurement_group: + callables.append(_Measure(measurement_group, self.data_set)) + measurement_group[:] = [] + + return callables + + def _compile_one(self, action, new_action_indices): + if isinstance(action, Wait): + return Task(self._wait, action.delay) + elif isinstance(action, ActiveLoop): + return _Nest(action, new_action_indices) + elif callable(action): + return action + else: + raise TypeError('unrecognized action', action) + + def _run_loop(self, first_delay=0, action_indices=(), + loop_indices=(), current_values=(), + **ignore_kwargs): + ''' + the routine that actually executes the loop, and can be called + from one loop to execute a nested loop + + first_delay: any delay carried over from an outer loop + action_indices: where we are in any outer loop action arrays + loop_indices: setpoint indices in any outer loops + current_values: setpoint values in any outer loops + signal_queue: queue to communicate with main process directly + ignore_kwargs: for compatibility with other loop tasks + ''' + + # at the beginning of the loop, the time to wait after setting + # the loop parameter may be increased if an outer loop requested longer + delay = max(self.delay, first_delay) + + callables = self._compile_actions(self.actions, action_indices) + + for i, value in enumerate(self.sweep_values): + self.sweep_values.set(value) + new_indices = loop_indices + (i,) + new_values = current_values + (value,) + set_name = self.data_set.action_id_map[action_indices] + self.data_set.store(new_indices, {set_name: value}) + + if not self._nest_first: + # only wait the delay time if an inner loop will not inherit it + self._wait(delay) + + for f in callables: + f(first_delay=delay, + loop_indices=new_indices, + values=new_values) + + # after the first action, no delay is inherited + delay = 0 + + # after the first setpoint, delay reverts to the loop delay + delay = self.delay + + if not current_values: + self.data_set.close() + + def _wait(self, delay): + finish_datetime = datetime.now() + timedelta(seconds=delay) + + if self._monitor: + self._monitor.call(finish_by=finish_datetime) + + self._check_signal() + time.sleep(wait_secs(finish_datetime)) + + +class MeasurementProcess(PrintableProcess): + name = 'MeasurementLoop' + + +class Task(object): + ''' + A predefined task to be executed within a measurement Loop + This form is for a simple task that does not measure any data, + and does not depend on the state of the loop when it is called. + + The first argument should be a callable, to which any subsequent + args and kwargs (which are evaluated before the loop starts) are passed. + + kwargs passed when the Task is called are ignored, + but are accepted for compatibility with other things happening in a Loop. + ''' + def __init__(self, func, *args, **kwargs): + self.func = func + self.args = args + self.kwargs = kwargs + + def __call__(self, **ignore_kwargs): + self.func(*self.args, **self.kwargs) + + +class Wait(object): + ''' + A simple class to tell a Loop to wait <delay> seconds + + This is transformed into a Task within the Loop, such that + it can do other things (monitor, check for halt) during the delay. + + But for use outside of a Loop, it is also callable (then it just sleeps) + ''' + def __init__(self, delay): + self.delay = delay + + def __call__(self): + time.sleep(self.delay) + + +class _Measure(object): + ''' + A callable collection of parameters to measure. + This should not be constructed manually, only by an ActiveLoop. + ''' + def __init__(self, params_indices, data_set): + # the applicable DataSet.store function + self.store = data_set.store + + # for performance, pre-calculate which params return data for + # multiple arrays, pre-create the dict to pass these to store fn + # and pre-calculate the name mappings + self.dict = {} + self.params_ids = [] + for param, action_indices in params_indices: + if hasattr(param, 'names'): + part_ids = [] + for i in range(len(param.names)): + param_id = data_set.action_id_map[action_indices + (i,)] + part_ids.append(param_id) + self.dict[param_id] = None + self.params_ids.append((param, None, part_ids)) + else: + param_id = data_set.action_id_map[action_indices] + self.params_ids.append((param, param_id, False)) + self.dict[param_id] = None + + def __call__(self, loop_indices, **ignore_kwargs): + for param, param_id, composite in self.params_ids: + if composite: + for val, part_id in zip(param.get(), composite): + self.dict[part_id] = val + else: + self.dict[param_id] = param.get() + + self.store(loop_indices, self.dict) + + +class _Nest(object): + ''' + wrapper to make a callable nested ActiveLoop + This should not be constructed manually, only by an ActiveLoop. + ''' + def __init__(self, inner_loop, action_indices): + self.inner_loop = inner_loop + self.action_indices = action_indices + + def __call__(self, **kwargs): + self.inner_loop._run_loop(action_indices=self.action_indices, **kwargs) diff --git a/qcodes/station.py b/qcodes/station.py index 478d141517f..1b4987a6099 100644 --- a/qcodes/station.py +++ b/qcodes/station.py @@ -1,312 +1,60 @@ -import time -from datetime import datetime, timedelta -import asyncio -import multiprocessing as mp - from qcodes.utils.metadata import Metadatable -from qcodes.utils.helpers import make_unique, wait_secs -from qcodes.utils.sync_async import mock_sync -from qcodes.storage import get_storage_manager -from qcodes.sweep_storage import MergedCSVStorage +from qcodes.utils.helpers import make_unique, safe_getattr class Station(Metadatable): default = None - def __init__(self, *instruments, storage_manager=None, - storage_class=MergedCSVStorage, monitor=None, default=True): + def __init__(self, *instruments, monitor=None, default=True): # when a new station is defined, store it in a class variable - # so it becomes the globally accessible default station for - # new sweeps etc after that. You can still have multiple stations - # defined, but to use other than the default one you must specify - # it explicitly in the MeasurementSet - # but if for some reason you want this new Station NOT to be the + # so it becomes the globally accessible default station. + # You can still have multiple stations defined, but to use + # other than the default one you must specify it explicitly. + # If for some reason you want this new Station NOT to be the # default, just specify default=False if default: Station.default = self self.instruments = {} for instrument in instruments: - self.add_instrument(instrument, instrument.name) + self.add_instrument(instrument) - self.storage_manager = storage_manager or get_storage_manager() - self.storage_class = storage_class self.monitor = monitor - def add_instrument(self, instrument, name): + def add_instrument(self, instrument, name=None): + if name is None: + name = getattr(instrument, 'name', + 'instrument{}'.format(len(self.instruments))) name = make_unique(str(name), self.instruments) self.instruments[name] = instrument return name - def set_measurement(self, *args, **kwargs): - ''' - create a MeasurementSet linked to this Station - and set it as the default for this station - ''' - self._measurement_set = MeasurementSet(*args, station=self, **kwargs) - return self._measurement_set - - def sweep(self, *args, **kwargs): - ''' - run a sweep using the default MeasurementSet for this Station - ''' - return self._measurement_set.sweep(*args, **kwargs) - - def __getitem__(self, key): - ''' - station['someinstrument'] - is a shortcut to: - station.instruments['someinstrument'] - ''' - return self.instruments[key] - - -def get_bg_sweep(): - processes = mp.active_children() - sweeps = [p for p in processes if getattr(p, 'is_sweep', False)] - - if len(sweeps) == 1: - return sweeps[0] - - if len(sweeps): - raise RuntimeError( - 'Oops, multiple sweeps are running, how did that happen?') - - return None - - -class MeasurementSet(object): - ''' - create a collection of parameters to measure and sweep - - args are a list of parameters, which can be instrument Parameters - or any other object with `get` and `get_async` methods - or they can be strings of the form '{instrument}:{parameter}' - as they are known to this MeasurementSet's linked Station - ''' - - HALT = 'HALT SWEEP' - - def __init__(self, *args, station=None, storage_manager=None, - monitor=None, storage_class=None): - self._station = station - if station: - self._storage_manager = storage_manager or station.storage_manager - self._monitor = monitor or station.monitor - self._storage_class = storage_class or station.storage_class - else: - self._storage_manager = storage_manager - self._monitor = monitor - self._storage_class = storage_class - self._parameters = [self._pick_param(arg) for arg in args] - - self.sweep_process = None - - self.signal_queue = mp.Queue() # for communicating with bg sweep - - def _pick_param(self, param_or_string): - if isinstance(param_or_string, str): - instrument_name, param_name = param_or_string.split(':') - return self._station[instrument_name][param_name] - else: - return param_or_string - - def get(self): - return tuple(p.get() for p in self._parameters) - - @asyncio.coroutine - def get_async(self): - outputs = (p.get_async() for p in self._parameters) - return (yield from asyncio.gather(*outputs)) - - def sweep(self, *args, location=None, storage_class=None, - background=True, use_async=True, enqueue=False): - ''' - execute a sweep, measuring this MeasurementSet at each point - - args: - SweepValues1, delay1, SweepValues2, delay2, ... - The first two are the outer loop, the next two are - nested inside it, etc - location: the location of the dataset, a string whose meaning - depends on the particular SweepStorage class we're using - storage_class: subclass of SweepStorage to use for storing this sweep - background: (default True) run this sweep in a separate process - so we can have live plotting and other analysis in the main process - use_async: (default True): execute the sweep asynchronously as much - as possible - enqueue: (default False): wait for a previous background sweep to - finish? If false, will raise an error if another sweep is running - - returns: - a SweepStorage object that we can use to plot - ''' - - prev_sweep = get_bg_sweep() - - if prev_sweep: - if enqueue: - prev_sweep.join() # wait until previous sweep finishes - else: - raise RuntimeError( - 'a sweep is already running in the background') - - self._init_sweep(args, location=location, storage_class=storage_class) - - sweep_fn = mock_sync(self._sweep_async) if use_async else self._sweep - - # clear any lingering signal queue items - while not self.signal_queue.empty(): - self.signal_queue.get() - - if background: - if not self._storage_manager: - raise RuntimeError('sweep can only run in the background ' - 'if it has a storage manager running') - - # start the sweep in a new process - # TODO: in notebooks, errors in a background sweep will just appear - # the next time a command is run. Do something better? - # (like log them somewhere, show in monitoring window)? - p = mp.Process(target=sweep_fn, daemon=True) - p.start() - - # flag this as a sweep process, and connect in its storage object - # so you can always find running sweeps and data even if you - # don't have a Station or MeasurementSet - p.is_sweep = True - p.storage = self._storage - p.measurement = self - self.sweep_process = p + def set_measurement(self, *actions): + self.default_measurement = actions - else: - sweep_fn() + def measure(self, *actions): + if not actions: + actions = self.default_measurement - self._storage.sync_live() - return self._storage + out = [] - def _init_sweep(self, args, location=None, storage_class=None): - if len(args) < 2: - raise TypeError('need at least one SweepValues, delay pair') - sweep_vals, delays = args[::2], args[1::2] - if len(sweep_vals) != len(delays): - raise TypeError('SweepValues without matching delay') + # this is a stripped down, uncompiled version of how + # ActiveLoop handles a set of actions + # callables (including Wait) return nothing, but can + # change system state. + for action in actions: + if hasattr(action, 'get'): + out.append(action.get()) + elif callable(action): + action() - # find the output array size we need - self._dim_size = [len(v) for v in sweep_vals] - self._sweep_params = [v.name for v in sweep_vals] - all_params = self._sweep_params + [p.name for p in self._parameters] + return out - # do any of the sweep params support feedback? - self._feedback = [v for v in sweep_vals if hasattr(v, 'feedback') - and callable(v.feedback)] - - if storage_class is None: - storage_class = self._storage_class - self._storage = storage_class(location, - param_names=all_params, - dim_sizes=self._dim_size, - storage_manager=self._storage_manager, - passthrough=True) - - self._sweep_def = tuple(zip(sweep_vals, delays)) - self._sweep_depth = len(sweep_vals) - - def _store(self, indices, set_values, measured): - self._storage.set_point(indices, set_values + tuple(measured)) - - # for adaptive sampling - pass this measurement back to - # any sweep param that supports feedback - for vals in self._feedback: - vals.feedback(set_values, measured) - - def _check_signal(self): - while not self.signal_queue.empty(): - signal = self.signal_queue.get() - if signal == self.HALT: - raise KeyboardInterrupt('sweep was halted') - - def _sweep(self, indices=(), current_values=()): - self._check_signal() - - current_depth = len(indices) - - if current_depth == self._sweep_depth: - measured = self.get() - self._store(indices, current_values, measured) - - else: - values, delay = self._sweep_def[current_depth] - for i, value in enumerate(values): - if i or not current_depth: - values.set(value) - - # if we're changing an outer loop variable, - # also change any inner variables before waiting - for inner_values, _ in self._sweep_def[current_depth + 1:]: - inner_values.set(inner_values[0]) - - finish_datetime = datetime.now() + timedelta(seconds=delay) - - if self._monitor: - self._monitor.call(finish_by=finish_datetime) - - self._check_signal() - time.sleep(wait_secs(finish_datetime)) - - # sweep the next level - self._sweep(indices + (i,), current_values + (value,)) - - if not current_depth: - self._storage.close() - - def _sweep_async(self, indices=(), current_values=()): - self._check_signal() - - current_depth = len(indices) - - if current_depth == self._sweep_depth: - measured = yield from self.get_async() - self._store(indices, current_values, measured) - - else: - values, delay = self._sweep_def[current_depth] - for i, value in enumerate(values): - if i or not current_depth: - setters = [values.set_async(value)] - - # if we're changing an outer loop variable, - # also change any inner variables before waiting - for inner_values, _ in self._sweep_def[current_depth + 1:]: - setters.append(inner_values.set_async(inner_values[0])) - - yield from asyncio.gather(*setters) - - finish_datetime = datetime.now() + timedelta(seconds=delay) - - if self._monitor: - yield from self._monitor.call_async( - finish_by=finish_datetime) - - self._check_signal() - yield from asyncio.sleep(wait_secs(finish_datetime)) - - # sweep the next level - yield from self._sweep_async(indices + (i,), - current_values + (value,)) - - if not current_depth: - self._storage.close() - - def halt_sweep(self, timeout=5): - sweep = get_bg_sweep() - if not sweep: - print('No sweep running') - return - - self.signal_queue.put(self.HALT) - sweep.join(timeout) + # station['someinstrument'] and station.someinstrument are both + # shortcuts to station.instruments['someinstrument'] + # (assuming 'someinstrument' doesn't have another meaning in Station) + def __getitem__(self, key): + return self.instruments[key] - if sweep.is_alive(): - sweep.terminate() - print('Background sweep did not respond, terminated') + def __getattr__(self, key): + return safe_getattr(self, key, 'instruments') diff --git a/qcodes/sweep_storage.py b/qcodes/sweep_storage.py deleted file mode 100644 index 97e19315ed6..00000000000 --- a/qcodes/sweep_storage.py +++ /dev/null @@ -1,329 +0,0 @@ -import math -import numpy as np -from datetime import datetime -import time -import csv -import re - - -class NoSweep(object): - def data_point(self, *args, **kwargs): - raise RuntimeError('no sweep to add data to') - - def update_storage_wrapper(self, *args, **kwargs): - pass - - -class SweepStorage(object): - ''' - base class for holding and storing sweep data - subclasses should override update_storage and read - - inputs: - location: a string, can represent different things - depending on what the storage physically represents. - can be a folder path (if the data is in separate files) - or a file path (if all the data is in one file) - or some other resource locator (for azure, AWS, etc) - param_names: a sequence of strings listing all parameters to store, - starting with the sweep parameters, from outer to innermost loop - dim_sizes: a sequence containing the size of each dimension of - the sweep, from outer to innermost loop - storage_manager: if we're given a StorageManager here, then this - instance is to be potentially connected to the storage server - process via this storage_manager: - If this is a new sweep, we create a mirror of it on the server. - If it's an existing sweep, we check whether it's the current live - sweep on the server, then allow syncing data from there - passthrough: if True and we have a storage_manager, don't keep a copy - of the data in this object, only in the server copy - - param_names and dim_sizes ust be provided if and only if this is a - new sweep. If omitted, location must reference an existing sweep - ''' - def __init__(self, location, param_names=None, dim_sizes=None, - storage_manager=None, passthrough=False): - self.location = location # TODO: auto location for new sweeps? - - self._passthrough = storage_manager and passthrough - - if param_names and dim_sizes: - self._init_new_sweep(param_names, dim_sizes, storage_manager) - - elif param_names is None and dim_sizes is None: - # omitted names and dim_sizes? we're reading from a saved file - self._init_existing_sweep() - else: - raise TypeError('you must provide either both or neither of ' - 'param_names and dim_sizes') - - # need to set storage_manager *after* _init_new_sweep - # because we can't send storage_manager through a queue - # to the storage_manager itself - self._storage_manager = storage_manager - - def _init_new_sweep(self, param_names, dim_sizes, storage_manager): - self.init_data(param_names, dim_sizes) - self.new_indices = set() - self.last_saved_index = -1 - - if storage_manager: - # If this class was not available when storage_manager was started, - # we can't unpickle it on the other end. - # So we'll try, then restart if this error occurs, then try again. - # - # This still has a pitfall, if the class has been *changed* since - # starting the server, it will still have the old version. - # If the user does that, they need to manually restart the server, - # using: - # storage_manager.restart() - try: - # The copy to be sent to the server should NOT be marked as - # syncable with the server, it's ON the server! - self._sync_to_server = False - storage_manager.ask('new_sweep', self) - except AttributeError: - storage_manager.restart() - storage_manager.ask('new_sweep', self) - - self._sync_to_server = True - - else: - self._sync_to_server = False - - def _init_existing_sweep(self): - initialized = False - if self._storage_manager: - with self._storage_manager._query_lock: - if self.check_live_sweep(): - live_obj = self._storage_manager.ask('get_sweep') - self.init_data(live_obj.param_names, - live_obj.dim_sizes, - live_obj.data) - initialized = True - - if not initialized: - self._sync_to_server = False - self.read() - - def init_on_server(self): - ''' - any changes we have to make when this object first arrives - on the storage server? - ''' - if self._passthrough: - # this is where we're passing FROM! - # so turn off passthrough here, and make the data arrays - self._passthrough = False - self.init_data(self.param_names, self.dim_sizes, - getattr(self, 'data', None)) - - def check_live_sweep(self): - if self._storage_manager: - live_location = self._storage_manager.ask('get_sweep', 'location') - self._sync_to_server = (self.location == live_location) - else: - self._sync_to_server = False - - return self._sync_to_server - - def sync_live(self): - if not (self._sync_to_server and self._storage_manager): - # assume that once we determine it's not the live sweep, - # it will never be the live sweep again - return - - self._passthrough = False - with self._storage_manager._query_lock: - self.check_live_sweep() - if not self._sync_to_server: - return - self.data = self._storage_manager.ask('get_sweep', 'data') - - def init_data(self, param_names, dim_sizes, data=None): - self.param_names = tuple(param_names) - self.dim_sizes = tuple(dim_sizes) - - if data: - self.data = data - elif not self._passthrough: - self.data = {} - for pn in self.param_names + ('ts',): - arr = np.ndarray(self.dim_sizes) - arr.fill(float("nan")) - self.data[pn] = arr - - def set_point(self, indices, values): - indices = tuple(indices) - - if self._sync_to_server: - self._storage_manager.write('set_sweep_point', indices, values) - - if not self._passthrough: - for pn, val in zip(self.param_names, values): - self.data[pn][indices] = val - - self.data['ts'][indices] = time.time() - - flat_index = np.ravel_multi_index(tuple(zip(indices)), - self.dim_sizes)[0] - self.new_indices.add(flat_index) - - def close(self): - if self._sync_to_server: - self._storage_manager.write('end_sweep') - - if not self._passthrough: - self.sync_live() - - self._sync_to_server = False - - def get(self, attr=None): - ''' - getter for use by storage server - either return the whole - object, or an attribute of it. - ''' - if attr is None: - return self - else: - return getattr(self, attr) - - def update_storage_wrapper(self): - if self._passthrough: - raise RuntimeError('This cobject has no data to save, ' - 'it\'s just a passthrough to the server.') - if not self.new_indices: - return - - self.update_storage() - - self.last_saved_index = max(self.last_saved_index, *self.new_indices) - self.new_indices = set() - - def update_storage(self): - ''' - write the data set (or changes to it) to storage - based on the data and definition attributes: - data - param_names - dim_sizes - and also info about what has changed since last write: - new_indices - last_saved_index - ''' - raise NotImplementedError - - def read(self): - ''' - read from a file into the data and definition attributes: - data (dict of numpy ndarray's) - param_names - dim_sizes - the file format is expected to provide all of this info - ''' - raise NotImplementedError - - def __getitem__(self, key): - return self.data[key] - - -class MergedCSVStorage(SweepStorage): - ''' - class that stores any sweep as a single file - with all parameters together, one line per data point - ''' - - index_head_re = re.compile('^i_.+\((\d+)\)$') - - def __init__(self, location, *args, **kwargs): - # set _path before __init__ so it can call .read if necessary - if location[-4:] == '.csv': - self._path = location - else: - self._path = location + '.csv' - - super().__init__(location, *args, **kwargs) - - def update_storage(self): - first_new_index = min(self.new_indices) - last_new_index = max(self.new_indices) - - if 0 < self.last_saved_index < first_new_index: - with open(self._path, 'a') as f: - writer = csv.writer(f) - self._writerange(writer, self.last_saved_index, - last_new_index + 1) - else: - with open(self._path, 'w') as f: - writer = csv.writer(f) - self._writeheader(writer) - self._writerange(writer, 0, last_new_index + 1) - - def _writerange(self, writer, istart, iend): - for i in range(istart, iend): - indices = np.unravel_index(i, self.dim_sizes) - - tsraw = self.data['ts'][indices] - if not math.isfinite(tsraw): - continue # don't store empty data points - - ts = datetime.fromtimestamp(tsraw) - rowhead = (ts.strftime('%Y-%m-%d %H:%M:%S:%f'),) + indices - - row = tuple(self.data[pn][indices] for pn in self.param_names) - - writer.writerow(rowhead + row) - - def _writeheader(self, writer): - loop_names = tuple('i_{}({})'.format(pn, ds) - for ds, pn in zip(self.dim_sizes, self.param_names)) - writer.writerow(('ts',) + loop_names + self.param_names) - - def _row(self, i): - indices = np.unravel_index(i, self.dim_sizes) - - ts = datetime.fromtimestamp(self.data['ts'][indices]) - - out = [ts.strftime('%Y-%m-%d %H:%M:%S:%f')] - out += [self.data[pn][indices] for pn in self.param_names] - - return out - - def read(self): - self._passthrough = False - with open(self._path, 'r') as f: - reader = csv.reader(f) - head = next(reader) - self._parse_header(head) - - dimensions = len(self.dim_sizes) - - for row in reader: - indices = tuple(map(int, row[1: dimensions + 1])) - for val, pn in zip(row[dimensions + 1:], self.param_names): - self.data[pn][indices] = val - - self.data['ts'][indices] = datetime.strptime( - row[0], '%Y-%m-%d %H:%M:%S:%f') - - def _parse_header(self, head): - if head[0] != 'ts': - raise ValueError('ts must be the first header for this format') - - dim_sizes = [] - for col in range(1, len(head)): - index_match = self.index_head_re.match(head[col]) - if not index_match: - break - dim_sizes += [int(index_match.groups()[0])] - - if not dim_sizes: - raise ValueError('no sweep dimensions found in header row') - - param_names = [] - for param_col in range(col, len(head)): - param_names.append(head[param_col]) - if not param_names: - raise ValueError('no param_names found in header row') - - self.init_data(param_names, dim_sizes) From d27d74773a43993c32e5fa5de08927a14ab93f43 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:50:43 +0100 Subject: [PATCH 07/33] update example notebook and output data --- Qcodes example.ipynb | 2711 +++++++++++++++++++++++++++--- test2d.csv | 1885 --------------------- test2d.dat | 1652 ++++++++++++++++++ test_multi_d/chan1.dat | 33 + test_multi_d/chan1_chan0.dat | 932 +++++++++++ test_multi_d/chan1_chan2.dat | 3032 ++++++++++++++++++++++++++++++++++ testsweep.csv | 480 ------ testsweep.dat | 403 +++++ 8 files changed, 8521 insertions(+), 2607 deletions(-) delete mode 100644 test2d.csv create mode 100644 test2d.dat create mode 100644 test_multi_d/chan1.dat create mode 100644 test_multi_d/chan1_chan0.dat create mode 100644 test_multi_d/chan1_chan2.dat delete mode 100644 testsweep.csv create mode 100644 testsweep.dat diff --git a/Qcodes example.ipynb b/Qcodes example.ipynb index b457e5b9829..80b77b6d05b 100644 --- a/Qcodes example.ipynb +++ b/Qcodes example.ipynb @@ -27,9 +27,9 @@ "if qcpath not in sys.path:\n", " sys.path.append(qcpath)\n", "\n", - "# force windows multiprocessing behavior on mac\n", - "import multiprocessing as mp\n", - "mp.set_start_method('spawn')" + "import qcodes as q\n", + "\n", + "q.set_mp_method('spawn') # force Windows behavior on mac" ] }, { @@ -56,7 +56,7 @@ "from toymodel import AModel, MockGates, MockSource, MockMeter\n", "\n", "# no extra processes running yet\n", - "mp.active_children()" + "q.active_children()" ] }, { @@ -69,7 +69,7 @@ { "data": { "text/plain": [ - "[<Process(Process-1, started daemon)>]" + "[]" ] }, "execution_count": 3, @@ -84,14 +84,11 @@ "source = MockSource('source', model)\n", "meter = MockMeter('meter', model)\n", "\n", - "from qcodes.station import Station\n", - "station = Station(gates, source, meter)\n", + "station = q.Station(gates, source, meter)\n", "\n", - "# could measure any number of things by adding to this list,\n", - "# but here we're just measuring one, the meter amplitude\n", - "# we can also create multiple measurement sets side-by-side,\n", - "# but only one is the default one stored in the station\n", - "measurement = station.set_measurement(meter['amplitude'])\n", + "# could measure any number of things by adding arguments to this\n", + "# function call, but here we're just measuring one, the meter amplitude\n", + "station.set_measurement(meter.amplitude)\n", "\n", "# it's nice to have the key parameters be part of the global namespace\n", "# that way they're objects that we can easily set, get, and slice\n", @@ -99,10 +96,11 @@ "# and adds them all as (disambiguated) globals, printing what it did\n", "# something like:\n", "# station.gather_parameters(globals())\n", - "c0, c1, c2, vsd = gates['chan0'], gates['chan1'], gates['chan2'], source['amplitude']\n", + "c0, c1, c2, vsd = gates.chan0, gates.chan1, gates.chan2, source.amplitude\n", "\n", - "# check that a StorageServer is running\n", - "mp.active_children()" + "# check that a DataServer is running (not yet implemented, but when we have\n", + "# a monitor, defining a station will start the DataServer to run the monitor)\n", + "q.active_children()" ] }, { @@ -115,7 +113,7 @@ { "data": { "text/plain": [ - "(0.117,)" + "[0.117]" ] }, "execution_count": 4, @@ -125,7 +123,7 @@ ], "source": [ "# we can get the measured quantities right now\n", - "measurement.get()" + "station.measure()" ] }, { @@ -136,23 +134,22 @@ }, "outputs": [ { - "data": { - "text/plain": [ - "<qcodes.sweep_storage.MergedCSVStorage at 0x101b25ac8>" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet: DataMode.PULL_FROM_SERVER, location='testsweep'\n", + " chan0: chan0\n", + " amplitude: amplitude\n", + "started at 2015-12-12 22:38:09\n" + ] } ], "source": [ - "# start a sweep (which by default runs in a seprarate process)\n", + "# start a Loop (which by default runs in a seprarate process)\n", "# the sweep values are defined by slicing the parameter object\n", "# but more complicated sweeps (eg nonlinear, or adaptive) can\n", "# easily be used instead\n", - "swp = measurement.sweep(c0[-20:20:0.1], 0.2, location='testsweep')\n", - "swp" + "data = q.Loop(c0[-20:20:0.1], 0.1).run(location='testsweep')" ] }, { @@ -165,7 +162,7 @@ { "data": { "text/plain": [ - "[<Process(Process-2, started daemon)>, <Process(Process-1, started daemon)>]" + "[<MeasurementLoop-2, started daemon>, <DataServer-1, started daemon>]" ] }, "execution_count": 6, @@ -174,13 +171,13 @@ } ], "source": [ - "# now there should be two processes running, StorageServer and a sweep\n", - "mp.active_children()" + "# now there should be two processes running, DataServer and a sweep\n", + "q.active_children()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": { "collapsed": false, "scrolled": true @@ -189,37 +186,38 @@ { "data": { "text/plain": [ - "{'amplitude': array([ 0.117, 0.117, 0.115, 0.111, 0.106, 0.099, 0.092, 0.085,\n", - " 0.077, 0.071, 0.064, 0.058, 0.053, 0.048, 0.044, 0.04 ,\n", - " 0.037, 0.034, 0.031, 0.029, 0.027, 0.025, 0.023, 0.022,\n", - " 0.02 , 0.019, 0.018, 0.017, 0.016, 0.015, 0.014, 0.013,\n", - " 0.013, 0.012, 0.011, 0.011, 0.01 , 0.01 , 0.01 , 0.009,\n", - " 0.009, 0.008, 0.008, 0.008, 0.007, 0.007, 0.007, 0.007,\n", - " 0.006, 0.006, 0.006, 0.006, 0.006, 0.007, 0.007, 0.007,\n", - " 0.007, 0.008, 0.008, 0.008, 0.009, 0.009, 0.01 , 0.01 ,\n", - " 0.01 , 0.011, 0.011, 0.012, 0.013, 0.013, 0.014, 0.015,\n", - " 0.016, 0.017, 0.018, 0.019, 0.02 , 0.022, 0.023, 0.025,\n", - " 0.027, 0.029, 0.031, 0.034, 0.037, 0.04 , 0.044, 0.048,\n", - " 0.053, 0.058, 0.064, 0.071, 0.077, 0.085, 0.092, 0.099,\n", - " 0.106, 0.111, 0.115, 0.117, 0.117, 0.117, 0.115, 0.111,\n", - " 0.106, 0.099, 0.092, 0.085, 0.077, 0.071, 0.064, 0.058,\n", - " 0.053, 0.048, 0.044, 0.04 , 0.037, 0.034, 0.031, 0.029,\n", - " 0.027, 0.025, 0.023, 0.022, 0.02 , 0.019, 0.018, 0.017,\n", - " 0.016, 0.015, 0.014, 0.013, 0.013, 0.012, 0.011, 0.011,\n", - " 0.01 , 0.01 , 0.01 , 0.009, 0.009, 0.008, 0.008, 0.008,\n", - " 0.007, 0.007, 0.007, 0.007, 0.006, 0.006, 0.006, 0.006,\n", - " 0.006, 0.007, 0.007, 0.007, 0.007, 0.008, 0.008, 0.008,\n", - " 0.009, 0.009, 0.01 , 0.01 , 0.01 , 0.011, 0.011, 0.012,\n", - " 0.013, 0.013, 0.014, 0.015, 0.016, 0.017, 0.018, 0.019,\n", - " 0.02 , 0.022, 0.023, 0.025, 0.027, 0.029, 0.031, 0.034,\n", - " 0.037, 0.04 , 0.044, 0.048, 0.053, 0.058, 0.064, 0.071,\n", - " 0.077, 0.085, 0.092, 0.099, 0.106, 0.111, 0.115, 0.117,\n", - " 0.117, 0.117, 0.115, 0.111, 0.106, 0.099, 0.092, 0.085,\n", + "{'amplitude': DataArray: amplitude\n", + " array([ 0.117, 0.117, 0.115, 0.111, 0.106, 0.099, 0.092, 0.085,\n", " 0.077, 0.071, 0.064, 0.058, 0.053, 0.048, 0.044, 0.04 ,\n", " 0.037, 0.034, 0.031, 0.029, 0.027, 0.025, 0.023, 0.022,\n", " 0.02 , 0.019, 0.018, 0.017, 0.016, 0.015, 0.014, 0.013,\n", " 0.013, 0.012, 0.011, 0.011, 0.01 , 0.01 , 0.01 , 0.009,\n", - " 0.009, 0.008, nan, nan, nan, nan, nan, nan,\n", + " 0.009, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -239,33 +237,20 @@ " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan]),\n", - " 'chan0': array([-20. , -19.9, -19.8, -19.7, -19.6, -19.5, -19.4, -19.3, -19.2,\n", + " 'chan0': DataArray: chan0\n", + " array([-20. , -19.9, -19.8, -19.7, -19.6, -19.5, -19.4, -19.3, -19.2,\n", " -19.1, -19. , -18.9, -18.8, -18.7, -18.6, -18.5, -18.4, -18.3,\n", " -18.2, -18.1, -18. , -17.9, -17.8, -17.7, -17.6, -17.5, -17.4,\n", " -17.3, -17.2, -17.1, -17. , -16.9, -16.8, -16.7, -16.6, -16.5,\n", - " -16.4, -16.3, -16.2, -16.1, -16. , -15.9, -15.8, -15.7, -15.6,\n", - " -15.5, -15.4, -15.3, -15.2, -15.1, -15. , -14.9, -14.8, -14.7,\n", - " -14.6, -14.5, -14.4, -14.3, -14.2, -14.1, -14. , -13.9, -13.8,\n", - " -13.7, -13.6, -13.5, -13.4, -13.3, -13.2, -13.1, -13. , -12.9,\n", - " -12.8, -12.7, -12.6, -12.5, -12.4, -12.3, -12.2, -12.1, -12. ,\n", - " -11.9, -11.8, -11.7, -11.6, -11.5, -11.4, -11.3, -11.2, -11.1,\n", - " -11. , -10.9, -10.8, -10.7, -10.6, -10.5, -10.4, -10.3, -10.2,\n", - " -10.1, -10. , -9.9, -9.8, -9.7, -9.6, -9.5, -9.4, -9.3,\n", - " -9.2, -9.1, -9. , -8.9, -8.8, -8.7, -8.6, -8.5, -8.4,\n", - " -8.3, -8.2, -8.1, -8. , -7.9, -7.8, -7.7, -7.6, -7.5,\n", - " -7.4, -7.3, -7.2, -7.1, -7. , -6.9, -6.8, -6.7, -6.6,\n", - " -6.5, -6.4, -6.3, -6.2, -6.1, -6. , -5.9, -5.8, -5.7,\n", - " -5.6, -5.5, -5.4, -5.3, -5.2, -5.1, -5. , -4.9, -4.8,\n", - " -4.7, -4.6, -4.5, -4.4, -4.3, -4.2, -4.1, -4. , -3.9,\n", - " -3.8, -3.7, -3.6, -3.5, -3.4, -3.3, -3.2, -3.1, -3. ,\n", - " -2.9, -2.8, -2.7, -2.6, -2.5, -2.4, -2.3, -2.2, -2.1,\n", - " -2. , -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2,\n", - " -1.1, -1. , -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3,\n", - " -0.2, -0.1, 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6,\n", - " 0.7, 0.8, 0.9, 1. , 1.1, 1.2, 1.3, 1.4, 1.5,\n", - " 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4,\n", - " 2.5, 2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3,\n", - " 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4. , 4.1, nan,\n", + " -16.4, -16.3, -16.2, -16.1, -16. , -15.9, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -283,158 +268,37 @@ " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan]),\n", - " 'ts': array([ 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503691e+09, 1.44503691e+09,\n", - " 1.44503691e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503692e+09,\n", - " 1.44503692e+09, 1.44503692e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503693e+09, 1.44503693e+09, 1.44503693e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503694e+09, 1.44503694e+09,\n", - " 1.44503694e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, 1.44503695e+09,\n", - " 1.44503695e+09, 1.44503695e+09, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan, nan, nan,\n", - " nan])}" + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan])}" ] }, - "execution_count": 10, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# bring the sweep data into the main process and display it as numbers\n", - "swp.sync_live()\n", - "# swp.read()\n", - "swp.data" + "# bring the data into the main process and display it as numbers\n", + "data.sync()\n", + "data.arrays" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": { "collapsed": false, "scrolled": false @@ -1194,26 +1058,47 @@ "# next up: create an active plot that will update itself automatically\n", "# (via javascript, so the main python stays accessible) as long as the sweep is running\n", "# as well as provide some nicer styling and labeling defaults\n", - "swp.sync_live()\n", + "data.sync()\n", "plt.figure(figsize=(12, 5))\n", - "plt.plot(swp['chan0'], swp['amplitude'])\n", + "# because we pass through the ndarray attributes, matplotlib can plot DataArrays directly\n", + "plt.plot(data.chan0, data.amplitude)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet: DataMode.PULL_FROM_SERVER, location='test2d'\n", + " chan1: chan1\n", + " amplitude_4: amplitude\n", + " chan0: chan0\n", + " amplitude_0: amplitude\n", + "started at 2015-12-12 22:39:06\n" + ] + } + ], "source": [ - "swp2 = measurement.sweep(c1[-15:15:1], 1, c0[-15:15:.5], 0.03, location='test2d')" + "data2 = q.Loop(c1[-15:15:1], 0.1).loop(c0[-15:12:.5], 0.01).each(\n", + " meter.amplitude, # first measurement, at c2=0 -> amplitude_0 bcs it's action 0\n", + " q.Task(c2.set, 1), # action 1 -> \n", + " q.Wait(0.001),\n", + " q.Task(print, '!'), # Loop runs in the background, so ! gets printed in the notebook server terminal\n", + " meter.amplitude, # second measurement, at c2=1 -> amplitude_4 bcs it's action 4\n", + " q.Task(c2.set, 0)\n", + " ).run(location='test2d')" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 25, "metadata": { "collapsed": false, "scrolled": false @@ -1958,7 +1843,7 @@ { "data": { "text/html": [ - "<img src=\"data:image/png;base64,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\">" + "<img src=\"data:image/png;base64,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\">" ], "text/plain": [ "<IPython.core.display.HTML object>" @@ -1970,13 +1855,14 @@ ], "source": [ "# again, can call this repeatedly while the plot is running\n", - "swp2.sync_live()\n", + "# this plot shows the first array collected, amplitude_0 (at c2=0)\n", + "data2.sync()\n", "import numpy.ma as ma\n", "plt.figure(figsize=(12, 5))\n", "# pcolormesh needs NaN masked out or it barfs\n", - "plt.pcolormesh(ma.masked_invalid(swp2['chan0']),\n", - " ma.masked_invalid(swp2['chan1']),\n", - " ma.masked_invalid(swp2['amplitude']),\n", + "plt.pcolormesh(ma.masked_invalid(data2.chan0),\n", + " ma.masked_invalid(data2.chan1),\n", + " ma.masked_invalid(data2.amplitude_0),\n", " cmap=plt.cm.hot)\n", "plt.colorbar()\n", "plt.show()" @@ -1984,16 +1870,2357 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 26, "metadata": { "collapsed": false }, - "outputs": [], - "source": [ - "# I obviously have a lot to figure out about matplotlib...\n", - "# calling the above redraws constantly to \"live update\"\n", - "# generates warnings after a while about too many open figures\n", - "plt.close('all')" + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " fig.waiting = false;\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " this.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width);\n", + " canvas.attr('height', height);\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'];\n", + " var y0 = fig.canvas.height - msg['y0'];\n", + " var x1 = msg['x1'];\n", + " var y1 = fig.canvas.height - msg['y1'];\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x;\n", + " var y = canvas_pos.y;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", + " fig.send_message('closing', {});\n", + " fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Close figure', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# this plot shows the second array collected, amplitude_0 (at c2=1)\n", + "# note that these are acquired within the same 2D sweep\n", + "# as you can see if you run this cell and the above while the Loop is running\n", + "plt.figure(figsize=(12, 5))\n", + "# pcolormesh needs NaN masked out or it barfs\n", + "plt.pcolormesh(ma.masked_invalid(data2.chan0),\n", + " ma.masked_invalid(data2.chan1),\n", + " ma.masked_invalid(data2.amplitude_4),\n", + " cmap=plt.cm.hot)\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# I obviously have a lot to figure out about matplotlib...\n", + "# calling the above redraws constantly to \"live update\"\n", + "# generates warnings after a while about too many open figures\n", + "plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet: DataMode.PULL_FROM_SERVER, location='test_multi_d'\n", + " amplitude_5_0: amplitude\n", + " chan2: chan2\n", + " amplitude_2: amplitude\n", + " chan0: chan0\n", + " chan1: chan1\n", + " amplitude_3_0: amplitude\n", + "started at 2015-12-12 22:51:20\n" + ] + } + ], + "source": [ + "data3 = q.Loop(c1[-15:15:1], 0.1).each(\n", + " q.Task(c0.set, -10),\n", + " q.Task(c2.set, 0),\n", + " # a 1D measurement\n", + " meter.amplitude,\n", + " # a 2D sweep, .each is actually unnecessary bcs this is the default measurement\n", + " q.Loop(c0[-15:15:1], 0.01).each(meter.amplitude),\n", + " q.Task(c0.set, -10),\n", + " # a 2D sweep with the same outer but different inner loop\n", + " q.Loop(c2[-10:10:0.2], 0.01)\n", + ").run(location='test_multi_d')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " fig.waiting = false;\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " this.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width);\n", + " canvas.attr('height', height);\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'];\n", + " var y0 = fig.canvas.height - msg['y0'];\n", + " var x1 = msg['x1'];\n", + " var y1 = fig.canvas.height - msg['y1'];\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x;\n", + " var y = canvas_pos.y;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", + " fig.send_message('closing', {});\n", + " fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Close figure', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data3.sync()\n", + "plt.figure(figsize=(12, 5))\n", + "# pcolormesh needs NaN masked out or it barfs\n", + "plt.pcolormesh(ma.masked_invalid(data3.chan0),\n", + " ma.masked_invalid(data3.chan1),\n", + " ma.masked_invalid(data3.amplitude_3_0),\n", + " cmap=plt.cm.hot)\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " fig.waiting = false;\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " this.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width);\n", + " canvas.attr('height', height);\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'];\n", + " var y0 = fig.canvas.height - msg['y0'];\n", + " var x1 = msg['x1'];\n", + " var y1 = fig.canvas.height - msg['y1'];\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x;\n", + " var y = canvas_pos.y;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", + " fig.send_message('closing', {});\n", + " fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Close figure', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 5))\n", + "# pcolormesh needs NaN masked out or it barfs\n", + "plt.pcolormesh(ma.masked_invalid(data3.chan2),\n", + " ma.masked_invalid(data3.chan1),\n", + " ma.masked_invalid(data3.amplitude_5_0),\n", + " cmap=plt.cm.hot)\n", + "plt.colorbar()\n", + "plt.show()" ] } ], diff --git a/test2d.csv b/test2d.csv deleted file mode 100644 index 213c1f42e44..00000000000 --- a/test2d.csv +++ /dev/null @@ -1,1885 +0,0 @@ -ts,i_chan1(30),i_chan0(60),chan1,chan0,amplitude -2015-10-17 01:09:58:957015,0,0,-15.0,-15.0,0.003 -2015-10-17 01:09:58:992206,0,1,-15.0,-14.5,0.004 -2015-10-17 01:09:59:029454,0,2,-15.0,-14.0,0.004 -2015-10-17 01:09:59:065906,0,3,-15.0,-13.5,0.004 -2015-10-17 01:09:59:097309,0,4,-15.0,-13.0,0.005 -2015-10-17 01:09:59:132695,0,5,-15.0,-12.5,0.005 -2015-10-17 01:09:59:169090,0,6,-15.0,-12.0,0.005 -2015-10-17 01:09:59:169090,0,6,-15.0,-12.0,0.005 -2015-10-17 01:09:59:201673,0,7,-15.0,-11.5,0.006 -2015-10-17 01:09:59:233119,0,8,-15.0,-11.0,0.006 -2015-10-17 01:09:59:265649,0,9,-15.0,-10.5,0.006 -2015-10-17 01:09:59:298476,0,10,-15.0,-10.0,0.006 -2015-10-17 01:09:59:332571,0,11,-15.0,-9.5,0.006 -2015-10-17 01:09:59:364145,0,12,-15.0,-9.0,0.006 -2015-10-17 01:09:59:397577,0,13,-15.0,-8.5,0.006 -2015-10-17 01:09:59:433248,0,14,-15.0,-8.0,0.005 -2015-10-17 01:09:59:469947,0,15,-15.0,-7.5,0.005 -2015-10-17 01:09:59:504888,0,16,-15.0,-7.0,0.005 -2015-10-17 01:09:59:537157,0,17,-15.0,-6.5,0.004 -2015-10-17 01:09:59:569664,0,18,-15.0,-6.0,0.004 -2015-10-17 01:09:59:602401,0,19,-15.0,-5.5,0.004 -2015-10-17 01:09:59:635559,0,20,-15.0,-5.0,0.003 -2015-10-17 01:09:59:670334,0,21,-15.0,-4.5,0.004 -2015-10-17 01:09:59:704129,0,22,-15.0,-4.0,0.004 -2015-10-17 01:09:59:738029,0,23,-15.0,-3.5,0.004 -2015-10-17 01:09:59:770030,0,24,-15.0,-3.0,0.005 -2015-10-17 01:09:59:802464,0,25,-15.0,-2.5,0.005 -2015-10-17 01:09:59:837990,0,26,-15.0,-2.0,0.005 -2015-10-17 01:09:59:874593,0,27,-15.0,-1.5,0.006 -2015-10-17 01:09:59:906514,0,28,-15.0,-1.0,0.006 -2015-10-17 01:09:59:943027,0,29,-15.0,-0.5,0.006 -2015-10-17 01:09:59:979427,0,30,-15.0,0.0,0.006 -2015-10-17 01:10:00:011297,0,31,-15.0,0.5,0.006 -2015-10-17 01:10:00:043819,0,32,-15.0,1.0,0.006 -2015-10-17 01:10:00:075731,0,33,-15.0,1.5,0.006 -2015-10-17 01:10:00:108232,0,34,-15.0,2.0,0.005 -2015-10-17 01:10:00:142901,0,35,-15.0,2.5,0.005 -2015-10-17 01:10:00:178896,0,36,-15.0,3.0,0.005 -2015-10-17 01:10:00:178896,0,36,-15.0,3.0,0.005 -2015-10-17 01:10:00:211000,0,37,-15.0,3.5,0.004 -2015-10-17 01:10:00:242856,0,38,-15.0,4.0,0.004 -2015-10-17 01:10:00:274957,0,39,-15.0,4.5,0.004 -2015-10-17 01:10:00:308806,0,40,-15.0,5.0,0.003 -2015-10-17 01:10:00:343708,0,41,-15.0,5.5,0.004 -2015-10-17 01:10:00:375901,0,42,-15.0,6.0,0.004 -2015-10-17 01:10:00:408622,0,43,-15.0,6.5,0.004 -2015-10-17 01:10:00:441407,0,44,-15.0,7.0,0.005 -2015-10-17 01:10:00:474298,0,45,-15.0,7.5,0.005 -2015-10-17 01:10:00:506311,0,46,-15.0,8.0,0.005 -2015-10-17 01:10:00:539122,0,47,-15.0,8.5,0.006 -2015-10-17 01:10:00:570456,0,48,-15.0,9.0,0.006 -2015-10-17 01:10:00:602624,0,49,-15.0,9.5,0.006 -2015-10-17 01:10:00:634901,0,50,-15.0,10.0,0.006 -2015-10-17 01:10:00:666939,0,51,-15.0,10.5,0.006 -2015-10-17 01:10:00:699569,0,52,-15.0,11.0,0.006 -2015-10-17 01:10:00:731200,0,53,-15.0,11.5,0.006 -2015-10-17 01:10:00:763189,0,54,-15.0,12.0,0.005 -2015-10-17 01:10:00:795134,0,55,-15.0,12.5,0.005 -2015-10-17 01:10:00:827110,0,56,-15.0,13.0,0.005 -2015-10-17 01:10:00:859293,0,57,-15.0,13.5,0.004 -2015-10-17 01:10:00:890966,0,58,-15.0,14.0,0.004 -2015-10-17 01:10:00:923171,0,59,-15.0,14.5,0.004 -2015-10-17 01:10:00:923171,0,59,-15.0,14.5,0.004 -2015-10-17 01:10:01:929327,1,0,-14.0,-15.0,0.004 -2015-10-17 01:10:01:961635,1,1,-14.0,-14.5,0.004 -2015-10-17 01:10:01:993659,1,2,-14.0,-14.0,0.005 -2015-10-17 01:10:02:027251,1,3,-14.0,-13.5,0.005 -2015-10-17 01:10:02:060430,1,4,-14.0,-13.0,0.006 -2015-10-17 01:10:02:095201,1,5,-14.0,-12.5,0.007 -2015-10-17 01:10:02:129065,1,6,-14.0,-12.0,0.007 -2015-10-17 01:10:02:163237,1,7,-14.0,-11.5,0.008 -2015-10-17 01:10:02:194062,1,8,-14.0,-11.0,0.008 -2015-10-17 01:10:02:231837,1,9,-14.0,-10.5,0.009 -2015-10-17 01:10:02:263905,1,10,-14.0,-10.0,0.009 -2015-10-17 01:10:02:295972,1,11,-14.0,-9.5,0.009 -2015-10-17 01:10:02:330544,1,12,-14.0,-9.0,0.008 -2015-10-17 01:10:02:330544,1,12,-14.0,-9.0,0.008 -2015-10-17 01:10:02:367496,1,13,-14.0,-8.5,0.008 -2015-10-17 01:10:02:402657,1,14,-14.0,-8.0,0.007 -2015-10-17 01:10:02:438798,1,15,-14.0,-7.5,0.007 -2015-10-17 01:10:02:471481,1,16,-14.0,-7.0,0.006 -2015-10-17 01:10:02:503710,1,17,-14.0,-6.5,0.005 -2015-10-17 01:10:02:535331,1,18,-14.0,-6.0,0.005 -2015-10-17 01:10:02:568964,1,19,-14.0,-5.5,0.004 -2015-10-17 01:10:02:603540,1,20,-14.0,-5.0,0.004 -2015-10-17 01:10:02:639853,1,21,-14.0,-4.5,0.004 -2015-10-17 01:10:02:673101,1,22,-14.0,-4.0,0.005 -2015-10-17 01:10:02:708986,1,23,-14.0,-3.5,0.005 -2015-10-17 01:10:02:742943,1,24,-14.0,-3.0,0.006 -2015-10-17 01:10:02:775790,1,25,-14.0,-2.5,0.007 -2015-10-17 01:10:02:807079,1,26,-14.0,-2.0,0.007 -2015-10-17 01:10:02:842966,1,27,-14.0,-1.5,0.008 -2015-10-17 01:10:02:877083,1,28,-14.0,-1.0,0.008 -2015-10-17 01:10:02:911618,1,29,-14.0,-0.5,0.009 -2015-10-17 01:10:02:946583,1,30,-14.0,0.0,0.009 -2015-10-17 01:10:02:982208,1,31,-14.0,0.5,0.009 -2015-10-17 01:10:03:015790,1,32,-14.0,1.0,0.008 -2015-10-17 01:10:03:047535,1,33,-14.0,1.5,0.008 -2015-10-17 01:10:03:082489,1,34,-14.0,2.0,0.007 -2015-10-17 01:10:03:116100,1,35,-14.0,2.5,0.007 -2015-10-17 01:10:03:149250,1,36,-14.0,3.0,0.006 -2015-10-17 01:10:03:185201,1,37,-14.0,3.5,0.005 -2015-10-17 01:10:03:216705,1,38,-14.0,4.0,0.005 -2015-10-17 01:10:03:248640,1,39,-14.0,4.5,0.004 -2015-10-17 01:10:03:280344,1,40,-14.0,5.0,0.004 -2015-10-17 01:10:03:311963,1,41,-14.0,5.5,0.004 -2015-10-17 01:10:03:344039,1,42,-14.0,6.0,0.005 -2015-10-17 01:10:03:344039,1,42,-14.0,6.0,0.005 -2015-10-17 01:10:03:375797,1,43,-14.0,6.5,0.005 -2015-10-17 01:10:03:407844,1,44,-14.0,7.0,0.006 -2015-10-17 01:10:03:445380,1,45,-14.0,7.5,0.007 -2015-10-17 01:10:03:480376,1,46,-14.0,8.0,0.007 -2015-10-17 01:10:03:512800,1,47,-14.0,8.5,0.008 -2015-10-17 01:10:03:544047,1,48,-14.0,9.0,0.008 -2015-10-17 01:10:03:580826,1,49,-14.0,9.5,0.009 -2015-10-17 01:10:03:616616,1,50,-14.0,10.0,0.009 -2015-10-17 01:10:03:647828,1,51,-14.0,10.5,0.009 -2015-10-17 01:10:03:680402,1,52,-14.0,11.0,0.008 -2015-10-17 01:10:03:712186,1,53,-14.0,11.5,0.008 -2015-10-17 01:10:03:744565,1,54,-14.0,12.0,0.007 -2015-10-17 01:10:03:776603,1,55,-14.0,12.5,0.007 -2015-10-17 01:10:03:809190,1,56,-14.0,13.0,0.006 -2015-10-17 01:10:03:844970,1,57,-14.0,13.5,0.005 -2015-10-17 01:10:03:877698,1,58,-14.0,14.0,0.005 -2015-10-17 01:10:03:909857,1,59,-14.0,14.5,0.004 -2015-10-17 01:10:03:909857,1,59,-14.0,14.5,0.004 -2015-10-17 01:10:04:913124,2,0,-13.0,-15.0,0.005 -2015-10-17 01:10:04:944442,2,1,-13.0,-14.5,0.005 -2015-10-17 01:10:04:977494,2,2,-13.0,-14.0,0.006 -2015-10-17 01:10:05:010641,2,3,-13.0,-13.5,0.007 -2015-10-17 01:10:05:045233,2,4,-13.0,-13.0,0.008 -2015-10-17 01:10:05:077902,2,5,-13.0,-12.5,0.009 -2015-10-17 01:10:05:111268,2,6,-13.0,-12.0,0.01 -2015-10-17 01:10:05:143985,2,7,-13.0,-11.5,0.012 -2015-10-17 01:10:05:180227,2,8,-13.0,-11.0,0.013 -2015-10-17 01:10:05:218126,2,9,-13.0,-10.5,0.014 -2015-10-17 01:10:05:247951,2,10,-13.0,-10.0,0.014 -2015-10-17 01:10:05:279510,2,11,-13.0,-9.5,0.014 -2015-10-17 01:10:05:313399,2,12,-13.0,-9.0,0.013 -2015-10-17 01:10:05:348674,2,13,-13.0,-8.5,0.012 -2015-10-17 01:10:05:382617,2,14,-13.0,-8.0,0.01 -2015-10-17 01:10:05:418618,2,15,-13.0,-7.5,0.009 -2015-10-17 01:10:05:451888,2,16,-13.0,-7.0,0.008 -2015-10-17 01:10:05:486068,2,17,-13.0,-6.5,0.007 -2015-10-17 01:10:05:519387,2,18,-13.0,-6.0,0.006 -2015-10-17 01:10:05:519387,2,18,-13.0,-6.0,0.006 -2015-10-17 01:10:05:553041,2,19,-13.0,-5.5,0.005 -2015-10-17 01:10:05:585407,2,20,-13.0,-5.0,0.005 -2015-10-17 01:10:05:621577,2,21,-13.0,-4.5,0.005 -2015-10-17 01:10:05:652757,2,22,-13.0,-4.0,0.006 -2015-10-17 01:10:05:686217,2,23,-13.0,-3.5,0.007 -2015-10-17 01:10:05:716964,2,24,-13.0,-3.0,0.008 -2015-10-17 01:10:05:753530,2,25,-13.0,-2.5,0.009 -2015-10-17 01:10:05:785902,2,26,-13.0,-2.0,0.01 -2015-10-17 01:10:05:818691,2,27,-13.0,-1.5,0.012 -2015-10-17 01:10:05:852545,2,28,-13.0,-1.0,0.013 -2015-10-17 01:10:05:886470,2,29,-13.0,-0.5,0.014 -2015-10-17 01:10:05:918843,2,30,-13.0,0.0,0.014 -2015-10-17 01:10:05:951844,2,31,-13.0,0.5,0.014 -2015-10-17 01:10:05:985946,2,32,-13.0,1.0,0.013 -2015-10-17 01:10:06:017293,2,33,-13.0,1.5,0.012 -2015-10-17 01:10:06:051779,2,34,-13.0,2.0,0.01 -2015-10-17 01:10:06:085896,2,35,-13.0,2.5,0.009 -2015-10-17 01:10:06:119385,2,36,-13.0,3.0,0.008 -2015-10-17 01:10:06:152880,2,37,-13.0,3.5,0.007 -2015-10-17 01:10:06:185473,2,38,-13.0,4.0,0.006 -2015-10-17 01:10:06:221766,2,39,-13.0,4.5,0.005 -2015-10-17 01:10:06:253902,2,40,-13.0,5.0,0.005 -2015-10-17 01:10:06:285692,2,41,-13.0,5.5,0.005 -2015-10-17 01:10:06:321221,2,42,-13.0,6.0,0.006 -2015-10-17 01:10:06:353085,2,43,-13.0,6.5,0.007 -2015-10-17 01:10:06:388881,2,44,-13.0,7.0,0.008 -2015-10-17 01:10:06:420422,2,45,-13.0,7.5,0.009 -2015-10-17 01:10:06:455293,2,46,-13.0,8.0,0.01 -2015-10-17 01:10:06:487596,2,47,-13.0,8.5,0.012 -2015-10-17 01:10:06:519705,2,48,-13.0,9.0,0.013 -2015-10-17 01:10:06:519705,2,48,-13.0,9.0,0.013 -2015-10-17 01:10:06:551266,2,49,-13.0,9.5,0.014 -2015-10-17 01:10:06:586097,2,50,-13.0,10.0,0.014 -2015-10-17 01:10:06:622430,2,51,-13.0,10.5,0.014 -2015-10-17 01:10:06:655767,2,52,-13.0,11.0,0.013 -2015-10-17 01:10:06:688119,2,53,-13.0,11.5,0.012 -2015-10-17 01:10:06:723555,2,54,-13.0,12.0,0.01 -2015-10-17 01:10:06:756822,2,55,-13.0,12.5,0.009 -2015-10-17 01:10:06:792857,2,56,-13.0,13.0,0.008 -2015-10-17 01:10:06:826122,2,57,-13.0,13.5,0.007 -2015-10-17 01:10:06:858006,2,58,-13.0,14.0,0.006 -2015-10-17 01:10:06:892896,2,59,-13.0,14.5,0.005 -2015-10-17 01:10:06:892896,2,59,-13.0,14.5,0.005 -2015-10-17 01:10:07:894577,3,0,-12.0,-15.0,0.005 -2015-10-17 01:10:07:928164,3,1,-12.0,-14.5,0.006 -2015-10-17 01:10:07:959805,3,2,-12.0,-14.0,0.007 -2015-10-17 01:10:07:992819,3,3,-12.0,-13.5,0.009 -2015-10-17 01:10:08:024059,3,4,-12.0,-13.0,0.01 -2015-10-17 01:10:08:056031,3,5,-12.0,-12.5,0.013 -2015-10-17 01:10:08:088753,3,6,-12.0,-12.0,0.016 -2015-10-17 01:10:08:119560,3,7,-12.0,-11.5,0.019 -2015-10-17 01:10:08:151849,3,8,-12.0,-11.0,0.023 -2015-10-17 01:10:08:189080,3,9,-12.0,-10.5,0.026 -2015-10-17 01:10:08:220503,3,10,-12.0,-10.0,0.027 -2015-10-17 01:10:08:254779,3,11,-12.0,-9.5,0.026 -2015-10-17 01:10:08:292038,3,12,-12.0,-9.0,0.023 -2015-10-17 01:10:08:328489,3,13,-12.0,-8.5,0.019 -2015-10-17 01:10:08:364942,3,14,-12.0,-8.0,0.016 -2015-10-17 01:10:08:396430,3,15,-12.0,-7.5,0.013 -2015-10-17 01:10:08:430551,3,16,-12.0,-7.0,0.01 -2015-10-17 01:10:08:463821,3,17,-12.0,-6.5,0.009 -2015-10-17 01:10:08:497243,3,18,-12.0,-6.0,0.007 -2015-10-17 01:10:08:530797,3,19,-12.0,-5.5,0.006 -2015-10-17 01:10:08:564270,3,20,-12.0,-5.0,0.005 -2015-10-17 01:10:08:597596,3,21,-12.0,-4.5,0.006 -2015-10-17 01:10:08:631189,3,22,-12.0,-4.0,0.007 -2015-10-17 01:10:08:664949,3,23,-12.0,-3.5,0.009 -2015-10-17 01:10:08:697892,3,24,-12.0,-3.0,0.01 -2015-10-17 01:10:08:735174,3,25,-12.0,-2.5,0.013 -2015-10-17 01:10:08:735174,3,25,-12.0,-2.5,0.013 -2015-10-17 01:10:08:768955,3,26,-12.0,-2.0,0.016 -2015-10-17 01:10:08:804948,3,27,-12.0,-1.5,0.019 -2015-10-17 01:10:08:837747,3,28,-12.0,-1.0,0.023 -2015-10-17 01:10:08:873464,3,29,-12.0,-0.5,0.026 -2015-10-17 01:10:08:906893,3,30,-12.0,0.0,0.027 -2015-10-17 01:10:08:940047,3,31,-12.0,0.5,0.026 -2015-10-17 01:10:08:974879,3,32,-12.0,1.0,0.023 -2015-10-17 01:10:09:010792,3,33,-12.0,1.5,0.019 -2015-10-17 01:10:09:044847,3,34,-12.0,2.0,0.016 -2015-10-17 01:10:09:076020,3,35,-12.0,2.5,0.013 -2015-10-17 01:10:09:112016,3,36,-12.0,3.0,0.01 -2015-10-17 01:10:09:145528,3,37,-12.0,3.5,0.009 -2015-10-17 01:10:09:177649,3,38,-12.0,4.0,0.007 -2015-10-17 01:10:09:210585,3,39,-12.0,4.5,0.006 -2015-10-17 01:10:09:245212,3,40,-12.0,5.0,0.005 -2015-10-17 01:10:09:278986,3,41,-12.0,5.5,0.006 -2015-10-17 01:10:09:312762,3,42,-12.0,6.0,0.007 -2015-10-17 01:10:09:347908,3,43,-12.0,6.5,0.009 -2015-10-17 01:10:09:380944,3,44,-12.0,7.0,0.01 -2015-10-17 01:10:09:416991,3,45,-12.0,7.5,0.013 -2015-10-17 01:10:09:449733,3,46,-12.0,8.0,0.016 -2015-10-17 01:10:09:485115,3,47,-12.0,8.5,0.019 -2015-10-17 01:10:09:517919,3,48,-12.0,9.0,0.023 -2015-10-17 01:10:09:553376,3,49,-12.0,9.5,0.026 -2015-10-17 01:10:09:585561,3,50,-12.0,10.0,0.027 -2015-10-17 01:10:09:617410,3,51,-12.0,10.5,0.026 -2015-10-17 01:10:09:649686,3,52,-12.0,11.0,0.023 -2015-10-17 01:10:09:685373,3,53,-12.0,11.5,0.019 -2015-10-17 01:10:09:715920,3,54,-12.0,12.0,0.016 -2015-10-17 01:10:09:751148,3,55,-12.0,12.5,0.013 -2015-10-17 01:10:09:751148,3,55,-12.0,12.5,0.013 -2015-10-17 01:10:09:785537,3,56,-12.0,13.0,0.01 -2015-10-17 01:10:09:819802,3,57,-12.0,13.5,0.009 -2015-10-17 01:10:09:851732,3,58,-12.0,14.0,0.007 -2015-10-17 01:10:09:888237,3,59,-12.0,14.5,0.006 -2015-10-17 01:10:10:894932,4,0,-11.0,-15.0,0.006 -2015-10-17 01:10:10:894932,4,0,-11.0,-15.0,0.006 -2015-10-17 01:10:10:927253,4,1,-11.0,-14.5,0.007 -2015-10-17 01:10:10:959563,4,2,-11.0,-14.0,0.008 -2015-10-17 01:10:10:991209,4,3,-11.0,-13.5,0.01 -2015-10-17 01:10:11:023257,4,4,-11.0,-13.0,0.013 -2015-10-17 01:10:11:054457,4,5,-11.0,-12.5,0.017 -2015-10-17 01:10:11:087229,4,6,-11.0,-12.0,0.023 -2015-10-17 01:10:11:119231,4,7,-11.0,-11.5,0.031 -2015-10-17 01:10:11:151294,4,8,-11.0,-11.0,0.044 -2015-10-17 01:10:11:183334,4,9,-11.0,-10.5,0.057 -2015-10-17 01:10:11:217238,4,10,-11.0,-10.0,0.064 -2015-10-17 01:10:11:254149,4,11,-11.0,-9.5,0.057 -2015-10-17 01:10:11:286818,4,12,-11.0,-9.0,0.044 -2015-10-17 01:10:11:322539,4,13,-11.0,-8.5,0.031 -2015-10-17 01:10:11:358527,4,14,-11.0,-8.0,0.023 -2015-10-17 01:10:11:390881,4,15,-11.0,-7.5,0.017 -2015-10-17 01:10:11:422643,4,16,-11.0,-7.0,0.013 -2015-10-17 01:10:11:454998,4,17,-11.0,-6.5,0.01 -2015-10-17 01:10:11:486613,4,18,-11.0,-6.0,0.008 -2015-10-17 01:10:11:521955,4,19,-11.0,-5.5,0.007 -2015-10-17 01:10:11:556174,4,20,-11.0,-5.0,0.006 -2015-10-17 01:10:11:587364,4,21,-11.0,-4.5,0.007 -2015-10-17 01:10:11:623133,4,22,-11.0,-4.0,0.008 -2015-10-17 01:10:11:655174,4,23,-11.0,-3.5,0.01 -2015-10-17 01:10:11:689038,4,24,-11.0,-3.0,0.013 -2015-10-17 01:10:11:720747,4,25,-11.0,-2.5,0.017 -2015-10-17 01:10:11:757098,4,26,-11.0,-2.0,0.023 -2015-10-17 01:10:11:791013,4,27,-11.0,-1.5,0.031 -2015-10-17 01:10:11:822618,4,28,-11.0,-1.0,0.044 -2015-10-17 01:10:11:855171,4,29,-11.0,-0.5,0.057 -2015-10-17 01:10:11:891632,4,30,-11.0,0.0,0.064 -2015-10-17 01:10:11:927706,4,31,-11.0,0.5,0.057 -2015-10-17 01:10:11:927706,4,31,-11.0,0.5,0.057 -2015-10-17 01:10:11:959218,4,32,-11.0,1.0,0.044 -2015-10-17 01:10:11:995385,4,33,-11.0,1.5,0.031 -2015-10-17 01:10:12:031864,4,34,-11.0,2.0,0.023 -2015-10-17 01:10:12:066632,4,35,-11.0,2.5,0.017 -2015-10-17 01:10:12:099431,4,36,-11.0,3.0,0.013 -2015-10-17 01:10:12:130601,4,37,-11.0,3.5,0.01 -2015-10-17 01:10:12:165627,4,38,-11.0,4.0,0.008 -2015-10-17 01:10:12:200031,4,39,-11.0,4.5,0.007 -2015-10-17 01:10:12:236682,4,40,-11.0,5.0,0.006 -2015-10-17 01:10:12:273207,4,41,-11.0,5.5,0.007 -2015-10-17 01:10:12:309653,4,42,-11.0,6.0,0.008 -2015-10-17 01:10:12:344161,4,43,-11.0,6.5,0.01 -2015-10-17 01:10:12:380017,4,44,-11.0,7.0,0.013 -2015-10-17 01:10:12:416901,4,45,-11.0,7.5,0.017 -2015-10-17 01:10:12:451914,4,46,-11.0,8.0,0.023 -2015-10-17 01:10:12:485224,4,47,-11.0,8.5,0.031 -2015-10-17 01:10:12:516762,4,48,-11.0,9.0,0.044 -2015-10-17 01:10:12:551532,4,49,-11.0,9.5,0.057 -2015-10-17 01:10:12:585031,4,50,-11.0,10.0,0.064 -2015-10-17 01:10:12:621680,4,51,-11.0,10.5,0.057 -2015-10-17 01:10:12:658364,4,52,-11.0,11.0,0.044 -2015-10-17 01:10:12:691497,4,53,-11.0,11.5,0.031 -2015-10-17 01:10:12:725951,4,54,-11.0,12.0,0.023 -2015-10-17 01:10:12:762422,4,55,-11.0,12.5,0.017 -2015-10-17 01:10:12:798397,4,56,-11.0,13.0,0.013 -2015-10-17 01:10:12:830715,4,57,-11.0,13.5,0.01 -2015-10-17 01:10:12:864433,4,58,-11.0,14.0,0.008 -2015-10-17 01:10:12:895581,4,59,-11.0,14.5,0.007 -2015-10-17 01:10:12:895581,4,59,-11.0,14.5,0.007 -2015-10-17 01:10:13:900660,5,0,-10.0,-15.0,0.006 -2015-10-17 01:10:13:932583,5,1,-10.0,-14.5,0.007 -2015-10-17 01:10:13:964514,5,2,-10.0,-14.0,0.009 -2015-10-17 01:10:13:996418,5,3,-10.0,-13.5,0.011 -2015-10-17 01:10:14:027750,5,4,-10.0,-13.0,0.014 -2015-10-17 01:10:14:061392,5,5,-10.0,-12.5,0.019 -2015-10-17 01:10:14:094280,5,6,-10.0,-12.0,0.027 -2015-10-17 01:10:14:125948,5,7,-10.0,-11.5,0.04 -2015-10-17 01:10:14:125948,5,7,-10.0,-11.5,0.04 -2015-10-17 01:10:14:157860,5,8,-10.0,-11.0,0.064 -2015-10-17 01:10:14:193802,5,9,-10.0,-10.5,0.099 -2015-10-17 01:10:14:223803,5,10,-10.0,-10.0,0.117 -2015-10-17 01:10:14:258560,5,11,-10.0,-9.5,0.099 -2015-10-17 01:10:14:292113,5,12,-10.0,-9.0,0.064 -2015-10-17 01:10:14:325896,5,13,-10.0,-8.5,0.04 -2015-10-17 01:10:14:359015,5,14,-10.0,-8.0,0.027 -2015-10-17 01:10:14:394361,5,15,-10.0,-7.5,0.019 -2015-10-17 01:10:14:427378,5,16,-10.0,-7.0,0.014 -2015-10-17 01:10:14:460068,5,17,-10.0,-6.5,0.011 -2015-10-17 01:10:14:492424,5,18,-10.0,-6.0,0.009 -2015-10-17 01:10:14:526884,5,19,-10.0,-5.5,0.007 -2015-10-17 01:10:14:558964,5,20,-10.0,-5.0,0.006 -2015-10-17 01:10:14:594491,5,21,-10.0,-4.5,0.007 -2015-10-17 01:10:14:627530,5,22,-10.0,-4.0,0.009 -2015-10-17 01:10:14:662908,5,23,-10.0,-3.5,0.011 -2015-10-17 01:10:14:697918,5,24,-10.0,-3.0,0.014 -2015-10-17 01:10:14:734430,5,25,-10.0,-2.5,0.019 -2015-10-17 01:10:14:766251,5,26,-10.0,-2.0,0.027 -2015-10-17 01:10:14:798662,5,27,-10.0,-1.5,0.04 -2015-10-17 01:10:14:831132,5,28,-10.0,-1.0,0.064 -2015-10-17 01:10:14:862344,5,29,-10.0,-0.5,0.099 -2015-10-17 01:10:14:897145,5,30,-10.0,0.0,0.117 -2015-10-17 01:10:14:934504,5,31,-10.0,0.5,0.099 -2015-10-17 01:10:14:966439,5,32,-10.0,1.0,0.064 -2015-10-17 01:10:14:998867,5,33,-10.0,1.5,0.04 -2015-10-17 01:10:15:030519,5,34,-10.0,2.0,0.027 -2015-10-17 01:10:15:065654,5,35,-10.0,2.5,0.019 -2015-10-17 01:10:15:102041,5,36,-10.0,3.0,0.014 -2015-10-17 01:10:15:134852,5,37,-10.0,3.5,0.011 -2015-10-17 01:10:15:134852,5,37,-10.0,3.5,0.011 -2015-10-17 01:10:15:166686,5,38,-10.0,4.0,0.009 -2015-10-17 01:10:15:199019,5,39,-10.0,4.5,0.007 -2015-10-17 01:10:15:232250,5,40,-10.0,5.0,0.006 -2015-10-17 01:10:15:268177,5,41,-10.0,5.5,0.007 -2015-10-17 01:10:15:305460,5,42,-10.0,6.0,0.009 -2015-10-17 01:10:15:337927,5,43,-10.0,6.5,0.011 -2015-10-17 01:10:15:369324,5,44,-10.0,7.0,0.014 -2015-10-17 01:10:15:401319,5,45,-10.0,7.5,0.019 -2015-10-17 01:10:15:439162,5,46,-10.0,8.0,0.027 -2015-10-17 01:10:15:475548,5,47,-10.0,8.5,0.04 -2015-10-17 01:10:15:511517,5,48,-10.0,9.0,0.064 -2015-10-17 01:10:15:547465,5,49,-10.0,9.5,0.099 -2015-10-17 01:10:15:582139,5,50,-10.0,10.0,0.117 -2015-10-17 01:10:15:616816,5,51,-10.0,10.5,0.099 -2015-10-17 01:10:15:650427,5,52,-10.0,11.0,0.064 -2015-10-17 01:10:15:682234,5,53,-10.0,11.5,0.04 -2015-10-17 01:10:15:715656,5,54,-10.0,12.0,0.027 -2015-10-17 01:10:15:748246,5,55,-10.0,12.5,0.019 -2015-10-17 01:10:15:781193,5,56,-10.0,13.0,0.014 -2015-10-17 01:10:15:814155,5,57,-10.0,13.5,0.011 -2015-10-17 01:10:15:846714,5,58,-10.0,14.0,0.009 -2015-10-17 01:10:15:878118,5,59,-10.0,14.5,0.007 -2015-10-17 01:10:15:878118,5,59,-10.0,14.5,0.007 -2015-10-17 01:10:16:880203,6,0,-9.0,-15.0,0.006 -2015-10-17 01:10:16:912444,6,1,-9.0,-14.5,0.007 -2015-10-17 01:10:16:944154,6,2,-9.0,-14.0,0.008 -2015-10-17 01:10:16:976145,6,3,-9.0,-13.5,0.01 -2015-10-17 01:10:17:008069,6,4,-9.0,-13.0,0.013 -2015-10-17 01:10:17:043987,6,5,-9.0,-12.5,0.017 -2015-10-17 01:10:17:076536,6,6,-9.0,-12.0,0.023 -2015-10-17 01:10:17:110760,6,7,-9.0,-11.5,0.031 -2015-10-17 01:10:17:144588,6,8,-9.0,-11.0,0.044 -2015-10-17 01:10:17:177618,6,9,-9.0,-10.5,0.057 -2015-10-17 01:10:17:210139,6,10,-9.0,-10.0,0.064 -2015-10-17 01:10:17:241657,6,11,-9.0,-9.5,0.057 -2015-10-17 01:10:17:274240,6,12,-9.0,-9.0,0.044 -2015-10-17 01:10:17:310946,6,13,-9.0,-8.5,0.031 -2015-10-17 01:10:17:310946,6,13,-9.0,-8.5,0.031 -2015-10-17 01:10:17:344424,6,14,-9.0,-8.0,0.023 -2015-10-17 01:10:17:377892,6,15,-9.0,-7.5,0.017 -2015-10-17 01:10:17:413463,6,16,-9.0,-7.0,0.013 -2015-10-17 01:10:17:445070,6,17,-9.0,-6.5,0.01 -2015-10-17 01:10:17:478452,6,18,-9.0,-6.0,0.008 -2015-10-17 01:10:17:511746,6,19,-9.0,-5.5,0.007 -2015-10-17 01:10:17:548187,6,20,-9.0,-5.0,0.006 -2015-10-17 01:10:17:580722,6,21,-9.0,-4.5,0.007 -2015-10-17 01:10:17:612879,6,22,-9.0,-4.0,0.008 -2015-10-17 01:10:17:645329,6,23,-9.0,-3.5,0.01 -2015-10-17 01:10:17:680922,6,24,-9.0,-3.0,0.013 -2015-10-17 01:10:17:713952,6,25,-9.0,-2.5,0.017 -2015-10-17 01:10:17:745579,6,26,-9.0,-2.0,0.023 -2015-10-17 01:10:17:783026,6,27,-9.0,-1.5,0.031 -2015-10-17 01:10:17:816128,6,28,-9.0,-1.0,0.044 -2015-10-17 01:10:17:852834,6,29,-9.0,-0.5,0.057 -2015-10-17 01:10:17:886029,6,30,-9.0,0.0,0.064 -2015-10-17 01:10:17:921751,6,31,-9.0,0.5,0.057 -2015-10-17 01:10:17:958218,6,32,-9.0,1.0,0.044 -2015-10-17 01:10:17:991664,6,33,-9.0,1.5,0.031 -2015-10-17 01:10:18:025650,6,34,-9.0,2.0,0.023 -2015-10-17 01:10:18:057449,6,35,-9.0,2.5,0.017 -2015-10-17 01:10:18:093529,6,36,-9.0,3.0,0.013 -2015-10-17 01:10:18:130130,6,37,-9.0,3.5,0.01 -2015-10-17 01:10:18:163588,6,38,-9.0,4.0,0.008 -2015-10-17 01:10:18:197552,6,39,-9.0,4.5,0.007 -2015-10-17 01:10:18:230798,6,40,-9.0,5.0,0.006 -2015-10-17 01:10:18:264394,6,41,-9.0,5.5,0.007 -2015-10-17 01:10:18:300409,6,42,-9.0,6.0,0.008 -2015-10-17 01:10:18:332864,6,43,-9.0,6.5,0.01 -2015-10-17 01:10:18:332864,6,43,-9.0,6.5,0.01 -2015-10-17 01:10:18:366187,6,44,-9.0,7.0,0.013 -2015-10-17 01:10:18:402087,6,45,-9.0,7.5,0.017 -2015-10-17 01:10:18:434840,6,46,-9.0,8.0,0.023 -2015-10-17 01:10:18:467498,6,47,-9.0,8.5,0.031 -2015-10-17 01:10:18:499393,6,48,-9.0,9.0,0.044 -2015-10-17 01:10:18:532984,6,49,-9.0,9.5,0.057 -2015-10-17 01:10:18:563463,6,50,-9.0,10.0,0.064 -2015-10-17 01:10:18:597527,6,51,-9.0,10.5,0.057 -2015-10-17 01:10:18:631020,6,52,-9.0,11.0,0.044 -2015-10-17 01:10:18:664740,6,53,-9.0,11.5,0.031 -2015-10-17 01:10:18:699570,6,54,-9.0,12.0,0.023 -2015-10-17 01:10:18:730717,6,55,-9.0,12.5,0.017 -2015-10-17 01:10:18:765755,6,56,-9.0,13.0,0.013 -2015-10-17 01:10:18:799645,6,57,-9.0,13.5,0.01 -2015-10-17 01:10:18:831792,6,58,-9.0,14.0,0.008 -2015-10-17 01:10:18:868513,6,59,-9.0,14.5,0.007 -2015-10-17 01:10:18:868513,6,59,-9.0,14.5,0.007 -2015-10-17 01:10:19:872857,7,0,-8.0,-15.0,0.005 -2015-10-17 01:10:19:906091,7,1,-8.0,-14.5,0.006 -2015-10-17 01:10:19:936892,7,2,-8.0,-14.0,0.007 -2015-10-17 01:10:19:969254,7,3,-8.0,-13.5,0.009 -2015-10-17 01:10:20:000871,7,4,-8.0,-13.0,0.01 -2015-10-17 01:10:20:031867,7,5,-8.0,-12.5,0.013 -2015-10-17 01:10:20:068737,7,6,-8.0,-12.0,0.016 -2015-10-17 01:10:20:102176,7,7,-8.0,-11.5,0.019 -2015-10-17 01:10:20:135453,7,8,-8.0,-11.0,0.023 -2015-10-17 01:10:20:168366,7,9,-8.0,-10.5,0.026 -2015-10-17 01:10:20:199990,7,10,-8.0,-10.0,0.027 -2015-10-17 01:10:20:236802,7,11,-8.0,-9.5,0.026 -2015-10-17 01:10:20:269355,7,12,-8.0,-9.0,0.023 -2015-10-17 01:10:20:303868,7,13,-8.0,-8.5,0.019 -2015-10-17 01:10:20:338438,7,14,-8.0,-8.0,0.016 -2015-10-17 01:10:20:374526,7,15,-8.0,-7.5,0.013 -2015-10-17 01:10:20:407836,7,16,-8.0,-7.0,0.01 -2015-10-17 01:10:20:441102,7,17,-8.0,-6.5,0.009 -2015-10-17 01:10:20:477282,7,18,-8.0,-6.0,0.007 -2015-10-17 01:10:20:477282,7,18,-8.0,-6.0,0.007 -2015-10-17 01:10:20:512721,7,19,-8.0,-5.5,0.006 -2015-10-17 01:10:20:544349,7,20,-8.0,-5.0,0.005 -2015-10-17 01:10:20:578533,7,21,-8.0,-4.5,0.006 -2015-10-17 01:10:20:614774,7,22,-8.0,-4.0,0.007 -2015-10-17 01:10:20:649538,7,23,-8.0,-3.5,0.009 -2015-10-17 01:10:20:681766,7,24,-8.0,-3.0,0.01 -2015-10-17 01:10:20:719281,7,25,-8.0,-2.5,0.013 -2015-10-17 01:10:20:751070,7,26,-8.0,-2.0,0.016 -2015-10-17 01:10:20:786972,7,27,-8.0,-1.5,0.019 -2015-10-17 01:10:20:823333,7,28,-8.0,-1.0,0.023 -2015-10-17 01:10:20:855623,7,29,-8.0,-0.5,0.026 -2015-10-17 01:10:20:888237,7,30,-8.0,0.0,0.027 -2015-10-17 01:10:20:924550,7,31,-8.0,0.5,0.026 -2015-10-17 01:10:20:960196,7,32,-8.0,1.0,0.023 -2015-10-17 01:10:20:992639,7,33,-8.0,1.5,0.019 -2015-10-17 01:10:21:024257,7,34,-8.0,2.0,0.016 -2015-10-17 01:10:21:055946,7,35,-8.0,2.5,0.013 -2015-10-17 01:10:21:088198,7,36,-8.0,3.0,0.01 -2015-10-17 01:10:21:124665,7,37,-8.0,3.5,0.009 -2015-10-17 01:10:21:161128,7,38,-8.0,4.0,0.007 -2015-10-17 01:10:21:197586,7,39,-8.0,4.5,0.006 -2015-10-17 01:10:21:234060,7,40,-8.0,5.0,0.005 -2015-10-17 01:10:21:267208,7,41,-8.0,5.5,0.006 -2015-10-17 01:10:21:303272,7,42,-8.0,6.0,0.007 -2015-10-17 01:10:21:336123,7,43,-8.0,6.5,0.009 -2015-10-17 01:10:21:369910,7,44,-8.0,7.0,0.01 -2015-10-17 01:10:21:402072,7,45,-8.0,7.5,0.013 -2015-10-17 01:10:21:436794,7,46,-8.0,8.0,0.016 -2015-10-17 01:10:21:474766,7,47,-8.0,8.5,0.019 -2015-10-17 01:10:21:506772,7,48,-8.0,9.0,0.023 -2015-10-17 01:10:21:506772,7,48,-8.0,9.0,0.023 -2015-10-17 01:10:21:541635,7,49,-8.0,9.5,0.026 -2015-10-17 01:10:21:575390,7,50,-8.0,10.0,0.027 -2015-10-17 01:10:21:607546,7,51,-8.0,10.5,0.026 -2015-10-17 01:10:21:640945,7,52,-8.0,11.0,0.023 -2015-10-17 01:10:21:673132,7,53,-8.0,11.5,0.019 -2015-10-17 01:10:21:705161,7,54,-8.0,12.0,0.016 -2015-10-17 01:10:21:737914,7,55,-8.0,12.5,0.013 -2015-10-17 01:10:21:769213,7,56,-8.0,13.0,0.01 -2015-10-17 01:10:21:801208,7,57,-8.0,13.5,0.009 -2015-10-17 01:10:21:836760,7,58,-8.0,14.0,0.007 -2015-10-17 01:10:21:869261,7,59,-8.0,14.5,0.006 -2015-10-17 01:10:21:869261,7,59,-8.0,14.5,0.006 -2015-10-17 01:10:22:872097,8,0,-7.0,-15.0,0.005 -2015-10-17 01:10:22:908046,8,1,-7.0,-14.5,0.005 -2015-10-17 01:10:22:939276,8,2,-7.0,-14.0,0.006 -2015-10-17 01:10:22:971985,8,3,-7.0,-13.5,0.007 -2015-10-17 01:10:23:004347,8,4,-7.0,-13.0,0.008 -2015-10-17 01:10:23:037794,8,5,-7.0,-12.5,0.009 -2015-10-17 01:10:23:073112,8,6,-7.0,-12.0,0.01 -2015-10-17 01:10:23:104830,8,7,-7.0,-11.5,0.012 -2015-10-17 01:10:23:137391,8,8,-7.0,-11.0,0.013 -2015-10-17 01:10:23:173602,8,9,-7.0,-10.5,0.014 -2015-10-17 01:10:23:206537,8,10,-7.0,-10.0,0.014 -2015-10-17 01:10:23:238109,8,11,-7.0,-9.5,0.014 -2015-10-17 01:10:23:270001,8,12,-7.0,-9.0,0.013 -2015-10-17 01:10:23:303388,8,13,-7.0,-8.5,0.012 -2015-10-17 01:10:23:338737,8,14,-7.0,-8.0,0.01 -2015-10-17 01:10:23:370029,8,15,-7.0,-7.5,0.009 -2015-10-17 01:10:23:401871,8,16,-7.0,-7.0,0.008 -2015-10-17 01:10:23:437148,8,17,-7.0,-6.5,0.007 -2015-10-17 01:10:23:469233,8,18,-7.0,-6.0,0.006 -2015-10-17 01:10:23:503366,8,19,-7.0,-5.5,0.005 -2015-10-17 01:10:23:538369,8,20,-7.0,-5.0,0.005 -2015-10-17 01:10:23:570693,8,21,-7.0,-4.5,0.005 -2015-10-17 01:10:23:606528,8,22,-7.0,-4.0,0.006 -2015-10-17 01:10:23:638447,8,23,-7.0,-3.5,0.007 -2015-10-17 01:10:23:671165,8,24,-7.0,-3.0,0.008 -2015-10-17 01:10:23:703074,8,25,-7.0,-2.5,0.009 -2015-10-17 01:10:23:703074,8,25,-7.0,-2.5,0.009 -2015-10-17 01:10:23:735399,8,26,-7.0,-2.0,0.01 -2015-10-17 01:10:23:768276,8,27,-7.0,-1.5,0.012 -2015-10-17 01:10:23:799932,8,28,-7.0,-1.0,0.013 -2015-10-17 01:10:23:831985,8,29,-7.0,-0.5,0.014 -2015-10-17 01:10:23:863513,8,30,-7.0,0.0,0.014 -2015-10-17 01:10:23:895468,8,31,-7.0,0.5,0.014 -2015-10-17 01:10:23:929825,8,32,-7.0,1.0,0.013 -2015-10-17 01:10:23:963522,8,33,-7.0,1.5,0.012 -2015-10-17 01:10:23:998923,8,34,-7.0,2.0,0.01 -2015-10-17 01:10:24:030514,8,35,-7.0,2.5,0.009 -2015-10-17 01:10:24:062096,8,36,-7.0,3.0,0.008 -2015-10-17 01:10:24:094876,8,37,-7.0,3.5,0.007 -2015-10-17 01:10:24:129719,8,38,-7.0,4.0,0.006 -2015-10-17 01:10:24:165517,8,39,-7.0,4.5,0.005 -2015-10-17 01:10:24:198906,8,40,-7.0,5.0,0.005 -2015-10-17 01:10:24:230832,8,41,-7.0,5.5,0.005 -2015-10-17 01:10:24:262810,8,42,-7.0,6.0,0.006 -2015-10-17 01:10:24:294333,8,43,-7.0,6.5,0.007 -2015-10-17 01:10:24:327033,8,44,-7.0,7.0,0.008 -2015-10-17 01:10:24:360629,8,45,-7.0,7.5,0.009 -2015-10-17 01:10:24:397357,8,46,-7.0,8.0,0.01 -2015-10-17 01:10:24:434107,8,47,-7.0,8.5,0.012 -2015-10-17 01:10:24:470741,8,48,-7.0,9.0,0.013 -2015-10-17 01:10:24:505201,8,49,-7.0,9.5,0.014 -2015-10-17 01:10:24:542294,8,50,-7.0,10.0,0.014 -2015-10-17 01:10:24:575853,8,51,-7.0,10.5,0.014 -2015-10-17 01:10:24:607851,8,52,-7.0,11.0,0.013 -2015-10-17 01:10:24:641096,8,53,-7.0,11.5,0.012 -2015-10-17 01:10:24:674963,8,54,-7.0,12.0,0.01 -2015-10-17 01:10:24:711276,8,55,-7.0,12.5,0.009 -2015-10-17 01:10:24:711276,8,55,-7.0,12.5,0.009 -2015-10-17 01:10:24:742088,8,56,-7.0,13.0,0.008 -2015-10-17 01:10:24:777479,8,57,-7.0,13.5,0.007 -2015-10-17 01:10:24:814099,8,58,-7.0,14.0,0.006 -2015-10-17 01:10:24:845952,8,59,-7.0,14.5,0.005 -2015-10-17 01:10:25:851142,9,0,-6.0,-15.0,0.004 -2015-10-17 01:10:25:851142,9,0,-6.0,-15.0,0.004 -2015-10-17 01:10:25:882512,9,1,-6.0,-14.5,0.004 -2015-10-17 01:10:25:914205,9,2,-6.0,-14.0,0.005 -2015-10-17 01:10:25:949278,9,3,-6.0,-13.5,0.005 -2015-10-17 01:10:25:980765,9,4,-6.0,-13.0,0.006 -2015-10-17 01:10:26:012696,9,5,-6.0,-12.5,0.007 -2015-10-17 01:10:26:044562,9,6,-6.0,-12.0,0.007 -2015-10-17 01:10:26:076634,9,7,-6.0,-11.5,0.008 -2015-10-17 01:10:26:107759,9,8,-6.0,-11.0,0.008 -2015-10-17 01:10:26:144210,9,9,-6.0,-10.5,0.009 -2015-10-17 01:10:26:179090,9,10,-6.0,-10.0,0.009 -2015-10-17 01:10:26:211642,9,11,-6.0,-9.5,0.009 -2015-10-17 01:10:26:243853,9,12,-6.0,-9.0,0.008 -2015-10-17 01:10:26:278218,9,13,-6.0,-8.5,0.008 -2015-10-17 01:10:26:310609,9,14,-6.0,-8.0,0.007 -2015-10-17 01:10:26:343462,9,15,-6.0,-7.5,0.007 -2015-10-17 01:10:26:376996,9,16,-6.0,-7.0,0.006 -2015-10-17 01:10:26:408776,9,17,-6.0,-6.5,0.005 -2015-10-17 01:10:26:443707,9,18,-6.0,-6.0,0.005 -2015-10-17 01:10:26:478022,9,19,-6.0,-5.5,0.004 -2015-10-17 01:10:26:510201,9,20,-6.0,-5.0,0.004 -2015-10-17 01:10:26:542002,9,21,-6.0,-4.5,0.004 -2015-10-17 01:10:26:575927,9,22,-6.0,-4.0,0.005 -2015-10-17 01:10:26:608901,9,23,-6.0,-3.5,0.005 -2015-10-17 01:10:26:643759,9,24,-6.0,-3.0,0.006 -2015-10-17 01:10:26:676812,9,25,-6.0,-2.5,0.007 -2015-10-17 01:10:26:710752,9,26,-6.0,-2.0,0.007 -2015-10-17 01:10:26:745157,9,27,-6.0,-1.5,0.008 -2015-10-17 01:10:26:782285,9,28,-6.0,-1.0,0.008 -2015-10-17 01:10:26:814737,9,29,-6.0,-0.5,0.009 -2015-10-17 01:10:26:846137,9,30,-6.0,0.0,0.009 -2015-10-17 01:10:26:878129,9,31,-6.0,0.5,0.009 -2015-10-17 01:10:26:878129,9,31,-6.0,0.5,0.009 -2015-10-17 01:10:26:910871,9,32,-6.0,1.0,0.008 -2015-10-17 01:10:26:945379,9,33,-6.0,1.5,0.008 -2015-10-17 01:10:26:977601,9,34,-6.0,2.0,0.007 -2015-10-17 01:10:27:009346,9,35,-6.0,2.5,0.007 -2015-10-17 01:10:27:042915,9,36,-6.0,3.0,0.006 -2015-10-17 01:10:27:075840,9,37,-6.0,3.5,0.005 -2015-10-17 01:10:27:108272,9,38,-6.0,4.0,0.005 -2015-10-17 01:10:27:145220,9,39,-6.0,4.5,0.004 -2015-10-17 01:10:27:176785,9,40,-6.0,5.0,0.004 -2015-10-17 01:10:27:209403,9,41,-6.0,5.5,0.004 -2015-10-17 01:10:27:241621,9,42,-6.0,6.0,0.005 -2015-10-17 01:10:27:273591,9,43,-6.0,6.5,0.005 -2015-10-17 01:10:27:305608,9,44,-6.0,7.0,0.006 -2015-10-17 01:10:27:338537,9,45,-6.0,7.5,0.007 -2015-10-17 01:10:27:375998,9,46,-6.0,8.0,0.007 -2015-10-17 01:10:27:409389,9,47,-6.0,8.5,0.008 -2015-10-17 01:10:27:441981,9,48,-6.0,9.0,0.008 -2015-10-17 01:10:27:474661,9,49,-6.0,9.5,0.009 -2015-10-17 01:10:27:506788,9,50,-6.0,10.0,0.009 -2015-10-17 01:10:27:538186,9,51,-6.0,10.5,0.009 -2015-10-17 01:10:27:573210,9,52,-6.0,11.0,0.008 -2015-10-17 01:10:27:609636,9,53,-6.0,11.5,0.008 -2015-10-17 01:10:27:645433,9,54,-6.0,12.0,0.007 -2015-10-17 01:10:27:680039,9,55,-6.0,12.5,0.007 -2015-10-17 01:10:27:717447,9,56,-6.0,13.0,0.006 -2015-10-17 01:10:27:753420,9,57,-6.0,13.5,0.005 -2015-10-17 01:10:27:786047,9,58,-6.0,14.0,0.005 -2015-10-17 01:10:27:822684,9,59,-6.0,14.5,0.004 -2015-10-17 01:10:27:822684,9,59,-6.0,14.5,0.004 -2015-10-17 01:10:28:828712,10,0,-5.0,-15.0,0.003 -2015-10-17 01:10:28:861485,10,1,-5.0,-14.5,0.004 -2015-10-17 01:10:28:893762,10,2,-5.0,-14.0,0.004 -2015-10-17 01:10:28:926925,10,3,-5.0,-13.5,0.004 -2015-10-17 01:10:28:959605,10,4,-5.0,-13.0,0.005 -2015-10-17 01:10:28:994194,10,5,-5.0,-12.5,0.005 -2015-10-17 01:10:29:025465,10,6,-5.0,-12.0,0.005 -2015-10-17 01:10:29:061553,10,7,-5.0,-11.5,0.006 -2015-10-17 01:10:29:061553,10,7,-5.0,-11.5,0.006 -2015-10-17 01:10:29:092915,10,8,-5.0,-11.0,0.006 -2015-10-17 01:10:29:127665,10,9,-5.0,-10.5,0.006 -2015-10-17 01:10:29:160008,10,10,-5.0,-10.0,0.006 -2015-10-17 01:10:29:193397,10,11,-5.0,-9.5,0.006 -2015-10-17 01:10:29:227262,10,12,-5.0,-9.0,0.006 -2015-10-17 01:10:29:260812,10,13,-5.0,-8.5,0.006 -2015-10-17 01:10:29:293301,10,14,-5.0,-8.0,0.005 -2015-10-17 01:10:29:329411,10,15,-5.0,-7.5,0.005 -2015-10-17 01:10:29:360904,10,16,-5.0,-7.0,0.005 -2015-10-17 01:10:29:393512,10,17,-5.0,-6.5,0.004 -2015-10-17 01:10:29:427829,10,18,-5.0,-6.0,0.004 -2015-10-17 01:10:29:461615,10,19,-5.0,-5.5,0.004 -2015-10-17 01:10:29:493935,10,20,-5.0,-5.0,0.003 -2015-10-17 01:10:29:528760,10,21,-5.0,-4.5,0.004 -2015-10-17 01:10:29:560770,10,22,-5.0,-4.0,0.004 -2015-10-17 01:10:29:593842,10,23,-5.0,-3.5,0.004 -2015-10-17 01:10:29:625428,10,24,-5.0,-3.0,0.005 -2015-10-17 01:10:29:660969,10,25,-5.0,-2.5,0.005 -2015-10-17 01:10:29:696475,10,26,-5.0,-2.0,0.005 -2015-10-17 01:10:29:729870,10,27,-5.0,-1.5,0.006 -2015-10-17 01:10:29:762622,10,28,-5.0,-1.0,0.006 -2015-10-17 01:10:29:795361,10,29,-5.0,-0.5,0.006 -2015-10-17 01:10:29:828936,10,30,-5.0,0.0,0.006 -2015-10-17 01:10:29:860340,10,31,-5.0,0.5,0.006 -2015-10-17 01:10:29:891933,10,32,-5.0,1.0,0.006 -2015-10-17 01:10:29:924437,10,33,-5.0,1.5,0.006 -2015-10-17 01:10:29:956080,10,34,-5.0,2.0,0.005 -2015-10-17 01:10:29:988055,10,35,-5.0,2.5,0.005 -2015-10-17 01:10:30:022861,10,36,-5.0,3.0,0.005 -2015-10-17 01:10:30:055080,10,37,-5.0,3.5,0.004 -2015-10-17 01:10:30:085505,10,38,-5.0,4.0,0.004 -2015-10-17 01:10:30:085505,10,38,-5.0,4.0,0.004 -2015-10-17 01:10:30:116686,10,39,-5.0,4.5,0.004 -2015-10-17 01:10:30:148726,10,40,-5.0,5.0,0.003 -2015-10-17 01:10:30:181020,10,41,-5.0,5.5,0.004 -2015-10-17 01:10:30:213907,10,42,-5.0,6.0,0.004 -2015-10-17 01:10:30:248527,10,43,-5.0,6.5,0.004 -2015-10-17 01:10:30:279342,10,44,-5.0,7.0,0.005 -2015-10-17 01:10:30:311786,10,45,-5.0,7.5,0.005 -2015-10-17 01:10:30:346510,10,46,-5.0,8.0,0.005 -2015-10-17 01:10:30:381671,10,47,-5.0,8.5,0.006 -2015-10-17 01:10:30:412831,10,48,-5.0,9.0,0.006 -2015-10-17 01:10:30:444324,10,49,-5.0,9.5,0.006 -2015-10-17 01:10:30:476394,10,50,-5.0,10.0,0.006 -2015-10-17 01:10:30:509052,10,51,-5.0,10.5,0.006 -2015-10-17 01:10:30:544368,10,52,-5.0,11.0,0.006 -2015-10-17 01:10:30:580575,10,53,-5.0,11.5,0.006 -2015-10-17 01:10:30:613634,10,54,-5.0,12.0,0.005 -2015-10-17 01:10:30:644759,10,55,-5.0,12.5,0.005 -2015-10-17 01:10:30:676836,10,56,-5.0,13.0,0.005 -2015-10-17 01:10:30:709192,10,57,-5.0,13.5,0.004 -2015-10-17 01:10:30:740547,10,58,-5.0,14.0,0.004 -2015-10-17 01:10:30:774633,10,59,-5.0,14.5,0.004 -2015-10-17 01:10:30:774633,10,59,-5.0,14.5,0.004 -2015-10-17 01:10:31:777410,11,0,-4.0,-15.0,0.004 -2015-10-17 01:10:31:810412,11,1,-4.0,-14.5,0.004 -2015-10-17 01:10:31:844168,11,2,-4.0,-14.0,0.005 -2015-10-17 01:10:31:878057,11,3,-4.0,-13.5,0.005 -2015-10-17 01:10:31:910835,11,4,-4.0,-13.0,0.006 -2015-10-17 01:10:31:944819,11,5,-4.0,-12.5,0.007 -2015-10-17 01:10:31:978018,11,6,-4.0,-12.0,0.007 -2015-10-17 01:10:32:014394,11,7,-4.0,-11.5,0.008 -2015-10-17 01:10:32:050719,11,8,-4.0,-11.0,0.008 -2015-10-17 01:10:32:086971,11,9,-4.0,-10.5,0.009 -2015-10-17 01:10:32:121303,11,10,-4.0,-10.0,0.009 -2015-10-17 01:10:32:157730,11,11,-4.0,-9.5,0.009 -2015-10-17 01:10:32:194350,11,12,-4.0,-9.0,0.008 -2015-10-17 01:10:32:194350,11,12,-4.0,-9.0,0.008 -2015-10-17 01:10:32:229418,11,13,-4.0,-8.5,0.008 -2015-10-17 01:10:32:261171,11,14,-4.0,-8.0,0.007 -2015-10-17 01:10:32:295994,11,15,-4.0,-7.5,0.007 -2015-10-17 01:10:32:330075,11,16,-4.0,-7.0,0.006 -2015-10-17 01:10:32:367105,11,17,-4.0,-6.5,0.005 -2015-10-17 01:10:32:403028,11,18,-4.0,-6.0,0.005 -2015-10-17 01:10:32:439775,11,19,-4.0,-5.5,0.004 -2015-10-17 01:10:32:475759,11,20,-4.0,-5.0,0.004 -2015-10-17 01:10:32:512414,11,21,-4.0,-4.5,0.004 -2015-10-17 01:10:32:546736,11,22,-4.0,-4.0,0.005 -2015-10-17 01:10:32:582588,11,23,-4.0,-3.5,0.005 -2015-10-17 01:10:32:619848,11,24,-4.0,-3.0,0.006 -2015-10-17 01:10:32:651909,11,25,-4.0,-2.5,0.007 -2015-10-17 01:10:32:688364,11,26,-4.0,-2.0,0.007 -2015-10-17 01:10:32:724821,11,27,-4.0,-1.5,0.008 -2015-10-17 01:10:32:760822,11,28,-4.0,-1.0,0.008 -2015-10-17 01:10:32:794209,11,29,-4.0,-0.5,0.009 -2015-10-17 01:10:32:830719,11,30,-4.0,0.0,0.009 -2015-10-17 01:10:32:862369,11,31,-4.0,0.5,0.009 -2015-10-17 01:10:32:893908,11,32,-4.0,1.0,0.008 -2015-10-17 01:10:32:925395,11,33,-4.0,1.5,0.008 -2015-10-17 01:10:32:959892,11,34,-4.0,2.0,0.007 -2015-10-17 01:10:32:993308,11,35,-4.0,2.5,0.007 -2015-10-17 01:10:33:028022,11,36,-4.0,3.0,0.006 -2015-10-17 01:10:33:064693,11,37,-4.0,3.5,0.005 -2015-10-17 01:10:33:096646,11,38,-4.0,4.0,0.005 -2015-10-17 01:10:33:127849,11,39,-4.0,4.5,0.004 -2015-10-17 01:10:33:159533,11,40,-4.0,5.0,0.004 -2015-10-17 01:10:33:191968,11,41,-4.0,5.5,0.004 -2015-10-17 01:10:33:226402,11,42,-4.0,6.0,0.005 -2015-10-17 01:10:33:226402,11,42,-4.0,6.0,0.005 -2015-10-17 01:10:33:259754,11,43,-4.0,6.5,0.005 -2015-10-17 01:10:33:292002,11,44,-4.0,7.0,0.006 -2015-10-17 01:10:33:324573,11,45,-4.0,7.5,0.007 -2015-10-17 01:10:33:359937,11,46,-4.0,8.0,0.007 -2015-10-17 01:10:33:391028,11,47,-4.0,8.5,0.008 -2015-10-17 01:10:33:423469,11,48,-4.0,9.0,0.008 -2015-10-17 01:10:33:458014,11,49,-4.0,9.5,0.009 -2015-10-17 01:10:33:494056,11,50,-4.0,10.0,0.009 -2015-10-17 01:10:33:529954,11,51,-4.0,10.5,0.009 -2015-10-17 01:10:33:564435,11,52,-4.0,11.0,0.008 -2015-10-17 01:10:33:598114,11,53,-4.0,11.5,0.008 -2015-10-17 01:10:33:631310,11,54,-4.0,12.0,0.007 -2015-10-17 01:10:33:662342,11,55,-4.0,12.5,0.007 -2015-10-17 01:10:33:697767,11,56,-4.0,13.0,0.006 -2015-10-17 01:10:33:729057,11,57,-4.0,13.5,0.005 -2015-10-17 01:10:33:764554,11,58,-4.0,14.0,0.005 -2015-10-17 01:10:33:796096,11,59,-4.0,14.5,0.004 -2015-10-17 01:10:33:796096,11,59,-4.0,14.5,0.004 -2015-10-17 01:10:34:801357,12,0,-3.0,-15.0,0.005 -2015-10-17 01:10:34:833013,12,1,-3.0,-14.5,0.005 -2015-10-17 01:10:34:868597,12,2,-3.0,-14.0,0.006 -2015-10-17 01:10:34:903122,12,3,-3.0,-13.5,0.007 -2015-10-17 01:10:34:937884,12,4,-3.0,-13.0,0.008 -2015-10-17 01:10:34:969113,12,5,-3.0,-12.5,0.009 -2015-10-17 01:10:35:001444,12,6,-3.0,-12.0,0.01 -2015-10-17 01:10:35:033598,12,7,-3.0,-11.5,0.012 -2015-10-17 01:10:35:068485,12,8,-3.0,-11.0,0.013 -2015-10-17 01:10:35:099317,12,9,-3.0,-10.5,0.014 -2015-10-17 01:10:35:133876,12,10,-3.0,-10.0,0.014 -2015-10-17 01:10:35:166939,12,11,-3.0,-9.5,0.014 -2015-10-17 01:10:35:203537,12,12,-3.0,-9.0,0.013 -2015-10-17 01:10:35:236236,12,13,-3.0,-8.5,0.012 -2015-10-17 01:10:35:269120,12,14,-3.0,-8.0,0.01 -2015-10-17 01:10:35:301476,12,15,-3.0,-7.5,0.009 -2015-10-17 01:10:35:334893,12,16,-3.0,-7.0,0.008 -2015-10-17 01:10:35:368570,12,17,-3.0,-6.5,0.007 -2015-10-17 01:10:35:401884,12,18,-3.0,-6.0,0.006 -2015-10-17 01:10:35:434940,12,19,-3.0,-5.5,0.005 -2015-10-17 01:10:35:434940,12,19,-3.0,-5.5,0.005 -2015-10-17 01:10:35:467225,12,20,-3.0,-5.0,0.005 -2015-10-17 01:10:35:500515,12,21,-3.0,-4.5,0.005 -2015-10-17 01:10:35:533066,12,22,-3.0,-4.0,0.006 -2015-10-17 01:10:35:566415,12,23,-3.0,-3.5,0.007 -2015-10-17 01:10:35:599512,12,24,-3.0,-3.0,0.008 -2015-10-17 01:10:35:632764,12,25,-3.0,-2.5,0.009 -2015-10-17 01:10:35:668293,12,26,-3.0,-2.0,0.01 -2015-10-17 01:10:35:704041,12,27,-3.0,-1.5,0.012 -2015-10-17 01:10:35:735827,12,28,-3.0,-1.0,0.013 -2015-10-17 01:10:35:767678,12,29,-3.0,-0.5,0.014 -2015-10-17 01:10:35:801069,12,30,-3.0,0.0,0.014 -2015-10-17 01:10:35:835052,12,31,-3.0,0.5,0.014 -2015-10-17 01:10:35:869602,12,32,-3.0,1.0,0.013 -2015-10-17 01:10:35:905255,12,33,-3.0,1.5,0.012 -2015-10-17 01:10:35:937313,12,34,-3.0,2.0,0.01 -2015-10-17 01:10:35:969789,12,35,-3.0,2.5,0.009 -2015-10-17 01:10:36:002821,12,36,-3.0,3.0,0.008 -2015-10-17 01:10:36:039253,12,37,-3.0,3.5,0.007 -2015-10-17 01:10:36:074871,12,38,-3.0,4.0,0.006 -2015-10-17 01:10:36:111777,12,39,-3.0,4.5,0.005 -2015-10-17 01:10:36:147072,12,40,-3.0,5.0,0.005 -2015-10-17 01:10:36:178781,12,41,-3.0,5.5,0.005 -2015-10-17 01:10:36:213706,12,42,-3.0,6.0,0.006 -2015-10-17 01:10:36:247251,12,43,-3.0,6.5,0.007 -2015-10-17 01:10:36:279905,12,44,-3.0,7.0,0.008 -2015-10-17 01:10:36:314815,12,45,-3.0,7.5,0.009 -2015-10-17 01:10:36:346770,12,46,-3.0,8.0,0.01 -2015-10-17 01:10:36:380148,12,47,-3.0,8.5,0.012 -2015-10-17 01:10:36:413682,12,48,-3.0,9.0,0.013 -2015-10-17 01:10:36:449233,12,49,-3.0,9.5,0.014 -2015-10-17 01:10:36:449233,12,49,-3.0,9.5,0.014 -2015-10-17 01:10:36:482006,12,50,-3.0,10.0,0.014 -2015-10-17 01:10:36:514250,12,51,-3.0,10.5,0.014 -2015-10-17 01:10:36:547241,12,52,-3.0,11.0,0.013 -2015-10-17 01:10:36:578618,12,53,-3.0,11.5,0.012 -2015-10-17 01:10:36:610677,12,54,-3.0,12.0,0.01 -2015-10-17 01:10:36:643942,12,55,-3.0,12.5,0.009 -2015-10-17 01:10:36:675134,12,56,-3.0,13.0,0.008 -2015-10-17 01:10:36:708962,12,57,-3.0,13.5,0.007 -2015-10-17 01:10:36:745213,12,58,-3.0,14.0,0.006 -2015-10-17 01:10:36:779664,12,59,-3.0,14.5,0.005 -2015-10-17 01:10:36:779664,12,59,-3.0,14.5,0.005 -2015-10-17 01:10:37:782602,13,0,-2.0,-15.0,0.005 -2015-10-17 01:10:37:817903,13,1,-2.0,-14.5,0.006 -2015-10-17 01:10:37:852603,13,2,-2.0,-14.0,0.007 -2015-10-17 01:10:37:884308,13,3,-2.0,-13.5,0.009 -2015-10-17 01:10:37:916651,13,4,-2.0,-13.0,0.01 -2015-10-17 01:10:37:948474,13,5,-2.0,-12.5,0.013 -2015-10-17 01:10:37:980715,13,6,-2.0,-12.0,0.016 -2015-10-17 01:10:38:012821,13,7,-2.0,-11.5,0.019 -2015-10-17 01:10:38:044653,13,8,-2.0,-11.0,0.023 -2015-10-17 01:10:38:076797,13,9,-2.0,-10.5,0.026 -2015-10-17 01:10:38:108714,13,10,-2.0,-10.0,0.027 -2015-10-17 01:10:38:140965,13,11,-2.0,-9.5,0.026 -2015-10-17 01:10:38:172771,13,12,-2.0,-9.0,0.023 -2015-10-17 01:10:38:204737,13,13,-2.0,-8.5,0.019 -2015-10-17 01:10:38:236901,13,14,-2.0,-8.0,0.016 -2015-10-17 01:10:38:268703,13,15,-2.0,-7.5,0.013 -2015-10-17 01:10:38:300949,13,16,-2.0,-7.0,0.01 -2015-10-17 01:10:38:332737,13,17,-2.0,-6.5,0.009 -2015-10-17 01:10:38:368612,13,18,-2.0,-6.0,0.007 -2015-10-17 01:10:38:405154,13,19,-2.0,-5.5,0.006 -2015-10-17 01:10:38:436954,13,20,-2.0,-5.0,0.005 -2015-10-17 01:10:38:469202,13,21,-2.0,-4.5,0.006 -2015-10-17 01:10:38:501054,13,22,-2.0,-4.0,0.007 -2015-10-17 01:10:38:533250,13,23,-2.0,-3.5,0.009 -2015-10-17 01:10:38:565171,13,24,-2.0,-3.0,0.01 -2015-10-17 01:10:38:597043,13,25,-2.0,-2.5,0.013 -2015-10-17 01:10:38:597043,13,25,-2.0,-2.5,0.013 -2015-10-17 01:10:38:629184,13,26,-2.0,-2.0,0.016 -2015-10-17 01:10:38:661294,13,27,-2.0,-1.5,0.019 -2015-10-17 01:10:38:692835,13,28,-2.0,-1.0,0.023 -2015-10-17 01:10:38:725274,13,29,-2.0,-0.5,0.026 -2015-10-17 01:10:38:757241,13,30,-2.0,0.0,0.027 -2015-10-17 01:10:38:791167,13,31,-2.0,0.5,0.026 -2015-10-17 01:10:38:827091,13,32,-2.0,1.0,0.023 -2015-10-17 01:10:38:861567,13,33,-2.0,1.5,0.019 -2015-10-17 01:10:38:893717,13,34,-2.0,2.0,0.016 -2015-10-17 01:10:38:925250,13,35,-2.0,2.5,0.013 -2015-10-17 01:10:38:957484,13,36,-2.0,3.0,0.01 -2015-10-17 01:10:38:989346,13,37,-2.0,3.5,0.009 -2015-10-17 01:10:39:023374,13,38,-2.0,4.0,0.007 -2015-10-17 01:10:39:059324,13,39,-2.0,4.5,0.006 -2015-10-17 01:10:39:096909,13,40,-2.0,5.0,0.005 -2015-10-17 01:10:39:133291,13,41,-2.0,5.5,0.006 -2015-10-17 01:10:39:168127,13,42,-2.0,6.0,0.007 -2015-10-17 01:10:39:204848,13,43,-2.0,6.5,0.009 -2015-10-17 01:10:39:237581,13,44,-2.0,7.0,0.01 -2015-10-17 01:10:39:269603,13,45,-2.0,7.5,0.013 -2015-10-17 01:10:39:301821,13,46,-2.0,8.0,0.016 -2015-10-17 01:10:39:333904,13,47,-2.0,8.5,0.019 -2015-10-17 01:10:39:365796,13,48,-2.0,9.0,0.023 -2015-10-17 01:10:39:400213,13,49,-2.0,9.5,0.026 -2015-10-17 01:10:39:436944,13,50,-2.0,10.0,0.027 -2015-10-17 01:10:39:470586,13,51,-2.0,10.5,0.026 -2015-10-17 01:10:39:502039,13,52,-2.0,11.0,0.023 -2015-10-17 01:10:39:534007,13,53,-2.0,11.5,0.019 -2015-10-17 01:10:39:565876,13,54,-2.0,12.0,0.016 -2015-10-17 01:10:39:598040,13,55,-2.0,12.5,0.013 -2015-10-17 01:10:39:598040,13,55,-2.0,12.5,0.013 -2015-10-17 01:10:39:629873,13,56,-2.0,13.0,0.01 -2015-10-17 01:10:39:662106,13,57,-2.0,13.5,0.009 -2015-10-17 01:10:39:693855,13,58,-2.0,14.0,0.007 -2015-10-17 01:10:39:726277,13,59,-2.0,14.5,0.006 -2015-10-17 01:10:40:732449,14,0,-1.0,-15.0,0.006 -2015-10-17 01:10:40:732449,14,0,-1.0,-15.0,0.006 -2015-10-17 01:10:40:769215,14,1,-1.0,-14.5,0.007 -2015-10-17 01:10:40:805330,14,2,-1.0,-14.0,0.008 -2015-10-17 01:10:40:839536,14,3,-1.0,-13.5,0.01 -2015-10-17 01:10:40:871268,14,4,-1.0,-13.0,0.013 -2015-10-17 01:10:40:903439,14,5,-1.0,-12.5,0.017 -2015-10-17 01:10:40:939642,14,6,-1.0,-12.0,0.023 -2015-10-17 01:10:40:975445,14,7,-1.0,-11.5,0.031 -2015-10-17 01:10:41:007307,14,8,-1.0,-11.0,0.044 -2015-10-17 01:10:41:039232,14,9,-1.0,-10.5,0.057 -2015-10-17 01:10:41:071356,14,10,-1.0,-10.0,0.064 -2015-10-17 01:10:41:103454,14,11,-1.0,-9.5,0.057 -2015-10-17 01:10:41:139194,14,12,-1.0,-9.0,0.044 -2015-10-17 01:10:41:175443,14,13,-1.0,-8.5,0.031 -2015-10-17 01:10:41:207636,14,14,-1.0,-8.0,0.023 -2015-10-17 01:10:41:239454,14,15,-1.0,-7.5,0.017 -2015-10-17 01:10:41:271622,14,16,-1.0,-7.0,0.013 -2015-10-17 01:10:41:303567,14,17,-1.0,-6.5,0.01 -2015-10-17 01:10:41:335670,14,18,-1.0,-6.0,0.008 -2015-10-17 01:10:41:367882,14,19,-1.0,-5.5,0.007 -2015-10-17 01:10:41:399720,14,20,-1.0,-5.0,0.006 -2015-10-17 01:10:41:431651,14,21,-1.0,-4.5,0.007 -2015-10-17 01:10:41:463999,14,22,-1.0,-4.0,0.008 -2015-10-17 01:10:41:495840,14,23,-1.0,-3.5,0.01 -2015-10-17 01:10:41:527900,14,24,-1.0,-3.0,0.013 -2015-10-17 01:10:41:559802,14,25,-1.0,-2.5,0.017 -2015-10-17 01:10:41:591746,14,26,-1.0,-2.0,0.023 -2015-10-17 01:10:41:623960,14,27,-1.0,-1.5,0.031 -2015-10-17 01:10:41:655740,14,28,-1.0,-1.0,0.044 -2015-10-17 01:10:41:688025,14,29,-1.0,-0.5,0.057 -2015-10-17 01:10:41:719896,14,30,-1.0,0.0,0.064 -2015-10-17 01:10:41:752234,14,31,-1.0,0.5,0.057 -2015-10-17 01:10:41:752234,14,31,-1.0,0.5,0.057 -2015-10-17 01:10:41:788094,14,32,-1.0,1.0,0.044 -2015-10-17 01:10:41:824142,14,33,-1.0,1.5,0.031 -2015-10-17 01:10:41:855969,14,34,-1.0,2.0,0.023 -2015-10-17 01:10:41:888292,14,35,-1.0,2.5,0.017 -2015-10-17 01:10:41:920584,14,36,-1.0,3.0,0.013 -2015-10-17 01:10:41:957020,14,37,-1.0,3.5,0.01 -2015-10-17 01:10:41:992257,14,38,-1.0,4.0,0.008 -2015-10-17 01:10:42:024410,14,39,-1.0,4.5,0.007 -2015-10-17 01:10:42:056225,14,40,-1.0,5.0,0.006 -2015-10-17 01:10:42:088406,14,41,-1.0,5.5,0.007 -2015-10-17 01:10:42:120235,14,42,-1.0,6.0,0.008 -2015-10-17 01:10:42:152442,14,43,-1.0,6.5,0.01 -2015-10-17 01:10:42:184607,14,44,-1.0,7.0,0.013 -2015-10-17 01:10:42:216432,14,45,-1.0,7.5,0.017 -2015-10-17 01:10:42:248661,14,46,-1.0,8.0,0.023 -2015-10-17 01:10:42:280524,14,47,-1.0,8.5,0.031 -2015-10-17 01:10:42:311918,14,48,-1.0,9.0,0.044 -2015-10-17 01:10:42:344458,14,49,-1.0,9.5,0.057 -2015-10-17 01:10:42:376569,14,50,-1.0,10.0,0.064 -2015-10-17 01:10:42:408761,14,51,-1.0,10.5,0.057 -2015-10-17 01:10:42:440593,14,52,-1.0,11.0,0.044 -2015-10-17 01:10:42:475944,14,53,-1.0,11.5,0.031 -2015-10-17 01:10:42:512583,14,54,-1.0,12.0,0.023 -2015-10-17 01:10:42:544975,14,55,-1.0,12.5,0.017 -2015-10-17 01:10:42:576730,14,56,-1.0,13.0,0.013 -2015-10-17 01:10:42:608565,14,57,-1.0,13.5,0.01 -2015-10-17 01:10:42:640772,14,58,-1.0,14.0,0.008 -2015-10-17 01:10:42:672808,14,59,-1.0,14.5,0.007 -2015-10-17 01:10:42:672808,14,59,-1.0,14.5,0.007 -2015-10-17 01:10:43:674196,15,0,0.0,-15.0,0.006 -2015-10-17 01:10:43:705178,15,1,0.0,-14.5,0.007 -2015-10-17 01:10:43:737643,15,2,0.0,-14.0,0.009 -2015-10-17 01:10:43:769496,15,3,0.0,-13.5,0.011 -2015-10-17 01:10:43:802409,15,4,0.0,-13.0,0.014 -2015-10-17 01:10:43:833887,15,5,0.0,-12.5,0.019 -2015-10-17 01:10:43:865884,15,6,0.0,-12.0,0.027 -2015-10-17 01:10:43:897732,15,7,0.0,-11.5,0.04 -2015-10-17 01:10:43:897732,15,7,0.0,-11.5,0.04 -2015-10-17 01:10:43:929867,15,8,0.0,-11.0,0.064 -2015-10-17 01:10:43:961839,15,9,0.0,-10.5,0.099 -2015-10-17 01:10:43:994016,15,10,0.0,-10.0,0.117 -2015-10-17 01:10:44:026173,15,11,0.0,-9.5,0.099 -2015-10-17 01:10:44:057846,15,12,0.0,-9.0,0.064 -2015-10-17 01:10:44:090152,15,13,0.0,-8.5,0.04 -2015-10-17 01:10:44:121995,15,14,0.0,-8.0,0.027 -2015-10-17 01:10:44:157979,15,15,0.0,-7.5,0.019 -2015-10-17 01:10:44:194019,15,16,0.0,-7.0,0.014 -2015-10-17 01:10:44:226181,15,17,0.0,-6.5,0.011 -2015-10-17 01:10:44:258646,15,18,0.0,-6.0,0.009 -2015-10-17 01:10:44:292891,15,19,0.0,-5.5,0.007 -2015-10-17 01:10:44:329597,15,20,0.0,-5.0,0.006 -2015-10-17 01:10:44:365674,15,21,0.0,-4.5,0.007 -2015-10-17 01:10:44:402286,15,22,0.0,-4.0,0.009 -2015-10-17 01:10:44:434272,15,23,0.0,-3.5,0.011 -2015-10-17 01:10:44:466428,15,24,0.0,-3.0,0.014 -2015-10-17 01:10:44:498276,15,25,0.0,-2.5,0.019 -2015-10-17 01:10:44:530819,15,26,0.0,-2.0,0.027 -2015-10-17 01:10:44:562542,15,27,0.0,-1.5,0.04 -2015-10-17 01:10:44:594489,15,28,0.0,-1.0,0.064 -2015-10-17 01:10:44:626714,15,29,0.0,-0.5,0.099 -2015-10-17 01:10:44:658497,15,30,0.0,0.0,0.117 -2015-10-17 01:10:44:690395,15,31,0.0,0.5,0.099 -2015-10-17 01:10:44:722596,15,32,0.0,1.0,0.064 -2015-10-17 01:10:44:754770,15,33,0.0,1.5,0.04 -2015-10-17 01:10:44:788716,15,34,0.0,2.0,0.027 -2015-10-17 01:10:44:820347,15,35,0.0,2.5,0.019 -2015-10-17 01:10:44:852385,15,36,0.0,3.0,0.014 -2015-10-17 01:10:44:888365,15,37,0.0,3.5,0.011 -2015-10-17 01:10:44:921977,15,38,0.0,4.0,0.009 -2015-10-17 01:10:44:921977,15,38,0.0,4.0,0.009 -2015-10-17 01:10:44:954711,15,39,0.0,4.5,0.007 -2015-10-17 01:10:44:986749,15,40,0.0,5.0,0.006 -2015-10-17 01:10:45:019608,15,41,0.0,5.5,0.007 -2015-10-17 01:10:45:054430,15,42,0.0,6.0,0.009 -2015-10-17 01:10:45:090886,15,43,0.0,6.5,0.011 -2015-10-17 01:10:45:122782,15,44,0.0,7.0,0.014 -2015-10-17 01:10:45:154849,15,45,0.0,7.5,0.019 -2015-10-17 01:10:45:187052,15,46,0.0,8.0,0.027 -2015-10-17 01:10:45:219120,15,47,0.0,8.5,0.04 -2015-10-17 01:10:45:250880,15,48,0.0,9.0,0.064 -2015-10-17 01:10:45:282932,15,49,0.0,9.5,0.099 -2015-10-17 01:10:45:315042,15,50,0.0,10.0,0.117 -2015-10-17 01:10:45:347210,15,51,0.0,10.5,0.099 -2015-10-17 01:10:45:379076,15,52,0.0,11.0,0.064 -2015-10-17 01:10:45:412034,15,53,0.0,11.5,0.04 -2015-10-17 01:10:45:443453,15,54,0.0,12.0,0.027 -2015-10-17 01:10:45:475384,15,55,0.0,12.5,0.019 -2015-10-17 01:10:45:507111,15,56,0.0,13.0,0.014 -2015-10-17 01:10:45:539206,15,57,0.0,13.5,0.011 -2015-10-17 01:10:45:575201,15,58,0.0,14.0,0.009 -2015-10-17 01:10:45:611443,15,59,0.0,14.5,0.007 -2015-10-17 01:10:45:611443,15,59,0.0,14.5,0.007 -2015-10-17 01:10:46:618067,16,0,1.0,-15.0,0.006 -2015-10-17 01:10:46:652265,16,1,1.0,-14.5,0.007 -2015-10-17 01:10:46:684138,16,2,1.0,-14.0,0.008 -2015-10-17 01:10:46:716399,16,3,1.0,-13.5,0.01 -2015-10-17 01:10:46:748485,16,4,1.0,-13.0,0.013 -2015-10-17 01:10:46:780415,16,5,1.0,-12.5,0.017 -2015-10-17 01:10:46:812238,16,6,1.0,-12.0,0.023 -2015-10-17 01:10:46:844230,16,7,1.0,-11.5,0.031 -2015-10-17 01:10:46:876321,16,8,1.0,-11.0,0.044 -2015-10-17 01:10:46:908529,16,9,1.0,-10.5,0.057 -2015-10-17 01:10:46:940217,16,10,1.0,-10.0,0.064 -2015-10-17 01:10:46:972378,16,11,1.0,-9.5,0.057 -2015-10-17 01:10:47:004527,16,12,1.0,-9.0,0.044 -2015-10-17 01:10:47:036065,16,13,1.0,-8.5,0.031 -2015-10-17 01:10:47:036065,16,13,1.0,-8.5,0.031 -2015-10-17 01:10:47:068387,16,14,1.0,-8.0,0.023 -2015-10-17 01:10:47:105150,16,15,1.0,-7.5,0.017 -2015-10-17 01:10:47:140568,16,16,1.0,-7.0,0.013 -2015-10-17 01:10:47:174319,16,17,1.0,-6.5,0.01 -2015-10-17 01:10:47:205956,16,18,1.0,-6.0,0.008 -2015-10-17 01:10:47:241952,16,19,1.0,-5.5,0.007 -2015-10-17 01:10:47:276796,16,20,1.0,-5.0,0.006 -2015-10-17 01:10:47:313184,16,21,1.0,-4.5,0.007 -2015-10-17 01:10:47:348584,16,22,1.0,-4.0,0.008 -2015-10-17 01:10:47:380592,16,23,1.0,-3.5,0.01 -2015-10-17 01:10:47:412661,16,24,1.0,-3.0,0.013 -2015-10-17 01:10:47:444385,16,25,1.0,-2.5,0.017 -2015-10-17 01:10:47:477230,16,26,1.0,-2.0,0.023 -2015-10-17 01:10:47:509341,16,27,1.0,-1.5,0.031 -2015-10-17 01:10:47:541054,16,28,1.0,-1.0,0.044 -2015-10-17 01:10:47:571718,16,29,1.0,-0.5,0.057 -2015-10-17 01:10:47:604803,16,30,1.0,0.0,0.064 -2015-10-17 01:10:47:636337,16,31,1.0,0.5,0.057 -2015-10-17 01:10:47:669089,16,32,1.0,1.0,0.044 -2015-10-17 01:10:47:700753,16,33,1.0,1.5,0.031 -2015-10-17 01:10:47:732645,16,34,1.0,2.0,0.023 -2015-10-17 01:10:47:764960,16,35,1.0,2.5,0.017 -2015-10-17 01:10:47:796511,16,36,1.0,3.0,0.013 -2015-10-17 01:10:47:833093,16,37,1.0,3.5,0.01 -2015-10-17 01:10:47:868475,16,38,1.0,4.0,0.008 -2015-10-17 01:10:47:901144,16,39,1.0,4.5,0.007 -2015-10-17 01:10:47:932982,16,40,1.0,5.0,0.006 -2015-10-17 01:10:47:965298,16,41,1.0,5.5,0.007 -2015-10-17 01:10:48:001409,16,42,1.0,6.0,0.008 -2015-10-17 01:10:48:033205,16,43,1.0,6.5,0.01 -2015-10-17 01:10:48:068000,16,44,1.0,7.0,0.013 -2015-10-17 01:10:48:068000,16,44,1.0,7.0,0.013 -2015-10-17 01:10:48:099689,16,45,1.0,7.5,0.017 -2015-10-17 01:10:48:133055,16,46,1.0,8.0,0.023 -2015-10-17 01:10:48:165841,16,47,1.0,8.5,0.031 -2015-10-17 01:10:48:199018,16,48,1.0,9.0,0.044 -2015-10-17 01:10:48:232399,16,49,1.0,9.5,0.057 -2015-10-17 01:10:48:268852,16,50,1.0,10.0,0.064 -2015-10-17 01:10:48:303420,16,51,1.0,10.5,0.057 -2015-10-17 01:10:48:339155,16,52,1.0,11.0,0.044 -2015-10-17 01:10:48:373513,16,53,1.0,11.5,0.031 -2015-10-17 01:10:48:405915,16,54,1.0,12.0,0.023 -2015-10-17 01:10:48:437756,16,55,1.0,12.5,0.017 -2015-10-17 01:10:48:469466,16,56,1.0,13.0,0.013 -2015-10-17 01:10:48:503485,16,57,1.0,13.5,0.01 -2015-10-17 01:10:48:539446,16,58,1.0,14.0,0.008 -2015-10-17 01:10:48:573648,16,59,1.0,14.5,0.007 -2015-10-17 01:10:48:573648,16,59,1.0,14.5,0.007 -2015-10-17 01:10:49:579612,17,0,2.0,-15.0,0.005 -2015-10-17 01:10:49:614300,17,1,2.0,-14.5,0.006 -2015-10-17 01:10:49:648287,17,2,2.0,-14.0,0.007 -2015-10-17 01:10:49:679218,17,3,2.0,-13.5,0.009 -2015-10-17 01:10:49:716521,17,4,2.0,-13.0,0.01 -2015-10-17 01:10:49:752469,17,5,2.0,-12.5,0.013 -2015-10-17 01:10:49:788368,17,6,2.0,-12.0,0.016 -2015-10-17 01:10:49:822220,17,7,2.0,-11.5,0.019 -2015-10-17 01:10:49:854557,17,8,2.0,-11.0,0.023 -2015-10-17 01:10:49:886535,17,9,2.0,-10.5,0.026 -2015-10-17 01:10:49:918487,17,10,2.0,-10.0,0.027 -2015-10-17 01:10:49:950747,17,11,2.0,-9.5,0.026 -2015-10-17 01:10:49:982810,17,12,2.0,-9.0,0.023 -2015-10-17 01:10:50:014878,17,13,2.0,-8.5,0.019 -2015-10-17 01:10:50:046964,17,14,2.0,-8.0,0.016 -2015-10-17 01:10:50:079993,17,15,2.0,-7.5,0.013 -2015-10-17 01:10:50:111543,17,16,2.0,-7.0,0.01 -2015-10-17 01:10:50:143337,17,17,2.0,-6.5,0.009 -2015-10-17 01:10:50:174979,17,18,2.0,-6.0,0.007 -2015-10-17 01:10:50:210675,17,19,2.0,-5.5,0.006 -2015-10-17 01:10:50:210675,17,19,2.0,-5.5,0.006 -2015-10-17 01:10:50:246665,17,20,2.0,-5.0,0.005 -2015-10-17 01:10:50:279098,17,21,2.0,-4.5,0.006 -2015-10-17 01:10:50:311641,17,22,2.0,-4.0,0.007 -2015-10-17 01:10:50:346414,17,23,2.0,-3.5,0.009 -2015-10-17 01:10:50:377322,17,24,2.0,-3.0,0.01 -2015-10-17 01:10:50:412656,17,25,2.0,-2.5,0.013 -2015-10-17 01:10:50:447001,17,26,2.0,-2.0,0.016 -2015-10-17 01:10:50:479275,17,27,2.0,-1.5,0.019 -2015-10-17 01:10:50:512964,17,28,2.0,-1.0,0.023 -2015-10-17 01:10:50:544241,17,29,2.0,-0.5,0.026 -2015-10-17 01:10:50:575797,17,30,2.0,0.0,0.027 -2015-10-17 01:10:50:607256,17,31,2.0,0.5,0.026 -2015-10-17 01:10:50:638767,17,32,2.0,1.0,0.023 -2015-10-17 01:10:50:670021,17,33,2.0,1.5,0.019 -2015-10-17 01:10:50:702297,17,34,2.0,2.0,0.016 -2015-10-17 01:10:50:733879,17,35,2.0,2.5,0.013 -2015-10-17 01:10:50:765960,17,36,2.0,3.0,0.01 -2015-10-17 01:10:50:797875,17,37,2.0,3.5,0.009 -2015-10-17 01:10:50:833493,17,38,2.0,4.0,0.007 -2015-10-17 01:10:50:870102,17,39,2.0,4.5,0.006 -2015-10-17 01:10:50:902061,17,40,2.0,5.0,0.005 -2015-10-17 01:10:50:934057,17,41,2.0,5.5,0.006 -2015-10-17 01:10:50:965827,17,42,2.0,6.0,0.007 -2015-10-17 01:10:50:997808,17,43,2.0,6.5,0.009 -2015-10-17 01:10:51:030209,17,44,2.0,7.0,0.01 -2015-10-17 01:10:51:064831,17,45,2.0,7.5,0.013 -2015-10-17 01:10:51:098244,17,46,2.0,8.0,0.016 -2015-10-17 01:10:51:130266,17,47,2.0,8.5,0.019 -2015-10-17 01:10:51:162065,17,48,2.0,9.0,0.023 -2015-10-17 01:10:51:194425,17,49,2.0,9.5,0.026 -2015-10-17 01:10:51:226624,17,50,2.0,10.0,0.027 -2015-10-17 01:10:51:226624,17,50,2.0,10.0,0.027 -2015-10-17 01:10:51:258378,17,51,2.0,10.5,0.026 -2015-10-17 01:10:51:290278,17,52,2.0,11.0,0.023 -2015-10-17 01:10:51:322402,17,53,2.0,11.5,0.019 -2015-10-17 01:10:51:354891,17,54,2.0,12.0,0.016 -2015-10-17 01:10:51:386249,17,55,2.0,12.5,0.013 -2015-10-17 01:10:51:418632,17,56,2.0,13.0,0.01 -2015-10-17 01:10:51:450560,17,57,2.0,13.5,0.009 -2015-10-17 01:10:51:482558,17,58,2.0,14.0,0.007 -2015-10-17 01:10:51:514369,17,59,2.0,14.5,0.006 -2015-10-17 01:10:51:514369,17,59,2.0,14.5,0.006 -2015-10-17 01:10:52:516889,18,0,3.0,-15.0,0.005 -2015-10-17 01:10:52:550884,18,1,3.0,-14.5,0.005 -2015-10-17 01:10:52:586916,18,2,3.0,-14.0,0.006 -2015-10-17 01:10:52:620655,18,3,3.0,-13.5,0.007 -2015-10-17 01:10:52:655002,18,4,3.0,-13.0,0.008 -2015-10-17 01:10:52:691775,18,5,3.0,-12.5,0.009 -2015-10-17 01:10:52:724189,18,6,3.0,-12.0,0.01 -2015-10-17 01:10:52:755669,18,7,3.0,-11.5,0.012 -2015-10-17 01:10:52:788121,18,8,3.0,-11.0,0.013 -2015-10-17 01:10:52:820401,18,9,3.0,-10.5,0.014 -2015-10-17 01:10:52:855171,18,10,3.0,-10.0,0.014 -2015-10-17 01:10:52:891846,18,11,3.0,-9.5,0.014 -2015-10-17 01:10:52:927359,18,12,3.0,-9.0,0.013 -2015-10-17 01:10:52:960741,18,13,3.0,-8.5,0.012 -2015-10-17 01:10:52:996452,18,14,3.0,-8.0,0.01 -2015-10-17 01:10:53:028383,18,15,3.0,-7.5,0.009 -2015-10-17 01:10:53:060338,18,16,3.0,-7.0,0.008 -2015-10-17 01:10:53:092582,18,17,3.0,-6.5,0.007 -2015-10-17 01:10:53:124500,18,18,3.0,-6.0,0.006 -2015-10-17 01:10:53:158837,18,19,3.0,-5.5,0.005 -2015-10-17 01:10:53:195554,18,20,3.0,-5.0,0.005 -2015-10-17 01:10:53:228610,18,21,3.0,-4.5,0.005 -2015-10-17 01:10:53:260507,18,22,3.0,-4.0,0.006 -2015-10-17 01:10:53:292701,18,23,3.0,-3.5,0.007 -2015-10-17 01:10:53:324687,18,24,3.0,-3.0,0.008 -2015-10-17 01:10:53:324687,18,24,3.0,-3.0,0.008 -2015-10-17 01:10:53:356698,18,25,3.0,-2.5,0.009 -2015-10-17 01:10:53:388744,18,26,3.0,-2.0,0.01 -2015-10-17 01:10:53:420715,18,27,3.0,-1.5,0.012 -2015-10-17 01:10:53:452862,18,28,3.0,-1.0,0.013 -2015-10-17 01:10:53:484281,18,29,3.0,-0.5,0.014 -2015-10-17 01:10:53:515794,18,30,3.0,0.0,0.014 -2015-10-17 01:10:53:553133,18,31,3.0,0.5,0.014 -2015-10-17 01:10:53:588871,18,32,3.0,1.0,0.013 -2015-10-17 01:10:53:624773,18,33,3.0,1.5,0.012 -2015-10-17 01:10:53:660958,18,34,3.0,2.0,0.01 -2015-10-17 01:10:53:694848,18,35,3.0,2.5,0.009 -2015-10-17 01:10:53:730788,18,36,3.0,3.0,0.008 -2015-10-17 01:10:53:767060,18,37,3.0,3.5,0.007 -2015-10-17 01:10:53:803818,18,38,3.0,4.0,0.006 -2015-10-17 01:10:53:836988,18,39,3.0,4.5,0.005 -2015-10-17 01:10:53:868731,18,40,3.0,5.0,0.005 -2015-10-17 01:10:53:900976,18,41,3.0,5.5,0.005 -2015-10-17 01:10:53:933003,18,42,3.0,6.0,0.006 -2015-10-17 01:10:53:964657,18,43,3.0,6.5,0.007 -2015-10-17 01:10:53:997256,18,44,3.0,7.0,0.008 -2015-10-17 01:10:54:029396,18,45,3.0,7.5,0.009 -2015-10-17 01:10:54:062899,18,46,3.0,8.0,0.01 -2015-10-17 01:10:54:094614,18,47,3.0,8.5,0.012 -2015-10-17 01:10:54:126909,18,48,3.0,9.0,0.013 -2015-10-17 01:10:54:158845,18,49,3.0,9.5,0.014 -2015-10-17 01:10:54:191154,18,50,3.0,10.0,0.014 -2015-10-17 01:10:54:222688,18,51,3.0,10.5,0.014 -2015-10-17 01:10:54:255124,18,52,3.0,11.0,0.013 -2015-10-17 01:10:54:287487,18,53,3.0,11.5,0.012 -2015-10-17 01:10:54:320997,18,54,3.0,12.0,0.01 -2015-10-17 01:10:54:353688,18,55,3.0,12.5,0.009 -2015-10-17 01:10:54:353688,18,55,3.0,12.5,0.009 -2015-10-17 01:10:54:387856,18,56,3.0,13.0,0.008 -2015-10-17 01:10:54:421267,18,57,3.0,13.5,0.007 -2015-10-17 01:10:54:454876,18,58,3.0,14.0,0.006 -2015-10-17 01:10:54:487015,18,59,3.0,14.5,0.005 -2015-10-17 01:10:55:491509,19,0,4.0,-15.0,0.004 -2015-10-17 01:10:55:491509,19,0,4.0,-15.0,0.004 -2015-10-17 01:10:55:525259,19,1,4.0,-14.5,0.004 -2015-10-17 01:10:55:560158,19,2,4.0,-14.0,0.005 -2015-10-17 01:10:55:592082,19,3,4.0,-13.5,0.005 -2015-10-17 01:10:55:624214,19,4,4.0,-13.0,0.006 -2015-10-17 01:10:55:655868,19,5,4.0,-12.5,0.007 -2015-10-17 01:10:55:688442,19,6,4.0,-12.0,0.007 -2015-10-17 01:10:55:720774,19,7,4.0,-11.5,0.008 -2015-10-17 01:10:55:751694,19,8,4.0,-11.0,0.008 -2015-10-17 01:10:55:784224,19,9,4.0,-10.5,0.009 -2015-10-17 01:10:55:820050,19,10,4.0,-10.0,0.009 -2015-10-17 01:10:55:856558,19,11,4.0,-9.5,0.009 -2015-10-17 01:10:55:891644,19,12,4.0,-9.0,0.008 -2015-10-17 01:10:55:928483,19,13,4.0,-8.5,0.008 -2015-10-17 01:10:55:960345,19,14,4.0,-8.0,0.007 -2015-10-17 01:10:55:992101,19,15,4.0,-7.5,0.007 -2015-10-17 01:10:56:026438,19,16,4.0,-7.0,0.006 -2015-10-17 01:10:56:062355,19,17,4.0,-6.5,0.005 -2015-10-17 01:10:56:094068,19,18,4.0,-6.0,0.005 -2015-10-17 01:10:56:128777,19,19,4.0,-5.5,0.004 -2015-10-17 01:10:56:160775,19,20,4.0,-5.0,0.004 -2015-10-17 01:10:56:192965,19,21,4.0,-4.5,0.004 -2015-10-17 01:10:56:227479,19,22,4.0,-4.0,0.005 -2015-10-17 01:10:56:264189,19,23,4.0,-3.5,0.005 -2015-10-17 01:10:56:296857,19,24,4.0,-3.0,0.006 -2015-10-17 01:10:56:328855,19,25,4.0,-2.5,0.007 -2015-10-17 01:10:56:360855,19,26,4.0,-2.0,0.007 -2015-10-17 01:10:56:397134,19,27,4.0,-1.5,0.008 -2015-10-17 01:10:56:432816,19,28,4.0,-1.0,0.008 -2015-10-17 01:10:56:464956,19,29,4.0,-0.5,0.009 -2015-10-17 01:10:56:497468,19,30,4.0,0.0,0.009 -2015-10-17 01:10:56:497468,19,30,4.0,0.0,0.009 -2015-10-17 01:10:56:529321,19,31,4.0,0.5,0.009 -2015-10-17 01:10:56:561397,19,32,4.0,1.0,0.008 -2015-10-17 01:10:56:593386,19,33,4.0,1.5,0.008 -2015-10-17 01:10:56:625089,19,34,4.0,2.0,0.007 -2015-10-17 01:10:56:659148,19,35,4.0,2.5,0.007 -2015-10-17 01:10:56:690567,19,36,4.0,3.0,0.006 -2015-10-17 01:10:56:725212,19,37,4.0,3.5,0.005 -2015-10-17 01:10:56:759211,19,38,4.0,4.0,0.005 -2015-10-17 01:10:56:793342,19,39,4.0,4.5,0.004 -2015-10-17 01:10:56:825180,19,40,4.0,5.0,0.004 -2015-10-17 01:10:56:857248,19,41,4.0,5.5,0.004 -2015-10-17 01:10:56:889178,19,42,4.0,6.0,0.005 -2015-10-17 01:10:56:921346,19,43,4.0,6.5,0.005 -2015-10-17 01:10:56:955909,19,44,4.0,7.0,0.006 -2015-10-17 01:10:56:992607,19,45,4.0,7.5,0.007 -2015-10-17 01:10:57:027002,19,46,4.0,8.0,0.007 -2015-10-17 01:10:57:065293,19,47,4.0,8.5,0.008 -2015-10-17 01:10:57:097448,19,48,4.0,9.0,0.008 -2015-10-17 01:10:57:129601,19,49,4.0,9.5,0.009 -2015-10-17 01:10:57:161665,19,50,4.0,10.0,0.009 -2015-10-17 01:10:57:193478,19,51,4.0,10.5,0.009 -2015-10-17 01:10:57:225552,19,52,4.0,11.0,0.008 -2015-10-17 01:10:57:257606,19,53,4.0,11.5,0.008 -2015-10-17 01:10:57:289724,19,54,4.0,12.0,0.007 -2015-10-17 01:10:57:321258,19,55,4.0,12.5,0.007 -2015-10-17 01:10:57:353929,19,56,4.0,13.0,0.006 -2015-10-17 01:10:57:385770,19,57,4.0,13.5,0.005 -2015-10-17 01:10:57:417684,19,58,4.0,14.0,0.005 -2015-10-17 01:10:57:453743,19,59,4.0,14.5,0.004 -2015-10-17 01:10:57:453743,19,59,4.0,14.5,0.004 -2015-10-17 01:10:58:458789,20,0,5.0,-15.0,0.003 -2015-10-17 01:10:58:492782,20,1,5.0,-14.5,0.004 -2015-10-17 01:10:58:529277,20,2,5.0,-14.0,0.004 -2015-10-17 01:10:58:562963,20,3,5.0,-13.5,0.004 -2015-10-17 01:10:58:594849,20,4,5.0,-13.0,0.005 -2015-10-17 01:10:58:626813,20,5,5.0,-12.5,0.005 -2015-10-17 01:10:58:658968,20,6,5.0,-12.0,0.005 -2015-10-17 01:10:58:658968,20,6,5.0,-12.0,0.005 -2015-10-17 01:10:58:689740,20,7,5.0,-11.5,0.006 -2015-10-17 01:10:58:722383,20,8,5.0,-11.0,0.006 -2015-10-17 01:10:58:755003,20,9,5.0,-10.5,0.006 -2015-10-17 01:10:58:790956,20,10,5.0,-10.0,0.006 -2015-10-17 01:10:58:826899,20,11,5.0,-9.5,0.006 -2015-10-17 01:10:58:859138,20,12,5.0,-9.0,0.006 -2015-10-17 01:10:58:891593,20,13,5.0,-8.5,0.006 -2015-10-17 01:10:58:927239,20,14,5.0,-8.0,0.005 -2015-10-17 01:10:58:962229,20,15,5.0,-7.5,0.005 -2015-10-17 01:10:58:995214,20,16,5.0,-7.0,0.005 -2015-10-17 01:10:59:027679,20,17,5.0,-6.5,0.004 -2015-10-17 01:10:59:063731,20,18,5.0,-6.0,0.004 -2015-10-17 01:10:59:099479,20,19,5.0,-5.5,0.004 -2015-10-17 01:10:59:131109,20,20,5.0,-5.0,0.003 -2015-10-17 01:10:59:163453,20,21,5.0,-4.5,0.004 -2015-10-17 01:10:59:195425,20,22,5.0,-4.0,0.004 -2015-10-17 01:10:59:230428,20,23,5.0,-3.5,0.004 -2015-10-17 01:10:59:267215,20,24,5.0,-3.0,0.005 -2015-10-17 01:10:59:299057,20,25,5.0,-2.5,0.005 -2015-10-17 01:10:59:331549,20,26,5.0,-2.0,0.005 -2015-10-17 01:10:59:363687,20,27,5.0,-1.5,0.006 -2015-10-17 01:10:59:395684,20,28,5.0,-1.0,0.006 -2015-10-17 01:10:59:427656,20,29,5.0,-0.5,0.006 -2015-10-17 01:10:59:459711,20,30,5.0,0.0,0.006 -2015-10-17 01:10:59:491772,20,31,5.0,0.5,0.006 -2015-10-17 01:10:59:523840,20,32,5.0,1.0,0.006 -2015-10-17 01:10:59:555701,20,33,5.0,1.5,0.006 -2015-10-17 01:10:59:587702,20,34,5.0,2.0,0.005 -2015-10-17 01:10:59:619852,20,35,5.0,2.5,0.005 -2015-10-17 01:10:59:651892,20,36,5.0,3.0,0.005 -2015-10-17 01:10:59:686075,20,37,5.0,3.5,0.004 -2015-10-17 01:10:59:686075,20,37,5.0,3.5,0.004 -2015-10-17 01:10:59:717427,20,38,5.0,4.0,0.004 -2015-10-17 01:10:59:753994,20,39,5.0,4.5,0.004 -2015-10-17 01:10:59:789613,20,40,5.0,5.0,0.003 -2015-10-17 01:10:59:822081,20,41,5.0,5.5,0.004 -2015-10-17 01:10:59:853410,20,42,5.0,6.0,0.004 -2015-10-17 01:10:59:889868,20,43,5.0,6.5,0.004 -2015-10-17 01:10:59:924153,20,44,5.0,7.0,0.005 -2015-10-17 01:10:59:955784,20,45,5.0,7.5,0.005 -2015-10-17 01:10:59:988327,20,46,5.0,8.0,0.005 -2015-10-17 01:11:00:020003,20,47,5.0,8.5,0.006 -2015-10-17 01:11:00:051965,20,48,5.0,9.0,0.006 -2015-10-17 01:11:00:084110,20,49,5.0,9.5,0.006 -2015-10-17 01:11:00:119797,20,50,5.0,10.0,0.006 -2015-10-17 01:11:00:156248,20,51,5.0,10.5,0.006 -2015-10-17 01:11:00:188386,20,52,5.0,11.0,0.006 -2015-10-17 01:11:00:220451,20,53,5.0,11.5,0.006 -2015-10-17 01:11:00:252549,20,54,5.0,12.0,0.005 -2015-10-17 01:11:00:284635,20,55,5.0,12.5,0.005 -2015-10-17 01:11:00:316570,20,56,5.0,13.0,0.005 -2015-10-17 01:11:00:348690,20,57,5.0,13.5,0.004 -2015-10-17 01:11:00:380665,20,58,5.0,14.0,0.004 -2015-10-17 01:11:00:412682,20,59,5.0,14.5,0.004 -2015-10-17 01:11:00:412682,20,59,5.0,14.5,0.004 -2015-10-17 01:11:01:419190,21,0,6.0,-15.0,0.004 -2015-10-17 01:11:01:453614,21,1,6.0,-14.5,0.004 -2015-10-17 01:11:01:485651,21,2,6.0,-14.0,0.005 -2015-10-17 01:11:01:517494,21,3,6.0,-13.5,0.005 -2015-10-17 01:11:01:549998,21,4,6.0,-13.0,0.006 -2015-10-17 01:11:01:581782,21,5,6.0,-12.5,0.007 -2015-10-17 01:11:01:613637,21,6,6.0,-12.0,0.007 -2015-10-17 01:11:01:645736,21,7,6.0,-11.5,0.008 -2015-10-17 01:11:01:677405,21,8,6.0,-11.0,0.008 -2015-10-17 01:11:01:709711,21,9,6.0,-10.5,0.009 -2015-10-17 01:11:01:741954,21,10,6.0,-10.0,0.009 -2015-10-17 01:11:01:773760,21,11,6.0,-9.5,0.009 -2015-10-17 01:11:01:805825,21,12,6.0,-9.0,0.008 -2015-10-17 01:11:01:841788,21,13,6.0,-8.5,0.008 -2015-10-17 01:11:01:841788,21,13,6.0,-8.5,0.008 -2015-10-17 01:11:01:877713,21,14,6.0,-8.0,0.007 -2015-10-17 01:11:01:909770,21,15,6.0,-7.5,0.007 -2015-10-17 01:11:01:941852,21,16,6.0,-7.0,0.006 -2015-10-17 01:11:01:973932,21,17,6.0,-6.5,0.005 -2015-10-17 01:11:02:005846,21,18,6.0,-6.0,0.005 -2015-10-17 01:11:02:040755,21,19,6.0,-5.5,0.004 -2015-10-17 01:11:02:077158,21,20,6.0,-5.0,0.004 -2015-10-17 01:11:02:112001,21,21,6.0,-4.5,0.004 -2015-10-17 01:11:02:147670,21,22,6.0,-4.0,0.005 -2015-10-17 01:11:02:182224,21,23,6.0,-3.5,0.005 -2015-10-17 01:11:02:214255,21,24,6.0,-3.0,0.006 -2015-10-17 01:11:02:246367,21,25,6.0,-2.5,0.007 -2015-10-17 01:11:02:278281,21,26,6.0,-2.0,0.007 -2015-10-17 01:11:02:310250,21,27,6.0,-1.5,0.008 -2015-10-17 01:11:02:342257,21,28,6.0,-1.0,0.008 -2015-10-17 01:11:02:373821,21,29,6.0,-0.5,0.009 -2015-10-17 01:11:02:406420,21,30,6.0,0.0,0.009 -2015-10-17 01:11:02:438348,21,31,6.0,0.5,0.009 -2015-10-17 01:11:02:470261,21,32,6.0,1.0,0.008 -2015-10-17 01:11:02:502346,21,33,6.0,1.5,0.008 -2015-10-17 01:11:02:534358,21,34,6.0,2.0,0.007 -2015-10-17 01:11:02:570005,21,35,6.0,2.5,0.007 -2015-10-17 01:11:02:601702,21,36,6.0,3.0,0.006 -2015-10-17 01:11:02:638708,21,37,6.0,3.5,0.005 -2015-10-17 01:11:02:670459,21,38,6.0,4.0,0.005 -2015-10-17 01:11:02:702734,21,39,6.0,4.5,0.004 -2015-10-17 01:11:02:734755,21,40,6.0,5.0,0.004 -2015-10-17 01:11:02:766508,21,41,6.0,5.5,0.004 -2015-10-17 01:11:02:800467,21,42,6.0,6.0,0.005 -2015-10-17 01:11:02:836414,21,43,6.0,6.5,0.005 -2015-10-17 01:11:02:872761,21,44,6.0,7.0,0.006 -2015-10-17 01:11:02:872761,21,44,6.0,7.0,0.006 -2015-10-17 01:11:02:904323,21,45,6.0,7.5,0.007 -2015-10-17 01:11:02:940948,21,46,6.0,8.0,0.007 -2015-10-17 01:11:02:974581,21,47,6.0,8.5,0.008 -2015-10-17 01:11:03:006849,21,48,6.0,9.0,0.008 -2015-10-17 01:11:03:038800,21,49,6.0,9.5,0.009 -2015-10-17 01:11:03:074640,21,50,6.0,10.0,0.009 -2015-10-17 01:11:03:106781,21,51,6.0,10.5,0.009 -2015-10-17 01:11:03:142240,21,52,6.0,11.0,0.008 -2015-10-17 01:11:03:175165,21,53,6.0,11.5,0.008 -2015-10-17 01:11:03:207170,21,54,6.0,12.0,0.007 -2015-10-17 01:11:03:239109,21,55,6.0,12.5,0.007 -2015-10-17 01:11:03:271080,21,56,6.0,13.0,0.006 -2015-10-17 01:11:03:302795,21,57,6.0,13.5,0.005 -2015-10-17 01:11:03:335289,21,58,6.0,14.0,0.005 -2015-10-17 01:11:03:366589,21,59,6.0,14.5,0.004 -2015-10-17 01:11:03:366589,21,59,6.0,14.5,0.004 -2015-10-17 01:11:04:373450,22,0,7.0,-15.0,0.005 -2015-10-17 01:11:04:410187,22,1,7.0,-14.5,0.005 -2015-10-17 01:11:04:443059,22,2,7.0,-14.0,0.006 -2015-10-17 01:11:04:480140,22,3,7.0,-13.5,0.007 -2015-10-17 01:11:04:517370,22,4,7.0,-13.0,0.008 -2015-10-17 01:11:04:551251,22,5,7.0,-12.5,0.009 -2015-10-17 01:11:04:586899,22,6,7.0,-12.0,0.01 -2015-10-17 01:11:04:619115,22,7,7.0,-11.5,0.012 -2015-10-17 01:11:04:652203,22,8,7.0,-11.0,0.013 -2015-10-17 01:11:04:688169,22,9,7.0,-10.5,0.014 -2015-10-17 01:11:04:722691,22,10,7.0,-10.0,0.014 -2015-10-17 01:11:04:757976,22,11,7.0,-9.5,0.014 -2015-10-17 01:11:04:794620,22,12,7.0,-9.0,0.013 -2015-10-17 01:11:04:826313,22,13,7.0,-8.5,0.012 -2015-10-17 01:11:04:857994,22,14,7.0,-8.0,0.01 -2015-10-17 01:11:04:890146,22,15,7.0,-7.5,0.009 -2015-10-17 01:11:04:923836,22,16,7.0,-7.0,0.008 -2015-10-17 01:11:04:957716,22,17,7.0,-6.5,0.007 -2015-10-17 01:11:04:993000,22,18,7.0,-6.0,0.006 -2015-10-17 01:11:04:993000,22,18,7.0,-6.0,0.006 -2015-10-17 01:11:05:026527,22,19,7.0,-5.5,0.005 -2015-10-17 01:11:05:063139,22,20,7.0,-5.0,0.005 -2015-10-17 01:11:05:099270,22,21,7.0,-4.5,0.005 -2015-10-17 01:11:05:136324,22,22,7.0,-4.0,0.006 -2015-10-17 01:11:05:172027,22,23,7.0,-3.5,0.007 -2015-10-17 01:11:05:208024,22,24,7.0,-3.0,0.008 -2015-10-17 01:11:05:239943,22,25,7.0,-2.5,0.009 -2015-10-17 01:11:05:276246,22,26,7.0,-2.0,0.01 -2015-10-17 01:11:05:309822,22,27,7.0,-1.5,0.012 -2015-10-17 01:11:05:341970,22,28,7.0,-1.0,0.013 -2015-10-17 01:11:05:378810,22,29,7.0,-0.5,0.014 -2015-10-17 01:11:05:416029,22,30,7.0,0.0,0.014 -2015-10-17 01:11:05:452491,22,31,7.0,0.5,0.014 -2015-10-17 01:11:05:488970,22,32,7.0,1.0,0.013 -2015-10-17 01:11:05:524967,22,33,7.0,1.5,0.012 -2015-10-17 01:11:05:560729,22,34,7.0,2.0,0.01 -2015-10-17 01:11:05:596834,22,35,7.0,2.5,0.009 -2015-10-17 01:11:05:632880,22,36,7.0,3.0,0.008 -2015-10-17 01:11:05:670069,22,37,7.0,3.5,0.007 -2015-10-17 01:11:05:705991,22,38,7.0,4.0,0.006 -2015-10-17 01:11:05:743225,22,39,7.0,4.5,0.005 -2015-10-17 01:11:05:775013,22,40,7.0,5.0,0.005 -2015-10-17 01:11:05:808052,22,41,7.0,5.5,0.005 -2015-10-17 01:11:05:841958,22,42,7.0,6.0,0.006 -2015-10-17 01:11:05:878423,22,43,7.0,6.5,0.007 -2015-10-17 01:11:05:914346,22,44,7.0,7.0,0.008 -2015-10-17 01:11:05:951587,22,45,7.0,7.5,0.009 -2015-10-17 01:11:05:988045,22,46,7.0,8.0,0.01 -2015-10-17 01:11:06:024501,22,47,7.0,8.5,0.012 -2015-10-17 01:11:06:024501,22,47,7.0,8.5,0.012 -2015-10-17 01:11:06:060427,22,48,7.0,9.0,0.013 -2015-10-17 01:11:06:097645,22,49,7.0,9.5,0.014 -2015-10-17 01:11:06:133656,22,50,7.0,10.0,0.014 -2015-10-17 01:11:06:168817,22,51,7.0,10.5,0.014 -2015-10-17 01:11:06:206152,22,52,7.0,11.0,0.013 -2015-10-17 01:11:06:242196,22,53,7.0,11.5,0.012 -2015-10-17 01:11:06:279419,22,54,7.0,12.0,0.01 -2015-10-17 01:11:06:310919,22,55,7.0,12.5,0.009 -2015-10-17 01:11:06:345726,22,56,7.0,13.0,0.008 -2015-10-17 01:11:06:382078,22,57,7.0,13.5,0.007 -2015-10-17 01:11:06:416343,22,58,7.0,14.0,0.006 -2015-10-17 01:11:06:448443,22,59,7.0,14.5,0.005 -2015-10-17 01:11:06:448443,22,59,7.0,14.5,0.005 -2015-10-17 01:11:07:450822,23,0,8.0,-15.0,0.005 -2015-10-17 01:11:07:483052,23,1,8.0,-14.5,0.006 -2015-10-17 01:11:07:516511,23,2,8.0,-14.0,0.007 -2015-10-17 01:11:07:550621,23,3,8.0,-13.5,0.009 -2015-10-17 01:11:07:582591,23,4,8.0,-13.0,0.01 -2015-10-17 01:11:07:617763,23,5,8.0,-12.5,0.013 -2015-10-17 01:11:07:651335,23,6,8.0,-12.0,0.016 -2015-10-17 01:11:07:684341,23,7,8.0,-11.5,0.019 -2015-10-17 01:11:07:719139,23,8,8.0,-11.0,0.023 -2015-10-17 01:11:07:755208,23,9,8.0,-10.5,0.026 -2015-10-17 01:11:07:789341,23,10,8.0,-10.0,0.027 -2015-10-17 01:11:07:820498,23,11,8.0,-9.5,0.026 -2015-10-17 01:11:07:853101,23,12,8.0,-9.0,0.023 -2015-10-17 01:11:07:884305,23,13,8.0,-8.5,0.019 -2015-10-17 01:11:07:915846,23,14,8.0,-8.0,0.016 -2015-10-17 01:11:07:948381,23,15,8.0,-7.5,0.013 -2015-10-17 01:11:07:981384,23,16,8.0,-7.0,0.01 -2015-10-17 01:11:08:013921,23,17,8.0,-6.5,0.009 -2015-10-17 01:11:08:044873,23,18,8.0,-6.0,0.007 -2015-10-17 01:11:08:076668,23,19,8.0,-5.5,0.006 -2015-10-17 01:11:08:076668,23,19,8.0,-5.5,0.006 -2015-10-17 01:11:08:109787,23,20,8.0,-5.0,0.005 -2015-10-17 01:11:08:141706,23,21,8.0,-4.5,0.006 -2015-10-17 01:11:08:177773,23,22,8.0,-4.0,0.007 -2015-10-17 01:11:08:210005,23,23,8.0,-3.5,0.009 -2015-10-17 01:11:08:242213,23,24,8.0,-3.0,0.01 -2015-10-17 01:11:08:278213,23,25,8.0,-2.5,0.013 -2015-10-17 01:11:08:313322,23,26,8.0,-2.0,0.016 -2015-10-17 01:11:08:347317,23,27,8.0,-1.5,0.019 -2015-10-17 01:11:08:379940,23,28,8.0,-1.0,0.023 -2015-10-17 01:11:08:411649,23,29,8.0,-0.5,0.026 -2015-10-17 01:11:08:442521,23,30,8.0,0.0,0.027 -2015-10-17 01:11:08:476938,23,31,8.0,0.5,0.026 -2015-10-17 01:11:08:508589,23,32,8.0,1.0,0.023 -2015-10-17 01:11:08:545154,23,33,8.0,1.5,0.019 -2015-10-17 01:11:08:577210,23,34,8.0,2.0,0.016 -2015-10-17 01:11:08:609518,23,35,8.0,2.5,0.013 -2015-10-17 01:11:08:642610,23,36,8.0,3.0,0.01 -2015-10-17 01:11:08:673655,23,37,8.0,3.5,0.009 -2015-10-17 01:11:08:706113,23,38,8.0,4.0,0.007 -2015-10-17 01:11:08:738527,23,39,8.0,4.5,0.006 -2015-10-17 01:11:08:774025,23,40,8.0,5.0,0.005 -2015-10-17 01:11:08:807722,23,41,8.0,5.5,0.006 -2015-10-17 01:11:08:842016,23,42,8.0,6.0,0.007 -2015-10-17 01:11:08:874001,23,43,8.0,6.5,0.009 -2015-10-17 01:11:08:906598,23,44,8.0,7.0,0.01 -2015-10-17 01:11:08:940402,23,45,8.0,7.5,0.013 -2015-10-17 01:11:08:972860,23,46,8.0,8.0,0.016 -2015-10-17 01:11:09:005055,23,47,8.0,8.5,0.019 -2015-10-17 01:11:09:035943,23,48,8.0,9.0,0.023 -2015-10-17 01:11:09:069550,23,49,8.0,9.5,0.026 -2015-10-17 01:11:09:101290,23,50,8.0,10.0,0.027 -2015-10-17 01:11:09:101290,23,50,8.0,10.0,0.027 -2015-10-17 01:11:09:136269,23,51,8.0,10.5,0.026 -2015-10-17 01:11:09:171094,23,52,8.0,11.0,0.023 -2015-10-17 01:11:09:202325,23,53,8.0,11.5,0.019 -2015-10-17 01:11:09:234450,23,54,8.0,12.0,0.016 -2015-10-17 01:11:09:267054,23,55,8.0,12.5,0.013 -2015-10-17 01:11:09:298151,23,56,8.0,13.0,0.01 -2015-10-17 01:11:09:330341,23,57,8.0,13.5,0.009 -2015-10-17 01:11:09:366488,23,58,8.0,14.0,0.007 -2015-10-17 01:11:09:399523,23,59,8.0,14.5,0.006 -2015-10-17 01:11:09:399523,23,59,8.0,14.5,0.006 -2015-10-17 01:11:10:401957,24,0,9.0,-15.0,0.006 -2015-10-17 01:11:10:433130,24,1,9.0,-14.5,0.007 -2015-10-17 01:11:10:464488,24,2,9.0,-14.0,0.008 -2015-10-17 01:11:10:499136,24,3,9.0,-13.5,0.01 -2015-10-17 01:11:10:531737,24,4,9.0,-13.0,0.013 -2015-10-17 01:11:10:567428,24,5,9.0,-12.5,0.017 -2015-10-17 01:11:10:604098,24,6,9.0,-12.0,0.023 -2015-10-17 01:11:10:636425,24,7,9.0,-11.5,0.031 -2015-10-17 01:11:10:668344,24,8,9.0,-11.0,0.044 -2015-10-17 01:11:10:700439,24,9,9.0,-10.5,0.057 -2015-10-17 01:11:10:732454,24,10,9.0,-10.0,0.064 -2015-10-17 01:11:10:764765,24,11,9.0,-9.5,0.057 -2015-10-17 01:11:10:799360,24,12,9.0,-9.0,0.044 -2015-10-17 01:11:10:836093,24,13,9.0,-8.5,0.031 -2015-10-17 01:11:10:868555,24,14,9.0,-8.0,0.023 -2015-10-17 01:11:10:900626,24,15,9.0,-7.5,0.017 -2015-10-17 01:11:10:932630,24,16,9.0,-7.0,0.013 -2015-10-17 01:11:10:964654,24,17,9.0,-6.5,0.01 -2015-10-17 01:11:10:996696,24,18,9.0,-6.0,0.008 -2015-10-17 01:11:11:031852,24,19,9.0,-5.5,0.007 -2015-10-17 01:11:11:067862,24,20,9.0,-5.0,0.006 -2015-10-17 01:11:11:100492,24,21,9.0,-4.5,0.007 -2015-10-17 01:11:11:132350,24,22,9.0,-4.0,0.008 -2015-10-17 01:11:11:167263,24,23,9.0,-3.5,0.01 -2015-10-17 01:11:11:200095,24,24,9.0,-3.0,0.013 -2015-10-17 01:11:11:233366,24,25,9.0,-2.5,0.017 -2015-10-17 01:11:11:233366,24,25,9.0,-2.5,0.017 -2015-10-17 01:11:11:267482,24,26,9.0,-2.0,0.023 -2015-10-17 01:11:11:300946,24,27,9.0,-1.5,0.031 -2015-10-17 01:11:11:332928,24,28,9.0,-1.0,0.044 -2015-10-17 01:11:11:365024,24,29,9.0,-0.5,0.057 -2015-10-17 01:11:11:401092,24,30,9.0,0.0,0.064 -2015-10-17 01:11:11:437103,24,31,9.0,0.5,0.057 -2015-10-17 01:11:11:468923,24,32,9.0,1.0,0.044 -2015-10-17 01:11:11:500751,24,33,9.0,1.5,0.031 -2015-10-17 01:11:11:533440,24,34,9.0,2.0,0.023 -2015-10-17 01:11:11:565109,24,35,9.0,2.5,0.017 -2015-10-17 01:11:11:597229,24,36,9.0,3.0,0.013 -2015-10-17 01:11:11:629183,24,37,9.0,3.5,0.01 -2015-10-17 01:11:11:661155,24,38,9.0,4.0,0.008 -2015-10-17 01:11:11:693290,24,39,9.0,4.5,0.007 -2015-10-17 01:11:11:725294,24,40,9.0,5.0,0.006 -2015-10-17 01:11:11:760135,24,41,9.0,5.5,0.007 -2015-10-17 01:11:11:796690,24,42,9.0,6.0,0.008 -2015-10-17 01:11:11:829344,24,43,9.0,6.5,0.01 -2015-10-17 01:11:11:861423,24,44,9.0,7.0,0.013 -2015-10-17 01:11:11:893450,24,45,9.0,7.5,0.017 -2015-10-17 01:11:11:925441,24,46,9.0,8.0,0.023 -2015-10-17 01:11:11:957474,24,47,9.0,8.5,0.031 -2015-10-17 01:11:11:989065,24,48,9.0,9.0,0.044 -2015-10-17 01:11:12:021363,24,49,9.0,9.5,0.057 -2015-10-17 01:11:12:052620,24,50,9.0,10.0,0.064 -2015-10-17 01:11:12:085134,24,51,9.0,10.5,0.057 -2015-10-17 01:11:12:120645,24,52,9.0,11.0,0.044 -2015-10-17 01:11:12:153712,24,53,9.0,11.5,0.031 -2015-10-17 01:11:12:188378,24,54,9.0,12.0,0.023 -2015-10-17 01:11:12:219587,24,55,9.0,12.5,0.017 -2015-10-17 01:11:12:253576,24,56,9.0,13.0,0.013 -2015-10-17 01:11:12:253576,24,56,9.0,13.0,0.013 -2015-10-17 01:11:12:288867,24,57,9.0,13.5,0.01 -2015-10-17 01:11:12:323041,24,58,9.0,14.0,0.008 -2015-10-17 01:11:12:358238,24,59,9.0,14.5,0.007 -2015-10-17 01:11:13:364738,25,0,10.0,-15.0,0.006 -2015-10-17 01:11:13:364738,25,0,10.0,-15.0,0.006 -2015-10-17 01:11:13:398989,25,1,10.0,-14.5,0.007 -2015-10-17 01:11:13:430928,25,2,10.0,-14.0,0.009 -2015-10-17 01:11:13:462987,25,3,10.0,-13.5,0.011 -2015-10-17 01:11:13:495065,25,4,10.0,-13.0,0.014 -2015-10-17 01:11:13:527041,25,5,10.0,-12.5,0.019 -2015-10-17 01:11:13:563205,25,6,10.0,-12.0,0.027 -2015-10-17 01:11:13:599191,25,7,10.0,-11.5,0.04 -2015-10-17 01:11:13:630987,25,8,10.0,-11.0,0.064 -2015-10-17 01:11:13:663578,25,9,10.0,-10.5,0.099 -2015-10-17 01:11:13:695204,25,10,10.0,-10.0,0.117 -2015-10-17 01:11:13:727221,25,11,10.0,-9.5,0.099 -2015-10-17 01:11:13:761234,25,12,10.0,-9.0,0.064 -2015-10-17 01:11:13:797262,25,13,10.0,-8.5,0.04 -2015-10-17 01:11:13:831310,25,14,10.0,-8.0,0.027 -2015-10-17 01:11:13:863401,25,15,10.0,-7.5,0.019 -2015-10-17 01:11:13:895399,25,16,10.0,-7.0,0.014 -2015-10-17 01:11:13:927433,25,17,10.0,-6.5,0.011 -2015-10-17 01:11:13:963115,25,18,10.0,-6.0,0.009 -2015-10-17 01:11:13:995203,25,19,10.0,-5.5,0.007 -2015-10-17 01:11:14:031538,25,20,10.0,-5.0,0.006 -2015-10-17 01:11:14:063030,25,21,10.0,-4.5,0.007 -2015-10-17 01:11:14:095582,25,22,10.0,-4.0,0.009 -2015-10-17 01:11:14:127579,25,23,10.0,-3.5,0.011 -2015-10-17 01:11:14:159673,25,24,10.0,-3.0,0.014 -2015-10-17 01:11:14:191656,25,25,10.0,-2.5,0.019 -2015-10-17 01:11:14:223654,25,26,10.0,-2.0,0.027 -2015-10-17 01:11:14:255733,25,27,10.0,-1.5,0.04 -2015-10-17 01:11:14:290503,25,28,10.0,-1.0,0.064 -2015-10-17 01:11:14:328054,25,29,10.0,-0.5,0.099 -2015-10-17 01:11:14:359885,25,30,10.0,0.0,0.117 -2015-10-17 01:11:14:391916,25,31,10.0,0.5,0.099 -2015-10-17 01:11:14:391916,25,31,10.0,0.5,0.099 -2015-10-17 01:11:14:423912,25,32,10.0,1.0,0.064 -2015-10-17 01:11:14:455976,25,33,10.0,1.5,0.04 -2015-10-17 01:11:14:488204,25,34,10.0,2.0,0.027 -2015-10-17 01:11:14:520096,25,35,10.0,2.5,0.019 -2015-10-17 01:11:14:552119,25,36,10.0,3.0,0.014 -2015-10-17 01:11:14:588325,25,37,10.0,3.5,0.011 -2015-10-17 01:11:14:624133,25,38,10.0,4.0,0.009 -2015-10-17 01:11:14:656179,25,39,10.0,4.5,0.007 -2015-10-17 01:11:14:688693,25,40,10.0,5.0,0.006 -2015-10-17 01:11:14:720309,25,41,10.0,5.5,0.007 -2015-10-17 01:11:14:752264,25,42,10.0,6.0,0.009 -2015-10-17 01:11:14:784665,25,43,10.0,6.5,0.011 -2015-10-17 01:11:14:816318,25,44,10.0,7.0,0.014 -2015-10-17 01:11:14:848373,25,45,10.0,7.5,0.019 -2015-10-17 01:11:14:880453,25,46,10.0,8.0,0.027 -2015-10-17 01:11:14:916282,25,47,10.0,8.5,0.04 -2015-10-17 01:11:14:952434,25,48,10.0,9.0,0.064 -2015-10-17 01:11:14:984482,25,49,10.0,9.5,0.099 -2015-10-17 01:11:15:016612,25,50,10.0,10.0,0.117 -2015-10-17 01:11:15:048520,25,51,10.0,10.5,0.099 -2015-10-17 01:11:15:080596,25,52,10.0,11.0,0.064 -2015-10-17 01:11:15:112586,25,53,10.0,11.5,0.04 -2015-10-17 01:11:15:144567,25,54,10.0,12.0,0.027 -2015-10-17 01:11:15:176599,25,55,10.0,12.5,0.019 -2015-10-17 01:11:15:208683,25,56,10.0,13.0,0.014 -2015-10-17 01:11:15:240729,25,57,10.0,13.5,0.011 -2015-10-17 01:11:15:272640,25,58,10.0,14.0,0.009 -2015-10-17 01:11:15:304910,25,59,10.0,14.5,0.007 -2015-10-17 01:11:15:304910,25,59,10.0,14.5,0.007 -2015-10-17 01:11:16:306720,26,0,11.0,-15.0,0.006 -2015-10-17 01:11:16:338645,26,1,11.0,-14.5,0.007 -2015-10-17 01:11:16:375509,26,2,11.0,-14.0,0.008 -2015-10-17 01:11:16:409519,26,3,11.0,-13.5,0.01 -2015-10-17 01:11:16:442423,26,4,11.0,-13.0,0.013 -2015-10-17 01:11:16:473509,26,5,11.0,-12.5,0.017 -2015-10-17 01:11:16:509834,26,6,11.0,-12.0,0.023 -2015-10-17 01:11:16:541428,26,7,11.0,-11.5,0.031 -2015-10-17 01:11:16:541428,26,7,11.0,-11.5,0.031 -2015-10-17 01:11:16:577064,26,8,11.0,-11.0,0.044 -2015-10-17 01:11:16:611705,26,9,11.0,-10.5,0.057 -2015-10-17 01:11:16:643910,26,10,11.0,-10.0,0.064 -2015-10-17 01:11:16:676088,26,11,11.0,-9.5,0.057 -2015-10-17 01:11:16:707675,26,12,11.0,-9.0,0.044 -2015-10-17 01:11:16:741298,26,13,11.0,-8.5,0.031 -2015-10-17 01:11:16:777904,26,14,11.0,-8.0,0.023 -2015-10-17 01:11:16:811664,26,15,11.0,-7.5,0.017 -2015-10-17 01:11:16:849134,26,16,11.0,-7.0,0.013 -2015-10-17 01:11:16:882232,26,17,11.0,-6.5,0.01 -2015-10-17 01:11:16:914086,26,18,11.0,-6.0,0.008 -2015-10-17 01:11:16:946187,26,19,11.0,-5.5,0.007 -2015-10-17 01:11:16:978260,26,20,11.0,-5.0,0.006 -2015-10-17 01:11:17:009936,26,21,11.0,-4.5,0.007 -2015-10-17 01:11:17:042324,26,22,11.0,-4.0,0.008 -2015-10-17 01:11:17:076318,26,23,11.0,-3.5,0.01 -2015-10-17 01:11:17:107561,26,24,11.0,-3.0,0.013 -2015-10-17 01:11:17:139347,26,25,11.0,-2.5,0.017 -2015-10-17 01:11:17:176038,26,26,11.0,-2.0,0.023 -2015-10-17 01:11:17:209541,26,27,11.0,-1.5,0.031 -2015-10-17 01:11:17:242314,26,28,11.0,-1.0,0.044 -2015-10-17 01:11:17:277103,26,29,11.0,-0.5,0.057 -2015-10-17 01:11:17:311857,26,30,11.0,0.0,0.064 -2015-10-17 01:11:17:346144,26,31,11.0,0.5,0.057 -2015-10-17 01:11:17:382649,26,32,11.0,1.0,0.044 -2015-10-17 01:11:17:416914,26,33,11.0,1.5,0.031 -2015-10-17 01:11:17:448772,26,34,11.0,2.0,0.023 -2015-10-17 01:11:17:482785,26,35,11.0,2.5,0.017 -2015-10-17 01:11:17:514633,26,36,11.0,3.0,0.013 -2015-10-17 01:11:17:546667,26,37,11.0,3.5,0.01 -2015-10-17 01:11:17:546667,26,37,11.0,3.5,0.01 -2015-10-17 01:11:17:578726,26,38,11.0,4.0,0.008 -2015-10-17 01:11:17:610693,26,39,11.0,4.5,0.007 -2015-10-17 01:11:17:644159,26,40,11.0,5.0,0.006 -2015-10-17 01:11:17:681482,26,41,11.0,5.5,0.007 -2015-10-17 01:11:17:714813,26,42,11.0,6.0,0.008 -2015-10-17 01:11:17:746815,26,43,11.0,6.5,0.01 -2015-10-17 01:11:17:778831,26,44,11.0,7.0,0.013 -2015-10-17 01:11:17:810869,26,45,11.0,7.5,0.017 -2015-10-17 01:11:17:846683,26,46,11.0,8.0,0.023 -2015-10-17 01:11:17:878272,26,47,11.0,8.5,0.031 -2015-10-17 01:11:17:913829,26,48,11.0,9.0,0.044 -2015-10-17 01:11:17:950980,26,49,11.0,9.5,0.057 -2015-10-17 01:11:17:986670,26,50,11.0,10.0,0.064 -2015-10-17 01:11:18:019567,26,51,11.0,10.5,0.057 -2015-10-17 01:11:18:055591,26,52,11.0,11.0,0.044 -2015-10-17 01:11:18:090850,26,53,11.0,11.5,0.031 -2015-10-17 01:11:18:123044,26,54,11.0,12.0,0.023 -2015-10-17 01:11:18:155035,26,55,11.0,12.5,0.017 -2015-10-17 01:11:18:191517,26,56,11.0,13.0,0.013 -2015-10-17 01:11:18:227188,26,57,11.0,13.5,0.01 -2015-10-17 01:11:18:259208,26,58,11.0,14.0,0.008 -2015-10-17 01:11:18:291191,26,59,11.0,14.5,0.007 -2015-10-17 01:11:18:291191,26,59,11.0,14.5,0.007 -2015-10-17 01:11:19:296219,27,0,12.0,-15.0,0.005 -2015-10-17 01:11:19:331471,27,1,12.0,-14.5,0.006 -2015-10-17 01:11:19:368155,27,2,12.0,-14.0,0.007 -2015-10-17 01:11:19:400201,27,3,12.0,-13.5,0.009 -2015-10-17 01:11:19:432264,27,4,12.0,-13.0,0.01 -2015-10-17 01:11:19:464272,27,5,12.0,-12.5,0.013 -2015-10-17 01:11:19:496341,27,6,12.0,-12.0,0.016 -2015-10-17 01:11:19:527901,27,7,12.0,-11.5,0.019 -2015-10-17 01:11:19:560306,27,8,12.0,-11.0,0.023 -2015-10-17 01:11:19:592369,27,9,12.0,-10.5,0.026 -2015-10-17 01:11:19:623347,27,10,12.0,-10.0,0.027 -2015-10-17 01:11:19:656600,27,11,12.0,-9.5,0.026 -2015-10-17 01:11:19:690937,27,12,12.0,-9.0,0.023 -2015-10-17 01:11:19:724308,27,13,12.0,-8.5,0.019 -2015-10-17 01:11:19:724308,27,13,12.0,-8.5,0.019 -2015-10-17 01:11:19:755686,27,14,12.0,-8.0,0.016 -2015-10-17 01:11:19:790627,27,15,12.0,-7.5,0.013 -2015-10-17 01:11:19:826433,27,16,12.0,-7.0,0.01 -2015-10-17 01:11:19:859337,27,17,12.0,-6.5,0.009 -2015-10-17 01:11:19:892033,27,18,12.0,-6.0,0.007 -2015-10-17 01:11:19:928411,27,19,12.0,-5.5,0.006 -2015-10-17 01:11:19:961076,27,20,12.0,-5.0,0.005 -2015-10-17 01:11:19:992444,27,21,12.0,-4.5,0.006 -2015-10-17 01:11:20:024223,27,22,12.0,-4.0,0.007 -2015-10-17 01:11:20:056533,27,23,12.0,-3.5,0.009 -2015-10-17 01:11:20:089417,27,24,12.0,-3.0,0.01 -2015-10-17 01:11:20:123831,27,25,12.0,-2.5,0.013 -2015-10-17 01:11:20:155752,27,26,12.0,-2.0,0.016 -2015-10-17 01:11:20:189244,27,27,12.0,-1.5,0.019 -2015-10-17 01:11:20:224699,27,28,12.0,-1.0,0.023 -2015-10-17 01:11:20:257719,27,29,12.0,-0.5,0.026 -2015-10-17 01:11:20:291543,27,30,12.0,0.0,0.027 -2015-10-17 01:11:20:325222,27,31,12.0,0.5,0.026 -2015-10-17 01:11:20:358175,27,32,12.0,1.0,0.023 -2015-10-17 01:11:20:393714,27,33,12.0,1.5,0.019 -2015-10-17 01:11:20:425858,27,34,12.0,2.0,0.016 -2015-10-17 01:11:20:457772,27,35,12.0,2.5,0.013 -2015-10-17 01:11:20:493706,27,36,12.0,3.0,0.01 -2015-10-17 01:11:20:529417,27,37,12.0,3.5,0.009 -2015-10-17 01:11:20:561326,27,38,12.0,4.0,0.007 -2015-10-17 01:11:20:593404,27,39,12.0,4.5,0.006 -2015-10-17 01:11:20:625401,27,40,12.0,5.0,0.005 -2015-10-17 01:11:20:657392,27,41,12.0,5.5,0.006 -2015-10-17 01:11:20:689485,27,42,12.0,6.0,0.007 -2015-10-17 01:11:20:724462,27,43,12.0,6.5,0.009 -2015-10-17 01:11:20:724462,27,43,12.0,6.5,0.009 -2015-10-17 01:11:20:760526,27,44,12.0,7.0,0.01 -2015-10-17 01:11:20:794126,27,45,12.0,7.5,0.013 -2015-10-17 01:11:20:826735,27,46,12.0,8.0,0.016 -2015-10-17 01:11:20:859909,27,47,12.0,8.5,0.019 -2015-10-17 01:11:20:893898,27,48,12.0,9.0,0.023 -2015-10-17 01:11:20:927587,27,49,12.0,9.5,0.026 -2015-10-17 01:11:20:960936,27,50,12.0,10.0,0.027 -2015-10-17 01:11:20:993307,27,51,12.0,10.5,0.026 -2015-10-17 01:11:21:025764,27,52,12.0,11.0,0.023 -2015-10-17 01:11:21:057775,27,53,12.0,11.5,0.019 -2015-10-17 01:11:21:089809,27,54,12.0,12.0,0.016 -2015-10-17 01:11:21:125447,27,55,12.0,12.5,0.013 -2015-10-17 01:11:21:161643,27,56,12.0,13.0,0.01 -2015-10-17 01:11:21:194063,27,57,12.0,13.5,0.009 -2015-10-17 01:11:21:226088,27,58,12.0,14.0,0.007 -2015-10-17 01:11:21:262295,27,59,12.0,14.5,0.006 -2015-10-17 01:11:21:262295,27,59,12.0,14.5,0.006 -2015-10-17 01:11:22:267141,28,0,13.0,-15.0,0.005 -2015-10-17 01:11:22:299025,28,1,13.0,-14.5,0.005 -2015-10-17 01:11:22:331048,28,2,13.0,-14.0,0.006 -2015-10-17 01:11:22:362817,28,3,13.0,-13.5,0.007 -2015-10-17 01:11:22:394941,28,4,13.0,-13.0,0.008 -2015-10-17 01:11:22:430130,28,5,13.0,-12.5,0.009 -2015-10-17 01:11:22:464505,28,6,13.0,-12.0,0.01 -2015-10-17 01:11:22:500142,28,7,13.0,-11.5,0.012 -2015-10-17 01:11:22:535084,28,8,13.0,-11.0,0.013 -2015-10-17 01:11:22:570487,28,9,13.0,-10.5,0.014 -2015-10-17 01:11:22:606909,28,10,13.0,-10.0,0.014 -2015-10-17 01:11:22:643620,28,11,13.0,-9.5,0.014 -2015-10-17 01:11:22:676121,28,12,13.0,-9.0,0.013 -2015-10-17 01:11:22:709047,28,13,13.0,-8.5,0.012 -2015-10-17 01:11:22:744462,28,14,13.0,-8.0,0.01 -2015-10-17 01:11:22:779412,28,15,13.0,-7.5,0.009 -2015-10-17 01:11:22:813935,28,16,13.0,-7.0,0.008 -2015-10-17 01:11:22:848675,28,17,13.0,-6.5,0.007 -2015-10-17 01:11:22:884143,28,18,13.0,-6.0,0.006 -2015-10-17 01:11:22:884143,28,18,13.0,-6.0,0.006 -2015-10-17 01:11:22:915955,28,19,13.0,-5.5,0.005 -2015-10-17 01:11:22:947602,28,20,13.0,-5.0,0.005 -2015-10-17 01:11:22:979650,28,21,13.0,-4.5,0.005 -2015-10-17 01:11:23:011684,28,22,13.0,-4.0,0.006 -2015-10-17 01:11:23:043447,28,23,13.0,-3.5,0.007 -2015-10-17 01:11:23:075927,28,24,13.0,-3.0,0.008 -2015-10-17 01:11:23:107733,28,25,13.0,-2.5,0.009 -2015-10-17 01:11:23:139780,28,26,13.0,-2.0,0.01 -2015-10-17 01:11:23:171961,28,27,13.0,-1.5,0.012 -2015-10-17 01:11:23:203881,28,28,13.0,-1.0,0.013 -2015-10-17 01:11:23:235896,28,29,13.0,-0.5,0.014 -2015-10-17 01:11:23:271076,28,30,13.0,0.0,0.014 -2015-10-17 01:11:23:304299,28,31,13.0,0.5,0.014 -2015-10-17 01:11:23:338227,28,32,13.0,1.0,0.013 -2015-10-17 01:11:23:371670,28,33,13.0,1.5,0.012 -2015-10-17 01:11:23:404300,28,34,13.0,2.0,0.01 -2015-10-17 01:11:23:438154,28,35,13.0,2.5,0.009 -2015-10-17 01:11:23:472244,28,36,13.0,3.0,0.008 -2015-10-17 01:11:23:506352,28,37,13.0,3.5,0.007 -2015-10-17 01:11:23:538511,28,38,13.0,4.0,0.006 -2015-10-17 01:11:23:572326,28,39,13.0,4.5,0.005 -2015-10-17 01:11:23:603976,28,40,13.0,5.0,0.005 -2015-10-17 01:11:23:636354,28,41,13.0,5.5,0.005 -2015-10-17 01:11:23:669317,28,42,13.0,6.0,0.006 -2015-10-17 01:11:23:700570,28,43,13.0,6.5,0.007 -2015-10-17 01:11:23:732342,28,44,13.0,7.0,0.008 -2015-10-17 01:11:23:764533,28,45,13.0,7.5,0.009 -2015-10-17 01:11:23:801245,28,46,13.0,8.0,0.01 -2015-10-17 01:11:23:836411,28,47,13.0,8.5,0.012 -2015-10-17 01:11:23:869148,28,48,13.0,9.0,0.013 -2015-10-17 01:11:23:904431,28,49,13.0,9.5,0.014 -2015-10-17 01:11:23:904431,28,49,13.0,9.5,0.014 -2015-10-17 01:11:23:936472,28,50,13.0,10.0,0.014 -2015-10-17 01:11:23:971426,28,51,13.0,10.5,0.014 -2015-10-17 01:11:24:003753,28,52,13.0,11.0,0.013 -2015-10-17 01:11:24:037185,28,53,13.0,11.5,0.012 -2015-10-17 01:11:24:068778,28,54,13.0,12.0,0.01 -2015-10-17 01:11:24:102571,28,55,13.0,12.5,0.009 -2015-10-17 01:11:24:134854,28,56,13.0,13.0,0.008 -2015-10-17 01:11:24:168921,28,57,13.0,13.5,0.007 -2015-10-17 01:11:24:201311,28,58,13.0,14.0,0.006 -2015-10-17 01:11:24:233982,28,59,13.0,14.5,0.005 -2015-10-17 01:11:24:233982,28,59,13.0,14.5,0.005 -2015-10-17 01:11:25:234970,29,0,14.0,-15.0,0.004 -2015-10-17 01:11:25:268517,29,1,14.0,-14.5,0.004 -2015-10-17 01:11:25:299686,29,2,14.0,-14.0,0.005 -2015-10-17 01:11:25:332607,29,3,14.0,-13.5,0.005 -2015-10-17 01:11:25:366007,29,4,14.0,-13.0,0.006 -2015-10-17 01:11:25:398206,29,5,14.0,-12.5,0.007 -2015-10-17 01:11:25:430583,29,6,14.0,-12.0,0.007 -2015-10-17 01:11:25:464360,29,7,14.0,-11.5,0.008 -2015-10-17 01:11:25:499716,29,8,14.0,-11.0,0.008 -2015-10-17 01:11:25:534214,29,9,14.0,-10.5,0.009 -2015-10-17 01:11:25:566148,29,10,14.0,-10.0,0.009 -2015-10-17 01:11:25:600512,29,11,14.0,-9.5,0.009 -2015-10-17 01:11:25:634577,29,12,14.0,-9.0,0.008 -2015-10-17 01:11:25:670269,29,13,14.0,-8.5,0.008 -2015-10-17 01:11:25:701848,29,14,14.0,-8.0,0.007 -2015-10-17 01:11:25:733103,29,15,14.0,-7.5,0.007 -2015-10-17 01:11:25:764399,29,16,14.0,-7.0,0.006 -2015-10-17 01:11:25:798346,29,17,14.0,-6.5,0.005 -2015-10-17 01:11:25:830162,29,18,14.0,-6.0,0.005 -2015-10-17 01:11:25:862003,29,19,14.0,-5.5,0.004 -2015-10-17 01:11:25:894613,29,20,14.0,-5.0,0.004 -2015-10-17 01:11:25:926397,29,21,14.0,-4.5,0.004 -2015-10-17 01:11:25:957932,29,22,14.0,-4.0,0.005 -2015-10-17 01:11:25:990123,29,23,14.0,-3.5,0.005 -2015-10-17 01:11:26:023755,29,24,14.0,-3.0,0.006 -2015-10-17 01:11:26:056633,29,25,14.0,-2.5,0.007 -2015-10-17 01:11:26:056633,29,25,14.0,-2.5,0.007 -2015-10-17 01:11:26:090893,29,26,14.0,-2.0,0.007 -2015-10-17 01:11:26:123230,29,27,14.0,-1.5,0.008 -2015-10-17 01:11:26:158665,29,28,14.0,-1.0,0.008 -2015-10-17 01:11:26:190681,29,29,14.0,-0.5,0.009 -2015-10-17 01:11:26:222644,29,30,14.0,0.0,0.009 -2015-10-17 01:11:26:254944,29,31,14.0,0.5,0.009 -2015-10-17 01:11:26:291364,29,32,14.0,1.0,0.008 -2015-10-17 01:11:26:326766,29,33,14.0,1.5,0.008 -2015-10-17 01:11:26:358788,29,34,14.0,2.0,0.007 -2015-10-17 01:11:26:390858,29,35,14.0,2.5,0.007 -2015-10-17 01:11:26:422962,29,36,14.0,3.0,0.006 -2015-10-17 01:11:26:454909,29,37,14.0,3.5,0.005 -2015-10-17 01:11:26:486918,29,38,14.0,4.0,0.005 -2015-10-17 01:11:26:518661,29,39,14.0,4.5,0.004 -2015-10-17 01:11:26:551004,29,40,14.0,5.0,0.004 -2015-10-17 01:11:26:586368,29,41,14.0,5.5,0.004 -2015-10-17 01:11:26:617873,29,42,14.0,6.0,0.005 -2015-10-17 01:11:26:650834,29,43,14.0,6.5,0.005 -2015-10-17 01:11:26:684210,29,44,14.0,7.0,0.006 -2015-10-17 01:11:26:719232,29,45,14.0,7.5,0.007 -2015-10-17 01:11:26:753185,29,46,14.0,8.0,0.007 -2015-10-17 01:11:26:787679,29,47,14.0,8.5,0.008 -2015-10-17 01:11:26:820007,29,48,14.0,9.0,0.008 -2015-10-17 01:11:26:856872,29,49,14.0,9.5,0.009 -2015-10-17 01:11:26:893332,29,50,14.0,10.0,0.009 -2015-10-17 01:11:26:929321,29,51,14.0,10.5,0.009 -2015-10-17 01:11:26:963438,29,52,14.0,11.0,0.008 -2015-10-17 01:11:26:995258,29,53,14.0,11.5,0.008 -2015-10-17 01:11:27:027436,29,54,14.0,12.0,0.007 -2015-10-17 01:11:27:059787,29,55,14.0,12.5,0.007 -2015-10-17 01:11:27:059787,29,55,14.0,12.5,0.007 -2015-10-17 01:11:27:092425,29,56,14.0,13.0,0.006 -2015-10-17 01:11:27:123336,29,57,14.0,13.5,0.005 -2015-10-17 01:11:27:155935,29,58,14.0,14.0,0.005 -2015-10-17 01:11:27:189765,29,59,14.0,14.5,0.004 diff --git a/test2d.dat b/test2d.dat new file mode 100644 index 00000000000..15981098b06 --- /dev/null +++ b/test2d.dat @@ -0,0 +1,1652 @@ +# chan1 chan0 amplitude_4 amplitude_0 +# "chan1" "chan0" "amplitude" "amplitude" +# 30 54 +-15 -15 0.009 0.003 +-15 -14.5 0.009 0.004 +-15 -14 0.01 0.004 +-15 -13.5 0.011 0.004 +-15 -13 0.012 0.005 +-15 -12.5 0.013 0.005 +-15 -12 0.014 0.005 +-15 -11.5 0.015 0.006 +-15 -11 0.016 0.006 +-15 -10.5 0.017 0.006 +-15 -10 0.017 0.006 +-15 -9.5 0.017 0.006 +-15 -9 0.016 0.006 +-15 -8.5 0.015 0.006 +-15 -8 0.014 0.005 +-15 -7.5 0.013 0.005 +-15 -7 0.012 0.005 +-15 -6.5 0.011 0.004 +-15 -6 0.01 0.004 +-15 -5.5 0.009 0.004 +-15 -5 0.009 0.003 +-15 -4.5 0.009 0.004 +-15 -4 0.01 0.004 +-15 -3.5 0.011 0.004 +-15 -3 0.012 0.005 +-15 -2.5 0.013 0.005 +-15 -2 0.014 0.005 +-15 -1.5 0.015 0.006 +-15 -1 0.016 0.006 +-15 -0.5 0.017 0.006 +-15 0 0.017 0.006 +-15 0.5 0.017 0.006 +-15 1 0.016 0.006 +-15 1.5 0.015 0.006 +-15 2 0.014 0.005 +-15 2.5 0.013 0.005 +-15 3 0.012 0.005 +-15 3.5 0.011 0.004 +-15 4 0.01 0.004 +-15 4.5 0.009 0.004 +-15 5 0.009 0.003 +-15 5.5 0.009 0.004 +-15 6 0.01 0.004 +-15 6.5 0.011 0.004 +-15 7 0.012 0.005 +-15 7.5 0.013 0.005 +-15 8 0.014 0.005 +-15 8.5 0.015 0.006 +-15 9 0.016 0.006 +-15 9.5 0.017 0.006 +-15 10 0.017 0.006 +-15 10.5 0.017 0.006 +-15 11 0.016 0.006 +-15 11.5 0.015 0.006 + +-14 -15 0.01 0.004 +-14 -14.5 0.012 0.004 +-14 -14 0.013 0.005 +-14 -13.5 0.015 0.005 +-14 -13 0.017 0.006 +-14 -12.5 0.019 0.007 +-14 -12 0.021 0.007 +-14 -11.5 0.023 0.008 +-14 -11 0.025 0.008 +-14 -10.5 0.026 0.009 +-14 -10 0.027 0.009 +-14 -9.5 0.026 0.009 +-14 -9 0.025 0.008 +-14 -8.5 0.023 0.008 +-14 -8 0.021 0.007 +-14 -7.5 0.019 0.007 +-14 -7 0.017 0.006 +-14 -6.5 0.015 0.005 +-14 -6 0.013 0.005 +-14 -5.5 0.012 0.004 +-14 -5 0.01 0.004 +-14 -4.5 0.012 0.004 +-14 -4 0.013 0.005 +-14 -3.5 0.015 0.005 +-14 -3 0.017 0.006 +-14 -2.5 0.019 0.007 +-14 -2 0.021 0.007 +-14 -1.5 0.023 0.008 +-14 -1 0.025 0.008 +-14 -0.5 0.026 0.009 +-14 0 0.027 0.009 +-14 0.5 0.026 0.009 +-14 1 0.025 0.008 +-14 1.5 0.023 0.008 +-14 2 0.021 0.007 +-14 2.5 0.019 0.007 +-14 3 0.017 0.006 +-14 3.5 0.015 0.005 +-14 4 0.013 0.005 +-14 4.5 0.012 0.004 +-14 5 0.01 0.004 +-14 5.5 0.012 0.004 +-14 6 0.013 0.005 +-14 6.5 0.015 0.005 +-14 7 0.017 0.006 +-14 7.5 0.019 0.007 +-14 8 0.021 0.007 +-14 8.5 0.023 0.008 +-14 9 0.025 0.008 +-14 9.5 0.026 0.009 +-14 10 0.027 0.009 +-14 10.5 0.026 0.009 +-14 11 0.025 0.008 +-14 11.5 0.023 0.008 + +-13 -15 0.012 0.005 +-13 -14.5 0.014 0.005 +-13 -14 0.017 0.006 +-13 -13.5 0.02 0.007 +-13 -13 0.024 0.008 +-13 -12.5 0.028 0.009 +-13 -12 0.033 0.01 +-13 -11.5 0.039 0.012 +-13 -11 0.044 0.013 +-13 -10.5 0.048 0.014 +-13 -10 0.05 0.014 +-13 -9.5 0.048 0.014 +-13 -9 0.044 0.013 +-13 -8.5 0.039 0.012 +-13 -8 0.033 0.01 +-13 -7.5 0.028 0.009 +-13 -7 0.024 0.008 +-13 -6.5 0.02 0.007 +-13 -6 0.017 0.006 +-13 -5.5 0.014 0.005 +-13 -5 0.012 0.005 +-13 -4.5 0.014 0.005 +-13 -4 0.017 0.006 +-13 -3.5 0.02 0.007 +-13 -3 0.024 0.008 +-13 -2.5 0.028 0.009 +-13 -2 0.033 0.01 +-13 -1.5 0.039 0.012 +-13 -1 0.044 0.013 +-13 -0.5 0.048 0.014 +-13 0 0.05 0.014 +-13 0.5 0.048 0.014 +-13 1 0.044 0.013 +-13 1.5 0.039 0.012 +-13 2 0.033 0.01 +-13 2.5 0.028 0.009 +-13 3 0.024 0.008 +-13 3.5 0.02 0.007 +-13 4 0.017 0.006 +-13 4.5 0.014 0.005 +-13 5 0.012 0.005 +-13 5.5 0.014 0.005 +-13 6 0.017 0.006 +-13 6.5 0.02 0.007 +-13 7 0.024 0.008 +-13 7.5 0.028 0.009 +-13 8 0.033 0.01 +-13 8.5 0.039 0.012 +-13 9 0.044 0.013 +-13 9.5 0.048 0.014 +-13 10 0.05 0.014 +-13 10.5 0.048 0.014 +-13 11 0.044 0.013 +-13 11.5 0.039 0.012 + +-12 -15 0.014 0.005 +-12 -14.5 0.017 0.006 +-12 -14 0.021 0.007 +-12 -13.5 0.026 0.009 +-12 -13 0.033 0.01 +-12 -12.5 0.043 0.013 +-12 -12 0.057 0.016 +-12 -11.5 0.074 0.019 +-12 -11 0.094 0.023 +-12 -10.5 0.11 0.026 +-12 -10 0.117 0.027 +-12 -9.5 0.11 0.026 +-12 -9 0.094 0.023 +-12 -8.5 0.074 0.019 +-12 -8 0.057 0.016 +-12 -7.5 0.043 0.013 +-12 -7 0.033 0.01 +-12 -6.5 0.026 0.009 +-12 -6 0.021 0.007 +-12 -5.5 0.017 0.006 +-12 -5 0.014 0.005 +-12 -4.5 0.017 0.006 +-12 -4 0.021 0.007 +-12 -3.5 0.026 0.009 +-12 -3 0.033 0.01 +-12 -2.5 0.043 0.013 +-12 -2 0.057 0.016 +-12 -1.5 0.074 0.019 +-12 -1 0.094 0.023 +-12 -0.5 0.11 0.026 +-12 0 0.117 0.027 +-12 0.5 0.11 0.026 +-12 1 0.094 0.023 +-12 1.5 0.074 0.019 +-12 2 0.057 0.016 +-12 2.5 0.043 0.013 +-12 3 0.033 0.01 +-12 3.5 0.026 0.009 +-12 4 0.021 0.007 +-12 4.5 0.017 0.006 +-12 5 0.014 0.005 +-12 5.5 0.017 0.006 +-12 6 0.021 0.007 +-12 6.5 0.026 0.009 +-12 7 0.033 0.01 +-12 7.5 0.043 0.013 +-12 8 0.057 0.016 +-12 8.5 0.074 0.019 +-12 9 0.094 0.023 +-12 9.5 0.11 0.026 +-12 10 0.117 0.027 +-12 10.5 0.11 0.026 +-12 11 0.094 0.023 +-12 11.5 0.074 0.019 + +-11 -15 0.016 0.006 +-11 -14.5 0.02 0.007 +-11 -14 0.025 0.008 +-11 -13.5 0.033 0.01 +-11 -13 0.044 0.013 +-11 -12.5 0.063 0.017 +-11 -12 0.094 0.023 +-11 -11.5 0.141 0.031 +-11 -11 0.196 0.044 +-11 -10.5 0.228 0.057 +-11 -10 0.233 0.064 +-11 -9.5 0.228 0.057 +-11 -9 0.196 0.044 +-11 -8.5 0.141 0.031 +-11 -8 0.094 0.023 +-11 -7.5 0.063 0.017 +-11 -7 0.044 0.013 +-11 -6.5 0.033 0.01 +-11 -6 0.025 0.008 +-11 -5.5 0.02 0.007 +-11 -5 0.016 0.006 +-11 -4.5 0.02 0.007 +-11 -4 0.025 0.008 +-11 -3.5 0.033 0.01 +-11 -3 0.044 0.013 +-11 -2.5 0.063 0.017 +-11 -2 0.094 0.023 +-11 -1.5 0.141 0.031 +-11 -1 0.196 0.044 +-11 -0.5 0.228 0.057 +-11 0 0.233 0.064 +-11 0.5 0.228 0.057 +-11 1 0.196 0.044 +-11 1.5 0.141 0.031 +-11 2 0.094 0.023 +-11 2.5 0.063 0.017 +-11 3 0.044 0.013 +-11 3.5 0.033 0.01 +-11 4 0.025 0.008 +-11 4.5 0.02 0.007 +-11 5 0.016 0.006 +-11 5.5 0.02 0.007 +-11 6 0.025 0.008 +-11 6.5 0.033 0.01 +-11 7 0.044 0.013 +-11 7.5 0.063 0.017 +-11 8 0.094 0.023 +-11 8.5 0.141 0.031 +-11 9 0.196 0.044 +-11 9.5 0.228 0.057 +-11 10 0.233 0.064 +-11 10.5 0.228 0.057 +-11 11 0.196 0.044 +-11 11.5 0.141 0.031 + +-10 -15 0.017 0.006 +-10 -14.5 0.021 0.007 +-10 -14 0.027 0.009 +-10 -13.5 0.035 0.011 +-10 -13 0.05 0.014 +-10 -12.5 0.074 0.019 +-10 -12 0.117 0.027 +-10 -11.5 0.184 0.04 +-10 -11 0.233 0.064 +-10 -10.5 0.201 0.099 +-10 -10 0.147 0.117 +-10 -9.5 0.201 0.099 +-10 -9 0.233 0.064 +-10 -8.5 0.184 0.04 +-10 -8 0.117 0.027 +-10 -7.5 0.074 0.019 +-10 -7 0.05 0.014 +-10 -6.5 0.035 0.011 +-10 -6 0.027 0.009 +-10 -5.5 0.021 0.007 +-10 -5 0.017 0.006 +-10 -4.5 0.021 0.007 +-10 -4 0.027 0.009 +-10 -3.5 0.035 0.011 +-10 -3 0.05 0.014 +-10 -2.5 0.074 0.019 +-10 -2 0.117 0.027 +-10 -1.5 0.184 0.04 +-10 -1 0.233 0.064 +-10 -0.5 0.201 0.099 +-10 0 0.147 0.117 +-10 0.5 0.201 0.099 +-10 1 0.233 0.064 +-10 1.5 0.184 0.04 +-10 2 0.117 0.027 +-10 2.5 0.074 0.019 +-10 3 0.05 0.014 +-10 3.5 0.035 0.011 +-10 4 0.027 0.009 +-10 4.5 0.021 0.007 +-10 5 0.017 0.006 +-10 5.5 0.021 0.007 +-10 6 0.027 0.009 +-10 6.5 0.035 0.011 +-10 7 0.05 0.014 +-10 7.5 0.074 0.019 +-10 8 0.117 0.027 +-10 8.5 0.184 0.04 +-10 9 0.233 0.064 +-10 9.5 0.201 0.099 +-10 10 0.147 0.117 +-10 10.5 0.201 0.099 +-10 11 0.233 0.064 +-10 11.5 0.184 0.04 + +-9 -15 0.016 0.006 +-9 -14.5 0.02 0.007 +-9 -14 0.025 0.008 +-9 -13.5 0.033 0.01 +-9 -13 0.044 0.013 +-9 -12.5 0.063 0.017 +-9 -12 0.094 0.023 +-9 -11.5 0.141 0.031 +-9 -11 0.196 0.044 +-9 -10.5 0.228 0.057 +-9 -10 0.233 0.064 +-9 -9.5 0.228 0.057 +-9 -9 0.196 0.044 +-9 -8.5 0.141 0.031 +-9 -8 0.094 0.023 +-9 -7.5 0.063 0.017 +-9 -7 0.044 0.013 +-9 -6.5 0.033 0.01 +-9 -6 0.025 0.008 +-9 -5.5 0.02 0.007 +-9 -5 0.016 0.006 +-9 -4.5 0.02 0.007 +-9 -4 0.025 0.008 +-9 -3.5 0.033 0.01 +-9 -3 0.044 0.013 +-9 -2.5 0.063 0.017 +-9 -2 0.094 0.023 +-9 -1.5 0.141 0.031 +-9 -1 0.196 0.044 +-9 -0.5 0.228 0.057 +-9 0 0.233 0.064 +-9 0.5 0.228 0.057 +-9 1 0.196 0.044 +-9 1.5 0.141 0.031 +-9 2 0.094 0.023 +-9 2.5 0.063 0.017 +-9 3 0.044 0.013 +-9 3.5 0.033 0.01 +-9 4 0.025 0.008 +-9 4.5 0.02 0.007 +-9 5 0.016 0.006 +-9 5.5 0.02 0.007 +-9 6 0.025 0.008 +-9 6.5 0.033 0.01 +-9 7 0.044 0.013 +-9 7.5 0.063 0.017 +-9 8 0.094 0.023 +-9 8.5 0.141 0.031 +-9 9 0.196 0.044 +-9 9.5 0.228 0.057 +-9 10 0.233 0.064 +-9 10.5 0.228 0.057 +-9 11 0.196 0.044 +-9 11.5 0.141 0.031 + +-8 -15 0.014 0.005 +-8 -14.5 0.017 0.006 +-8 -14 0.021 0.007 +-8 -13.5 0.026 0.009 +-8 -13 0.033 0.01 +-8 -12.5 0.043 0.013 +-8 -12 0.057 0.016 +-8 -11.5 0.074 0.019 +-8 -11 0.094 0.023 +-8 -10.5 0.11 0.026 +-8 -10 0.117 0.027 +-8 -9.5 0.11 0.026 +-8 -9 0.094 0.023 +-8 -8.5 0.074 0.019 +-8 -8 0.057 0.016 +-8 -7.5 0.043 0.013 +-8 -7 0.033 0.01 +-8 -6.5 0.026 0.009 +-8 -6 0.021 0.007 +-8 -5.5 0.017 0.006 +-8 -5 0.014 0.005 +-8 -4.5 0.017 0.006 +-8 -4 0.021 0.007 +-8 -3.5 0.026 0.009 +-8 -3 0.033 0.01 +-8 -2.5 0.043 0.013 +-8 -2 0.057 0.016 +-8 -1.5 0.074 0.019 +-8 -1 0.094 0.023 +-8 -0.5 0.11 0.026 +-8 0 0.117 0.027 +-8 0.5 0.11 0.026 +-8 1 0.094 0.023 +-8 1.5 0.074 0.019 +-8 2 0.057 0.016 +-8 2.5 0.043 0.013 +-8 3 0.033 0.01 +-8 3.5 0.026 0.009 +-8 4 0.021 0.007 +-8 4.5 0.017 0.006 +-8 5 0.014 0.005 +-8 5.5 0.017 0.006 +-8 6 0.021 0.007 +-8 6.5 0.026 0.009 +-8 7 0.033 0.01 +-8 7.5 0.043 0.013 +-8 8 0.057 0.016 +-8 8.5 0.074 0.019 +-8 9 0.094 0.023 +-8 9.5 0.11 0.026 +-8 10 0.117 0.027 +-8 10.5 0.11 0.026 +-8 11 0.094 0.023 +-8 11.5 0.074 0.019 + +-7 -15 0.012 0.005 +-7 -14.5 0.014 0.005 +-7 -14 0.017 0.006 +-7 -13.5 0.02 0.007 +-7 -13 0.024 0.008 +-7 -12.5 0.028 0.009 +-7 -12 0.033 0.01 +-7 -11.5 0.039 0.012 +-7 -11 0.044 0.013 +-7 -10.5 0.048 0.014 +-7 -10 0.05 0.014 +-7 -9.5 0.048 0.014 +-7 -9 0.044 0.013 +-7 -8.5 0.039 0.012 +-7 -8 0.033 0.01 +-7 -7.5 0.028 0.009 +-7 -7 0.024 0.008 +-7 -6.5 0.02 0.007 +-7 -6 0.017 0.006 +-7 -5.5 0.014 0.005 +-7 -5 0.012 0.005 +-7 -4.5 0.014 0.005 +-7 -4 0.017 0.006 +-7 -3.5 0.02 0.007 +-7 -3 0.024 0.008 +-7 -2.5 0.028 0.009 +-7 -2 0.033 0.01 +-7 -1.5 0.039 0.012 +-7 -1 0.044 0.013 +-7 -0.5 0.048 0.014 +-7 0 0.05 0.014 +-7 0.5 0.048 0.014 +-7 1 0.044 0.013 +-7 1.5 0.039 0.012 +-7 2 0.033 0.01 +-7 2.5 0.028 0.009 +-7 3 0.024 0.008 +-7 3.5 0.02 0.007 +-7 4 0.017 0.006 +-7 4.5 0.014 0.005 +-7 5 0.012 0.005 +-7 5.5 0.014 0.005 +-7 6 0.017 0.006 +-7 6.5 0.02 0.007 +-7 7 0.024 0.008 +-7 7.5 0.028 0.009 +-7 8 0.033 0.01 +-7 8.5 0.039 0.012 +-7 9 0.044 0.013 +-7 9.5 0.048 0.014 +-7 10 0.05 0.014 +-7 10.5 0.048 0.014 +-7 11 0.044 0.013 +-7 11.5 0.039 0.012 + +-6 -15 0.01 0.004 +-6 -14.5 0.012 0.004 +-6 -14 0.013 0.005 +-6 -13.5 0.015 0.005 +-6 -13 0.017 0.006 +-6 -12.5 0.019 0.007 +-6 -12 0.021 0.007 +-6 -11.5 0.023 0.008 +-6 -11 0.025 0.008 +-6 -10.5 0.026 0.009 +-6 -10 0.027 0.009 +-6 -9.5 0.026 0.009 +-6 -9 0.025 0.008 +-6 -8.5 0.023 0.008 +-6 -8 0.021 0.007 +-6 -7.5 0.019 0.007 +-6 -7 0.017 0.006 +-6 -6.5 0.015 0.005 +-6 -6 0.013 0.005 +-6 -5.5 0.012 0.004 +-6 -5 0.01 0.004 +-6 -4.5 0.012 0.004 +-6 -4 0.013 0.005 +-6 -3.5 0.015 0.005 +-6 -3 0.017 0.006 +-6 -2.5 0.019 0.007 +-6 -2 0.021 0.007 +-6 -1.5 0.023 0.008 +-6 -1 0.025 0.008 +-6 -0.5 0.026 0.009 +-6 0 0.027 0.009 +-6 0.5 0.026 0.009 +-6 1 0.025 0.008 +-6 1.5 0.023 0.008 +-6 2 0.021 0.007 +-6 2.5 0.019 0.007 +-6 3 0.017 0.006 +-6 3.5 0.015 0.005 +-6 4 0.013 0.005 +-6 4.5 0.012 0.004 +-6 5 0.01 0.004 +-6 5.5 0.012 0.004 +-6 6 0.013 0.005 +-6 6.5 0.015 0.005 +-6 7 0.017 0.006 +-6 7.5 0.019 0.007 +-6 8 0.021 0.007 +-6 8.5 0.023 0.008 +-6 9 0.025 0.008 +-6 9.5 0.026 0.009 +-6 10 0.027 0.009 +-6 10.5 0.026 0.009 +-6 11 0.025 0.008 +-6 11.5 0.023 0.008 + +-5 -15 0.009 0.003 +-5 -14.5 0.009 0.004 +-5 -14 0.01 0.004 +-5 -13.5 0.011 0.004 +-5 -13 0.012 0.005 +-5 -12.5 0.013 0.005 +-5 -12 0.014 0.005 +-5 -11.5 0.015 0.006 +-5 -11 0.016 0.006 +-5 -10.5 0.017 0.006 +-5 -10 0.017 0.006 +-5 -9.5 0.017 0.006 +-5 -9 0.016 0.006 +-5 -8.5 0.015 0.006 +-5 -8 0.014 0.005 +-5 -7.5 0.013 0.005 +-5 -7 0.012 0.005 +-5 -6.5 0.011 0.004 +-5 -6 0.01 0.004 +-5 -5.5 0.009 0.004 +-5 -5 0.009 0.003 +-5 -4.5 0.009 0.004 +-5 -4 0.01 0.004 +-5 -3.5 0.011 0.004 +-5 -3 0.012 0.005 +-5 -2.5 0.013 0.005 +-5 -2 0.014 0.005 +-5 -1.5 0.015 0.006 +-5 -1 0.016 0.006 +-5 -0.5 0.017 0.006 +-5 0 0.017 0.006 +-5 0.5 0.017 0.006 +-5 1 0.016 0.006 +-5 1.5 0.015 0.006 +-5 2 0.014 0.005 +-5 2.5 0.013 0.005 +-5 3 0.012 0.005 +-5 3.5 0.011 0.004 +-5 4 0.01 0.004 +-5 4.5 0.009 0.004 +-5 5 0.009 0.003 +-5 5.5 0.009 0.004 +-5 6 0.01 0.004 +-5 6.5 0.011 0.004 +-5 7 0.012 0.005 +-5 7.5 0.013 0.005 +-5 8 0.014 0.005 +-5 8.5 0.015 0.006 +-5 9 0.016 0.006 +-5 9.5 0.017 0.006 +-5 10 0.017 0.006 +-5 10.5 0.017 0.006 +-5 11 0.016 0.006 +-5 11.5 0.015 0.006 + +-4 -15 0.01 0.004 +-4 -14.5 0.012 0.004 +-4 -14 0.013 0.005 +-4 -13.5 0.015 0.005 +-4 -13 0.017 0.006 +-4 -12.5 0.019 0.007 +-4 -12 0.021 0.007 +-4 -11.5 0.023 0.008 +-4 -11 0.025 0.008 +-4 -10.5 0.026 0.009 +-4 -10 0.027 0.009 +-4 -9.5 0.026 0.009 +-4 -9 0.025 0.008 +-4 -8.5 0.023 0.008 +-4 -8 0.021 0.007 +-4 -7.5 0.019 0.007 +-4 -7 0.017 0.006 +-4 -6.5 0.015 0.005 +-4 -6 0.013 0.005 +-4 -5.5 0.012 0.004 +-4 -5 0.01 0.004 +-4 -4.5 0.012 0.004 +-4 -4 0.013 0.005 +-4 -3.5 0.015 0.005 +-4 -3 0.017 0.006 +-4 -2.5 0.019 0.007 +-4 -2 0.021 0.007 +-4 -1.5 0.023 0.008 +-4 -1 0.025 0.008 +-4 -0.5 0.026 0.009 +-4 0 0.027 0.009 +-4 0.5 0.026 0.009 +-4 1 0.025 0.008 +-4 1.5 0.023 0.008 +-4 2 0.021 0.007 +-4 2.5 0.019 0.007 +-4 3 0.017 0.006 +-4 3.5 0.015 0.005 +-4 4 0.013 0.005 +-4 4.5 0.012 0.004 +-4 5 0.01 0.004 +-4 5.5 0.012 0.004 +-4 6 0.013 0.005 +-4 6.5 0.015 0.005 +-4 7 0.017 0.006 +-4 7.5 0.019 0.007 +-4 8 0.021 0.007 +-4 8.5 0.023 0.008 +-4 9 0.025 0.008 +-4 9.5 0.026 0.009 +-4 10 0.027 0.009 +-4 10.5 0.026 0.009 +-4 11 0.025 0.008 +-4 11.5 0.023 0.008 + +-3 -15 0.012 0.005 +-3 -14.5 0.014 0.005 +-3 -14 0.017 0.006 +-3 -13.5 0.02 0.007 +-3 -13 0.024 0.008 +-3 -12.5 0.028 0.009 +-3 -12 0.033 0.01 +-3 -11.5 0.039 0.012 +-3 -11 0.044 0.013 +-3 -10.5 0.048 0.014 +-3 -10 0.05 0.014 +-3 -9.5 0.048 0.014 +-3 -9 0.044 0.013 +-3 -8.5 0.039 0.012 +-3 -8 0.033 0.01 +-3 -7.5 0.028 0.009 +-3 -7 0.024 0.008 +-3 -6.5 0.02 0.007 +-3 -6 0.017 0.006 +-3 -5.5 0.014 0.005 +-3 -5 0.012 0.005 +-3 -4.5 0.014 0.005 +-3 -4 0.017 0.006 +-3 -3.5 0.02 0.007 +-3 -3 0.024 0.008 +-3 -2.5 0.028 0.009 +-3 -2 0.033 0.01 +-3 -1.5 0.039 0.012 +-3 -1 0.044 0.013 +-3 -0.5 0.048 0.014 +-3 0 0.05 0.014 +-3 0.5 0.048 0.014 +-3 1 0.044 0.013 +-3 1.5 0.039 0.012 +-3 2 0.033 0.01 +-3 2.5 0.028 0.009 +-3 3 0.024 0.008 +-3 3.5 0.02 0.007 +-3 4 0.017 0.006 +-3 4.5 0.014 0.005 +-3 5 0.012 0.005 +-3 5.5 0.014 0.005 +-3 6 0.017 0.006 +-3 6.5 0.02 0.007 +-3 7 0.024 0.008 +-3 7.5 0.028 0.009 +-3 8 0.033 0.01 +-3 8.5 0.039 0.012 +-3 9 0.044 0.013 +-3 9.5 0.048 0.014 +-3 10 0.05 0.014 +-3 10.5 0.048 0.014 +-3 11 0.044 0.013 +-3 11.5 0.039 0.012 + +-2 -15 0.014 0.005 +-2 -14.5 0.017 0.006 +-2 -14 0.021 0.007 +-2 -13.5 0.026 0.009 +-2 -13 0.033 0.01 +-2 -12.5 0.043 0.013 +-2 -12 0.057 0.016 +-2 -11.5 0.074 0.019 +-2 -11 0.094 0.023 +-2 -10.5 0.11 0.026 +-2 -10 0.117 0.027 +-2 -9.5 0.11 0.026 +-2 -9 0.094 0.023 +-2 -8.5 0.074 0.019 +-2 -8 0.057 0.016 +-2 -7.5 0.043 0.013 +-2 -7 0.033 0.01 +-2 -6.5 0.026 0.009 +-2 -6 0.021 0.007 +-2 -5.5 0.017 0.006 +-2 -5 0.014 0.005 +-2 -4.5 0.017 0.006 +-2 -4 0.021 0.007 +-2 -3.5 0.026 0.009 +-2 -3 0.033 0.01 +-2 -2.5 0.043 0.013 +-2 -2 0.057 0.016 +-2 -1.5 0.074 0.019 +-2 -1 0.094 0.023 +-2 -0.5 0.11 0.026 +-2 0 0.117 0.027 +-2 0.5 0.11 0.026 +-2 1 0.094 0.023 +-2 1.5 0.074 0.019 +-2 2 0.057 0.016 +-2 2.5 0.043 0.013 +-2 3 0.033 0.01 +-2 3.5 0.026 0.009 +-2 4 0.021 0.007 +-2 4.5 0.017 0.006 +-2 5 0.014 0.005 +-2 5.5 0.017 0.006 +-2 6 0.021 0.007 +-2 6.5 0.026 0.009 +-2 7 0.033 0.01 +-2 7.5 0.043 0.013 +-2 8 0.057 0.016 +-2 8.5 0.074 0.019 +-2 9 0.094 0.023 +-2 9.5 0.11 0.026 +-2 10 0.117 0.027 +-2 10.5 0.11 0.026 +-2 11 0.094 0.023 +-2 11.5 0.074 0.019 + +-1 -15 0.016 0.006 +-1 -14.5 0.02 0.007 +-1 -14 0.025 0.008 +-1 -13.5 0.033 0.01 +-1 -13 0.044 0.013 +-1 -12.5 0.063 0.017 +-1 -12 0.094 0.023 +-1 -11.5 0.141 0.031 +-1 -11 0.196 0.044 +-1 -10.5 0.228 0.057 +-1 -10 0.233 0.064 +-1 -9.5 0.228 0.057 +-1 -9 0.196 0.044 +-1 -8.5 0.141 0.031 +-1 -8 0.094 0.023 +-1 -7.5 0.063 0.017 +-1 -7 0.044 0.013 +-1 -6.5 0.033 0.01 +-1 -6 0.025 0.008 +-1 -5.5 0.02 0.007 +-1 -5 0.016 0.006 +-1 -4.5 0.02 0.007 +-1 -4 0.025 0.008 +-1 -3.5 0.033 0.01 +-1 -3 0.044 0.013 +-1 -2.5 0.063 0.017 +-1 -2 0.094 0.023 +-1 -1.5 0.141 0.031 +-1 -1 0.196 0.044 +-1 -0.5 0.228 0.057 +-1 0 0.233 0.064 +-1 0.5 0.228 0.057 +-1 1 0.196 0.044 +-1 1.5 0.141 0.031 +-1 2 0.094 0.023 +-1 2.5 0.063 0.017 +-1 3 0.044 0.013 +-1 3.5 0.033 0.01 +-1 4 0.025 0.008 +-1 4.5 0.02 0.007 +-1 5 0.016 0.006 +-1 5.5 0.02 0.007 +-1 6 0.025 0.008 +-1 6.5 0.033 0.01 +-1 7 0.044 0.013 +-1 7.5 0.063 0.017 +-1 8 0.094 0.023 +-1 8.5 0.141 0.031 +-1 9 0.196 0.044 +-1 9.5 0.228 0.057 +-1 10 0.233 0.064 +-1 10.5 0.228 0.057 +-1 11 0.196 0.044 +-1 11.5 0.141 0.031 + +0 -15 0.017 0.006 +0 -14.5 0.021 0.007 +0 -14 0.027 0.009 +0 -13.5 0.035 0.011 +0 -13 0.05 0.014 +0 -12.5 0.074 0.019 +0 -12 0.117 0.027 +0 -11.5 0.184 0.04 +0 -11 0.233 0.064 +0 -10.5 0.201 0.099 +0 -10 0.147 0.117 +0 -9.5 0.201 0.099 +0 -9 0.233 0.064 +0 -8.5 0.184 0.04 +0 -8 0.117 0.027 +0 -7.5 0.074 0.019 +0 -7 0.05 0.014 +0 -6.5 0.035 0.011 +0 -6 0.027 0.009 +0 -5.5 0.021 0.007 +0 -5 0.017 0.006 +0 -4.5 0.021 0.007 +0 -4 0.027 0.009 +0 -3.5 0.035 0.011 +0 -3 0.05 0.014 +0 -2.5 0.074 0.019 +0 -2 0.117 0.027 +0 -1.5 0.184 0.04 +0 -1 0.233 0.064 +0 -0.5 0.201 0.099 +0 0 0.147 0.117 +0 0.5 0.201 0.099 +0 1 0.233 0.064 +0 1.5 0.184 0.04 +0 2 0.117 0.027 +0 2.5 0.074 0.019 +0 3 0.05 0.014 +0 3.5 0.035 0.011 +0 4 0.027 0.009 +0 4.5 0.021 0.007 +0 5 0.017 0.006 +0 5.5 0.021 0.007 +0 6 0.027 0.009 +0 6.5 0.035 0.011 +0 7 0.05 0.014 +0 7.5 0.074 0.019 +0 8 0.117 0.027 +0 8.5 0.184 0.04 +0 9 0.233 0.064 +0 9.5 0.201 0.099 +0 10 0.147 0.117 +0 10.5 0.201 0.099 +0 11 0.233 0.064 +0 11.5 0.184 0.04 + +1 -15 0.016 0.006 +1 -14.5 0.02 0.007 +1 -14 0.025 0.008 +1 -13.5 0.033 0.01 +1 -13 0.044 0.013 +1 -12.5 0.063 0.017 +1 -12 0.094 0.023 +1 -11.5 0.141 0.031 +1 -11 0.196 0.044 +1 -10.5 0.228 0.057 +1 -10 0.233 0.064 +1 -9.5 0.228 0.057 +1 -9 0.196 0.044 +1 -8.5 0.141 0.031 +1 -8 0.094 0.023 +1 -7.5 0.063 0.017 +1 -7 0.044 0.013 +1 -6.5 0.033 0.01 +1 -6 0.025 0.008 +1 -5.5 0.02 0.007 +1 -5 0.016 0.006 +1 -4.5 0.02 0.007 +1 -4 0.025 0.008 +1 -3.5 0.033 0.01 +1 -3 0.044 0.013 +1 -2.5 0.063 0.017 +1 -2 0.094 0.023 +1 -1.5 0.141 0.031 +1 -1 0.196 0.044 +1 -0.5 0.228 0.057 +1 0 0.233 0.064 +1 0.5 0.228 0.057 +1 1 0.196 0.044 +1 1.5 0.141 0.031 +1 2 0.094 0.023 +1 2.5 0.063 0.017 +1 3 0.044 0.013 +1 3.5 0.033 0.01 +1 4 0.025 0.008 +1 4.5 0.02 0.007 +1 5 0.016 0.006 +1 5.5 0.02 0.007 +1 6 0.025 0.008 +1 6.5 0.033 0.01 +1 7 0.044 0.013 +1 7.5 0.063 0.017 +1 8 0.094 0.023 +1 8.5 0.141 0.031 +1 9 0.196 0.044 +1 9.5 0.228 0.057 +1 10 0.233 0.064 +1 10.5 0.228 0.057 +1 11 0.196 0.044 +1 11.5 0.141 0.031 + +2 -15 0.014 0.005 +2 -14.5 0.017 0.006 +2 -14 0.021 0.007 +2 -13.5 0.026 0.009 +2 -13 0.033 0.01 +2 -12.5 0.043 0.013 +2 -12 0.057 0.016 +2 -11.5 0.074 0.019 +2 -11 0.094 0.023 +2 -10.5 0.11 0.026 +2 -10 0.117 0.027 +2 -9.5 0.11 0.026 +2 -9 0.094 0.023 +2 -8.5 0.074 0.019 +2 -8 0.057 0.016 +2 -7.5 0.043 0.013 +2 -7 0.033 0.01 +2 -6.5 0.026 0.009 +2 -6 0.021 0.007 +2 -5.5 0.017 0.006 +2 -5 0.014 0.005 +2 -4.5 0.017 0.006 +2 -4 0.021 0.007 +2 -3.5 0.026 0.009 +2 -3 0.033 0.01 +2 -2.5 0.043 0.013 +2 -2 0.057 0.016 +2 -1.5 0.074 0.019 +2 -1 0.094 0.023 +2 -0.5 0.11 0.026 +2 0 0.117 0.027 +2 0.5 0.11 0.026 +2 1 0.094 0.023 +2 1.5 0.074 0.019 +2 2 0.057 0.016 +2 2.5 0.043 0.013 +2 3 0.033 0.01 +2 3.5 0.026 0.009 +2 4 0.021 0.007 +2 4.5 0.017 0.006 +2 5 0.014 0.005 +2 5.5 0.017 0.006 +2 6 0.021 0.007 +2 6.5 0.026 0.009 +2 7 0.033 0.01 +2 7.5 0.043 0.013 +2 8 0.057 0.016 +2 8.5 0.074 0.019 +2 9 0.094 0.023 +2 9.5 0.11 0.026 +2 10 0.117 0.027 +2 10.5 0.11 0.026 +2 11 0.094 0.023 +2 11.5 0.074 0.019 + +3 -15 0.012 0.005 +3 -14.5 0.014 0.005 +3 -14 0.017 0.006 +3 -13.5 0.02 0.007 +3 -13 0.024 0.008 +3 -12.5 0.028 0.009 +3 -12 0.033 0.01 +3 -11.5 0.039 0.012 +3 -11 0.044 0.013 +3 -10.5 0.048 0.014 +3 -10 0.05 0.014 +3 -9.5 0.048 0.014 +3 -9 0.044 0.013 +3 -8.5 0.039 0.012 +3 -8 0.033 0.01 +3 -7.5 0.028 0.009 +3 -7 0.024 0.008 +3 -6.5 0.02 0.007 +3 -6 0.017 0.006 +3 -5.5 0.014 0.005 +3 -5 0.012 0.005 +3 -4.5 0.014 0.005 +3 -4 0.017 0.006 +3 -3.5 0.02 0.007 +3 -3 0.024 0.008 +3 -2.5 0.028 0.009 +3 -2 0.033 0.01 +3 -1.5 0.039 0.012 +3 -1 0.044 0.013 +3 -0.5 0.048 0.014 +3 0 0.05 0.014 +3 0.5 0.048 0.014 +3 1 0.044 0.013 +3 1.5 0.039 0.012 +3 2 0.033 0.01 +3 2.5 0.028 0.009 +3 3 0.024 0.008 +3 3.5 0.02 0.007 +3 4 0.017 0.006 +3 4.5 0.014 0.005 +3 5 0.012 0.005 +3 5.5 0.014 0.005 +3 6 0.017 0.006 +3 6.5 0.02 0.007 +3 7 0.024 0.008 +3 7.5 0.028 0.009 +3 8 0.033 0.01 +3 8.5 0.039 0.012 +3 9 0.044 0.013 +3 9.5 0.048 0.014 +3 10 0.05 0.014 +3 10.5 0.048 0.014 +3 11 0.044 0.013 +3 11.5 0.039 0.012 + +4 -15 0.01 0.004 +4 -14.5 0.012 0.004 +4 -14 0.013 0.005 +4 -13.5 0.015 0.005 +4 -13 0.017 0.006 +4 -12.5 0.019 0.007 +4 -12 0.021 0.007 +4 -11.5 0.023 0.008 +4 -11 0.025 0.008 +4 -10.5 0.026 0.009 +4 -10 0.027 0.009 +4 -9.5 0.026 0.009 +4 -9 0.025 0.008 +4 -8.5 0.023 0.008 +4 -8 0.021 0.007 +4 -7.5 0.019 0.007 +4 -7 0.017 0.006 +4 -6.5 0.015 0.005 +4 -6 0.013 0.005 +4 -5.5 0.012 0.004 +4 -5 0.01 0.004 +4 -4.5 0.012 0.004 +4 -4 0.013 0.005 +4 -3.5 0.015 0.005 +4 -3 0.017 0.006 +4 -2.5 0.019 0.007 +4 -2 0.021 0.007 +4 -1.5 0.023 0.008 +4 -1 0.025 0.008 +4 -0.5 0.026 0.009 +4 0 0.027 0.009 +4 0.5 0.026 0.009 +4 1 0.025 0.008 +4 1.5 0.023 0.008 +4 2 0.021 0.007 +4 2.5 0.019 0.007 +4 3 0.017 0.006 +4 3.5 0.015 0.005 +4 4 0.013 0.005 +4 4.5 0.012 0.004 +4 5 0.01 0.004 +4 5.5 0.012 0.004 +4 6 0.013 0.005 +4 6.5 0.015 0.005 +4 7 0.017 0.006 +4 7.5 0.019 0.007 +4 8 0.021 0.007 +4 8.5 0.023 0.008 +4 9 0.025 0.008 +4 9.5 0.026 0.009 +4 10 0.027 0.009 +4 10.5 0.026 0.009 +4 11 0.025 0.008 +4 11.5 0.023 0.008 + +5 -15 0.009 0.003 +5 -14.5 0.009 0.004 +5 -14 0.01 0.004 +5 -13.5 0.011 0.004 +5 -13 0.012 0.005 +5 -12.5 0.013 0.005 +5 -12 0.014 0.005 +5 -11.5 0.015 0.006 +5 -11 0.016 0.006 +5 -10.5 0.017 0.006 +5 -10 0.017 0.006 +5 -9.5 0.017 0.006 +5 -9 0.016 0.006 +5 -8.5 0.015 0.006 +5 -8 0.014 0.005 +5 -7.5 0.013 0.005 +5 -7 0.012 0.005 +5 -6.5 0.011 0.004 +5 -6 0.01 0.004 +5 -5.5 0.009 0.004 +5 -5 0.009 0.003 +5 -4.5 0.009 0.004 +5 -4 0.01 0.004 +5 -3.5 0.011 0.004 +5 -3 0.012 0.005 +5 -2.5 0.013 0.005 +5 -2 0.014 0.005 +5 -1.5 0.015 0.006 +5 -1 0.016 0.006 +5 -0.5 0.017 0.006 +5 0 0.017 0.006 +5 0.5 0.017 0.006 +5 1 0.016 0.006 +5 1.5 0.015 0.006 +5 2 0.014 0.005 +5 2.5 0.013 0.005 +5 3 0.012 0.005 +5 3.5 0.011 0.004 +5 4 0.01 0.004 +5 4.5 0.009 0.004 +5 5 0.009 0.003 +5 5.5 0.009 0.004 +5 6 0.01 0.004 +5 6.5 0.011 0.004 +5 7 0.012 0.005 +5 7.5 0.013 0.005 +5 8 0.014 0.005 +5 8.5 0.015 0.006 +5 9 0.016 0.006 +5 9.5 0.017 0.006 +5 10 0.017 0.006 +5 10.5 0.017 0.006 +5 11 0.016 0.006 +5 11.5 0.015 0.006 + +6 -15 0.01 0.004 +6 -14.5 0.012 0.004 +6 -14 0.013 0.005 +6 -13.5 0.015 0.005 +6 -13 0.017 0.006 +6 -12.5 0.019 0.007 +6 -12 0.021 0.007 +6 -11.5 0.023 0.008 +6 -11 0.025 0.008 +6 -10.5 0.026 0.009 +6 -10 0.027 0.009 +6 -9.5 0.026 0.009 +6 -9 0.025 0.008 +6 -8.5 0.023 0.008 +6 -8 0.021 0.007 +6 -7.5 0.019 0.007 +6 -7 0.017 0.006 +6 -6.5 0.015 0.005 +6 -6 0.013 0.005 +6 -5.5 0.012 0.004 +6 -5 0.01 0.004 +6 -4.5 0.012 0.004 +6 -4 0.013 0.005 +6 -3.5 0.015 0.005 +6 -3 0.017 0.006 +6 -2.5 0.019 0.007 +6 -2 0.021 0.007 +6 -1.5 0.023 0.008 +6 -1 0.025 0.008 +6 -0.5 0.026 0.009 +6 0 0.027 0.009 +6 0.5 0.026 0.009 +6 1 0.025 0.008 +6 1.5 0.023 0.008 +6 2 0.021 0.007 +6 2.5 0.019 0.007 +6 3 0.017 0.006 +6 3.5 0.015 0.005 +6 4 0.013 0.005 +6 4.5 0.012 0.004 +6 5 0.01 0.004 +6 5.5 0.012 0.004 +6 6 0.013 0.005 +6 6.5 0.015 0.005 +6 7 0.017 0.006 +6 7.5 0.019 0.007 +6 8 0.021 0.007 +6 8.5 0.023 0.008 +6 9 0.025 0.008 +6 9.5 0.026 0.009 +6 10 0.027 0.009 +6 10.5 0.026 0.009 +6 11 0.025 0.008 +6 11.5 0.023 0.008 + +7 -15 0.012 0.005 +7 -14.5 0.014 0.005 +7 -14 0.017 0.006 +7 -13.5 0.02 0.007 +7 -13 0.024 0.008 +7 -12.5 0.028 0.009 +7 -12 0.033 0.01 +7 -11.5 0.039 0.012 +7 -11 0.044 0.013 +7 -10.5 0.048 0.014 +7 -10 0.05 0.014 +7 -9.5 0.048 0.014 +7 -9 0.044 0.013 +7 -8.5 0.039 0.012 +7 -8 0.033 0.01 +7 -7.5 0.028 0.009 +7 -7 0.024 0.008 +7 -6.5 0.02 0.007 +7 -6 0.017 0.006 +7 -5.5 0.014 0.005 +7 -5 0.012 0.005 +7 -4.5 0.014 0.005 +7 -4 0.017 0.006 +7 -3.5 0.02 0.007 +7 -3 0.024 0.008 +7 -2.5 0.028 0.009 +7 -2 0.033 0.01 +7 -1.5 0.039 0.012 +7 -1 0.044 0.013 +7 -0.5 0.048 0.014 +7 0 0.05 0.014 +7 0.5 0.048 0.014 +7 1 0.044 0.013 +7 1.5 0.039 0.012 +7 2 0.033 0.01 +7 2.5 0.028 0.009 +7 3 0.024 0.008 +7 3.5 0.02 0.007 +7 4 0.017 0.006 +7 4.5 0.014 0.005 +7 5 0.012 0.005 +7 5.5 0.014 0.005 +7 6 0.017 0.006 +7 6.5 0.02 0.007 +7 7 0.024 0.008 +7 7.5 0.028 0.009 +7 8 0.033 0.01 +7 8.5 0.039 0.012 +7 9 0.044 0.013 +7 9.5 0.048 0.014 +7 10 0.05 0.014 +7 10.5 0.048 0.014 +7 11 0.044 0.013 +7 11.5 0.039 0.012 + +8 -15 0.014 0.005 +8 -14.5 0.017 0.006 +8 -14 0.021 0.007 +8 -13.5 0.026 0.009 +8 -13 0.033 0.01 +8 -12.5 0.043 0.013 +8 -12 0.057 0.016 +8 -11.5 0.074 0.019 +8 -11 0.094 0.023 +8 -10.5 0.11 0.026 +8 -10 0.117 0.027 +8 -9.5 0.11 0.026 +8 -9 0.094 0.023 +8 -8.5 0.074 0.019 +8 -8 0.057 0.016 +8 -7.5 0.043 0.013 +8 -7 0.033 0.01 +8 -6.5 0.026 0.009 +8 -6 0.021 0.007 +8 -5.5 0.017 0.006 +8 -5 0.014 0.005 +8 -4.5 0.017 0.006 +8 -4 0.021 0.007 +8 -3.5 0.026 0.009 +8 -3 0.033 0.01 +8 -2.5 0.043 0.013 +8 -2 0.057 0.016 +8 -1.5 0.074 0.019 +8 -1 0.094 0.023 +8 -0.5 0.11 0.026 +8 0 0.117 0.027 +8 0.5 0.11 0.026 +8 1 0.094 0.023 +8 1.5 0.074 0.019 +8 2 0.057 0.016 +8 2.5 0.043 0.013 +8 3 0.033 0.01 +8 3.5 0.026 0.009 +8 4 0.021 0.007 +8 4.5 0.017 0.006 +8 5 0.014 0.005 +8 5.5 0.017 0.006 +8 6 0.021 0.007 +8 6.5 0.026 0.009 +8 7 0.033 0.01 +8 7.5 0.043 0.013 +8 8 0.057 0.016 +8 8.5 0.074 0.019 +8 9 0.094 0.023 +8 9.5 0.11 0.026 +8 10 0.117 0.027 +8 10.5 0.11 0.026 +8 11 0.094 0.023 +8 11.5 0.074 0.019 + +9 -15 0.016 0.006 +9 -14.5 0.02 0.007 +9 -14 0.025 0.008 +9 -13.5 0.033 0.01 +9 -13 0.044 0.013 +9 -12.5 0.063 0.017 +9 -12 0.094 0.023 +9 -11.5 0.141 0.031 +9 -11 0.196 0.044 +9 -10.5 0.228 0.057 +9 -10 0.233 0.064 +9 -9.5 0.228 0.057 +9 -9 0.196 0.044 +9 -8.5 0.141 0.031 +9 -8 0.094 0.023 +9 -7.5 0.063 0.017 +9 -7 0.044 0.013 +9 -6.5 0.033 0.01 +9 -6 0.025 0.008 +9 -5.5 0.02 0.007 +9 -5 0.016 0.006 +9 -4.5 0.02 0.007 +9 -4 0.025 0.008 +9 -3.5 0.033 0.01 +9 -3 0.044 0.013 +9 -2.5 0.063 0.017 +9 -2 0.094 0.023 +9 -1.5 0.141 0.031 +9 -1 0.196 0.044 +9 -0.5 0.228 0.057 +9 0 0.233 0.064 +9 0.5 0.228 0.057 +9 1 0.196 0.044 +9 1.5 0.141 0.031 +9 2 0.094 0.023 +9 2.5 0.063 0.017 +9 3 0.044 0.013 +9 3.5 0.033 0.01 +9 4 0.025 0.008 +9 4.5 0.02 0.007 +9 5 0.016 0.006 +9 5.5 0.02 0.007 +9 6 0.025 0.008 +9 6.5 0.033 0.01 +9 7 0.044 0.013 +9 7.5 0.063 0.017 +9 8 0.094 0.023 +9 8.5 0.141 0.031 +9 9 0.196 0.044 +9 9.5 0.228 0.057 +9 10 0.233 0.064 +9 10.5 0.228 0.057 +9 11 0.196 0.044 +9 11.5 0.141 0.031 + +10 -15 0.017 0.006 +10 -14.5 0.021 0.007 +10 -14 0.027 0.009 +10 -13.5 0.035 0.011 +10 -13 0.05 0.014 +10 -12.5 0.074 0.019 +10 -12 0.117 0.027 +10 -11.5 0.184 0.04 +10 -11 0.233 0.064 +10 -10.5 0.201 0.099 +10 -10 0.147 0.117 +10 -9.5 0.201 0.099 +10 -9 0.233 0.064 +10 -8.5 0.184 0.04 +10 -8 0.117 0.027 +10 -7.5 0.074 0.019 +10 -7 0.05 0.014 +10 -6.5 0.035 0.011 +10 -6 0.027 0.009 +10 -5.5 0.021 0.007 +10 -5 0.017 0.006 +10 -4.5 0.021 0.007 +10 -4 0.027 0.009 +10 -3.5 0.035 0.011 +10 -3 0.05 0.014 +10 -2.5 0.074 0.019 +10 -2 0.117 0.027 +10 -1.5 0.184 0.04 +10 -1 0.233 0.064 +10 -0.5 0.201 0.099 +10 0 0.147 0.117 +10 0.5 0.201 0.099 +10 1 0.233 0.064 +10 1.5 0.184 0.04 +10 2 0.117 0.027 +10 2.5 0.074 0.019 +10 3 0.05 0.014 +10 3.5 0.035 0.011 +10 4 0.027 0.009 +10 4.5 0.021 0.007 +10 5 0.017 0.006 +10 5.5 0.021 0.007 +10 6 0.027 0.009 +10 6.5 0.035 0.011 +10 7 0.05 0.014 +10 7.5 0.074 0.019 +10 8 0.117 0.027 +10 8.5 0.184 0.04 +10 9 0.233 0.064 +10 9.5 0.201 0.099 +10 10 0.147 0.117 +10 10.5 0.201 0.099 +10 11 0.233 0.064 +10 11.5 0.184 0.04 + +11 -15 0.016 0.006 +11 -14.5 0.02 0.007 +11 -14 0.025 0.008 +11 -13.5 0.033 0.01 +11 -13 0.044 0.013 +11 -12.5 0.063 0.017 +11 -12 0.094 0.023 +11 -11.5 0.141 0.031 +11 -11 0.196 0.044 +11 -10.5 0.228 0.057 +11 -10 0.233 0.064 +11 -9.5 0.228 0.057 +11 -9 0.196 0.044 +11 -8.5 0.141 0.031 +11 -8 0.094 0.023 +11 -7.5 0.063 0.017 +11 -7 0.044 0.013 +11 -6.5 0.033 0.01 +11 -6 0.025 0.008 +11 -5.5 0.02 0.007 +11 -5 0.016 0.006 +11 -4.5 0.02 0.007 +11 -4 0.025 0.008 +11 -3.5 0.033 0.01 +11 -3 0.044 0.013 +11 -2.5 0.063 0.017 +11 -2 0.094 0.023 +11 -1.5 0.141 0.031 +11 -1 0.196 0.044 +11 -0.5 0.228 0.057 +11 0 0.233 0.064 +11 0.5 0.228 0.057 +11 1 0.196 0.044 +11 1.5 0.141 0.031 +11 2 0.094 0.023 +11 2.5 0.063 0.017 +11 3 0.044 0.013 +11 3.5 0.033 0.01 +11 4 0.025 0.008 +11 4.5 0.02 0.007 +11 5 0.016 0.006 +11 5.5 0.02 0.007 +11 6 0.025 0.008 +11 6.5 0.033 0.01 +11 7 0.044 0.013 +11 7.5 0.063 0.017 +11 8 0.094 0.023 +11 8.5 0.141 0.031 +11 9 0.196 0.044 +11 9.5 0.228 0.057 +11 10 0.233 0.064 +11 10.5 0.228 0.057 +11 11 0.196 0.044 +11 11.5 0.141 0.031 + +12 -15 0.014 0.005 +12 -14.5 0.017 0.006 +12 -14 0.021 0.007 +12 -13.5 0.026 0.009 +12 -13 0.033 0.01 +12 -12.5 0.043 0.013 +12 -12 0.057 0.016 +12 -11.5 0.074 0.019 +12 -11 0.094 0.023 +12 -10.5 0.11 0.026 +12 -10 0.117 0.027 +12 -9.5 0.11 0.026 +12 -9 0.094 0.023 +12 -8.5 0.074 0.019 +12 -8 0.057 0.016 +12 -7.5 0.043 0.013 +12 -7 0.033 0.01 +12 -6.5 0.026 0.009 +12 -6 0.021 0.007 +12 -5.5 0.017 0.006 +12 -5 0.014 0.005 +12 -4.5 0.017 0.006 +12 -4 0.021 0.007 +12 -3.5 0.026 0.009 +12 -3 0.033 0.01 +12 -2.5 0.043 0.013 +12 -2 0.057 0.016 +12 -1.5 0.074 0.019 +12 -1 0.094 0.023 +12 -0.5 0.11 0.026 +12 0 0.117 0.027 +12 0.5 0.11 0.026 +12 1 0.094 0.023 +12 1.5 0.074 0.019 +12 2 0.057 0.016 +12 2.5 0.043 0.013 +12 3 0.033 0.01 +12 3.5 0.026 0.009 +12 4 0.021 0.007 +12 4.5 0.017 0.006 +12 5 0.014 0.005 +12 5.5 0.017 0.006 +12 6 0.021 0.007 +12 6.5 0.026 0.009 +12 7 0.033 0.01 +12 7.5 0.043 0.013 +12 8 0.057 0.016 +12 8.5 0.074 0.019 +12 9 0.094 0.023 +12 9.5 0.11 0.026 +12 10 0.117 0.027 +12 10.5 0.11 0.026 +12 11 0.094 0.023 +12 11.5 0.074 0.019 + +13 -15 0.012 0.005 +13 -14.5 0.014 0.005 +13 -14 0.017 0.006 +13 -13.5 0.02 0.007 +13 -13 0.024 0.008 +13 -12.5 0.028 0.009 +13 -12 0.033 0.01 +13 -11.5 0.039 0.012 +13 -11 0.044 0.013 +13 -10.5 0.048 0.014 +13 -10 0.05 0.014 +13 -9.5 0.048 0.014 +13 -9 0.044 0.013 +13 -8.5 0.039 0.012 +13 -8 0.033 0.01 +13 -7.5 0.028 0.009 +13 -7 0.024 0.008 +13 -6.5 0.02 0.007 +13 -6 0.017 0.006 +13 -5.5 0.014 0.005 +13 -5 0.012 0.005 +13 -4.5 0.014 0.005 +13 -4 0.017 0.006 +13 -3.5 0.02 0.007 +13 -3 0.024 0.008 +13 -2.5 0.028 0.009 +13 -2 0.033 0.01 +13 -1.5 0.039 0.012 +13 -1 0.044 0.013 +13 -0.5 0.048 0.014 +13 0 0.05 0.014 +13 0.5 0.048 0.014 +13 1 0.044 0.013 +13 1.5 0.039 0.012 +13 2 0.033 0.01 +13 2.5 0.028 0.009 +13 3 0.024 0.008 +13 3.5 0.02 0.007 +13 4 0.017 0.006 +13 4.5 0.014 0.005 +13 5 0.012 0.005 +13 5.5 0.014 0.005 +13 6 0.017 0.006 +13 6.5 0.02 0.007 +13 7 0.024 0.008 +13 7.5 0.028 0.009 +13 8 0.033 0.01 +13 8.5 0.039 0.012 +13 9 0.044 0.013 +13 9.5 0.048 0.014 +13 10 0.05 0.014 +13 10.5 0.048 0.014 +13 11 0.044 0.013 +13 11.5 0.039 0.012 + +14 -15 0.01 0.004 +14 -14.5 0.012 0.004 +14 -14 0.013 0.005 +14 -13.5 0.015 0.005 +14 -13 0.017 0.006 +14 -12.5 0.019 0.007 +14 -12 0.021 0.007 +14 -11.5 0.023 0.008 +14 -11 0.025 0.008 +14 -10.5 0.026 0.009 +14 -10 0.027 0.009 +14 -9.5 0.026 0.009 +14 -9 0.025 0.008 +14 -8.5 0.023 0.008 +14 -8 0.021 0.007 +14 -7.5 0.019 0.007 +14 -7 0.017 0.006 +14 -6.5 0.015 0.005 +14 -6 0.013 0.005 +14 -5.5 0.012 0.004 +14 -5 0.01 0.004 +14 -4.5 0.012 0.004 +14 -4 0.013 0.005 +14 -3.5 0.015 0.005 +14 -3 0.017 0.006 +14 -2.5 0.019 0.007 +14 -2 0.021 0.007 +14 -1.5 0.023 0.008 +14 -1 0.025 0.008 +14 -0.5 0.026 0.009 +14 0 0.027 0.009 +14 0.5 0.026 0.009 +14 1 0.025 0.008 +14 1.5 0.023 0.008 +14 2 0.021 0.007 +14 2.5 0.019 0.007 +14 3 0.017 0.006 +14 3.5 0.015 0.005 +14 4 0.013 0.005 +14 4.5 0.012 0.004 +14 5 0.01 0.004 +14 5.5 0.012 0.004 +14 6 0.013 0.005 +14 6.5 0.015 0.005 +14 7 0.017 0.006 +14 7.5 0.019 0.007 +14 8 0.021 0.007 +14 8.5 0.023 0.008 +14 9 0.025 0.008 +14 9.5 0.026 0.009 +14 10 0.027 0.009 +14 10.5 0.026 0.009 +14 11 0.025 0.008 +14 11.5 0.023 0.008 diff --git a/test_multi_d/chan1.dat b/test_multi_d/chan1.dat new file mode 100644 index 00000000000..9924c59e9a7 --- /dev/null +++ b/test_multi_d/chan1.dat @@ -0,0 +1,33 @@ +# chan1 amplitude_2 +# "chan1" "amplitude" +# 30 +-15 0.006 +-14 0.009 +-13 0.014 +-12 0.027 +-11 0.064 +-10 0.117 +-9 0.064 +-8 0.027 +-7 0.014 +-6 0.009 +-5 0.006 +-4 0.009 +-3 0.014 +-2 0.027 +-1 0.064 +0 0.117 +1 0.064 +2 0.027 +3 0.014 +4 0.009 +5 0.006 +6 0.009 +7 0.014 +8 0.027 +9 0.064 +10 0.117 +11 0.064 +12 0.027 +13 0.014 +14 0.009 diff --git a/test_multi_d/chan1_chan0.dat b/test_multi_d/chan1_chan0.dat new file mode 100644 index 00000000000..dc0912eab98 --- /dev/null +++ b/test_multi_d/chan1_chan0.dat @@ -0,0 +1,932 @@ +# chan1 chan0 amplitude_3_0 +# "chan1" "chan0" "amplitude" +# 30 30 +-15 -15 0.003 +-15 -14 0.004 +-15 -13 0.005 +-15 -12 0.005 +-15 -11 0.006 +-15 -10 0.006 +-15 -9 0.006 +-15 -8 0.005 +-15 -7 0.005 +-15 -6 0.004 +-15 -5 0.003 +-15 -4 0.004 +-15 -3 0.005 +-15 -2 0.005 +-15 -1 0.006 +-15 0 0.006 +-15 1 0.006 +-15 2 0.005 +-15 3 0.005 +-15 4 0.004 +-15 5 0.003 +-15 6 0.004 +-15 7 0.005 +-15 8 0.005 +-15 9 0.006 +-15 10 0.006 +-15 11 0.006 +-15 12 0.005 +-15 13 0.005 +-15 14 0.004 + +-14 -15 0.004 +-14 -14 0.005 +-14 -13 0.006 +-14 -12 0.007 +-14 -11 0.008 +-14 -10 0.009 +-14 -9 0.008 +-14 -8 0.007 +-14 -7 0.006 +-14 -6 0.005 +-14 -5 0.004 +-14 -4 0.005 +-14 -3 0.006 +-14 -2 0.007 +-14 -1 0.008 +-14 0 0.009 +-14 1 0.008 +-14 2 0.007 +-14 3 0.006 +-14 4 0.005 +-14 5 0.004 +-14 6 0.005 +-14 7 0.006 +-14 8 0.007 +-14 9 0.008 +-14 10 0.009 +-14 11 0.008 +-14 12 0.007 +-14 13 0.006 +-14 14 0.005 + +-13 -15 0.005 +-13 -14 0.006 +-13 -13 0.008 +-13 -12 0.01 +-13 -11 0.013 +-13 -10 0.014 +-13 -9 0.013 +-13 -8 0.01 +-13 -7 0.008 +-13 -6 0.006 +-13 -5 0.005 +-13 -4 0.006 +-13 -3 0.008 +-13 -2 0.01 +-13 -1 0.013 +-13 0 0.014 +-13 1 0.013 +-13 2 0.01 +-13 3 0.008 +-13 4 0.006 +-13 5 0.005 +-13 6 0.006 +-13 7 0.008 +-13 8 0.01 +-13 9 0.013 +-13 10 0.014 +-13 11 0.013 +-13 12 0.01 +-13 13 0.008 +-13 14 0.006 + +-12 -15 0.005 +-12 -14 0.007 +-12 -13 0.01 +-12 -12 0.016 +-12 -11 0.023 +-12 -10 0.027 +-12 -9 0.023 +-12 -8 0.016 +-12 -7 0.01 +-12 -6 0.007 +-12 -5 0.005 +-12 -4 0.007 +-12 -3 0.01 +-12 -2 0.016 +-12 -1 0.023 +-12 0 0.027 +-12 1 0.023 +-12 2 0.016 +-12 3 0.01 +-12 4 0.007 +-12 5 0.005 +-12 6 0.007 +-12 7 0.01 +-12 8 0.016 +-12 9 0.023 +-12 10 0.027 +-12 11 0.023 +-12 12 0.016 +-12 13 0.01 +-12 14 0.007 + +-11 -15 0.006 +-11 -14 0.008 +-11 -13 0.013 +-11 -12 0.023 +-11 -11 0.044 +-11 -10 0.064 +-11 -9 0.044 +-11 -8 0.023 +-11 -7 0.013 +-11 -6 0.008 +-11 -5 0.006 +-11 -4 0.008 +-11 -3 0.013 +-11 -2 0.023 +-11 -1 0.044 +-11 0 0.064 +-11 1 0.044 +-11 2 0.023 +-11 3 0.013 +-11 4 0.008 +-11 5 0.006 +-11 6 0.008 +-11 7 0.013 +-11 8 0.023 +-11 9 0.044 +-11 10 0.064 +-11 11 0.044 +-11 12 0.023 +-11 13 0.013 +-11 14 0.008 + +-10 -15 0.006 +-10 -14 0.009 +-10 -13 0.014 +-10 -12 0.027 +-10 -11 0.064 +-10 -10 0.117 +-10 -9 0.064 +-10 -8 0.027 +-10 -7 0.014 +-10 -6 0.009 +-10 -5 0.006 +-10 -4 0.009 +-10 -3 0.014 +-10 -2 0.027 +-10 -1 0.064 +-10 0 0.117 +-10 1 0.064 +-10 2 0.027 +-10 3 0.014 +-10 4 0.009 +-10 5 0.006 +-10 6 0.009 +-10 7 0.014 +-10 8 0.027 +-10 9 0.064 +-10 10 0.117 +-10 11 0.064 +-10 12 0.027 +-10 13 0.014 +-10 14 0.009 + +-9 -15 0.006 +-9 -14 0.008 +-9 -13 0.013 +-9 -12 0.023 +-9 -11 0.044 +-9 -10 0.064 +-9 -9 0.044 +-9 -8 0.023 +-9 -7 0.013 +-9 -6 0.008 +-9 -5 0.006 +-9 -4 0.008 +-9 -3 0.013 +-9 -2 0.023 +-9 -1 0.044 +-9 0 0.064 +-9 1 0.044 +-9 2 0.023 +-9 3 0.013 +-9 4 0.008 +-9 5 0.006 +-9 6 0.008 +-9 7 0.013 +-9 8 0.023 +-9 9 0.044 +-9 10 0.064 +-9 11 0.044 +-9 12 0.023 +-9 13 0.013 +-9 14 0.008 + +-8 -15 0.005 +-8 -14 0.007 +-8 -13 0.01 +-8 -12 0.016 +-8 -11 0.023 +-8 -10 0.027 +-8 -9 0.023 +-8 -8 0.016 +-8 -7 0.01 +-8 -6 0.007 +-8 -5 0.005 +-8 -4 0.007 +-8 -3 0.01 +-8 -2 0.016 +-8 -1 0.023 +-8 0 0.027 +-8 1 0.023 +-8 2 0.016 +-8 3 0.01 +-8 4 0.007 +-8 5 0.005 +-8 6 0.007 +-8 7 0.01 +-8 8 0.016 +-8 9 0.023 +-8 10 0.027 +-8 11 0.023 +-8 12 0.016 +-8 13 0.01 +-8 14 0.007 + +-7 -15 0.005 +-7 -14 0.006 +-7 -13 0.008 +-7 -12 0.01 +-7 -11 0.013 +-7 -10 0.014 +-7 -9 0.013 +-7 -8 0.01 +-7 -7 0.008 +-7 -6 0.006 +-7 -5 0.005 +-7 -4 0.006 +-7 -3 0.008 +-7 -2 0.01 +-7 -1 0.013 +-7 0 0.014 +-7 1 0.013 +-7 2 0.01 +-7 3 0.008 +-7 4 0.006 +-7 5 0.005 +-7 6 0.006 +-7 7 0.008 +-7 8 0.01 +-7 9 0.013 +-7 10 0.014 +-7 11 0.013 +-7 12 0.01 +-7 13 0.008 +-7 14 0.006 + +-6 -15 0.004 +-6 -14 0.005 +-6 -13 0.006 +-6 -12 0.007 +-6 -11 0.008 +-6 -10 0.009 +-6 -9 0.008 +-6 -8 0.007 +-6 -7 0.006 +-6 -6 0.005 +-6 -5 0.004 +-6 -4 0.005 +-6 -3 0.006 +-6 -2 0.007 +-6 -1 0.008 +-6 0 0.009 +-6 1 0.008 +-6 2 0.007 +-6 3 0.006 +-6 4 0.005 +-6 5 0.004 +-6 6 0.005 +-6 7 0.006 +-6 8 0.007 +-6 9 0.008 +-6 10 0.009 +-6 11 0.008 +-6 12 0.007 +-6 13 0.006 +-6 14 0.005 + +-5 -15 0.003 +-5 -14 0.004 +-5 -13 0.005 +-5 -12 0.005 +-5 -11 0.006 +-5 -10 0.006 +-5 -9 0.006 +-5 -8 0.005 +-5 -7 0.005 +-5 -6 0.004 +-5 -5 0.003 +-5 -4 0.004 +-5 -3 0.005 +-5 -2 0.005 +-5 -1 0.006 +-5 0 0.006 +-5 1 0.006 +-5 2 0.005 +-5 3 0.005 +-5 4 0.004 +-5 5 0.003 +-5 6 0.004 +-5 7 0.005 +-5 8 0.005 +-5 9 0.006 +-5 10 0.006 +-5 11 0.006 +-5 12 0.005 +-5 13 0.005 +-5 14 0.004 + +-4 -15 0.004 +-4 -14 0.005 +-4 -13 0.006 +-4 -12 0.007 +-4 -11 0.008 +-4 -10 0.009 +-4 -9 0.008 +-4 -8 0.007 +-4 -7 0.006 +-4 -6 0.005 +-4 -5 0.004 +-4 -4 0.005 +-4 -3 0.006 +-4 -2 0.007 +-4 -1 0.008 +-4 0 0.009 +-4 1 0.008 +-4 2 0.007 +-4 3 0.006 +-4 4 0.005 +-4 5 0.004 +-4 6 0.005 +-4 7 0.006 +-4 8 0.007 +-4 9 0.008 +-4 10 0.009 +-4 11 0.008 +-4 12 0.007 +-4 13 0.006 +-4 14 0.005 + +-3 -15 0.005 +-3 -14 0.006 +-3 -13 0.008 +-3 -12 0.01 +-3 -11 0.013 +-3 -10 0.014 +-3 -9 0.013 +-3 -8 0.01 +-3 -7 0.008 +-3 -6 0.006 +-3 -5 0.005 +-3 -4 0.006 +-3 -3 0.008 +-3 -2 0.01 +-3 -1 0.013 +-3 0 0.014 +-3 1 0.013 +-3 2 0.01 +-3 3 0.008 +-3 4 0.006 +-3 5 0.005 +-3 6 0.006 +-3 7 0.008 +-3 8 0.01 +-3 9 0.013 +-3 10 0.014 +-3 11 0.013 +-3 12 0.01 +-3 13 0.008 +-3 14 0.006 + +-2 -15 0.005 +-2 -14 0.007 +-2 -13 0.01 +-2 -12 0.016 +-2 -11 0.023 +-2 -10 0.027 +-2 -9 0.023 +-2 -8 0.016 +-2 -7 0.01 +-2 -6 0.007 +-2 -5 0.005 +-2 -4 0.007 +-2 -3 0.01 +-2 -2 0.016 +-2 -1 0.023 +-2 0 0.027 +-2 1 0.023 +-2 2 0.016 +-2 3 0.01 +-2 4 0.007 +-2 5 0.005 +-2 6 0.007 +-2 7 0.01 +-2 8 0.016 +-2 9 0.023 +-2 10 0.027 +-2 11 0.023 +-2 12 0.016 +-2 13 0.01 +-2 14 0.007 + +-1 -15 0.006 +-1 -14 0.008 +-1 -13 0.013 +-1 -12 0.023 +-1 -11 0.044 +-1 -10 0.064 +-1 -9 0.044 +-1 -8 0.023 +-1 -7 0.013 +-1 -6 0.008 +-1 -5 0.006 +-1 -4 0.008 +-1 -3 0.013 +-1 -2 0.023 +-1 -1 0.044 +-1 0 0.064 +-1 1 0.044 +-1 2 0.023 +-1 3 0.013 +-1 4 0.008 +-1 5 0.006 +-1 6 0.008 +-1 7 0.013 +-1 8 0.023 +-1 9 0.044 +-1 10 0.064 +-1 11 0.044 +-1 12 0.023 +-1 13 0.013 +-1 14 0.008 + +0 -15 0.006 +0 -14 0.009 +0 -13 0.014 +0 -12 0.027 +0 -11 0.064 +0 -10 0.117 +0 -9 0.064 +0 -8 0.027 +0 -7 0.014 +0 -6 0.009 +0 -5 0.006 +0 -4 0.009 +0 -3 0.014 +0 -2 0.027 +0 -1 0.064 +0 0 0.117 +0 1 0.064 +0 2 0.027 +0 3 0.014 +0 4 0.009 +0 5 0.006 +0 6 0.009 +0 7 0.014 +0 8 0.027 +0 9 0.064 +0 10 0.117 +0 11 0.064 +0 12 0.027 +0 13 0.014 +0 14 0.009 + +1 -15 0.006 +1 -14 0.008 +1 -13 0.013 +1 -12 0.023 +1 -11 0.044 +1 -10 0.064 +1 -9 0.044 +1 -8 0.023 +1 -7 0.013 +1 -6 0.008 +1 -5 0.006 +1 -4 0.008 +1 -3 0.013 +1 -2 0.023 +1 -1 0.044 +1 0 0.064 +1 1 0.044 +1 2 0.023 +1 3 0.013 +1 4 0.008 +1 5 0.006 +1 6 0.008 +1 7 0.013 +1 8 0.023 +1 9 0.044 +1 10 0.064 +1 11 0.044 +1 12 0.023 +1 13 0.013 +1 14 0.008 + +2 -15 0.005 +2 -14 0.007 +2 -13 0.01 +2 -12 0.016 +2 -11 0.023 +2 -10 0.027 +2 -9 0.023 +2 -8 0.016 +2 -7 0.01 +2 -6 0.007 +2 -5 0.005 +2 -4 0.007 +2 -3 0.01 +2 -2 0.016 +2 -1 0.023 +2 0 0.027 +2 1 0.023 +2 2 0.016 +2 3 0.01 +2 4 0.007 +2 5 0.005 +2 6 0.007 +2 7 0.01 +2 8 0.016 +2 9 0.023 +2 10 0.027 +2 11 0.023 +2 12 0.016 +2 13 0.01 +2 14 0.007 + +3 -15 0.005 +3 -14 0.006 +3 -13 0.008 +3 -12 0.01 +3 -11 0.013 +3 -10 0.014 +3 -9 0.013 +3 -8 0.01 +3 -7 0.008 +3 -6 0.006 +3 -5 0.005 +3 -4 0.006 +3 -3 0.008 +3 -2 0.01 +3 -1 0.013 +3 0 0.014 +3 1 0.013 +3 2 0.01 +3 3 0.008 +3 4 0.006 +3 5 0.005 +3 6 0.006 +3 7 0.008 +3 8 0.01 +3 9 0.013 +3 10 0.014 +3 11 0.013 +3 12 0.01 +3 13 0.008 +3 14 0.006 + +4 -15 0.004 +4 -14 0.005 +4 -13 0.006 +4 -12 0.007 +4 -11 0.008 +4 -10 0.009 +4 -9 0.008 +4 -8 0.007 +4 -7 0.006 +4 -6 0.005 +4 -5 0.004 +4 -4 0.005 +4 -3 0.006 +4 -2 0.007 +4 -1 0.008 +4 0 0.009 +4 1 0.008 +4 2 0.007 +4 3 0.006 +4 4 0.005 +4 5 0.004 +4 6 0.005 +4 7 0.006 +4 8 0.007 +4 9 0.008 +4 10 0.009 +4 11 0.008 +4 12 0.007 +4 13 0.006 +4 14 0.005 + +5 -15 0.003 +5 -14 0.004 +5 -13 0.005 +5 -12 0.005 +5 -11 0.006 +5 -10 0.006 +5 -9 0.006 +5 -8 0.005 +5 -7 0.005 +5 -6 0.004 +5 -5 0.003 +5 -4 0.004 +5 -3 0.005 +5 -2 0.005 +5 -1 0.006 +5 0 0.006 +5 1 0.006 +5 2 0.005 +5 3 0.005 +5 4 0.004 +5 5 0.003 +5 6 0.004 +5 7 0.005 +5 8 0.005 +5 9 0.006 +5 10 0.006 +5 11 0.006 +5 12 0.005 +5 13 0.005 +5 14 0.004 + +6 -15 0.004 +6 -14 0.005 +6 -13 0.006 +6 -12 0.007 +6 -11 0.008 +6 -10 0.009 +6 -9 0.008 +6 -8 0.007 +6 -7 0.006 +6 -6 0.005 +6 -5 0.004 +6 -4 0.005 +6 -3 0.006 +6 -2 0.007 +6 -1 0.008 +6 0 0.009 +6 1 0.008 +6 2 0.007 +6 3 0.006 +6 4 0.005 +6 5 0.004 +6 6 0.005 +6 7 0.006 +6 8 0.007 +6 9 0.008 +6 10 0.009 +6 11 0.008 +6 12 0.007 +6 13 0.006 +6 14 0.005 + +7 -15 0.005 +7 -14 0.006 +7 -13 0.008 +7 -12 0.01 +7 -11 0.013 +7 -10 0.014 +7 -9 0.013 +7 -8 0.01 +7 -7 0.008 +7 -6 0.006 +7 -5 0.005 +7 -4 0.006 +7 -3 0.008 +7 -2 0.01 +7 -1 0.013 +7 0 0.014 +7 1 0.013 +7 2 0.01 +7 3 0.008 +7 4 0.006 +7 5 0.005 +7 6 0.006 +7 7 0.008 +7 8 0.01 +7 9 0.013 +7 10 0.014 +7 11 0.013 +7 12 0.01 +7 13 0.008 +7 14 0.006 + +8 -15 0.005 +8 -14 0.007 +8 -13 0.01 +8 -12 0.016 +8 -11 0.023 +8 -10 0.027 +8 -9 0.023 +8 -8 0.016 +8 -7 0.01 +8 -6 0.007 +8 -5 0.005 +8 -4 0.007 +8 -3 0.01 +8 -2 0.016 +8 -1 0.023 +8 0 0.027 +8 1 0.023 +8 2 0.016 +8 3 0.01 +8 4 0.007 +8 5 0.005 +8 6 0.007 +8 7 0.01 +8 8 0.016 +8 9 0.023 +8 10 0.027 +8 11 0.023 +8 12 0.016 +8 13 0.01 +8 14 0.007 + +9 -15 0.006 +9 -14 0.008 +9 -13 0.013 +9 -12 0.023 +9 -11 0.044 +9 -10 0.064 +9 -9 0.044 +9 -8 0.023 +9 -7 0.013 +9 -6 0.008 +9 -5 0.006 +9 -4 0.008 +9 -3 0.013 +9 -2 0.023 +9 -1 0.044 +9 0 0.064 +9 1 0.044 +9 2 0.023 +9 3 0.013 +9 4 0.008 +9 5 0.006 +9 6 0.008 +9 7 0.013 +9 8 0.023 +9 9 0.044 +9 10 0.064 +9 11 0.044 +9 12 0.023 +9 13 0.013 +9 14 0.008 + +10 -15 0.006 +10 -14 0.009 +10 -13 0.014 +10 -12 0.027 +10 -11 0.064 +10 -10 0.117 +10 -9 0.064 +10 -8 0.027 +10 -7 0.014 +10 -6 0.009 +10 -5 0.006 +10 -4 0.009 +10 -3 0.014 +10 -2 0.027 +10 -1 0.064 +10 0 0.117 +10 1 0.064 +10 2 0.027 +10 3 0.014 +10 4 0.009 +10 5 0.006 +10 6 0.009 +10 7 0.014 +10 8 0.027 +10 9 0.064 +10 10 0.117 +10 11 0.064 +10 12 0.027 +10 13 0.014 +10 14 0.009 + +11 -15 0.006 +11 -14 0.008 +11 -13 0.013 +11 -12 0.023 +11 -11 0.044 +11 -10 0.064 +11 -9 0.044 +11 -8 0.023 +11 -7 0.013 +11 -6 0.008 +11 -5 0.006 +11 -4 0.008 +11 -3 0.013 +11 -2 0.023 +11 -1 0.044 +11 0 0.064 +11 1 0.044 +11 2 0.023 +11 3 0.013 +11 4 0.008 +11 5 0.006 +11 6 0.008 +11 7 0.013 +11 8 0.023 +11 9 0.044 +11 10 0.064 +11 11 0.044 +11 12 0.023 +11 13 0.013 +11 14 0.008 + +12 -15 0.005 +12 -14 0.007 +12 -13 0.01 +12 -12 0.016 +12 -11 0.023 +12 -10 0.027 +12 -9 0.023 +12 -8 0.016 +12 -7 0.01 +12 -6 0.007 +12 -5 0.005 +12 -4 0.007 +12 -3 0.01 +12 -2 0.016 +12 -1 0.023 +12 0 0.027 +12 1 0.023 +12 2 0.016 +12 3 0.01 +12 4 0.007 +12 5 0.005 +12 6 0.007 +12 7 0.01 +12 8 0.016 +12 9 0.023 +12 10 0.027 +12 11 0.023 +12 12 0.016 +12 13 0.01 +12 14 0.007 + +13 -15 0.005 +13 -14 0.006 +13 -13 0.008 +13 -12 0.01 +13 -11 0.013 +13 -10 0.014 +13 -9 0.013 +13 -8 0.01 +13 -7 0.008 +13 -6 0.006 +13 -5 0.005 +13 -4 0.006 +13 -3 0.008 +13 -2 0.01 +13 -1 0.013 +13 0 0.014 +13 1 0.013 +13 2 0.01 +13 3 0.008 +13 4 0.006 +13 5 0.005 +13 6 0.006 +13 7 0.008 +13 8 0.01 +13 9 0.013 +13 10 0.014 +13 11 0.013 +13 12 0.01 +13 13 0.008 +13 14 0.006 + +14 -15 0.004 +14 -14 0.005 +14 -13 0.006 +14 -12 0.007 +14 -11 0.008 +14 -10 0.009 +14 -9 0.008 +14 -8 0.007 +14 -7 0.006 +14 -6 0.005 +14 -5 0.004 +14 -4 0.005 +14 -3 0.006 +14 -2 0.007 +14 -1 0.008 +14 0 0.009 +14 1 0.008 +14 2 0.007 +14 3 0.006 +14 4 0.005 +14 5 0.004 +14 6 0.005 +14 7 0.006 +14 8 0.007 +14 9 0.008 +14 10 0.009 +14 11 0.008 +14 12 0.007 +14 13 0.006 +14 14 0.005 diff --git a/test_multi_d/chan1_chan2.dat b/test_multi_d/chan1_chan2.dat new file mode 100644 index 00000000000..23fc578160a --- /dev/null +++ b/test_multi_d/chan1_chan2.dat @@ -0,0 +1,3032 @@ +# chan1 chan2 amplitude_5_0 +# "chan1" "chan2" "amplitude" +# 30 100 +-15 -10 3.362 +-15 -9.8 3.253 +-15 -9.6 3.148 +-15 -9.4 3.047 +-15 -9.2 2.95 +-15 -9 2.858 +-15 -8.8 2.771 +-15 -8.6 2.689 +-15 -8.4 2.613 +-15 -8.2 2.544 +-15 -8 2.483 +-15 -7.8 2.43 +-15 -7.6 2.388 +-15 -7.4 2.357 +-15 -7.2 2.339 +-15 -7 2.339 +-15 -6.8 2.359 +-15 -6.6 2.402 +-15 -6.4 2.475 +-15 -6.2 2.581 +-15 -6 2.721 +-15 -5.8 2.889 +-15 -5.6 3.062 +-15 -5.4 3.188 +-15 -5.2 3.192 +-15 -5 3.01 +-15 -4.8 2.644 +-15 -4.6 2.177 +-15 -4.4 1.709 +-15 -4.2 1.306 +-15 -4 0.985 +-15 -3.8 0.741 +-15 -3.6 0.559 +-15 -3.4 0.424 +-15 -3.2 0.323 +-15 -3 0.247 +-15 -2.8 0.19 +-15 -2.6 0.146 +-15 -2.4 0.112 +-15 -2.2 0.086 +-15 -2 0.066 +-15 -1.8 0.051 +-15 -1.6 0.039 +-15 -1.4 0.029 +-15 -1.2 0.022 +-15 -1 0.017 +-15 -0.8 0.013 +-15 -0.6 0.01 +-15 -0.4 0.008 +-15 -0.2 0.007 +-15 0 0.006 +-15 0.2 0.007 +-15 0.4 0.008 +-15 0.6 0.01 +-15 0.8 0.013 +-15 1 0.017 +-15 1.2 0.022 +-15 1.4 0.029 +-15 1.6 0.039 +-15 1.8 0.051 +-15 2 0.066 +-15 2.2 0.086 +-15 2.4 0.112 +-15 2.6 0.146 +-15 2.8 0.19 +-15 3 0.247 +-15 3.2 0.323 +-15 3.4 0.424 +-15 3.6 0.559 +-15 3.8 0.741 +-15 4 0.985 +-15 4.2 1.306 +-15 4.4 1.709 +-15 4.6 2.177 +-15 4.8 2.644 +-15 5 3.01 +-15 5.2 3.192 +-15 5.4 3.188 +-15 5.6 3.062 +-15 5.8 2.889 +-15 6 2.721 +-15 6.2 2.581 +-15 6.4 2.475 +-15 6.6 2.402 +-15 6.8 2.359 +-15 7 2.339 +-15 7.2 2.339 +-15 7.4 2.357 +-15 7.6 2.388 +-15 7.8 2.43 +-15 8 2.483 +-15 8.2 2.544 +-15 8.4 2.613 +-15 8.6 2.689 +-15 8.8 2.771 +-15 9 2.858 +-15 9.2 2.95 +-15 9.4 3.047 +-15 9.6 3.148 +-15 9.8 3.253 + +-14 -10 3.279 +-14 -9.8 3.163 +-14 -9.6 3.05 +-14 -9.4 2.94 +-14 -9.2 2.833 +-14 -9 2.73 +-14 -8.8 2.63 +-14 -8.6 2.533 +-14 -8.4 2.44 +-14 -8.2 2.351 +-14 -8 2.265 +-14 -7.8 2.184 +-14 -7.6 2.108 +-14 -7.4 2.036 +-14 -7.2 1.97 +-14 -7 1.91 +-14 -6.8 1.857 +-14 -6.6 1.811 +-14 -6.4 1.773 +-14 -6.2 1.746 +-14 -6 1.731 +-14 -5.8 1.73 +-14 -5.6 1.745 +-14 -5.4 1.779 +-14 -5.2 1.835 +-14 -5 1.912 +-14 -4.8 2.005 +-14 -4.6 2.097 +-14 -4.4 2.152 +-14 -4.2 2.122 +-14 -4 1.968 +-14 -3.8 1.699 +-14 -3.6 1.372 +-14 -3.4 1.055 +-14 -3.2 0.788 +-14 -3 0.58 +-14 -2.8 0.425 +-14 -2.6 0.311 +-14 -2.4 0.228 +-14 -2.2 0.168 +-14 -2 0.124 +-14 -1.8 0.091 +-14 -1.6 0.067 +-14 -1.4 0.049 +-14 -1.2 0.036 +-14 -1 0.027 +-14 -0.8 0.02 +-14 -0.6 0.015 +-14 -0.4 0.012 +-14 -0.2 0.01 +-14 0 0.009 +-14 0.2 0.01 +-14 0.4 0.012 +-14 0.6 0.015 +-14 0.8 0.02 +-14 1 0.027 +-14 1.2 0.036 +-14 1.4 0.049 +-14 1.6 0.067 +-14 1.8 0.091 +-14 2 0.124 +-14 2.2 0.168 +-14 2.4 0.228 +-14 2.6 0.311 +-14 2.8 0.425 +-14 3 0.58 +-14 3.2 0.788 +-14 3.4 1.055 +-14 3.6 1.372 +-14 3.8 1.699 +-14 4 1.968 +-14 4.2 2.122 +-14 4.4 2.152 +-14 4.6 2.097 +-14 4.8 2.005 +-14 5 1.912 +-14 5.2 1.835 +-14 5.4 1.779 +-14 5.6 1.745 +-14 5.8 1.73 +-14 6 1.731 +-14 6.2 1.746 +-14 6.4 1.773 +-14 6.6 1.811 +-14 6.8 1.857 +-14 7 1.91 +-14 7.2 1.97 +-14 7.4 2.036 +-14 7.6 2.108 +-14 7.8 2.184 +-14 8 2.265 +-14 8.2 2.351 +-14 8.4 2.44 +-14 8.6 2.533 +-14 8.8 2.63 +-14 9 2.73 +-14 9.2 2.833 +-14 9.4 2.94 +-14 9.6 3.05 +-14 9.8 3.163 + +-13 -10 3.232 +-13 -9.8 3.113 +-13 -9.6 2.996 +-13 -9.4 2.882 +-13 -9.2 2.771 +-13 -9 2.663 +-13 -8.8 2.557 +-13 -8.6 2.454 +-13 -8.4 2.355 +-13 -8.2 2.258 +-13 -8 2.164 +-13 -7.8 2.073 +-13 -7.6 1.986 +-13 -7.4 1.901 +-13 -7.2 1.82 +-13 -7 1.743 +-13 -6.8 1.669 +-13 -6.6 1.599 +-13 -6.4 1.533 +-13 -6.2 1.471 +-13 -6 1.414 +-13 -5.8 1.361 +-13 -5.6 1.315 +-13 -5.4 1.275 +-13 -5.2 1.242 +-13 -5 1.216 +-13 -4.8 1.2 +-13 -4.6 1.195 +-13 -4.4 1.201 +-13 -4.2 1.22 +-13 -4 1.25 +-13 -3.8 1.288 +-13 -3.6 1.321 +-13 -3.4 1.328 +-13 -3.2 1.28 +-13 -3 1.158 +-13 -2.8 0.973 +-13 -2.6 0.763 +-13 -2.4 0.569 +-13 -2.2 0.41 +-13 -2 0.291 +-13 -1.8 0.204 +-13 -1.6 0.143 +-13 -1.4 0.1 +-13 -1.2 0.07 +-13 -1 0.05 +-13 -0.8 0.035 +-13 -0.6 0.026 +-13 -0.4 0.02 +-13 -0.2 0.016 +-13 0 0.014 +-13 0.2 0.016 +-13 0.4 0.02 +-13 0.6 0.026 +-13 0.8 0.035 +-13 1 0.05 +-13 1.2 0.07 +-13 1.4 0.1 +-13 1.6 0.143 +-13 1.8 0.204 +-13 2 0.291 +-13 2.2 0.41 +-13 2.4 0.569 +-13 2.6 0.763 +-13 2.8 0.973 +-13 3 1.158 +-13 3.2 1.28 +-13 3.4 1.328 +-13 3.6 1.321 +-13 3.8 1.288 +-13 4 1.25 +-13 4.2 1.22 +-13 4.4 1.201 +-13 4.6 1.195 +-13 4.8 1.2 +-13 5 1.216 +-13 5.2 1.242 +-13 5.4 1.275 +-13 5.6 1.315 +-13 5.8 1.361 +-13 6 1.414 +-13 6.2 1.471 +-13 6.4 1.533 +-13 6.6 1.599 +-13 6.8 1.669 +-13 7 1.743 +-13 7.2 1.82 +-13 7.4 1.901 +-13 7.6 1.986 +-13 7.8 2.073 +-13 8 2.164 +-13 8.2 2.258 +-13 8.4 2.355 +-13 8.6 2.454 +-13 8.8 2.557 +-13 9 2.663 +-13 9.2 2.771 +-13 9.4 2.882 +-13 9.6 2.996 +-13 9.8 3.113 + +-12 -10 3.203 +-12 -9.8 3.082 +-12 -9.6 2.964 +-12 -9.4 2.848 +-12 -9.2 2.735 +-12 -9 2.624 +-12 -8.8 2.516 +-12 -8.6 2.411 +-12 -8.4 2.308 +-12 -8.2 2.208 +-12 -8 2.111 +-12 -7.8 2.016 +-12 -7.6 1.924 +-12 -7.4 1.835 +-12 -7.2 1.748 +-12 -7 1.665 +-12 -6.8 1.584 +-12 -6.6 1.506 +-12 -6.4 1.431 +-12 -6.2 1.359 +-12 -6 1.29 +-12 -5.8 1.224 +-12 -5.6 1.161 +-12 -5.4 1.102 +-12 -5.2 1.046 +-12 -5 0.993 +-12 -4.8 0.945 +-12 -4.6 0.901 +-12 -4.4 0.861 +-12 -4.2 0.825 +-12 -4 0.795 +-12 -3.8 0.771 +-12 -3.6 0.753 +-12 -3.4 0.741 +-12 -3.2 0.736 +-12 -3 0.736 +-12 -2.8 0.738 +-12 -2.6 0.735 +-12 -2.4 0.715 +-12 -2.2 0.666 +-12 -2 0.58 +-12 -1.8 0.468 +-12 -1.6 0.351 +-12 -1.4 0.25 +-12 -1.2 0.172 +-12 -1 0.117 +-12 -0.8 0.08 +-12 -0.6 0.055 +-12 -0.4 0.04 +-12 -0.2 0.031 +-12 0 0.027 +-12 0.2 0.031 +-12 0.4 0.04 +-12 0.6 0.055 +-12 0.8 0.08 +-12 1 0.117 +-12 1.2 0.172 +-12 1.4 0.25 +-12 1.6 0.351 +-12 1.8 0.468 +-12 2 0.58 +-12 2.2 0.666 +-12 2.4 0.715 +-12 2.6 0.735 +-12 2.8 0.738 +-12 3 0.736 +-12 3.2 0.736 +-12 3.4 0.741 +-12 3.6 0.753 +-12 3.8 0.771 +-12 4 0.795 +-12 4.2 0.825 +-12 4.4 0.861 +-12 4.6 0.901 +-12 4.8 0.945 +-12 5 0.993 +-12 5.2 1.046 +-12 5.4 1.102 +-12 5.6 1.161 +-12 5.8 1.224 +-12 6 1.29 +-12 6.2 1.359 +-12 6.4 1.431 +-12 6.6 1.506 +-12 6.8 1.584 +-12 7 1.665 +-12 7.2 1.748 +-12 7.4 1.835 +-12 7.6 1.924 +-12 7.8 2.016 +-12 8 2.111 +-12 8.2 2.208 +-12 8.4 2.308 +-12 8.6 2.411 +-12 8.8 2.516 +-12 9 2.624 +-12 9.2 2.735 +-12 9.4 2.848 +-12 9.6 2.964 +-12 9.8 3.082 + +-11 -10 3.185 +-11 -9.8 3.063 +-11 -9.6 2.943 +-11 -9.4 2.827 +-11 -9.2 2.712 +-11 -9 2.601 +-11 -8.8 2.491 +-11 -8.6 2.385 +-11 -8.4 2.281 +-11 -8.2 2.179 +-11 -8 2.08 +-11 -7.8 1.984 +-11 -7.6 1.89 +-11 -7.4 1.799 +-11 -7.2 1.71 +-11 -7 1.624 +-11 -6.8 1.54 +-11 -6.6 1.459 +-11 -6.4 1.381 +-11 -6.2 1.305 +-11 -6 1.232 +-11 -5.8 1.161 +-11 -5.6 1.094 +-11 -5.4 1.029 +-11 -5.2 0.966 +-11 -5 0.906 +-11 -4.8 0.849 +-11 -4.6 0.795 +-11 -4.4 0.744 +-11 -4.2 0.695 +-11 -4 0.65 +-11 -3.8 0.607 +-11 -3.6 0.567 +-11 -3.4 0.531 +-11 -3.2 0.498 +-11 -3 0.468 +-11 -2.8 0.442 +-11 -2.6 0.419 +-11 -2.4 0.399 +-11 -2.2 0.382 +-11 -2 0.368 +-11 -1.8 0.354 +-11 -1.6 0.337 +-11 -1.4 0.313 +-11 -1.2 0.279 +-11 -1 0.233 +-11 -0.8 0.182 +-11 -0.6 0.135 +-11 -0.4 0.099 +-11 -0.2 0.075 +-11 0 0.064 +-11 0.2 0.075 +-11 0.4 0.099 +-11 0.6 0.135 +-11 0.8 0.182 +-11 1 0.233 +-11 1.2 0.279 +-11 1.4 0.313 +-11 1.6 0.337 +-11 1.8 0.354 +-11 2 0.368 +-11 2.2 0.382 +-11 2.4 0.399 +-11 2.6 0.419 +-11 2.8 0.442 +-11 3 0.468 +-11 3.2 0.498 +-11 3.4 0.531 +-11 3.6 0.567 +-11 3.8 0.607 +-11 4 0.65 +-11 4.2 0.695 +-11 4.4 0.744 +-11 4.6 0.795 +-11 4.8 0.849 +-11 5 0.906 +-11 5.2 0.966 +-11 5.4 1.029 +-11 5.6 1.094 +-11 5.8 1.161 +-11 6 1.232 +-11 6.2 1.305 +-11 6.4 1.381 +-11 6.6 1.459 +-11 6.8 1.54 +-11 7 1.624 +-11 7.2 1.71 +-11 7.4 1.799 +-11 7.6 1.89 +-11 7.8 1.984 +-11 8 2.08 +-11 8.2 2.179 +-11 8.4 2.281 +-11 8.6 2.385 +-11 8.8 2.491 +-11 9 2.601 +-11 9.2 2.712 +-11 9.4 2.827 +-11 9.6 2.943 +-11 9.8 3.063 + +-10 -10 3.173 +-10 -9.8 3.05 +-10 -9.6 2.93 +-10 -9.4 2.813 +-10 -9.2 2.698 +-10 -9 2.586 +-10 -8.8 2.476 +-10 -8.6 2.368 +-10 -8.4 2.264 +-10 -8.2 2.161 +-10 -8 2.062 +-10 -7.8 1.964 +-10 -7.6 1.869 +-10 -7.4 1.777 +-10 -7.2 1.687 +-10 -7 1.6 +-10 -6.8 1.515 +-10 -6.6 1.433 +-10 -6.4 1.353 +-10 -6.2 1.276 +-10 -6 1.202 +-10 -5.8 1.129 +-10 -5.6 1.06 +-10 -5.4 0.993 +-10 -5.2 0.928 +-10 -5 0.866 +-10 -4.8 0.806 +-10 -4.6 0.749 +-10 -4.4 0.694 +-10 -4.2 0.642 +-10 -4 0.593 +-10 -3.8 0.546 +-10 -3.6 0.501 +-10 -3.4 0.459 +-10 -3.2 0.419 +-10 -3 0.382 +-10 -2.8 0.348 +-10 -2.6 0.316 +-10 -2.4 0.286 +-10 -2.2 0.259 +-10 -2 0.234 +-10 -1.8 0.212 +-10 -1.6 0.192 +-10 -1.4 0.175 +-10 -1.2 0.16 +-10 -1 0.147 +-10 -0.8 0.137 +-10 -0.6 0.129 +-10 -0.4 0.123 +-10 -0.2 0.119 +-10 0 0.117 +-10 0.2 0.119 +-10 0.4 0.123 +-10 0.6 0.129 +-10 0.8 0.137 +-10 1 0.147 +-10 1.2 0.16 +-10 1.4 0.175 +-10 1.6 0.192 +-10 1.8 0.212 +-10 2 0.234 +-10 2.2 0.259 +-10 2.4 0.286 +-10 2.6 0.316 +-10 2.8 0.348 +-10 3 0.382 +-10 3.2 0.419 +-10 3.4 0.459 +-10 3.6 0.501 +-10 3.8 0.546 +-10 4 0.593 +-10 4.2 0.642 +-10 4.4 0.694 +-10 4.6 0.749 +-10 4.8 0.806 +-10 5 0.866 +-10 5.2 0.928 +-10 5.4 0.993 +-10 5.6 1.06 +-10 5.8 1.129 +-10 6 1.202 +-10 6.2 1.276 +-10 6.4 1.353 +-10 6.6 1.433 +-10 6.8 1.515 +-10 7 1.6 +-10 7.2 1.687 +-10 7.4 1.777 +-10 7.6 1.869 +-10 7.8 1.964 +-10 8 2.062 +-10 8.2 2.161 +-10 8.4 2.264 +-10 8.6 2.368 +-10 8.8 2.476 +-10 9 2.586 +-10 9.2 2.698 +-10 9.4 2.813 +-10 9.6 2.93 +-10 9.8 3.05 + +-9 -10 3.185 +-9 -9.8 3.063 +-9 -9.6 2.943 +-9 -9.4 2.827 +-9 -9.2 2.712 +-9 -9 2.601 +-9 -8.8 2.491 +-9 -8.6 2.385 +-9 -8.4 2.281 +-9 -8.2 2.179 +-9 -8 2.08 +-9 -7.8 1.984 +-9 -7.6 1.89 +-9 -7.4 1.799 +-9 -7.2 1.71 +-9 -7 1.624 +-9 -6.8 1.54 +-9 -6.6 1.459 +-9 -6.4 1.381 +-9 -6.2 1.305 +-9 -6 1.232 +-9 -5.8 1.161 +-9 -5.6 1.094 +-9 -5.4 1.029 +-9 -5.2 0.966 +-9 -5 0.906 +-9 -4.8 0.849 +-9 -4.6 0.795 +-9 -4.4 0.744 +-9 -4.2 0.695 +-9 -4 0.65 +-9 -3.8 0.607 +-9 -3.6 0.567 +-9 -3.4 0.531 +-9 -3.2 0.498 +-9 -3 0.468 +-9 -2.8 0.442 +-9 -2.6 0.419 +-9 -2.4 0.399 +-9 -2.2 0.382 +-9 -2 0.368 +-9 -1.8 0.354 +-9 -1.6 0.337 +-9 -1.4 0.313 +-9 -1.2 0.279 +-9 -1 0.233 +-9 -0.8 0.182 +-9 -0.6 0.135 +-9 -0.4 0.099 +-9 -0.2 0.075 +-9 0 0.064 +-9 0.2 0.075 +-9 0.4 0.099 +-9 0.6 0.135 +-9 0.8 0.182 +-9 1 0.233 +-9 1.2 0.279 +-9 1.4 0.313 +-9 1.6 0.337 +-9 1.8 0.354 +-9 2 0.368 +-9 2.2 0.382 +-9 2.4 0.399 +-9 2.6 0.419 +-9 2.8 0.442 +-9 3 0.468 +-9 3.2 0.498 +-9 3.4 0.531 +-9 3.6 0.567 +-9 3.8 0.607 +-9 4 0.65 +-9 4.2 0.695 +-9 4.4 0.744 +-9 4.6 0.795 +-9 4.8 0.849 +-9 5 0.906 +-9 5.2 0.966 +-9 5.4 1.029 +-9 5.6 1.094 +-9 5.8 1.161 +-9 6 1.232 +-9 6.2 1.305 +-9 6.4 1.381 +-9 6.6 1.459 +-9 6.8 1.54 +-9 7 1.624 +-9 7.2 1.71 +-9 7.4 1.799 +-9 7.6 1.89 +-9 7.8 1.984 +-9 8 2.08 +-9 8.2 2.179 +-9 8.4 2.281 +-9 8.6 2.385 +-9 8.8 2.491 +-9 9 2.601 +-9 9.2 2.712 +-9 9.4 2.827 +-9 9.6 2.943 +-9 9.8 3.063 + +-8 -10 3.203 +-8 -9.8 3.082 +-8 -9.6 2.964 +-8 -9.4 2.848 +-8 -9.2 2.735 +-8 -9 2.624 +-8 -8.8 2.516 +-8 -8.6 2.411 +-8 -8.4 2.308 +-8 -8.2 2.208 +-8 -8 2.111 +-8 -7.8 2.016 +-8 -7.6 1.924 +-8 -7.4 1.835 +-8 -7.2 1.748 +-8 -7 1.665 +-8 -6.8 1.584 +-8 -6.6 1.506 +-8 -6.4 1.431 +-8 -6.2 1.359 +-8 -6 1.29 +-8 -5.8 1.224 +-8 -5.6 1.161 +-8 -5.4 1.102 +-8 -5.2 1.046 +-8 -5 0.993 +-8 -4.8 0.945 +-8 -4.6 0.901 +-8 -4.4 0.861 +-8 -4.2 0.825 +-8 -4 0.795 +-8 -3.8 0.771 +-8 -3.6 0.753 +-8 -3.4 0.741 +-8 -3.2 0.736 +-8 -3 0.736 +-8 -2.8 0.738 +-8 -2.6 0.735 +-8 -2.4 0.715 +-8 -2.2 0.666 +-8 -2 0.58 +-8 -1.8 0.468 +-8 -1.6 0.351 +-8 -1.4 0.25 +-8 -1.2 0.172 +-8 -1 0.117 +-8 -0.8 0.08 +-8 -0.6 0.055 +-8 -0.4 0.04 +-8 -0.2 0.031 +-8 0 0.027 +-8 0.2 0.031 +-8 0.4 0.04 +-8 0.6 0.055 +-8 0.8 0.08 +-8 1 0.117 +-8 1.2 0.172 +-8 1.4 0.25 +-8 1.6 0.351 +-8 1.8 0.468 +-8 2 0.58 +-8 2.2 0.666 +-8 2.4 0.715 +-8 2.6 0.735 +-8 2.8 0.738 +-8 3 0.736 +-8 3.2 0.736 +-8 3.4 0.741 +-8 3.6 0.753 +-8 3.8 0.771 +-8 4 0.795 +-8 4.2 0.825 +-8 4.4 0.861 +-8 4.6 0.901 +-8 4.8 0.945 +-8 5 0.993 +-8 5.2 1.046 +-8 5.4 1.102 +-8 5.6 1.161 +-8 5.8 1.224 +-8 6 1.29 +-8 6.2 1.359 +-8 6.4 1.431 +-8 6.6 1.506 +-8 6.8 1.584 +-8 7 1.665 +-8 7.2 1.748 +-8 7.4 1.835 +-8 7.6 1.924 +-8 7.8 2.016 +-8 8 2.111 +-8 8.2 2.208 +-8 8.4 2.308 +-8 8.6 2.411 +-8 8.8 2.516 +-8 9 2.624 +-8 9.2 2.735 +-8 9.4 2.848 +-8 9.6 2.964 +-8 9.8 3.082 + +-7 -10 3.232 +-7 -9.8 3.113 +-7 -9.6 2.996 +-7 -9.4 2.882 +-7 -9.2 2.771 +-7 -9 2.663 +-7 -8.8 2.557 +-7 -8.6 2.454 +-7 -8.4 2.355 +-7 -8.2 2.258 +-7 -8 2.164 +-7 -7.8 2.073 +-7 -7.6 1.986 +-7 -7.4 1.901 +-7 -7.2 1.82 +-7 -7 1.743 +-7 -6.8 1.669 +-7 -6.6 1.599 +-7 -6.4 1.533 +-7 -6.2 1.471 +-7 -6 1.414 +-7 -5.8 1.361 +-7 -5.6 1.315 +-7 -5.4 1.275 +-7 -5.2 1.242 +-7 -5 1.216 +-7 -4.8 1.2 +-7 -4.6 1.195 +-7 -4.4 1.201 +-7 -4.2 1.22 +-7 -4 1.25 +-7 -3.8 1.288 +-7 -3.6 1.321 +-7 -3.4 1.328 +-7 -3.2 1.28 +-7 -3 1.158 +-7 -2.8 0.973 +-7 -2.6 0.763 +-7 -2.4 0.569 +-7 -2.2 0.41 +-7 -2 0.291 +-7 -1.8 0.204 +-7 -1.6 0.143 +-7 -1.4 0.1 +-7 -1.2 0.07 +-7 -1 0.05 +-7 -0.8 0.035 +-7 -0.6 0.026 +-7 -0.4 0.02 +-7 -0.2 0.016 +-7 0 0.014 +-7 0.2 0.016 +-7 0.4 0.02 +-7 0.6 0.026 +-7 0.8 0.035 +-7 1 0.05 +-7 1.2 0.07 +-7 1.4 0.1 +-7 1.6 0.143 +-7 1.8 0.204 +-7 2 0.291 +-7 2.2 0.41 +-7 2.4 0.569 +-7 2.6 0.763 +-7 2.8 0.973 +-7 3 1.158 +-7 3.2 1.28 +-7 3.4 1.328 +-7 3.6 1.321 +-7 3.8 1.288 +-7 4 1.25 +-7 4.2 1.22 +-7 4.4 1.201 +-7 4.6 1.195 +-7 4.8 1.2 +-7 5 1.216 +-7 5.2 1.242 +-7 5.4 1.275 +-7 5.6 1.315 +-7 5.8 1.361 +-7 6 1.414 +-7 6.2 1.471 +-7 6.4 1.533 +-7 6.6 1.599 +-7 6.8 1.669 +-7 7 1.743 +-7 7.2 1.82 +-7 7.4 1.901 +-7 7.6 1.986 +-7 7.8 2.073 +-7 8 2.164 +-7 8.2 2.258 +-7 8.4 2.355 +-7 8.6 2.454 +-7 8.8 2.557 +-7 9 2.663 +-7 9.2 2.771 +-7 9.4 2.882 +-7 9.6 2.996 +-7 9.8 3.113 + +-6 -10 3.279 +-6 -9.8 3.163 +-6 -9.6 3.05 +-6 -9.4 2.94 +-6 -9.2 2.833 +-6 -9 2.73 +-6 -8.8 2.63 +-6 -8.6 2.533 +-6 -8.4 2.44 +-6 -8.2 2.351 +-6 -8 2.265 +-6 -7.8 2.184 +-6 -7.6 2.108 +-6 -7.4 2.036 +-6 -7.2 1.97 +-6 -7 1.91 +-6 -6.8 1.857 +-6 -6.6 1.811 +-6 -6.4 1.773 +-6 -6.2 1.746 +-6 -6 1.731 +-6 -5.8 1.73 +-6 -5.6 1.745 +-6 -5.4 1.779 +-6 -5.2 1.835 +-6 -5 1.912 +-6 -4.8 2.005 +-6 -4.6 2.097 +-6 -4.4 2.152 +-6 -4.2 2.122 +-6 -4 1.968 +-6 -3.8 1.699 +-6 -3.6 1.372 +-6 -3.4 1.055 +-6 -3.2 0.788 +-6 -3 0.58 +-6 -2.8 0.425 +-6 -2.6 0.311 +-6 -2.4 0.228 +-6 -2.2 0.168 +-6 -2 0.124 +-6 -1.8 0.091 +-6 -1.6 0.067 +-6 -1.4 0.049 +-6 -1.2 0.036 +-6 -1 0.027 +-6 -0.8 0.02 +-6 -0.6 0.015 +-6 -0.4 0.012 +-6 -0.2 0.01 +-6 0 0.009 +-6 0.2 0.01 +-6 0.4 0.012 +-6 0.6 0.015 +-6 0.8 0.02 +-6 1 0.027 +-6 1.2 0.036 +-6 1.4 0.049 +-6 1.6 0.067 +-6 1.8 0.091 +-6 2 0.124 +-6 2.2 0.168 +-6 2.4 0.228 +-6 2.6 0.311 +-6 2.8 0.425 +-6 3 0.58 +-6 3.2 0.788 +-6 3.4 1.055 +-6 3.6 1.372 +-6 3.8 1.699 +-6 4 1.968 +-6 4.2 2.122 +-6 4.4 2.152 +-6 4.6 2.097 +-6 4.8 2.005 +-6 5 1.912 +-6 5.2 1.835 +-6 5.4 1.779 +-6 5.6 1.745 +-6 5.8 1.73 +-6 6 1.731 +-6 6.2 1.746 +-6 6.4 1.773 +-6 6.6 1.811 +-6 6.8 1.857 +-6 7 1.91 +-6 7.2 1.97 +-6 7.4 2.036 +-6 7.6 2.108 +-6 7.8 2.184 +-6 8 2.265 +-6 8.2 2.351 +-6 8.4 2.44 +-6 8.6 2.533 +-6 8.8 2.63 +-6 9 2.73 +-6 9.2 2.833 +-6 9.4 2.94 +-6 9.6 3.05 +-6 9.8 3.163 + +-5 -10 3.362 +-5 -9.8 3.253 +-5 -9.6 3.148 +-5 -9.4 3.047 +-5 -9.2 2.95 +-5 -9 2.858 +-5 -8.8 2.771 +-5 -8.6 2.689 +-5 -8.4 2.613 +-5 -8.2 2.544 +-5 -8 2.483 +-5 -7.8 2.43 +-5 -7.6 2.388 +-5 -7.4 2.357 +-5 -7.2 2.339 +-5 -7 2.339 +-5 -6.8 2.359 +-5 -6.6 2.402 +-5 -6.4 2.475 +-5 -6.2 2.581 +-5 -6 2.721 +-5 -5.8 2.889 +-5 -5.6 3.062 +-5 -5.4 3.188 +-5 -5.2 3.192 +-5 -5 3.01 +-5 -4.8 2.644 +-5 -4.6 2.177 +-5 -4.4 1.709 +-5 -4.2 1.306 +-5 -4 0.985 +-5 -3.8 0.741 +-5 -3.6 0.559 +-5 -3.4 0.424 +-5 -3.2 0.323 +-5 -3 0.247 +-5 -2.8 0.19 +-5 -2.6 0.146 +-5 -2.4 0.112 +-5 -2.2 0.086 +-5 -2 0.066 +-5 -1.8 0.051 +-5 -1.6 0.039 +-5 -1.4 0.029 +-5 -1.2 0.022 +-5 -1 0.017 +-5 -0.8 0.013 +-5 -0.6 0.01 +-5 -0.4 0.008 +-5 -0.2 0.007 +-5 0 0.006 +-5 0.2 0.007 +-5 0.4 0.008 +-5 0.6 0.01 +-5 0.8 0.013 +-5 1 0.017 +-5 1.2 0.022 +-5 1.4 0.029 +-5 1.6 0.039 +-5 1.8 0.051 +-5 2 0.066 +-5 2.2 0.086 +-5 2.4 0.112 +-5 2.6 0.146 +-5 2.8 0.19 +-5 3 0.247 +-5 3.2 0.323 +-5 3.4 0.424 +-5 3.6 0.559 +-5 3.8 0.741 +-5 4 0.985 +-5 4.2 1.306 +-5 4.4 1.709 +-5 4.6 2.177 +-5 4.8 2.644 +-5 5 3.01 +-5 5.2 3.192 +-5 5.4 3.188 +-5 5.6 3.062 +-5 5.8 2.889 +-5 6 2.721 +-5 6.2 2.581 +-5 6.4 2.475 +-5 6.6 2.402 +-5 6.8 2.359 +-5 7 2.339 +-5 7.2 2.339 +-5 7.4 2.357 +-5 7.6 2.388 +-5 7.8 2.43 +-5 8 2.483 +-5 8.2 2.544 +-5 8.4 2.613 +-5 8.6 2.689 +-5 8.8 2.771 +-5 9 2.858 +-5 9.2 2.95 +-5 9.4 3.047 +-5 9.6 3.148 +-5 9.8 3.253 + +-4 -10 3.279 +-4 -9.8 3.163 +-4 -9.6 3.05 +-4 -9.4 2.94 +-4 -9.2 2.833 +-4 -9 2.73 +-4 -8.8 2.63 +-4 -8.6 2.533 +-4 -8.4 2.44 +-4 -8.2 2.351 +-4 -8 2.265 +-4 -7.8 2.184 +-4 -7.6 2.108 +-4 -7.4 2.036 +-4 -7.2 1.97 +-4 -7 1.91 +-4 -6.8 1.857 +-4 -6.6 1.811 +-4 -6.4 1.773 +-4 -6.2 1.746 +-4 -6 1.731 +-4 -5.8 1.73 +-4 -5.6 1.745 +-4 -5.4 1.779 +-4 -5.2 1.835 +-4 -5 1.912 +-4 -4.8 2.005 +-4 -4.6 2.097 +-4 -4.4 2.152 +-4 -4.2 2.122 +-4 -4 1.968 +-4 -3.8 1.699 +-4 -3.6 1.372 +-4 -3.4 1.055 +-4 -3.2 0.788 +-4 -3 0.58 +-4 -2.8 0.425 +-4 -2.6 0.311 +-4 -2.4 0.228 +-4 -2.2 0.168 +-4 -2 0.124 +-4 -1.8 0.091 +-4 -1.6 0.067 +-4 -1.4 0.049 +-4 -1.2 0.036 +-4 -1 0.027 +-4 -0.8 0.02 +-4 -0.6 0.015 +-4 -0.4 0.012 +-4 -0.2 0.01 +-4 0 0.009 +-4 0.2 0.01 +-4 0.4 0.012 +-4 0.6 0.015 +-4 0.8 0.02 +-4 1 0.027 +-4 1.2 0.036 +-4 1.4 0.049 +-4 1.6 0.067 +-4 1.8 0.091 +-4 2 0.124 +-4 2.2 0.168 +-4 2.4 0.228 +-4 2.6 0.311 +-4 2.8 0.425 +-4 3 0.58 +-4 3.2 0.788 +-4 3.4 1.055 +-4 3.6 1.372 +-4 3.8 1.699 +-4 4 1.968 +-4 4.2 2.122 +-4 4.4 2.152 +-4 4.6 2.097 +-4 4.8 2.005 +-4 5 1.912 +-4 5.2 1.835 +-4 5.4 1.779 +-4 5.6 1.745 +-4 5.8 1.73 +-4 6 1.731 +-4 6.2 1.746 +-4 6.4 1.773 +-4 6.6 1.811 +-4 6.8 1.857 +-4 7 1.91 +-4 7.2 1.97 +-4 7.4 2.036 +-4 7.6 2.108 +-4 7.8 2.184 +-4 8 2.265 +-4 8.2 2.351 +-4 8.4 2.44 +-4 8.6 2.533 +-4 8.8 2.63 +-4 9 2.73 +-4 9.2 2.833 +-4 9.4 2.94 +-4 9.6 3.05 +-4 9.8 3.163 + +-3 -10 3.232 +-3 -9.8 3.113 +-3 -9.6 2.996 +-3 -9.4 2.882 +-3 -9.2 2.771 +-3 -9 2.663 +-3 -8.8 2.557 +-3 -8.6 2.454 +-3 -8.4 2.355 +-3 -8.2 2.258 +-3 -8 2.164 +-3 -7.8 2.073 +-3 -7.6 1.986 +-3 -7.4 1.901 +-3 -7.2 1.82 +-3 -7 1.743 +-3 -6.8 1.669 +-3 -6.6 1.599 +-3 -6.4 1.533 +-3 -6.2 1.471 +-3 -6 1.414 +-3 -5.8 1.361 +-3 -5.6 1.315 +-3 -5.4 1.275 +-3 -5.2 1.242 +-3 -5 1.216 +-3 -4.8 1.2 +-3 -4.6 1.195 +-3 -4.4 1.201 +-3 -4.2 1.22 +-3 -4 1.25 +-3 -3.8 1.288 +-3 -3.6 1.321 +-3 -3.4 1.328 +-3 -3.2 1.28 +-3 -3 1.158 +-3 -2.8 0.973 +-3 -2.6 0.763 +-3 -2.4 0.569 +-3 -2.2 0.41 +-3 -2 0.291 +-3 -1.8 0.204 +-3 -1.6 0.143 +-3 -1.4 0.1 +-3 -1.2 0.07 +-3 -1 0.05 +-3 -0.8 0.035 +-3 -0.6 0.026 +-3 -0.4 0.02 +-3 -0.2 0.016 +-3 0 0.014 +-3 0.2 0.016 +-3 0.4 0.02 +-3 0.6 0.026 +-3 0.8 0.035 +-3 1 0.05 +-3 1.2 0.07 +-3 1.4 0.1 +-3 1.6 0.143 +-3 1.8 0.204 +-3 2 0.291 +-3 2.2 0.41 +-3 2.4 0.569 +-3 2.6 0.763 +-3 2.8 0.973 +-3 3 1.158 +-3 3.2 1.28 +-3 3.4 1.328 +-3 3.6 1.321 +-3 3.8 1.288 +-3 4 1.25 +-3 4.2 1.22 +-3 4.4 1.201 +-3 4.6 1.195 +-3 4.8 1.2 +-3 5 1.216 +-3 5.2 1.242 +-3 5.4 1.275 +-3 5.6 1.315 +-3 5.8 1.361 +-3 6 1.414 +-3 6.2 1.471 +-3 6.4 1.533 +-3 6.6 1.599 +-3 6.8 1.669 +-3 7 1.743 +-3 7.2 1.82 +-3 7.4 1.901 +-3 7.6 1.986 +-3 7.8 2.073 +-3 8 2.164 +-3 8.2 2.258 +-3 8.4 2.355 +-3 8.6 2.454 +-3 8.8 2.557 +-3 9 2.663 +-3 9.2 2.771 +-3 9.4 2.882 +-3 9.6 2.996 +-3 9.8 3.113 + +-2 -10 3.203 +-2 -9.8 3.082 +-2 -9.6 2.964 +-2 -9.4 2.848 +-2 -9.2 2.735 +-2 -9 2.624 +-2 -8.8 2.516 +-2 -8.6 2.411 +-2 -8.4 2.308 +-2 -8.2 2.208 +-2 -8 2.111 +-2 -7.8 2.016 +-2 -7.6 1.924 +-2 -7.4 1.835 +-2 -7.2 1.748 +-2 -7 1.665 +-2 -6.8 1.584 +-2 -6.6 1.506 +-2 -6.4 1.431 +-2 -6.2 1.359 +-2 -6 1.29 +-2 -5.8 1.224 +-2 -5.6 1.161 +-2 -5.4 1.102 +-2 -5.2 1.046 +-2 -5 0.993 +-2 -4.8 0.945 +-2 -4.6 0.901 +-2 -4.4 0.861 +-2 -4.2 0.825 +-2 -4 0.795 +-2 -3.8 0.771 +-2 -3.6 0.753 +-2 -3.4 0.741 +-2 -3.2 0.736 +-2 -3 0.736 +-2 -2.8 0.738 +-2 -2.6 0.735 +-2 -2.4 0.715 +-2 -2.2 0.666 +-2 -2 0.58 +-2 -1.8 0.468 +-2 -1.6 0.351 +-2 -1.4 0.25 +-2 -1.2 0.172 +-2 -1 0.117 +-2 -0.8 0.08 +-2 -0.6 0.055 +-2 -0.4 0.04 +-2 -0.2 0.031 +-2 0 0.027 +-2 0.2 0.031 +-2 0.4 0.04 +-2 0.6 0.055 +-2 0.8 0.08 +-2 1 0.117 +-2 1.2 0.172 +-2 1.4 0.25 +-2 1.6 0.351 +-2 1.8 0.468 +-2 2 0.58 +-2 2.2 0.666 +-2 2.4 0.715 +-2 2.6 0.735 +-2 2.8 0.738 +-2 3 0.736 +-2 3.2 0.736 +-2 3.4 0.741 +-2 3.6 0.753 +-2 3.8 0.771 +-2 4 0.795 +-2 4.2 0.825 +-2 4.4 0.861 +-2 4.6 0.901 +-2 4.8 0.945 +-2 5 0.993 +-2 5.2 1.046 +-2 5.4 1.102 +-2 5.6 1.161 +-2 5.8 1.224 +-2 6 1.29 +-2 6.2 1.359 +-2 6.4 1.431 +-2 6.6 1.506 +-2 6.8 1.584 +-2 7 1.665 +-2 7.2 1.748 +-2 7.4 1.835 +-2 7.6 1.924 +-2 7.8 2.016 +-2 8 2.111 +-2 8.2 2.208 +-2 8.4 2.308 +-2 8.6 2.411 +-2 8.8 2.516 +-2 9 2.624 +-2 9.2 2.735 +-2 9.4 2.848 +-2 9.6 2.964 +-2 9.8 3.082 + +-1 -10 3.185 +-1 -9.8 3.063 +-1 -9.6 2.943 +-1 -9.4 2.827 +-1 -9.2 2.712 +-1 -9 2.601 +-1 -8.8 2.491 +-1 -8.6 2.385 +-1 -8.4 2.281 +-1 -8.2 2.179 +-1 -8 2.08 +-1 -7.8 1.984 +-1 -7.6 1.89 +-1 -7.4 1.799 +-1 -7.2 1.71 +-1 -7 1.624 +-1 -6.8 1.54 +-1 -6.6 1.459 +-1 -6.4 1.381 +-1 -6.2 1.305 +-1 -6 1.232 +-1 -5.8 1.161 +-1 -5.6 1.094 +-1 -5.4 1.029 +-1 -5.2 0.966 +-1 -5 0.906 +-1 -4.8 0.849 +-1 -4.6 0.795 +-1 -4.4 0.744 +-1 -4.2 0.695 +-1 -4 0.65 +-1 -3.8 0.607 +-1 -3.6 0.567 +-1 -3.4 0.531 +-1 -3.2 0.498 +-1 -3 0.468 +-1 -2.8 0.442 +-1 -2.6 0.419 +-1 -2.4 0.399 +-1 -2.2 0.382 +-1 -2 0.368 +-1 -1.8 0.354 +-1 -1.6 0.337 +-1 -1.4 0.313 +-1 -1.2 0.279 +-1 -1 0.233 +-1 -0.8 0.182 +-1 -0.6 0.135 +-1 -0.4 0.099 +-1 -0.2 0.075 +-1 0 0.064 +-1 0.2 0.075 +-1 0.4 0.099 +-1 0.6 0.135 +-1 0.8 0.182 +-1 1 0.233 +-1 1.2 0.279 +-1 1.4 0.313 +-1 1.6 0.337 +-1 1.8 0.354 +-1 2 0.368 +-1 2.2 0.382 +-1 2.4 0.399 +-1 2.6 0.419 +-1 2.8 0.442 +-1 3 0.468 +-1 3.2 0.498 +-1 3.4 0.531 +-1 3.6 0.567 +-1 3.8 0.607 +-1 4 0.65 +-1 4.2 0.695 +-1 4.4 0.744 +-1 4.6 0.795 +-1 4.8 0.849 +-1 5 0.906 +-1 5.2 0.966 +-1 5.4 1.029 +-1 5.6 1.094 +-1 5.8 1.161 +-1 6 1.232 +-1 6.2 1.305 +-1 6.4 1.381 +-1 6.6 1.459 +-1 6.8 1.54 +-1 7 1.624 +-1 7.2 1.71 +-1 7.4 1.799 +-1 7.6 1.89 +-1 7.8 1.984 +-1 8 2.08 +-1 8.2 2.179 +-1 8.4 2.281 +-1 8.6 2.385 +-1 8.8 2.491 +-1 9 2.601 +-1 9.2 2.712 +-1 9.4 2.827 +-1 9.6 2.943 +-1 9.8 3.063 + +0 -10 3.173 +0 -9.8 3.05 +0 -9.6 2.93 +0 -9.4 2.813 +0 -9.2 2.698 +0 -9 2.586 +0 -8.8 2.476 +0 -8.6 2.368 +0 -8.4 2.264 +0 -8.2 2.161 +0 -8 2.062 +0 -7.8 1.964 +0 -7.6 1.869 +0 -7.4 1.777 +0 -7.2 1.687 +0 -7 1.6 +0 -6.8 1.515 +0 -6.6 1.433 +0 -6.4 1.353 +0 -6.2 1.276 +0 -6 1.202 +0 -5.8 1.129 +0 -5.6 1.06 +0 -5.4 0.993 +0 -5.2 0.928 +0 -5 0.866 +0 -4.8 0.806 +0 -4.6 0.749 +0 -4.4 0.694 +0 -4.2 0.642 +0 -4 0.593 +0 -3.8 0.546 +0 -3.6 0.501 +0 -3.4 0.459 +0 -3.2 0.419 +0 -3 0.382 +0 -2.8 0.348 +0 -2.6 0.316 +0 -2.4 0.286 +0 -2.2 0.259 +0 -2 0.234 +0 -1.8 0.212 +0 -1.6 0.192 +0 -1.4 0.175 +0 -1.2 0.16 +0 -1 0.147 +0 -0.8 0.137 +0 -0.6 0.129 +0 -0.4 0.123 +0 -0.2 0.119 +0 0 0.117 +0 0.2 0.119 +0 0.4 0.123 +0 0.6 0.129 +0 0.8 0.137 +0 1 0.147 +0 1.2 0.16 +0 1.4 0.175 +0 1.6 0.192 +0 1.8 0.212 +0 2 0.234 +0 2.2 0.259 +0 2.4 0.286 +0 2.6 0.316 +0 2.8 0.348 +0 3 0.382 +0 3.2 0.419 +0 3.4 0.459 +0 3.6 0.501 +0 3.8 0.546 +0 4 0.593 +0 4.2 0.642 +0 4.4 0.694 +0 4.6 0.749 +0 4.8 0.806 +0 5 0.866 +0 5.2 0.928 +0 5.4 0.993 +0 5.6 1.06 +0 5.8 1.129 +0 6 1.202 +0 6.2 1.276 +0 6.4 1.353 +0 6.6 1.433 +0 6.8 1.515 +0 7 1.6 +0 7.2 1.687 +0 7.4 1.777 +0 7.6 1.869 +0 7.8 1.964 +0 8 2.062 +0 8.2 2.161 +0 8.4 2.264 +0 8.6 2.368 +0 8.8 2.476 +0 9 2.586 +0 9.2 2.698 +0 9.4 2.813 +0 9.6 2.93 +0 9.8 3.05 + +1 -10 3.185 +1 -9.8 3.063 +1 -9.6 2.943 +1 -9.4 2.827 +1 -9.2 2.712 +1 -9 2.601 +1 -8.8 2.491 +1 -8.6 2.385 +1 -8.4 2.281 +1 -8.2 2.179 +1 -8 2.08 +1 -7.8 1.984 +1 -7.6 1.89 +1 -7.4 1.799 +1 -7.2 1.71 +1 -7 1.624 +1 -6.8 1.54 +1 -6.6 1.459 +1 -6.4 1.381 +1 -6.2 1.305 +1 -6 1.232 +1 -5.8 1.161 +1 -5.6 1.094 +1 -5.4 1.029 +1 -5.2 0.966 +1 -5 0.906 +1 -4.8 0.849 +1 -4.6 0.795 +1 -4.4 0.744 +1 -4.2 0.695 +1 -4 0.65 +1 -3.8 0.607 +1 -3.6 0.567 +1 -3.4 0.531 +1 -3.2 0.498 +1 -3 0.468 +1 -2.8 0.442 +1 -2.6 0.419 +1 -2.4 0.399 +1 -2.2 0.382 +1 -2 0.368 +1 -1.8 0.354 +1 -1.6 0.337 +1 -1.4 0.313 +1 -1.2 0.279 +1 -1 0.233 +1 -0.8 0.182 +1 -0.6 0.135 +1 -0.4 0.099 +1 -0.2 0.075 +1 0 0.064 +1 0.2 0.075 +1 0.4 0.099 +1 0.6 0.135 +1 0.8 0.182 +1 1 0.233 +1 1.2 0.279 +1 1.4 0.313 +1 1.6 0.337 +1 1.8 0.354 +1 2 0.368 +1 2.2 0.382 +1 2.4 0.399 +1 2.6 0.419 +1 2.8 0.442 +1 3 0.468 +1 3.2 0.498 +1 3.4 0.531 +1 3.6 0.567 +1 3.8 0.607 +1 4 0.65 +1 4.2 0.695 +1 4.4 0.744 +1 4.6 0.795 +1 4.8 0.849 +1 5 0.906 +1 5.2 0.966 +1 5.4 1.029 +1 5.6 1.094 +1 5.8 1.161 +1 6 1.232 +1 6.2 1.305 +1 6.4 1.381 +1 6.6 1.459 +1 6.8 1.54 +1 7 1.624 +1 7.2 1.71 +1 7.4 1.799 +1 7.6 1.89 +1 7.8 1.984 +1 8 2.08 +1 8.2 2.179 +1 8.4 2.281 +1 8.6 2.385 +1 8.8 2.491 +1 9 2.601 +1 9.2 2.712 +1 9.4 2.827 +1 9.6 2.943 +1 9.8 3.063 + +2 -10 3.203 +2 -9.8 3.082 +2 -9.6 2.964 +2 -9.4 2.848 +2 -9.2 2.735 +2 -9 2.624 +2 -8.8 2.516 +2 -8.6 2.411 +2 -8.4 2.308 +2 -8.2 2.208 +2 -8 2.111 +2 -7.8 2.016 +2 -7.6 1.924 +2 -7.4 1.835 +2 -7.2 1.748 +2 -7 1.665 +2 -6.8 1.584 +2 -6.6 1.506 +2 -6.4 1.431 +2 -6.2 1.359 +2 -6 1.29 +2 -5.8 1.224 +2 -5.6 1.161 +2 -5.4 1.102 +2 -5.2 1.046 +2 -5 0.993 +2 -4.8 0.945 +2 -4.6 0.901 +2 -4.4 0.861 +2 -4.2 0.825 +2 -4 0.795 +2 -3.8 0.771 +2 -3.6 0.753 +2 -3.4 0.741 +2 -3.2 0.736 +2 -3 0.736 +2 -2.8 0.738 +2 -2.6 0.735 +2 -2.4 0.715 +2 -2.2 0.666 +2 -2 0.58 +2 -1.8 0.468 +2 -1.6 0.351 +2 -1.4 0.25 +2 -1.2 0.172 +2 -1 0.117 +2 -0.8 0.08 +2 -0.6 0.055 +2 -0.4 0.04 +2 -0.2 0.031 +2 0 0.027 +2 0.2 0.031 +2 0.4 0.04 +2 0.6 0.055 +2 0.8 0.08 +2 1 0.117 +2 1.2 0.172 +2 1.4 0.25 +2 1.6 0.351 +2 1.8 0.468 +2 2 0.58 +2 2.2 0.666 +2 2.4 0.715 +2 2.6 0.735 +2 2.8 0.738 +2 3 0.736 +2 3.2 0.736 +2 3.4 0.741 +2 3.6 0.753 +2 3.8 0.771 +2 4 0.795 +2 4.2 0.825 +2 4.4 0.861 +2 4.6 0.901 +2 4.8 0.945 +2 5 0.993 +2 5.2 1.046 +2 5.4 1.102 +2 5.6 1.161 +2 5.8 1.224 +2 6 1.29 +2 6.2 1.359 +2 6.4 1.431 +2 6.6 1.506 +2 6.8 1.584 +2 7 1.665 +2 7.2 1.748 +2 7.4 1.835 +2 7.6 1.924 +2 7.8 2.016 +2 8 2.111 +2 8.2 2.208 +2 8.4 2.308 +2 8.6 2.411 +2 8.8 2.516 +2 9 2.624 +2 9.2 2.735 +2 9.4 2.848 +2 9.6 2.964 +2 9.8 3.082 + +3 -10 3.232 +3 -9.8 3.113 +3 -9.6 2.996 +3 -9.4 2.882 +3 -9.2 2.771 +3 -9 2.663 +3 -8.8 2.557 +3 -8.6 2.454 +3 -8.4 2.355 +3 -8.2 2.258 +3 -8 2.164 +3 -7.8 2.073 +3 -7.6 1.986 +3 -7.4 1.901 +3 -7.2 1.82 +3 -7 1.743 +3 -6.8 1.669 +3 -6.6 1.599 +3 -6.4 1.533 +3 -6.2 1.471 +3 -6 1.414 +3 -5.8 1.361 +3 -5.6 1.315 +3 -5.4 1.275 +3 -5.2 1.242 +3 -5 1.216 +3 -4.8 1.2 +3 -4.6 1.195 +3 -4.4 1.201 +3 -4.2 1.22 +3 -4 1.25 +3 -3.8 1.288 +3 -3.6 1.321 +3 -3.4 1.328 +3 -3.2 1.28 +3 -3 1.158 +3 -2.8 0.973 +3 -2.6 0.763 +3 -2.4 0.569 +3 -2.2 0.41 +3 -2 0.291 +3 -1.8 0.204 +3 -1.6 0.143 +3 -1.4 0.1 +3 -1.2 0.07 +3 -1 0.05 +3 -0.8 0.035 +3 -0.6 0.026 +3 -0.4 0.02 +3 -0.2 0.016 +3 0 0.014 +3 0.2 0.016 +3 0.4 0.02 +3 0.6 0.026 +3 0.8 0.035 +3 1 0.05 +3 1.2 0.07 +3 1.4 0.1 +3 1.6 0.143 +3 1.8 0.204 +3 2 0.291 +3 2.2 0.41 +3 2.4 0.569 +3 2.6 0.763 +3 2.8 0.973 +3 3 1.158 +3 3.2 1.28 +3 3.4 1.328 +3 3.6 1.321 +3 3.8 1.288 +3 4 1.25 +3 4.2 1.22 +3 4.4 1.201 +3 4.6 1.195 +3 4.8 1.2 +3 5 1.216 +3 5.2 1.242 +3 5.4 1.275 +3 5.6 1.315 +3 5.8 1.361 +3 6 1.414 +3 6.2 1.471 +3 6.4 1.533 +3 6.6 1.599 +3 6.8 1.669 +3 7 1.743 +3 7.2 1.82 +3 7.4 1.901 +3 7.6 1.986 +3 7.8 2.073 +3 8 2.164 +3 8.2 2.258 +3 8.4 2.355 +3 8.6 2.454 +3 8.8 2.557 +3 9 2.663 +3 9.2 2.771 +3 9.4 2.882 +3 9.6 2.996 +3 9.8 3.113 + +4 -10 3.279 +4 -9.8 3.163 +4 -9.6 3.05 +4 -9.4 2.94 +4 -9.2 2.833 +4 -9 2.73 +4 -8.8 2.63 +4 -8.6 2.533 +4 -8.4 2.44 +4 -8.2 2.351 +4 -8 2.265 +4 -7.8 2.184 +4 -7.6 2.108 +4 -7.4 2.036 +4 -7.2 1.97 +4 -7 1.91 +4 -6.8 1.857 +4 -6.6 1.811 +4 -6.4 1.773 +4 -6.2 1.746 +4 -6 1.731 +4 -5.8 1.73 +4 -5.6 1.745 +4 -5.4 1.779 +4 -5.2 1.835 +4 -5 1.912 +4 -4.8 2.005 +4 -4.6 2.097 +4 -4.4 2.152 +4 -4.2 2.122 +4 -4 1.968 +4 -3.8 1.699 +4 -3.6 1.372 +4 -3.4 1.055 +4 -3.2 0.788 +4 -3 0.58 +4 -2.8 0.425 +4 -2.6 0.311 +4 -2.4 0.228 +4 -2.2 0.168 +4 -2 0.124 +4 -1.8 0.091 +4 -1.6 0.067 +4 -1.4 0.049 +4 -1.2 0.036 +4 -1 0.027 +4 -0.8 0.02 +4 -0.6 0.015 +4 -0.4 0.012 +4 -0.2 0.01 +4 0 0.009 +4 0.2 0.01 +4 0.4 0.012 +4 0.6 0.015 +4 0.8 0.02 +4 1 0.027 +4 1.2 0.036 +4 1.4 0.049 +4 1.6 0.067 +4 1.8 0.091 +4 2 0.124 +4 2.2 0.168 +4 2.4 0.228 +4 2.6 0.311 +4 2.8 0.425 +4 3 0.58 +4 3.2 0.788 +4 3.4 1.055 +4 3.6 1.372 +4 3.8 1.699 +4 4 1.968 +4 4.2 2.122 +4 4.4 2.152 +4 4.6 2.097 +4 4.8 2.005 +4 5 1.912 +4 5.2 1.835 +4 5.4 1.779 +4 5.6 1.745 +4 5.8 1.73 +4 6 1.731 +4 6.2 1.746 +4 6.4 1.773 +4 6.6 1.811 +4 6.8 1.857 +4 7 1.91 +4 7.2 1.97 +4 7.4 2.036 +4 7.6 2.108 +4 7.8 2.184 +4 8 2.265 +4 8.2 2.351 +4 8.4 2.44 +4 8.6 2.533 +4 8.8 2.63 +4 9 2.73 +4 9.2 2.833 +4 9.4 2.94 +4 9.6 3.05 +4 9.8 3.163 + +5 -10 3.362 +5 -9.8 3.253 +5 -9.6 3.148 +5 -9.4 3.047 +5 -9.2 2.95 +5 -9 2.858 +5 -8.8 2.771 +5 -8.6 2.689 +5 -8.4 2.613 +5 -8.2 2.544 +5 -8 2.483 +5 -7.8 2.43 +5 -7.6 2.388 +5 -7.4 2.357 +5 -7.2 2.339 +5 -7 2.339 +5 -6.8 2.359 +5 -6.6 2.402 +5 -6.4 2.475 +5 -6.2 2.581 +5 -6 2.721 +5 -5.8 2.889 +5 -5.6 3.062 +5 -5.4 3.188 +5 -5.2 3.192 +5 -5 3.01 +5 -4.8 2.644 +5 -4.6 2.177 +5 -4.4 1.709 +5 -4.2 1.306 +5 -4 0.985 +5 -3.8 0.741 +5 -3.6 0.559 +5 -3.4 0.424 +5 -3.2 0.323 +5 -3 0.247 +5 -2.8 0.19 +5 -2.6 0.146 +5 -2.4 0.112 +5 -2.2 0.086 +5 -2 0.066 +5 -1.8 0.051 +5 -1.6 0.039 +5 -1.4 0.029 +5 -1.2 0.022 +5 -1 0.017 +5 -0.8 0.013 +5 -0.6 0.01 +5 -0.4 0.008 +5 -0.2 0.007 +5 0 0.006 +5 0.2 0.007 +5 0.4 0.008 +5 0.6 0.01 +5 0.8 0.013 +5 1 0.017 +5 1.2 0.022 +5 1.4 0.029 +5 1.6 0.039 +5 1.8 0.051 +5 2 0.066 +5 2.2 0.086 +5 2.4 0.112 +5 2.6 0.146 +5 2.8 0.19 +5 3 0.247 +5 3.2 0.323 +5 3.4 0.424 +5 3.6 0.559 +5 3.8 0.741 +5 4 0.985 +5 4.2 1.306 +5 4.4 1.709 +5 4.6 2.177 +5 4.8 2.644 +5 5 3.01 +5 5.2 3.192 +5 5.4 3.188 +5 5.6 3.062 +5 5.8 2.889 +5 6 2.721 +5 6.2 2.581 +5 6.4 2.475 +5 6.6 2.402 +5 6.8 2.359 +5 7 2.339 +5 7.2 2.339 +5 7.4 2.357 +5 7.6 2.388 +5 7.8 2.43 +5 8 2.483 +5 8.2 2.544 +5 8.4 2.613 +5 8.6 2.689 +5 8.8 2.771 +5 9 2.858 +5 9.2 2.95 +5 9.4 3.047 +5 9.6 3.148 +5 9.8 3.253 + +6 -10 3.279 +6 -9.8 3.163 +6 -9.6 3.05 +6 -9.4 2.94 +6 -9.2 2.833 +6 -9 2.73 +6 -8.8 2.63 +6 -8.6 2.533 +6 -8.4 2.44 +6 -8.2 2.351 +6 -8 2.265 +6 -7.8 2.184 +6 -7.6 2.108 +6 -7.4 2.036 +6 -7.2 1.97 +6 -7 1.91 +6 -6.8 1.857 +6 -6.6 1.811 +6 -6.4 1.773 +6 -6.2 1.746 +6 -6 1.731 +6 -5.8 1.73 +6 -5.6 1.745 +6 -5.4 1.779 +6 -5.2 1.835 +6 -5 1.912 +6 -4.8 2.005 +6 -4.6 2.097 +6 -4.4 2.152 +6 -4.2 2.122 +6 -4 1.968 +6 -3.8 1.699 +6 -3.6 1.372 +6 -3.4 1.055 +6 -3.2 0.788 +6 -3 0.58 +6 -2.8 0.425 +6 -2.6 0.311 +6 -2.4 0.228 +6 -2.2 0.168 +6 -2 0.124 +6 -1.8 0.091 +6 -1.6 0.067 +6 -1.4 0.049 +6 -1.2 0.036 +6 -1 0.027 +6 -0.8 0.02 +6 -0.6 0.015 +6 -0.4 0.012 +6 -0.2 0.01 +6 0 0.009 +6 0.2 0.01 +6 0.4 0.012 +6 0.6 0.015 +6 0.8 0.02 +6 1 0.027 +6 1.2 0.036 +6 1.4 0.049 +6 1.6 0.067 +6 1.8 0.091 +6 2 0.124 +6 2.2 0.168 +6 2.4 0.228 +6 2.6 0.311 +6 2.8 0.425 +6 3 0.58 +6 3.2 0.788 +6 3.4 1.055 +6 3.6 1.372 +6 3.8 1.699 +6 4 1.968 +6 4.2 2.122 +6 4.4 2.152 +6 4.6 2.097 +6 4.8 2.005 +6 5 1.912 +6 5.2 1.835 +6 5.4 1.779 +6 5.6 1.745 +6 5.8 1.73 +6 6 1.731 +6 6.2 1.746 +6 6.4 1.773 +6 6.6 1.811 +6 6.8 1.857 +6 7 1.91 +6 7.2 1.97 +6 7.4 2.036 +6 7.6 2.108 +6 7.8 2.184 +6 8 2.265 +6 8.2 2.351 +6 8.4 2.44 +6 8.6 2.533 +6 8.8 2.63 +6 9 2.73 +6 9.2 2.833 +6 9.4 2.94 +6 9.6 3.05 +6 9.8 3.163 + +7 -10 3.232 +7 -9.8 3.113 +7 -9.6 2.996 +7 -9.4 2.882 +7 -9.2 2.771 +7 -9 2.663 +7 -8.8 2.557 +7 -8.6 2.454 +7 -8.4 2.355 +7 -8.2 2.258 +7 -8 2.164 +7 -7.8 2.073 +7 -7.6 1.986 +7 -7.4 1.901 +7 -7.2 1.82 +7 -7 1.743 +7 -6.8 1.669 +7 -6.6 1.599 +7 -6.4 1.533 +7 -6.2 1.471 +7 -6 1.414 +7 -5.8 1.361 +7 -5.6 1.315 +7 -5.4 1.275 +7 -5.2 1.242 +7 -5 1.216 +7 -4.8 1.2 +7 -4.6 1.195 +7 -4.4 1.201 +7 -4.2 1.22 +7 -4 1.25 +7 -3.8 1.288 +7 -3.6 1.321 +7 -3.4 1.328 +7 -3.2 1.28 +7 -3 1.158 +7 -2.8 0.973 +7 -2.6 0.763 +7 -2.4 0.569 +7 -2.2 0.41 +7 -2 0.291 +7 -1.8 0.204 +7 -1.6 0.143 +7 -1.4 0.1 +7 -1.2 0.07 +7 -1 0.05 +7 -0.8 0.035 +7 -0.6 0.026 +7 -0.4 0.02 +7 -0.2 0.016 +7 0 0.014 +7 0.2 0.016 +7 0.4 0.02 +7 0.6 0.026 +7 0.8 0.035 +7 1 0.05 +7 1.2 0.07 +7 1.4 0.1 +7 1.6 0.143 +7 1.8 0.204 +7 2 0.291 +7 2.2 0.41 +7 2.4 0.569 +7 2.6 0.763 +7 2.8 0.973 +7 3 1.158 +7 3.2 1.28 +7 3.4 1.328 +7 3.6 1.321 +7 3.8 1.288 +7 4 1.25 +7 4.2 1.22 +7 4.4 1.201 +7 4.6 1.195 +7 4.8 1.2 +7 5 1.216 +7 5.2 1.242 +7 5.4 1.275 +7 5.6 1.315 +7 5.8 1.361 +7 6 1.414 +7 6.2 1.471 +7 6.4 1.533 +7 6.6 1.599 +7 6.8 1.669 +7 7 1.743 +7 7.2 1.82 +7 7.4 1.901 +7 7.6 1.986 +7 7.8 2.073 +7 8 2.164 +7 8.2 2.258 +7 8.4 2.355 +7 8.6 2.454 +7 8.8 2.557 +7 9 2.663 +7 9.2 2.771 +7 9.4 2.882 +7 9.6 2.996 +7 9.8 3.113 + +8 -10 3.203 +8 -9.8 3.082 +8 -9.6 2.964 +8 -9.4 2.848 +8 -9.2 2.735 +8 -9 2.624 +8 -8.8 2.516 +8 -8.6 2.411 +8 -8.4 2.308 +8 -8.2 2.208 +8 -8 2.111 +8 -7.8 2.016 +8 -7.6 1.924 +8 -7.4 1.835 +8 -7.2 1.748 +8 -7 1.665 +8 -6.8 1.584 +8 -6.6 1.506 +8 -6.4 1.431 +8 -6.2 1.359 +8 -6 1.29 +8 -5.8 1.224 +8 -5.6 1.161 +8 -5.4 1.102 +8 -5.2 1.046 +8 -5 0.993 +8 -4.8 0.945 +8 -4.6 0.901 +8 -4.4 0.861 +8 -4.2 0.825 +8 -4 0.795 +8 -3.8 0.771 +8 -3.6 0.753 +8 -3.4 0.741 +8 -3.2 0.736 +8 -3 0.736 +8 -2.8 0.738 +8 -2.6 0.735 +8 -2.4 0.715 +8 -2.2 0.666 +8 -2 0.58 +8 -1.8 0.468 +8 -1.6 0.351 +8 -1.4 0.25 +8 -1.2 0.172 +8 -1 0.117 +8 -0.8 0.08 +8 -0.6 0.055 +8 -0.4 0.04 +8 -0.2 0.031 +8 0 0.027 +8 0.2 0.031 +8 0.4 0.04 +8 0.6 0.055 +8 0.8 0.08 +8 1 0.117 +8 1.2 0.172 +8 1.4 0.25 +8 1.6 0.351 +8 1.8 0.468 +8 2 0.58 +8 2.2 0.666 +8 2.4 0.715 +8 2.6 0.735 +8 2.8 0.738 +8 3 0.736 +8 3.2 0.736 +8 3.4 0.741 +8 3.6 0.753 +8 3.8 0.771 +8 4 0.795 +8 4.2 0.825 +8 4.4 0.861 +8 4.6 0.901 +8 4.8 0.945 +8 5 0.993 +8 5.2 1.046 +8 5.4 1.102 +8 5.6 1.161 +8 5.8 1.224 +8 6 1.29 +8 6.2 1.359 +8 6.4 1.431 +8 6.6 1.506 +8 6.8 1.584 +8 7 1.665 +8 7.2 1.748 +8 7.4 1.835 +8 7.6 1.924 +8 7.8 2.016 +8 8 2.111 +8 8.2 2.208 +8 8.4 2.308 +8 8.6 2.411 +8 8.8 2.516 +8 9 2.624 +8 9.2 2.735 +8 9.4 2.848 +8 9.6 2.964 +8 9.8 3.082 + +9 -10 3.185 +9 -9.8 3.063 +9 -9.6 2.943 +9 -9.4 2.827 +9 -9.2 2.712 +9 -9 2.601 +9 -8.8 2.491 +9 -8.6 2.385 +9 -8.4 2.281 +9 -8.2 2.179 +9 -8 2.08 +9 -7.8 1.984 +9 -7.6 1.89 +9 -7.4 1.799 +9 -7.2 1.71 +9 -7 1.624 +9 -6.8 1.54 +9 -6.6 1.459 +9 -6.4 1.381 +9 -6.2 1.305 +9 -6 1.232 +9 -5.8 1.161 +9 -5.6 1.094 +9 -5.4 1.029 +9 -5.2 0.966 +9 -5 0.906 +9 -4.8 0.849 +9 -4.6 0.795 +9 -4.4 0.744 +9 -4.2 0.695 +9 -4 0.65 +9 -3.8 0.607 +9 -3.6 0.567 +9 -3.4 0.531 +9 -3.2 0.498 +9 -3 0.468 +9 -2.8 0.442 +9 -2.6 0.419 +9 -2.4 0.399 +9 -2.2 0.382 +9 -2 0.368 +9 -1.8 0.354 +9 -1.6 0.337 +9 -1.4 0.313 +9 -1.2 0.279 +9 -1 0.233 +9 -0.8 0.182 +9 -0.6 0.135 +9 -0.4 0.099 +9 -0.2 0.075 +9 0 0.064 +9 0.2 0.075 +9 0.4 0.099 +9 0.6 0.135 +9 0.8 0.182 +9 1 0.233 +9 1.2 0.279 +9 1.4 0.313 +9 1.6 0.337 +9 1.8 0.354 +9 2 0.368 +9 2.2 0.382 +9 2.4 0.399 +9 2.6 0.419 +9 2.8 0.442 +9 3 0.468 +9 3.2 0.498 +9 3.4 0.531 +9 3.6 0.567 +9 3.8 0.607 +9 4 0.65 +9 4.2 0.695 +9 4.4 0.744 +9 4.6 0.795 +9 4.8 0.849 +9 5 0.906 +9 5.2 0.966 +9 5.4 1.029 +9 5.6 1.094 +9 5.8 1.161 +9 6 1.232 +9 6.2 1.305 +9 6.4 1.381 +9 6.6 1.459 +9 6.8 1.54 +9 7 1.624 +9 7.2 1.71 +9 7.4 1.799 +9 7.6 1.89 +9 7.8 1.984 +9 8 2.08 +9 8.2 2.179 +9 8.4 2.281 +9 8.6 2.385 +9 8.8 2.491 +9 9 2.601 +9 9.2 2.712 +9 9.4 2.827 +9 9.6 2.943 +9 9.8 3.063 + +10 -10 3.173 +10 -9.8 3.05 +10 -9.6 2.93 +10 -9.4 2.813 +10 -9.2 2.698 +10 -9 2.586 +10 -8.8 2.476 +10 -8.6 2.368 +10 -8.4 2.264 +10 -8.2 2.161 +10 -8 2.062 +10 -7.8 1.964 +10 -7.6 1.869 +10 -7.4 1.777 +10 -7.2 1.687 +10 -7 1.6 +10 -6.8 1.515 +10 -6.6 1.433 +10 -6.4 1.353 +10 -6.2 1.276 +10 -6 1.202 +10 -5.8 1.129 +10 -5.6 1.06 +10 -5.4 0.993 +10 -5.2 0.928 +10 -5 0.866 +10 -4.8 0.806 +10 -4.6 0.749 +10 -4.4 0.694 +10 -4.2 0.642 +10 -4 0.593 +10 -3.8 0.546 +10 -3.6 0.501 +10 -3.4 0.459 +10 -3.2 0.419 +10 -3 0.382 +10 -2.8 0.348 +10 -2.6 0.316 +10 -2.4 0.286 +10 -2.2 0.259 +10 -2 0.234 +10 -1.8 0.212 +10 -1.6 0.192 +10 -1.4 0.175 +10 -1.2 0.16 +10 -1 0.147 +10 -0.8 0.137 +10 -0.6 0.129 +10 -0.4 0.123 +10 -0.2 0.119 +10 0 0.117 +10 0.2 0.119 +10 0.4 0.123 +10 0.6 0.129 +10 0.8 0.137 +10 1 0.147 +10 1.2 0.16 +10 1.4 0.175 +10 1.6 0.192 +10 1.8 0.212 +10 2 0.234 +10 2.2 0.259 +10 2.4 0.286 +10 2.6 0.316 +10 2.8 0.348 +10 3 0.382 +10 3.2 0.419 +10 3.4 0.459 +10 3.6 0.501 +10 3.8 0.546 +10 4 0.593 +10 4.2 0.642 +10 4.4 0.694 +10 4.6 0.749 +10 4.8 0.806 +10 5 0.866 +10 5.2 0.928 +10 5.4 0.993 +10 5.6 1.06 +10 5.8 1.129 +10 6 1.202 +10 6.2 1.276 +10 6.4 1.353 +10 6.6 1.433 +10 6.8 1.515 +10 7 1.6 +10 7.2 1.687 +10 7.4 1.777 +10 7.6 1.869 +10 7.8 1.964 +10 8 2.062 +10 8.2 2.161 +10 8.4 2.264 +10 8.6 2.368 +10 8.8 2.476 +10 9 2.586 +10 9.2 2.698 +10 9.4 2.813 +10 9.6 2.93 +10 9.8 3.05 + +11 -10 3.185 +11 -9.8 3.063 +11 -9.6 2.943 +11 -9.4 2.827 +11 -9.2 2.712 +11 -9 2.601 +11 -8.8 2.491 +11 -8.6 2.385 +11 -8.4 2.281 +11 -8.2 2.179 +11 -8 2.08 +11 -7.8 1.984 +11 -7.6 1.89 +11 -7.4 1.799 +11 -7.2 1.71 +11 -7 1.624 +11 -6.8 1.54 +11 -6.6 1.459 +11 -6.4 1.381 +11 -6.2 1.305 +11 -6 1.232 +11 -5.8 1.161 +11 -5.6 1.094 +11 -5.4 1.029 +11 -5.2 0.966 +11 -5 0.906 +11 -4.8 0.849 +11 -4.6 0.795 +11 -4.4 0.744 +11 -4.2 0.695 +11 -4 0.65 +11 -3.8 0.607 +11 -3.6 0.567 +11 -3.4 0.531 +11 -3.2 0.498 +11 -3 0.468 +11 -2.8 0.442 +11 -2.6 0.419 +11 -2.4 0.399 +11 -2.2 0.382 +11 -2 0.368 +11 -1.8 0.354 +11 -1.6 0.337 +11 -1.4 0.313 +11 -1.2 0.279 +11 -1 0.233 +11 -0.8 0.182 +11 -0.6 0.135 +11 -0.4 0.099 +11 -0.2 0.075 +11 0 0.064 +11 0.2 0.075 +11 0.4 0.099 +11 0.6 0.135 +11 0.8 0.182 +11 1 0.233 +11 1.2 0.279 +11 1.4 0.313 +11 1.6 0.337 +11 1.8 0.354 +11 2 0.368 +11 2.2 0.382 +11 2.4 0.399 +11 2.6 0.419 +11 2.8 0.442 +11 3 0.468 +11 3.2 0.498 +11 3.4 0.531 +11 3.6 0.567 +11 3.8 0.607 +11 4 0.65 +11 4.2 0.695 +11 4.4 0.744 +11 4.6 0.795 +11 4.8 0.849 +11 5 0.906 +11 5.2 0.966 +11 5.4 1.029 +11 5.6 1.094 +11 5.8 1.161 +11 6 1.232 +11 6.2 1.305 +11 6.4 1.381 +11 6.6 1.459 +11 6.8 1.54 +11 7 1.624 +11 7.2 1.71 +11 7.4 1.799 +11 7.6 1.89 +11 7.8 1.984 +11 8 2.08 +11 8.2 2.179 +11 8.4 2.281 +11 8.6 2.385 +11 8.8 2.491 +11 9 2.601 +11 9.2 2.712 +11 9.4 2.827 +11 9.6 2.943 +11 9.8 3.063 + +12 -10 3.203 +12 -9.8 3.082 +12 -9.6 2.964 +12 -9.4 2.848 +12 -9.2 2.735 +12 -9 2.624 +12 -8.8 2.516 +12 -8.6 2.411 +12 -8.4 2.308 +12 -8.2 2.208 +12 -8 2.111 +12 -7.8 2.016 +12 -7.6 1.924 +12 -7.4 1.835 +12 -7.2 1.748 +12 -7 1.665 +12 -6.8 1.584 +12 -6.6 1.506 +12 -6.4 1.431 +12 -6.2 1.359 +12 -6 1.29 +12 -5.8 1.224 +12 -5.6 1.161 +12 -5.4 1.102 +12 -5.2 1.046 +12 -5 0.993 +12 -4.8 0.945 +12 -4.6 0.901 +12 -4.4 0.861 +12 -4.2 0.825 +12 -4 0.795 +12 -3.8 0.771 +12 -3.6 0.753 +12 -3.4 0.741 +12 -3.2 0.736 +12 -3 0.736 +12 -2.8 0.738 +12 -2.6 0.735 +12 -2.4 0.715 +12 -2.2 0.666 +12 -2 0.58 +12 -1.8 0.468 +12 -1.6 0.351 +12 -1.4 0.25 +12 -1.2 0.172 +12 -1 0.117 +12 -0.8 0.08 +12 -0.6 0.055 +12 -0.4 0.04 +12 -0.2 0.031 +12 0 0.027 +12 0.2 0.031 +12 0.4 0.04 +12 0.6 0.055 +12 0.8 0.08 +12 1 0.117 +12 1.2 0.172 +12 1.4 0.25 +12 1.6 0.351 +12 1.8 0.468 +12 2 0.58 +12 2.2 0.666 +12 2.4 0.715 +12 2.6 0.735 +12 2.8 0.738 +12 3 0.736 +12 3.2 0.736 +12 3.4 0.741 +12 3.6 0.753 +12 3.8 0.771 +12 4 0.795 +12 4.2 0.825 +12 4.4 0.861 +12 4.6 0.901 +12 4.8 0.945 +12 5 0.993 +12 5.2 1.046 +12 5.4 1.102 +12 5.6 1.161 +12 5.8 1.224 +12 6 1.29 +12 6.2 1.359 +12 6.4 1.431 +12 6.6 1.506 +12 6.8 1.584 +12 7 1.665 +12 7.2 1.748 +12 7.4 1.835 +12 7.6 1.924 +12 7.8 2.016 +12 8 2.111 +12 8.2 2.208 +12 8.4 2.308 +12 8.6 2.411 +12 8.8 2.516 +12 9 2.624 +12 9.2 2.735 +12 9.4 2.848 +12 9.6 2.964 +12 9.8 3.082 + +13 -10 3.232 +13 -9.8 3.113 +13 -9.6 2.996 +13 -9.4 2.882 +13 -9.2 2.771 +13 -9 2.663 +13 -8.8 2.557 +13 -8.6 2.454 +13 -8.4 2.355 +13 -8.2 2.258 +13 -8 2.164 +13 -7.8 2.073 +13 -7.6 1.986 +13 -7.4 1.901 +13 -7.2 1.82 +13 -7 1.743 +13 -6.8 1.669 +13 -6.6 1.599 +13 -6.4 1.533 +13 -6.2 1.471 +13 -6 1.414 +13 -5.8 1.361 +13 -5.6 1.315 +13 -5.4 1.275 +13 -5.2 1.242 +13 -5 1.216 +13 -4.8 1.2 +13 -4.6 1.195 +13 -4.4 1.201 +13 -4.2 1.22 +13 -4 1.25 +13 -3.8 1.288 +13 -3.6 1.321 +13 -3.4 1.328 +13 -3.2 1.28 +13 -3 1.158 +13 -2.8 0.973 +13 -2.6 0.763 +13 -2.4 0.569 +13 -2.2 0.41 +13 -2 0.291 +13 -1.8 0.204 +13 -1.6 0.143 +13 -1.4 0.1 +13 -1.2 0.07 +13 -1 0.05 +13 -0.8 0.035 +13 -0.6 0.026 +13 -0.4 0.02 +13 -0.2 0.016 +13 0 0.014 +13 0.2 0.016 +13 0.4 0.02 +13 0.6 0.026 +13 0.8 0.035 +13 1 0.05 +13 1.2 0.07 +13 1.4 0.1 +13 1.6 0.143 +13 1.8 0.204 +13 2 0.291 +13 2.2 0.41 +13 2.4 0.569 +13 2.6 0.763 +13 2.8 0.973 +13 3 1.158 +13 3.2 1.28 +13 3.4 1.328 +13 3.6 1.321 +13 3.8 1.288 +13 4 1.25 +13 4.2 1.22 +13 4.4 1.201 +13 4.6 1.195 +13 4.8 1.2 +13 5 1.216 +13 5.2 1.242 +13 5.4 1.275 +13 5.6 1.315 +13 5.8 1.361 +13 6 1.414 +13 6.2 1.471 +13 6.4 1.533 +13 6.6 1.599 +13 6.8 1.669 +13 7 1.743 +13 7.2 1.82 +13 7.4 1.901 +13 7.6 1.986 +13 7.8 2.073 +13 8 2.164 +13 8.2 2.258 +13 8.4 2.355 +13 8.6 2.454 +13 8.8 2.557 +13 9 2.663 +13 9.2 2.771 +13 9.4 2.882 +13 9.6 2.996 +13 9.8 3.113 + +14 -10 3.279 +14 -9.8 3.163 +14 -9.6 3.05 +14 -9.4 2.94 +14 -9.2 2.833 +14 -9 2.73 +14 -8.8 2.63 +14 -8.6 2.533 +14 -8.4 2.44 +14 -8.2 2.351 +14 -8 2.265 +14 -7.8 2.184 +14 -7.6 2.108 +14 -7.4 2.036 +14 -7.2 1.97 +14 -7 1.91 +14 -6.8 1.857 +14 -6.6 1.811 +14 -6.4 1.773 +14 -6.2 1.746 +14 -6 1.731 +14 -5.8 1.73 +14 -5.6 1.745 +14 -5.4 1.779 +14 -5.2 1.835 +14 -5 1.912 +14 -4.8 2.005 +14 -4.6 2.097 +14 -4.4 2.152 +14 -4.2 2.122 +14 -4 1.968 +14 -3.8 1.699 +14 -3.6 1.372 +14 -3.4 1.055 +14 -3.2 0.788 +14 -3 0.58 +14 -2.8 0.425 +14 -2.6 0.311 +14 -2.4 0.228 +14 -2.2 0.168 +14 -2 0.124 +14 -1.8 0.091 +14 -1.6 0.067 +14 -1.4 0.049 +14 -1.2 0.036 +14 -1 0.027 +14 -0.8 0.02 +14 -0.6 0.015 +14 -0.4 0.012 +14 -0.2 0.01 +14 0 0.009 +14 0.2 0.01 +14 0.4 0.012 +14 0.6 0.015 +14 0.8 0.02 +14 1 0.027 +14 1.2 0.036 +14 1.4 0.049 +14 1.6 0.067 +14 1.8 0.091 +14 2 0.124 +14 2.2 0.168 +14 2.4 0.228 +14 2.6 0.311 +14 2.8 0.425 +14 3 0.58 +14 3.2 0.788 +14 3.4 1.055 +14 3.6 1.372 +14 3.8 1.699 +14 4 1.968 +14 4.2 2.122 +14 4.4 2.152 +14 4.6 2.097 +14 4.8 2.005 +14 5 1.912 +14 5.2 1.835 +14 5.4 1.779 +14 5.6 1.745 +14 5.8 1.73 +14 6 1.731 +14 6.2 1.746 +14 6.4 1.773 +14 6.6 1.811 +14 6.8 1.857 +14 7 1.91 +14 7.2 1.97 +14 7.4 2.036 +14 7.6 2.108 +14 7.8 2.184 +14 8 2.265 +14 8.2 2.351 +14 8.4 2.44 +14 8.6 2.533 +14 8.8 2.63 +14 9 2.73 +14 9.2 2.833 +14 9.4 2.94 +14 9.6 3.05 +14 9.8 3.163 diff --git a/testsweep.csv b/testsweep.csv deleted file mode 100644 index 0a701bb1955..00000000000 --- a/testsweep.csv +++ /dev/null @@ -1,480 +0,0 @@ -ts,i_chan0(400),chan0,amplitude -2015-10-17 01:08:25:066818,0,-20.0,0.117 -2015-10-17 01:08:25:272614,1,-19.9,0.117 -2015-10-17 01:08:25:477351,2,-19.8,0.115 -2015-10-17 01:08:25:683882,3,-19.7,0.111 -2015-10-17 01:08:25:890434,4,-19.6,0.106 -2015-10-17 01:08:25:890434,4,-19.6,0.106 -2015-10-17 01:08:26:096571,5,-19.5,0.099 -2015-10-17 01:08:26:302896,6,-19.4,0.092 -2015-10-17 01:08:26:509334,7,-19.3,0.085 -2015-10-17 01:08:26:712697,8,-19.2,0.077 -2015-10-17 01:08:26:914103,9,-19.1,0.071 -2015-10-17 01:08:26:914103,9,-19.1,0.071 -2015-10-17 01:08:27:117491,10,-19.0,0.064 -2015-10-17 01:08:27:323689,11,-18.9,0.058 -2015-10-17 01:08:27:528680,12,-18.8,0.053 -2015-10-17 01:08:27:734919,13,-18.7,0.048 -2015-10-17 01:08:27:941441,14,-18.6,0.044 -2015-10-17 01:08:27:941441,14,-18.6,0.044 -2015-10-17 01:08:28:147449,15,-18.5,0.04 -2015-10-17 01:08:28:354581,16,-18.4,0.037 -2015-10-17 01:08:28:560971,17,-18.3,0.034 -2015-10-17 01:08:28:767400,18,-18.2,0.031 -2015-10-17 01:08:28:973360,19,-18.1,0.029 -2015-10-17 01:08:28:973360,19,-18.1,0.029 -2015-10-17 01:08:29:179899,20,-18.0,0.027 -2015-10-17 01:08:29:386045,21,-17.9,0.025 -2015-10-17 01:08:29:589390,22,-17.8,0.023 -2015-10-17 01:08:29:791675,23,-17.7,0.022 -2015-10-17 01:08:29:995402,24,-17.6,0.02 -2015-10-17 01:08:29:995402,24,-17.6,0.02 -2015-10-17 01:08:30:197972,25,-17.5,0.019 -2015-10-17 01:08:30:399327,26,-17.4,0.018 -2015-10-17 01:08:30:602835,27,-17.3,0.017 -2015-10-17 01:08:30:808404,28,-17.2,0.016 -2015-10-17 01:08:31:012270,29,-17.1,0.015 -2015-10-17 01:08:31:012270,29,-17.1,0.015 -2015-10-17 01:08:31:218347,30,-17.0,0.014 -2015-10-17 01:08:31:425131,31,-16.9,0.013 -2015-10-17 01:08:31:631597,32,-16.8,0.013 -2015-10-17 01:08:31:838021,33,-16.7,0.012 -2015-10-17 01:08:32:044581,34,-16.6,0.011 -2015-10-17 01:08:32:044581,34,-16.6,0.011 -2015-10-17 01:08:32:250560,35,-16.5,0.011 -2015-10-17 01:08:32:457495,36,-16.4,0.01 -2015-10-17 01:08:32:663925,37,-16.3,0.01 -2015-10-17 01:08:32:870353,38,-16.2,0.01 -2015-10-17 01:08:33:076791,39,-16.1,0.009 -2015-10-17 01:08:33:076791,39,-16.1,0.009 -2015-10-17 01:08:33:280467,40,-16.0,0.009 -2015-10-17 01:08:33:486903,41,-15.9,0.008 -2015-10-17 01:08:33:691401,42,-15.8,0.008 -2015-10-17 01:08:33:897834,43,-15.7,0.008 -2015-10-17 01:08:34:104460,44,-15.6,0.007 -2015-10-17 01:08:34:104460,44,-15.6,0.007 -2015-10-17 01:08:34:310444,45,-15.5,0.007 -2015-10-17 01:08:34:517390,46,-15.4,0.007 -2015-10-17 01:08:34:723954,47,-15.3,0.007 -2015-10-17 01:08:34:930402,48,-15.2,0.006 -2015-10-17 01:08:35:136816,49,-15.1,0.006 -2015-10-17 01:08:35:136816,49,-15.1,0.006 -2015-10-17 01:08:35:343415,50,-15.0,0.006 -2015-10-17 01:08:35:549375,51,-14.9,0.006 -2015-10-17 01:08:35:756330,52,-14.8,0.006 -2015-10-17 01:08:35:962227,53,-14.7,0.007 -2015-10-17 01:08:36:169303,54,-14.6,0.007 -2015-10-17 01:08:36:169303,54,-14.6,0.007 -2015-10-17 01:08:36:375811,55,-14.5,0.007 -2015-10-17 01:08:36:581095,56,-14.4,0.007 -2015-10-17 01:08:36:786794,57,-14.3,0.008 -2015-10-17 01:08:36:987164,58,-14.2,0.008 -2015-10-17 01:08:37:189052,59,-14.1,0.008 -2015-10-17 01:08:37:189052,59,-14.1,0.008 -2015-10-17 01:08:37:390893,60,-14.0,0.009 -2015-10-17 01:08:37:598052,61,-13.9,0.009 -2015-10-17 01:08:37:804445,62,-13.8,0.01 -2015-10-17 01:08:38:010402,63,-13.7,0.01 -2015-10-17 01:08:38:217518,64,-13.6,0.01 -2015-10-17 01:08:38:217518,64,-13.6,0.01 -2015-10-17 01:08:38:421855,65,-13.5,0.011 -2015-10-17 01:08:38:623521,66,-13.4,0.011 -2015-10-17 01:08:38:827320,67,-13.3,0.012 -2015-10-17 01:08:39:030795,68,-13.2,0.013 -2015-10-17 01:08:39:233954,69,-13.1,0.013 -2015-10-17 01:08:39:233954,69,-13.1,0.013 -2015-10-17 01:08:39:438425,70,-13.0,0.014 -2015-10-17 01:08:39:641976,71,-12.9,0.015 -2015-10-17 01:08:39:846889,72,-12.8,0.016 -2015-10-17 01:08:40:047851,73,-12.7,0.017 -2015-10-17 01:08:40:250781,74,-12.6,0.018 -2015-10-17 01:08:40:250781,74,-12.6,0.018 -2015-10-17 01:08:40:456381,75,-12.5,0.019 -2015-10-17 01:08:40:663041,76,-12.4,0.02 -2015-10-17 01:08:40:869473,77,-12.3,0.022 -2015-10-17 01:08:41:072945,78,-12.2,0.023 -2015-10-17 01:08:41:275260,79,-12.1,0.025 -2015-10-17 01:08:41:275260,79,-12.1,0.025 -2015-10-17 01:08:41:476995,80,-12.0,0.027 -2015-10-17 01:08:41:678407,81,-11.9,0.029 -2015-10-17 01:08:41:882884,82,-11.8,0.031 -2015-10-17 01:08:42:087207,83,-11.7,0.034 -2015-10-17 01:08:42:291228,84,-11.6,0.037 -2015-10-17 01:08:42:291228,84,-11.6,0.037 -2015-10-17 01:08:42:497550,85,-11.5,0.04 -2015-10-17 01:08:42:700372,86,-11.4,0.044 -2015-10-17 01:08:42:904526,87,-11.3,0.048 -2015-10-17 01:08:43:106188,88,-11.2,0.053 -2015-10-17 01:08:43:312608,89,-11.1,0.058 -2015-10-17 01:08:43:312608,89,-11.1,0.058 -2015-10-17 01:08:43:516957,90,-11.0,0.064 -2015-10-17 01:08:43:722358,91,-10.9,0.071 -2015-10-17 01:08:43:925930,92,-10.8,0.077 -2015-10-17 01:08:44:129729,93,-10.7,0.085 -2015-10-17 01:08:44:333129,94,-10.6,0.092 -2015-10-17 01:08:44:333129,94,-10.6,0.092 -2015-10-17 01:08:44:539686,95,-10.5,0.099 -2015-10-17 01:08:44:746177,96,-10.4,0.106 -2015-10-17 01:08:44:952608,97,-10.3,0.111 -2015-10-17 01:08:45:159087,98,-10.2,0.115 -2015-10-17 01:08:45:365511,99,-10.1,0.117 -2015-10-17 01:08:45:365511,99,-10.1,0.117 -2015-10-17 01:08:45:572074,100,-10.0,0.117 -2015-10-17 01:08:45:778078,101,-9.9,0.117 -2015-10-17 01:08:45:984385,102,-9.8,0.115 -2015-10-17 01:08:46:186357,103,-9.7,0.111 -2015-10-17 01:08:46:391071,104,-9.6,0.106 -2015-10-17 01:08:46:391071,104,-9.6,0.106 -2015-10-17 01:08:46:597429,105,-9.5,0.099 -2015-10-17 01:08:46:801541,106,-9.4,0.092 -2015-10-17 01:08:47:004053,107,-9.3,0.085 -2015-10-17 01:08:47:210587,108,-9.2,0.077 -2015-10-17 01:08:47:416357,109,-9.1,0.071 -2015-10-17 01:08:47:416357,109,-9.1,0.071 -2015-10-17 01:08:47:618598,110,-9.0,0.064 -2015-10-17 01:08:47:820846,111,-8.9,0.058 -2015-10-17 01:08:48:023591,112,-8.8,0.053 -2015-10-17 01:08:48:226031,113,-8.7,0.048 -2015-10-17 01:08:48:432471,114,-8.6,0.044 -2015-10-17 01:08:48:432471,114,-8.6,0.044 -2015-10-17 01:08:48:637543,115,-8.5,0.04 -2015-10-17 01:08:48:841939,116,-8.4,0.037 -2015-10-17 01:08:49:044442,117,-8.3,0.034 -2015-10-17 01:08:49:248390,118,-8.2,0.031 -2015-10-17 01:08:49:452331,119,-8.1,0.029 -2015-10-17 01:08:49:452331,119,-8.1,0.029 -2015-10-17 01:08:49:654798,120,-8.0,0.027 -2015-10-17 01:08:49:855576,121,-7.9,0.025 -2015-10-17 01:08:50:057071,122,-7.8,0.023 -2015-10-17 01:08:50:264153,123,-7.7,0.022 -2015-10-17 01:08:50:468308,124,-7.6,0.02 -2015-10-17 01:08:50:468308,124,-7.6,0.02 -2015-10-17 01:08:50:672899,125,-7.5,0.019 -2015-10-17 01:08:50:876487,126,-7.4,0.018 -2015-10-17 01:08:51:078548,127,-7.3,0.017 -2015-10-17 01:08:51:280437,128,-7.2,0.016 -2015-10-17 01:08:51:487586,129,-7.1,0.015 -2015-10-17 01:08:51:487586,129,-7.1,0.015 -2015-10-17 01:08:51:691382,130,-7.0,0.014 -2015-10-17 01:08:51:896049,131,-6.9,0.013 -2015-10-17 01:08:52:097634,132,-6.8,0.013 -2015-10-17 01:08:52:304223,133,-6.7,0.012 -2015-10-17 01:08:52:511697,134,-6.6,0.011 -2015-10-17 01:08:52:712528,135,-6.5,0.011 -2015-10-17 01:08:52:712528,135,-6.5,0.011 -2015-10-17 01:08:52:919926,136,-6.4,0.01 -2015-10-17 01:08:53:123019,137,-6.3,0.01 -2015-10-17 01:08:53:324753,138,-6.2,0.01 -2015-10-17 01:08:53:528206,139,-6.1,0.009 -2015-10-17 01:08:53:528206,139,-6.1,0.009 -2015-10-17 01:08:53:730047,140,-6.0,0.009 -2015-10-17 01:08:53:934696,141,-5.9,0.008 -2015-10-17 01:08:54:140749,142,-5.8,0.008 -2015-10-17 01:08:54:346396,143,-5.7,0.008 -2015-10-17 01:08:54:547262,144,-5.6,0.007 -2015-10-17 01:08:54:547262,144,-5.6,0.007 -2015-10-17 01:08:54:754296,145,-5.5,0.007 -2015-10-17 01:08:54:958062,146,-5.4,0.007 -2015-10-17 01:08:55:159589,147,-5.3,0.007 -2015-10-17 01:08:55:362231,148,-5.2,0.006 -2015-10-17 01:08:55:567305,149,-5.1,0.006 -2015-10-17 01:08:55:567305,149,-5.1,0.006 -2015-10-17 01:08:55:772267,150,-5.0,0.006 -2015-10-17 01:08:55:973639,151,-4.9,0.006 -2015-10-17 01:08:56:178694,152,-4.8,0.006 -2015-10-17 01:08:56:382744,153,-4.7,0.007 -2015-10-17 01:08:56:585253,154,-4.6,0.007 -2015-10-17 01:08:56:585253,154,-4.6,0.007 -2015-10-17 01:08:56:791481,155,-4.5,0.007 -2015-10-17 01:08:56:994375,156,-4.4,0.007 -2015-10-17 01:08:57:196595,157,-4.3,0.008 -2015-10-17 01:08:57:398339,158,-4.2,0.008 -2015-10-17 01:08:57:602207,159,-4.1,0.008 -2015-10-17 01:08:57:602207,159,-4.1,0.008 -2015-10-17 01:08:57:804439,160,-4.0,0.009 -2015-10-17 01:08:58:009306,161,-3.9,0.009 -2015-10-17 01:08:58:211158,162,-3.8,0.01 -2015-10-17 01:08:58:412695,163,-3.7,0.01 -2015-10-17 01:08:58:618581,164,-3.6,0.01 -2015-10-17 01:08:58:618581,164,-3.6,0.01 -2015-10-17 01:08:58:821444,165,-3.5,0.011 -2015-10-17 01:08:59:022761,166,-3.4,0.011 -2015-10-17 01:08:59:224515,167,-3.3,0.012 -2015-10-17 01:08:59:426049,168,-3.2,0.013 -2015-10-17 01:08:59:631730,169,-3.1,0.013 -2015-10-17 01:08:59:631730,169,-3.1,0.013 -2015-10-17 01:08:59:834439,170,-3.0,0.014 -2015-10-17 01:09:00:039694,171,-2.9,0.015 -2015-10-17 01:09:00:244563,172,-2.8,0.016 -2015-10-17 01:09:00:446875,173,-2.7,0.017 -2015-10-17 01:09:00:653546,174,-2.6,0.018 -2015-10-17 01:09:00:653546,174,-2.6,0.018 -2015-10-17 01:09:00:856120,175,-2.5,0.019 -2015-10-17 01:09:01:057571,176,-2.4,0.02 -2015-10-17 01:09:01:262276,177,-2.3,0.022 -2015-10-17 01:09:01:465554,178,-2.2,0.023 -2015-10-17 01:09:01:670305,179,-2.1,0.025 -2015-10-17 01:09:01:670305,179,-2.1,0.025 -2015-10-17 01:09:01:873423,180,-2.0,0.027 -2015-10-17 01:09:02:080410,181,-1.9,0.029 -2015-10-17 01:09:02:284684,182,-1.8,0.031 -2015-10-17 01:09:02:486174,183,-1.7,0.034 -2015-10-17 01:09:02:688014,184,-1.6,0.037 -2015-10-17 01:09:02:688014,184,-1.6,0.037 -2015-10-17 01:09:02:895173,185,-1.5,0.04 -2015-10-17 01:09:03:099103,186,-1.4,0.044 -2015-10-17 01:09:03:305836,187,-1.3,0.048 -2015-10-17 01:09:03:508621,188,-1.2,0.053 -2015-10-17 01:09:03:709373,189,-1.1,0.058 -2015-10-17 01:09:03:709373,189,-1.1,0.058 -2015-10-17 01:09:03:911310,190,-1.0,0.064 -2015-10-17 01:09:04:117754,191,-0.9,0.071 -2015-10-17 01:09:04:320308,192,-0.8,0.077 -2015-10-17 01:09:04:525469,193,-0.7,0.085 -2015-10-17 01:09:04:730840,194,-0.6,0.092 -2015-10-17 01:09:04:730840,194,-0.6,0.092 -2015-10-17 01:09:04:937340,195,-0.5,0.099 -2015-10-17 01:09:05:140306,196,-0.4,0.106 -2015-10-17 01:09:05:342407,197,-0.3,0.111 -2015-10-17 01:09:05:548100,198,-0.2,0.115 -2015-10-17 01:09:05:753362,199,-0.1,0.117 -2015-10-17 01:09:05:753362,199,-0.1,0.117 -2015-10-17 01:09:05:955718,200,0.0,0.117 -2015-10-17 01:09:06:161382,201,0.1,0.117 -2015-10-17 01:09:06:362839,202,0.2,0.115 -2015-10-17 01:09:06:564141,203,0.3,0.111 -2015-10-17 01:09:06:768455,204,0.4,0.106 -2015-10-17 01:09:06:768455,204,0.4,0.106 -2015-10-17 01:09:06:972218,205,0.5,0.099 -2015-10-17 01:09:07:175029,206,0.6,0.092 -2015-10-17 01:09:07:380009,207,0.7,0.085 -2015-10-17 01:09:07:586292,208,0.8,0.077 -2015-10-17 01:09:07:789344,209,0.9,0.071 -2015-10-17 01:09:07:789344,209,0.9,0.071 -2015-10-17 01:09:07:993746,210,1.0,0.064 -2015-10-17 01:09:08:196331,211,1.1,0.058 -2015-10-17 01:09:08:397974,212,1.2,0.053 -2015-10-17 01:09:08:600244,213,1.3,0.048 -2015-10-17 01:09:08:804068,214,1.4,0.044 -2015-10-17 01:09:08:804068,214,1.4,0.044 -2015-10-17 01:09:09:006069,215,1.5,0.04 -2015-10-17 01:09:09:208774,216,1.6,0.037 -2015-10-17 01:09:09:411084,217,1.7,0.034 -2015-10-17 01:09:09:613102,218,1.8,0.031 -2015-10-17 01:09:09:815551,219,1.9,0.029 -2015-10-17 01:09:09:815551,219,1.9,0.029 -2015-10-17 01:09:10:018059,220,2.0,0.027 -2015-10-17 01:09:10:221442,221,2.1,0.025 -2015-10-17 01:09:10:425992,222,2.2,0.023 -2015-10-17 01:09:10:629908,223,2.3,0.022 -2015-10-17 01:09:10:833956,224,2.4,0.02 -2015-10-17 01:09:10:833956,224,2.4,0.02 -2015-10-17 01:09:11:035923,225,2.5,0.019 -2015-10-17 01:09:11:242522,226,2.6,0.018 -2015-10-17 01:09:11:448470,227,2.7,0.017 -2015-10-17 01:09:11:651542,228,2.8,0.016 -2015-10-17 01:09:11:858015,229,2.9,0.015 -2015-10-17 01:09:11:858015,229,2.9,0.015 -2015-10-17 01:09:12:059396,230,3.0,0.014 -2015-10-17 01:09:12:265155,231,3.1,0.013 -2015-10-17 01:09:12:469124,232,3.2,0.013 -2015-10-17 01:09:12:675091,233,3.3,0.012 -2015-10-17 01:09:12:880806,234,3.4,0.011 -2015-10-17 01:09:12:880806,234,3.4,0.011 -2015-10-17 01:09:13:082930,235,3.5,0.011 -2015-10-17 01:09:13:285099,236,3.6,0.01 -2015-10-17 01:09:13:491619,237,3.7,0.01 -2015-10-17 01:09:13:692632,238,3.8,0.01 -2015-10-17 01:09:13:899633,239,3.9,0.009 -2015-10-17 01:09:13:899633,239,3.9,0.009 -2015-10-17 01:09:14:106257,240,4.0,0.009 -2015-10-17 01:09:14:312725,241,4.1,0.008 -2015-10-17 01:09:14:516634,242,4.2,0.008 -2015-10-17 01:09:14:719816,243,4.3,0.008 -2015-10-17 01:09:14:925967,244,4.4,0.007 -2015-10-17 01:09:14:925967,244,4.4,0.007 -2015-10-17 01:09:15:131989,245,4.5,0.007 -2015-10-17 01:09:15:334357,246,4.6,0.007 -2015-10-17 01:09:15:537003,247,4.7,0.007 -2015-10-17 01:09:15:742435,248,4.8,0.006 -2015-10-17 01:09:15:949086,249,4.9,0.006 -2015-10-17 01:09:15:949086,249,4.9,0.006 -2015-10-17 01:09:16:153599,250,5.0,0.006 -2015-10-17 01:09:16:359133,251,5.1,0.006 -2015-10-17 01:09:16:561062,252,5.2,0.006 -2015-10-17 01:09:16:763118,253,5.3,0.007 -2015-10-17 01:09:16:967849,254,5.4,0.007 -2015-10-17 01:09:16:967849,254,5.4,0.007 -2015-10-17 01:09:17:173851,255,5.5,0.007 -2015-10-17 01:09:17:376817,256,5.6,0.007 -2015-10-17 01:09:17:583100,257,5.7,0.008 -2015-10-17 01:09:17:784624,258,5.8,0.008 -2015-10-17 01:09:17:986485,259,5.9,0.008 -2015-10-17 01:09:17:986485,259,5.9,0.008 -2015-10-17 01:09:18:188419,260,6.0,0.009 -2015-10-17 01:09:18:392844,261,6.1,0.009 -2015-10-17 01:09:18:599097,262,6.2,0.01 -2015-10-17 01:09:18:804582,263,6.3,0.01 -2015-10-17 01:09:19:007190,264,6.4,0.01 -2015-10-17 01:09:19:007190,264,6.4,0.01 -2015-10-17 01:09:19:209311,265,6.5,0.011 -2015-10-17 01:09:19:415297,266,6.6,0.011 -2015-10-17 01:09:19:621963,267,6.7,0.012 -2015-10-17 01:09:19:824362,268,6.8,0.013 -2015-10-17 01:09:20:025173,269,6.9,0.013 -2015-10-17 01:09:20:025173,269,6.9,0.013 -2015-10-17 01:09:20:229321,270,7.0,0.014 -2015-10-17 01:09:20:436335,271,7.1,0.015 -2015-10-17 01:09:20:641376,272,7.2,0.016 -2015-10-17 01:09:20:847479,273,7.3,0.017 -2015-10-17 01:09:21:054078,274,7.4,0.018 -2015-10-17 01:09:21:054078,274,7.4,0.018 -2015-10-17 01:09:21:255338,275,7.5,0.019 -2015-10-17 01:09:21:458858,276,7.6,0.02 -2015-10-17 01:09:21:663583,277,7.7,0.022 -2015-10-17 01:09:21:864914,278,7.8,0.023 -2015-10-17 01:09:22:066288,279,7.9,0.025 -2015-10-17 01:09:22:066288,279,7.9,0.025 -2015-10-17 01:09:22:272567,280,8.0,0.027 -2015-10-17 01:09:22:476943,281,8.1,0.029 -2015-10-17 01:09:22:680470,282,8.2,0.031 -2015-10-17 01:09:22:887260,283,8.3,0.034 -2015-10-17 01:09:23:093561,284,8.4,0.037 -2015-10-17 01:09:23:093561,284,8.4,0.037 -2015-10-17 01:09:23:296585,285,8.5,0.04 -2015-10-17 01:09:23:499690,286,8.6,0.044 -2015-10-17 01:09:23:701518,287,8.7,0.048 -2015-10-17 01:09:23:905838,288,8.8,0.053 -2015-10-17 01:09:24:108553,289,8.9,0.058 -2015-10-17 01:09:24:108553,289,8.9,0.058 -2015-10-17 01:09:24:311527,290,9.0,0.064 -2015-10-17 01:09:24:517398,291,9.1,0.071 -2015-10-17 01:09:24:719160,292,9.2,0.077 -2015-10-17 01:09:24:921022,293,9.3,0.085 -2015-10-17 01:09:25:127167,294,9.4,0.092 -2015-10-17 01:09:25:127167,294,9.4,0.092 -2015-10-17 01:09:25:333755,295,9.5,0.099 -2015-10-17 01:09:25:536073,296,9.6,0.106 -2015-10-17 01:09:25:742501,297,9.7,0.111 -2015-10-17 01:09:25:949489,298,9.8,0.115 -2015-10-17 01:09:26:155441,299,9.9,0.117 -2015-10-17 01:09:26:155441,299,9.9,0.117 -2015-10-17 01:09:26:359266,300,10.0,0.117 -2015-10-17 01:09:26:561160,301,10.1,0.117 -2015-10-17 01:09:26:767659,302,10.2,0.115 -2015-10-17 01:09:26:973226,303,10.3,0.111 -2015-10-17 01:09:27:177553,304,10.4,0.106 -2015-10-17 01:09:27:177553,304,10.4,0.106 -2015-10-17 01:09:27:382031,305,10.5,0.099 -2015-10-17 01:09:27:587624,306,10.6,0.092 -2015-10-17 01:09:27:792568,307,10.7,0.085 -2015-10-17 01:09:27:999433,308,10.8,0.077 -2015-10-17 01:09:28:204092,309,10.9,0.071 -2015-10-17 01:09:28:204092,309,10.9,0.071 -2015-10-17 01:09:28:409817,310,11.0,0.064 -2015-10-17 01:09:28:614008,311,11.1,0.058 -2015-10-17 01:09:28:815294,312,11.2,0.053 -2015-10-17 01:09:29:018455,313,11.3,0.048 -2015-10-17 01:09:29:220715,314,11.4,0.044 -2015-10-17 01:09:29:220715,314,11.4,0.044 -2015-10-17 01:09:29:423566,315,11.5,0.04 -2015-10-17 01:09:29:626374,316,11.6,0.037 -2015-10-17 01:09:29:832680,317,11.7,0.034 -2015-10-17 01:09:30:034018,318,11.8,0.031 -2015-10-17 01:09:30:240523,319,11.9,0.029 -2015-10-17 01:09:30:441956,320,12.0,0.027 -2015-10-17 01:09:30:441956,320,12.0,0.027 -2015-10-17 01:09:30:643096,321,12.1,0.025 -2015-10-17 01:09:30:847075,322,12.2,0.023 -2015-10-17 01:09:31:051599,323,12.3,0.022 -2015-10-17 01:09:31:253968,324,12.4,0.02 -2015-10-17 01:09:31:253968,324,12.4,0.02 -2015-10-17 01:09:31:459898,325,12.5,0.019 -2015-10-17 01:09:31:663248,326,12.6,0.018 -2015-10-17 01:09:31:865894,327,12.7,0.017 -2015-10-17 01:09:32:067924,328,12.8,0.016 -2015-10-17 01:09:32:274281,329,12.9,0.015 -2015-10-17 01:09:32:274281,329,12.9,0.015 -2015-10-17 01:09:32:479515,330,13.0,0.014 -2015-10-17 01:09:32:682030,331,13.1,0.013 -2015-10-17 01:09:32:884778,332,13.2,0.013 -2015-10-17 01:09:33:086234,333,13.3,0.012 -2015-10-17 01:09:33:292639,334,13.4,0.011 -2015-10-17 01:09:33:292639,334,13.4,0.011 -2015-10-17 01:09:33:494311,335,13.5,0.011 -2015-10-17 01:09:33:696573,336,13.6,0.01 -2015-10-17 01:09:33:901810,337,13.7,0.01 -2015-10-17 01:09:34:106535,338,13.8,0.01 -2015-10-17 01:09:34:310223,339,13.9,0.009 -2015-10-17 01:09:34:310223,339,13.9,0.009 -2015-10-17 01:09:34:511892,340,14.0,0.009 -2015-10-17 01:09:34:718833,341,14.1,0.008 -2015-10-17 01:09:34:925275,342,14.2,0.008 -2015-10-17 01:09:35:128402,343,14.3,0.008 -2015-10-17 01:09:35:330416,344,14.4,0.007 -2015-10-17 01:09:35:330416,344,14.4,0.007 -2015-10-17 01:09:35:536595,345,14.5,0.007 -2015-10-17 01:09:35:739464,346,14.6,0.007 -2015-10-17 01:09:35:940828,347,14.7,0.007 -2015-10-17 01:09:36:146485,348,14.8,0.006 -2015-10-17 01:09:36:351402,349,14.9,0.006 -2015-10-17 01:09:36:351402,349,14.9,0.006 -2015-10-17 01:09:36:555006,350,15.0,0.006 -2015-10-17 01:09:36:755922,351,15.1,0.006 -2015-10-17 01:09:36:960180,352,15.2,0.006 -2015-10-17 01:09:37:160418,353,15.3,0.007 -2015-10-17 01:09:37:364479,354,15.4,0.007 -2015-10-17 01:09:37:364479,354,15.4,0.007 -2015-10-17 01:09:37:570445,355,15.5,0.007 -2015-10-17 01:09:37:772689,356,15.6,0.007 -2015-10-17 01:09:37:973714,357,15.7,0.008 -2015-10-17 01:09:38:180522,358,15.8,0.008 -2015-10-17 01:09:38:383090,359,15.9,0.008 -2015-10-17 01:09:38:383090,359,15.9,0.008 -2015-10-17 01:09:38:588733,360,16.0,0.009 -2015-10-17 01:09:38:792109,361,16.1,0.009 -2015-10-17 01:09:38:999489,362,16.2,0.01 -2015-10-17 01:09:39:201193,363,16.3,0.01 -2015-10-17 01:09:39:402575,364,16.4,0.01 -2015-10-17 01:09:39:402575,364,16.4,0.01 -2015-10-17 01:09:39:606547,365,16.5,0.011 -2015-10-17 01:09:39:810950,366,16.6,0.011 -2015-10-17 01:09:40:016688,367,16.7,0.012 -2015-10-17 01:09:40:223113,368,16.8,0.013 -2015-10-17 01:09:40:427113,369,16.9,0.013 -2015-10-17 01:09:40:628886,370,17.0,0.014 -2015-10-17 01:09:40:628886,370,17.0,0.014 -2015-10-17 01:09:40:835211,371,17.1,0.015 -2015-10-17 01:09:41:040904,372,17.2,0.016 -2015-10-17 01:09:41:242244,373,17.3,0.017 -2015-10-17 01:09:41:445403,374,17.4,0.018 -2015-10-17 01:09:41:445403,374,17.4,0.018 -2015-10-17 01:09:41:651107,375,17.5,0.019 -2015-10-17 01:09:41:853971,376,17.6,0.02 -2015-10-17 01:09:42:056371,377,17.7,0.022 -2015-10-17 01:09:42:258091,378,17.8,0.023 -2015-10-17 01:09:42:460295,379,17.9,0.025 -2015-10-17 01:09:42:460295,379,17.9,0.025 -2015-10-17 01:09:42:663557,380,18.0,0.027 -2015-10-17 01:09:42:868999,381,18.1,0.029 -2015-10-17 01:09:43:071242,382,18.2,0.031 -2015-10-17 01:09:43:277060,383,18.3,0.034 -2015-10-17 01:09:43:482980,384,18.4,0.037 -2015-10-17 01:09:43:482980,384,18.4,0.037 -2015-10-17 01:09:43:687364,385,18.5,0.04 -2015-10-17 01:09:43:888969,386,18.6,0.044 -2015-10-17 01:09:44:092695,387,18.7,0.048 -2015-10-17 01:09:44:294025,388,18.8,0.053 -2015-10-17 01:09:44:497405,389,18.9,0.058 -2015-10-17 01:09:44:497405,389,18.9,0.058 -2015-10-17 01:09:44:699218,390,19.0,0.064 -2015-10-17 01:09:44:902956,391,19.1,0.071 -2015-10-17 01:09:45:105514,392,19.2,0.077 -2015-10-17 01:09:45:307991,393,19.3,0.085 -2015-10-17 01:09:45:514537,394,19.4,0.092 -2015-10-17 01:09:45:514537,394,19.4,0.092 -2015-10-17 01:09:45:719667,395,19.5,0.099 -2015-10-17 01:09:45:922041,396,19.6,0.106 -2015-10-17 01:09:46:126713,397,19.7,0.111 -2015-10-17 01:09:46:333146,398,19.8,0.115 -2015-10-17 01:09:46:539082,399,19.9,0.117 diff --git a/testsweep.dat b/testsweep.dat new file mode 100644 index 00000000000..6a8ad39a170 --- /dev/null +++ b/testsweep.dat @@ -0,0 +1,403 @@ +# chan0 amplitude +# "chan0" "amplitude" +# 400 +-20 0.117 +-19.9 0.117 +-19.8 0.115 +-19.7 0.111 +-19.6 0.106 +-19.5 0.099 +-19.4 0.092 +-19.3 0.085 +-19.2 0.077 +-19.1 0.071 +-19 0.064 +-18.9 0.058 +-18.8 0.053 +-18.7 0.048 +-18.6 0.044 +-18.5 0.04 +-18.4 0.037 +-18.3 0.034 +-18.2 0.031 +-18.1 0.029 +-18 0.027 +-17.9 0.025 +-17.8 0.023 +-17.7 0.022 +-17.6 0.02 +-17.5 0.019 +-17.4 0.018 +-17.3 0.017 +-17.2 0.016 +-17.1 0.015 +-17 0.014 +-16.9 0.013 +-16.8 0.013 +-16.7 0.012 +-16.6 0.011 +-16.5 0.011 +-16.4 0.01 +-16.3 0.01 +-16.2 0.01 +-16.1 0.009 +-16 0.009 +-15.9 0.008 +-15.8 0.008 +-15.7 0.008 +-15.6 0.007 +-15.5 0.007 +-15.4 0.007 +-15.3 0.007 +-15.2 0.006 +-15.1 0.006 +-15 0.006 +-14.9 0.006 +-14.8 0.006 +-14.7 0.007 +-14.6 0.007 +-14.5 0.007 +-14.4 0.007 +-14.3 0.008 +-14.2 0.008 +-14.1 0.008 +-14 0.009 +-13.9 0.009 +-13.8 0.01 +-13.7 0.01 +-13.6 0.01 +-13.5 0.011 +-13.4 0.011 +-13.3 0.012 +-13.2 0.013 +-13.1 0.013 +-13 0.014 +-12.9 0.015 +-12.8 0.016 +-12.7 0.017 +-12.6 0.018 +-12.5 0.019 +-12.4 0.02 +-12.3 0.022 +-12.2 0.023 +-12.1 0.025 +-12 0.027 +-11.9 0.029 +-11.8 0.031 +-11.7 0.034 +-11.6 0.037 +-11.5 0.04 +-11.4 0.044 +-11.3 0.048 +-11.2 0.053 +-11.1 0.058 +-11 0.064 +-10.9 0.071 +-10.8 0.077 +-10.7 0.085 +-10.6 0.092 +-10.5 0.099 +-10.4 0.106 +-10.3 0.111 +-10.2 0.115 +-10.1 0.117 +-10 0.117 +-9.9 0.117 +-9.8 0.115 +-9.7 0.111 +-9.6 0.106 +-9.5 0.099 +-9.4 0.092 +-9.3 0.085 +-9.2 0.077 +-9.1 0.071 +-9 0.064 +-8.9 0.058 +-8.8 0.053 +-8.7 0.048 +-8.6 0.044 +-8.5 0.04 +-8.4 0.037 +-8.3 0.034 +-8.2 0.031 +-8.1 0.029 +-8 0.027 +-7.9 0.025 +-7.8 0.023 +-7.7 0.022 +-7.6 0.02 +-7.5 0.019 +-7.4 0.018 +-7.3 0.017 +-7.2 0.016 +-7.1 0.015 +-7 0.014 +-6.9 0.013 +-6.8 0.013 +-6.7 0.012 +-6.6 0.011 +-6.5 0.011 +-6.4 0.01 +-6.3 0.01 +-6.2 0.01 +-6.1 0.009 +-6 0.009 +-5.9 0.008 +-5.8 0.008 +-5.7 0.008 +-5.6 0.007 +-5.5 0.007 +-5.4 0.007 +-5.3 0.007 +-5.2 0.006 +-5.1 0.006 +-5 0.006 +-4.9 0.006 +-4.8 0.006 +-4.7 0.007 +-4.6 0.007 +-4.5 0.007 +-4.4 0.007 +-4.3 0.008 +-4.2 0.008 +-4.1 0.008 +-4 0.009 +-3.9 0.009 +-3.8 0.01 +-3.7 0.01 +-3.6 0.01 +-3.5 0.011 +-3.4 0.011 +-3.3 0.012 +-3.2 0.013 +-3.1 0.013 +-3 0.014 +-2.9 0.015 +-2.8 0.016 +-2.7 0.017 +-2.6 0.018 +-2.5 0.019 +-2.4 0.02 +-2.3 0.022 +-2.2 0.023 +-2.1 0.025 +-2 0.027 +-1.9 0.029 +-1.8 0.031 +-1.7 0.034 +-1.6 0.037 +-1.5 0.04 +-1.4 0.044 +-1.3 0.048 +-1.2 0.053 +-1.1 0.058 +-1 0.064 +-0.9 0.071 +-0.8 0.077 +-0.7 0.085 +-0.6 0.092 +-0.5 0.099 +-0.4 0.106 +-0.3 0.111 +-0.2 0.115 +-0.1 0.117 +0 0.117 +0.1 0.117 +0.2 0.115 +0.3 0.111 +0.4 0.106 +0.5 0.099 +0.6 0.092 +0.7 0.085 +0.8 0.077 +0.9 0.071 +1 0.064 +1.1 0.058 +1.2 0.053 +1.3 0.048 +1.4 0.044 +1.5 0.04 +1.6 0.037 +1.7 0.034 +1.8 0.031 +1.9 0.029 +2 0.027 +2.1 0.025 +2.2 0.023 +2.3 0.022 +2.4 0.02 +2.5 0.019 +2.6 0.018 +2.7 0.017 +2.8 0.016 +2.9 0.015 +3 0.014 +3.1 0.013 +3.2 0.013 +3.3 0.012 +3.4 0.011 +3.5 0.011 +3.6 0.01 +3.7 0.01 +3.8 0.01 +3.9 0.009 +4 0.009 +4.1 0.008 +4.2 0.008 +4.3 0.008 +4.4 0.007 +4.5 0.007 +4.6 0.007 +4.7 0.007 +4.8 0.006 +4.9 0.006 +5 0.006 +5.1 0.006 +5.2 0.006 +5.3 0.007 +5.4 0.007 +5.5 0.007 +5.6 0.007 +5.7 0.008 +5.8 0.008 +5.9 0.008 +6 0.009 +6.1 0.009 +6.2 0.01 +6.3 0.01 +6.4 0.01 +6.5 0.011 +6.6 0.011 +6.7 0.012 +6.8 0.013 +6.9 0.013 +7 0.014 +7.1 0.015 +7.2 0.016 +7.3 0.017 +7.4 0.018 +7.5 0.019 +7.6 0.02 +7.7 0.022 +7.8 0.023 +7.9 0.025 +8 0.027 +8.1 0.029 +8.2 0.031 +8.3 0.034 +8.4 0.037 +8.5 0.04 +8.6 0.044 +8.7 0.048 +8.8 0.053 +8.9 0.058 +9 0.064 +9.1 0.071 +9.2 0.077 +9.3 0.085 +9.4 0.092 +9.5 0.099 +9.6 0.106 +9.7 0.111 +9.8 0.115 +9.9 0.117 +10 0.117 +10.1 0.117 +10.2 0.115 +10.3 0.111 +10.4 0.106 +10.5 0.099 +10.6 0.092 +10.7 0.085 +10.8 0.077 +10.9 0.071 +11 0.064 +11.1 0.058 +11.2 0.053 +11.3 0.048 +11.4 0.044 +11.5 0.04 +11.6 0.037 +11.7 0.034 +11.8 0.031 +11.9 0.029 +12 0.027 +12.1 0.025 +12.2 0.023 +12.3 0.022 +12.4 0.02 +12.5 0.019 +12.6 0.018 +12.7 0.017 +12.8 0.016 +12.9 0.015 +13 0.014 +13.1 0.013 +13.2 0.013 +13.3 0.012 +13.4 0.011 +13.5 0.011 +13.6 0.01 +13.7 0.01 +13.8 0.01 +13.9 0.009 +14 0.009 +14.1 0.008 +14.2 0.008 +14.3 0.008 +14.4 0.007 +14.5 0.007 +14.6 0.007 +14.7 0.007 +14.8 0.006 +14.9 0.006 +15 0.006 +15.1 0.006 +15.2 0.006 +15.3 0.007 +15.4 0.007 +15.5 0.007 +15.6 0.007 +15.7 0.008 +15.8 0.008 +15.9 0.008 +16 0.009 +16.1 0.009 +16.2 0.01 +16.3 0.01 +16.4 0.01 +16.5 0.011 +16.6 0.011 +16.7 0.012 +16.8 0.013 +16.9 0.013 +17 0.014 +17.1 0.015 +17.2 0.016 +17.3 0.017 +17.4 0.018 +17.5 0.019 +17.6 0.02 +17.7 0.022 +17.8 0.023 +17.9 0.025 +18 0.027 +18.1 0.029 +18.2 0.031 +18.3 0.034 +18.4 0.037 +18.5 0.04 +18.6 0.044 +18.7 0.048 +18.8 0.053 +18.9 0.058 +19 0.064 +19.1 0.071 +19.2 0.077 +19.3 0.085 +19.4 0.092 +19.5 0.099 +19.6 0.106 +19.7 0.111 +19.8 0.115 +19.9 0.117 From 8e6845117daa80ead8737da837cab6fd695dd6c8 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 12 Dec 2015 23:52:07 +0100 Subject: [PATCH 08/33] primary namespace and import cleanup --- qcodes/__init__.py | 26 ++++++++++++++++++++++++++ qcodes/utils/sync_async.py | 2 +- toymodel.py | 2 +- 3 files changed, 28 insertions(+), 2 deletions(-) diff --git a/qcodes/__init__.py b/qcodes/__init__.py index e69de29bb2d..379b89502a0 100644 --- a/qcodes/__init__.py +++ b/qcodes/__init__.py @@ -0,0 +1,26 @@ +# set up the qcodes namespace +# flake8: noqa (we don't need the "<...> imported but unused" error) + +from qcodes.station import Station +from qcodes.loops import get_bg, halt_bg, Loop, Task, Wait + +from qcodes.data.manager import get_data_manager +from qcodes.data.data_set import DataSet +from qcodes.data.data_array import DataArray +from qcodes.data.format import Formatter, GNUPlotFormat +from qcodes.data.io import DiskIO + +from qcodes.instrument.base import Instrument +from qcodes.instrument.ip import IPInstrument +from qcodes.instrument.visa import VisaInstrument +from qcodes.instrument.mock import MockInstrument + +from qcodes.instrument.function import Function +from qcodes.instrument.parameter import Parameter, InstrumentParameter +from qcodes.instrument.sweep_values import SweepFixedValues, AdaptiveSweep + +from qcodes.utils.helpers import set_mp_method + +# just for convenience in debugging, so we don't have to +# separately import multiprocessing +from multiprocessing import active_children diff --git a/qcodes/utils/sync_async.py b/qcodes/utils/sync_async.py index d5ec6775efa..db05435cdf2 100644 --- a/qcodes/utils/sync_async.py +++ b/qcodes/utils/sync_async.py @@ -1,6 +1,6 @@ import asyncio -from qcodes.utils.helpers import is_function +from .helpers import is_function def wait_for_async(f, *args, **kwargs): diff --git a/toymodel.py b/toymodel.py index 590cf88c0f1..ccb4feb4c9a 100644 --- a/toymodel.py +++ b/toymodel.py @@ -2,7 +2,7 @@ import math -from qcodes.instrument.mock import MockInstrument +from qcodes import MockInstrument from qcodes.utils.validators import Numbers From a7918d187f1b73c2c701f727b61e240f00e7229a Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sun, 13 Dec 2015 01:00:16 +0100 Subject: [PATCH 09/33] update object hierarchy --- objects.md | 151 ++++++++++++++++++++++++++++++++--------------------- 1 file changed, 92 insertions(+), 59 deletions(-) diff --git a/objects.md b/objects.md index d30055d9d0b..6f114568fdb 100644 --- a/objects.md +++ b/objects.md @@ -7,32 +7,32 @@ In *italics* the container just holds this object (or class) as a default for de Normal text the container includes and uses this object - Station - - BaseInstrument: IPInstrument, VisaInstrument, MockInstrument - - **Parameter** + - Instrument: IPInstrument, VisaInstrument, MockInstrument + - **Parameter**: InstrumentParameter - Validator: Anything, Strings, Numbers, Ints, Enum, MultiType - **SweepValues**: SweepFixedValues, AdaptiveSweep - Function - Validator - - *SweepStorage class*: MergedCSVStorage, ? - **Monitor** - - MeasurementSet - - StorageManager, Monitor - - *SweepStorage class* - - .sweep - - SweepValues - - **SweepStorage** - - **StorageManager** - - **StorageServer** - - SweepStorage - - Monitor + - *actions* +- DataManager + - **DataServer** +- Loop + - actions: Parameter, Task, Wait, (Active)Loop + - **ActiveLoop** + - **DataSet** + - **DataArray** + - **Formatter**: GNUPlotFormat + - **DiskIO** (may become subclass of IOManager?) ## Station A representation of the entire physical setup. -Lists all the connected `Instrument`s, keeps references to the `StorageManager` and -`Monitor` objects that are running, and holds various default settings, such as -the default `MeasurementSet` and the default `SweepStorage` class in use right now. +Lists all the connected `Instrument`s and the current default +measurement (a list of actions). Contains a convenience method +`.measure()` to measure these defaults right now, but this is separate +from the code used by `Loop`. ## Instrument @@ -40,7 +40,7 @@ A representation of one particular piece of hardware. Lists all `Parameter`s and `Function`s this hardware is capable of, and handles the underlying communication with the hardware. -`BaseInstrument` sets the common structure but real instruments will generally derive +`Instrument` sets the common structure but real instruments will generally derive from its subclasses, such as `IPInstrument` and `VisaInstrument`. There is also `MockInstrument` for making simulated instruments, connected to a `Model` that mimics a serialized communication channel with an apparatus. @@ -49,12 +49,20 @@ a serialized communication channel with an apparatus. A representation of one particular state variable. -Most `Parameter`s are part of an `Instrument`, but you can also create `Parameter`s -that execute arbitrary functions, for example to combine several gate voltages in a -diagonal sweep. Parameters can have setters and/or getters (they must define at least -a setter OR a getter but do not need to define both) +Most `Parameter`s are part of an `Instrument`, using the subclass +`InstrumentParameter` which links it to specific commands sent to a specific +instrument. But you can also create `Parameter`s that execute arbitrary functions, +for example to combine several gate voltages in a diagonal sweep. Parameters can +have setters and/or getters (they must define at least a setter OR a getter but +do not need to define both) -`Parameter`s can be sliced to create a `SweepFixedValues` object. +Gettable `Parameter`s often return one value, but can return a collection of +values - several values with different names, or one or more arrays of values, +ie if an instrument provides a whole data set at once, or if you want to save +raw and calculated data side-by-side + +Settable `Parameter`s take a single value, and can be sliced to create a +`SweepFixedValues` object. ## Validator @@ -79,26 +87,6 @@ on the `.feedback` method by which the sweep passes measured values back into th A representation of some action an `Instrument` can perform, which is not connected to any particular state variable (eg calibrate, reset, identify) -## StorageManager - -The gateway to the separate storage process. - -Sweeps and monitoring routines all pass their data through the `StorageManager` to the -`StorageServer`, which the `StorageManager` started and is running in a separate process. -Likewise, plotting & display routines query the `StorageServer` via the `StorageManager` -to retrieve current data. - -## StorageServer - -Running in its own process, receives, holds, and returns current sweep and monitor data, -and writes it to disk (or other storage) - -When a sweep is *not* running, the StorageServer also calls the monitor routine itself. -But when a sweep *is* running, the sweep calls the monitor so that it can avoid conflicts. -Also while a sweep is running, there are complementary `SweepStorage` objects in the sweep -and `StorageServer` processes - they are nearly identical objects, but are configured -differently. - ## Monitor Measures all system parameters periodically and logs these measurements @@ -109,27 +97,72 @@ so that during sweeps it can be given a command "measure for no longer than X se it will figure out which parameters it has time to measure, and which of those are most important (primarily, I guess, the most important were last measured the longest time ago) -## MeasurementSet +## DataManager + +The gateway to the separate DataServer process. + +Measurement `Loop`s and monitoring routines all pass their data through the +`DataManager` to the `DataServer`, which the `DataManager` started and is +running in a separate process. +Likewise, plotting & display routines query the `DataServer` via the `DataManager` +to retrieve current data. + +## DataServer + +Running in its own process, receives, holds, and returns current `Loop` and +monitor data, and writes it to disk (or other storage) + +When a `Loop` is *not* running, the DataServer also calls the monitor routine. +But when a `Loop` *is* running, *it* calls the monitor so that it can avoid conflicts. +Also while a `Loop` is running, there are complementary `DataSet` objects in the loop +and `DataServer` processes - they are nearly identical objects, but are configured +differently so that the loop `DataSet` doesn't hold any data itself, it only +passes that data on to the `DataServer` + +## Loop + +Describes a sequence of `Parameter` settings to loop over. When you attach +`action`s to a `Loop`, it becomes an `ActiveLoop` that you can `.run()`, or +you can run a `Loop` directly, in which case it takes the default `action`s from +the default `Station` + +`actions` are a sequence of things to do at each `Loop` step: they can be +`Parameter`s to measure, `Task`s to do (any callable that does not yield data), +`Wait` times, other `ActiveLoop`s to nest inside this one, or `Loop`s to nest using +the default `actions`. + +## ActiveLoop + +After a `Loop` has actions attached to it, all you can do with it is `.run()` it, +or use it as an action inside another `Loop` which will `.run()` the whole thing. + +The `ActiveLoop` determines what `DataArray`s it will need to hold the data it +collects, and it creates a `DataSet` holding these `DataArray`s + +## DataSet + +A collection of `DataArray`s that contains all the data from one measurement +(normally one `Loop`). During measurement, it creates a twin of itself on the +`DataServer`, and yet another copy persists in the main thread for live plotting. + +You also get a `DataSet` if you read back in an old data set, so it can use the +same API for plotting and analysis during and after acquisition. -A list of parameters to measure while sweeping, along with the sweep methods. +Contains defaults for `Formatter` (`GNUPlotFormat`) and IO Manager (`DiskIO`), +but they are kept as separate objects so that you can change them if you want +to move or reformat an existing `DataSet`. -Usually created from a `Station` and inheriting the `StorageManager`, `Monitor`, -and default `SweepStorage` class from it. +## DataArray -The `.sweep` method starts a sweep, which creates a `SweepStorage` object and, -if the sweep is to run in the background (the default), this method starts the -sweep process. +One n-dimensional data array. If it is a measured `Parameter`, it references +other `DataArray`(s) as its setpoints. -## SweepStorage +## Formatter -Object that holds sweep data and knows how to read from and write to disk or -other long-term storage, as well as how to communicate with its clone on the -`StorageServer` if one exists. +Describes the file format used to read and write a `DataSet`. Uses an +IO Manager to actually perform the storage (so that the same format can be +used on disk, in the cloud, in a database...) -A `SweepStorage` is created when a new sweep is started, and this one clones -itself on the `StorageServer`. But you can also create a `SweepStorage` from -a previous sweep, in which case it simply reads in the sweep and holds it -for plotting or analysis. +## IO Manager -Subclasses (eg `MergedCSVStorage`, later perhaps `AzureStorage` etc) define -the connection with the particular long-term storage you are using. +Performs the actual reading and writing of files generated by a `Formatter` \ No newline at end of file From 5cfee730b7224957cc18b07e764c130e88cd5446 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Mon, 14 Dec 2015 14:45:10 +0100 Subject: [PATCH 10/33] DataSet.is_live property --- qcodes/data/data_set.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/qcodes/data/data_set.py b/qcodes/data/data_set.py index f5bcf1cfaff..400a243511a 100644 --- a/qcodes/data/data_set.py +++ b/qcodes/data/data_set.py @@ -123,8 +123,20 @@ def _init_live(self, data_manager): self._init_local() + @property + def is_live(self): + ''' + indicate whether this DataSet thinks it is live in the DataServer + without actually talking to the DataServer or syncing with it + ''' + return self.mode in self.SERVER_MODES and self.data_manager + def check_live_data(self): - if self.mode in self.SERVER_MODES and self.data_manager: + ''' + check whether this DataSet really *is* the one in the DataServer + and if it thought it was but isn't, convert it to mode=LOCAL + ''' + if self.is_live: live_location = self.data_manager.ask('get_data', 'location') if self.location is None: From 1c8adb1916f27dba8096325419aa9ac25b913af3 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Tue, 15 Dec 2015 15:10:55 +0100 Subject: [PATCH 11/33] reorg dataset sync --- qcodes/data/data_set.py | 73 ++++++++++++++++++++++------------------- 1 file changed, 40 insertions(+), 33 deletions(-) diff --git a/qcodes/data/data_set.py b/qcodes/data/data_set.py index 400a243511a..981c8755a52 100644 --- a/qcodes/data/data_set.py +++ b/qcodes/data/data_set.py @@ -48,7 +48,6 @@ def __init__(self, location=None, mode=None, arrays=None, self.location = location self.formatter = formatter or self.default_formatter self.io = io or self.default_io - self.mode = mode if mode is None: if arrays: @@ -59,6 +58,8 @@ def __init__(self, location=None, mode=None, arrays=None, # check if this is the live measurement, make it sync if it is mode = DataMode.PULL_FROM_SERVER + self.mode = mode + self.arrays = {} if arrays: self.action_id_map = self._clean_array_ids(arrays) @@ -116,62 +117,68 @@ def init_on_server(self): def _init_live(self, data_manager): self.data_manager = data_manager with self.data_manager.query_lock: - if self.check_live_data(): + if self.is_on_server: live_obj = data_manager.ask('get_data') self.arrays = live_obj.arrays - return - - self._init_local() + else: + self._init_local() @property - def is_live(self): + def is_live_mode(self): ''' indicate whether this DataSet thinks it is live in the DataServer without actually talking to the DataServer or syncing with it ''' - return self.mode in self.SERVER_MODES and self.data_manager + return self.mode in self.SERVER_MODES and self.data_manager and True - def check_live_data(self): + @property + def is_on_server(self): ''' check whether this DataSet really *is* the one in the DataServer and if it thought it was but isn't, convert it to mode=LOCAL ''' - if self.is_live: + if not self.is_live_mode: + return False + + with self.data_manager.query_lock: live_location = self.data_manager.ask('get_data', 'location') if self.location is None: # no location given yet, pull it from the live data self.location = live_location - if self.location == live_location: - return True - - if self.mode != DataMode.LOCAL: - # just stopped being the live data - drop the data and reload it, - # in case more arrived after the live measurement ended - self.arrays = {} - self._init_local() - - return False + return self.location == live_location def sync(self): - # TODO: anything we can do to reduce the amount of data to send? - # seems like in the most general case this would need to remember - # each client DataSet on the server, and what has changed since - # that particular client last synced (at least first and last pt) - if self.mode not in self.SERVER_MODES: + if not self.is_live_mode: + # LOCAL DataSet - just read it in + # TODO: compare timestamps to know if we need to read? + self.read() return + with self.data_manager.query_lock: - if not self.check_live_data(): - # note that check_live_data switches us to LOCAL - # and reads the data set back from storage, - # if the server says the data isn't there anymore - # (ie the measurement is done) + if self.is_on_server: + # TODO: can we reduce the amount of data to send? + # seems like in the most general case this would need to + # remember each client DataSet on the server, and what has + # changed since that particular client last synced + # (at least first and last pt) + live_data = self.data_manager.ask('get_data').arrays + for array_id in self.arrays: + self.arrays[array_id].data = live_data[array_id].data + + measuring = self.data_manager.ask('get_measuring') + if not measuring: + # we must have *just* stopped measuring + # but the DataSet is still on the server, + # so we got the data, and don't need to read. + self.mode = DataMode.LOCAL return - live_data = self.data_manager.ask('get_data').arrays - - for array_id in self.arrays: - self.arrays[array_id].data = live_data[array_id].data + else: + # this DataSet *thought* it was on the server, but it wasn't, + # so we haven't synced yet and need to read from storage + self.mode = DataMode.LOCAL + self.read() def add_array(self, data_array): self.arrays[data_array.array_id] = data_array From 14a7ca4009f81e82bfdf419483e59ee8467c677d Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Tue, 15 Dec 2015 15:46:20 +0100 Subject: [PATCH 12/33] fix bug in _run_loop args --- qcodes/loops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qcodes/loops.py b/qcodes/loops.py index 11fd94cd46a..5430c8a9af3 100644 --- a/qcodes/loops.py +++ b/qcodes/loops.py @@ -436,7 +436,7 @@ def _run_loop(self, first_delay=0, action_indices=(), for f in callables: f(first_delay=delay, loop_indices=new_indices, - values=new_values) + current_values=new_values) # after the first action, no delay is inherited delay = 0 From 4670225a528792cca1d9a49d5d4a8c956aca71d1 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Tue, 15 Dec 2015 15:47:39 +0100 Subject: [PATCH 13/33] more error reporting from formatter --- qcodes/data/format.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/qcodes/data/format.py b/qcodes/data/format.py index aaabefa93e1..0480df8471c 100644 --- a/qcodes/data/format.py +++ b/qcodes/data/format.py @@ -28,6 +28,7 @@ import numpy as np import re import math +from traceback import format_exc from .data_array import DataArray @@ -75,6 +76,7 @@ def read(self, data_set): try: self.read_one_file(data_set, f, ids_read) except ValueError: + print(format_exc()) print('error reading file ' + fn) def read_one_file(self, data_set, f, ids_read): From f440a15e533925e90df6fd40b7c66203251dc3cd Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Wed, 16 Dec 2015 12:00:57 +0100 Subject: [PATCH 14/33] expose DataMode in the main API --- qcodes/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qcodes/__init__.py b/qcodes/__init__.py index 379b89502a0..92dcb322254 100644 --- a/qcodes/__init__.py +++ b/qcodes/__init__.py @@ -5,7 +5,7 @@ from qcodes.loops import get_bg, halt_bg, Loop, Task, Wait from qcodes.data.manager import get_data_manager -from qcodes.data.data_set import DataSet +from qcodes.data.data_set import DataMode, DataSet from qcodes.data.data_array import DataArray from qcodes.data.format import Formatter, GNUPlotFormat from qcodes.data.io import DiskIO From f5af28cddeec4bac9975658d71906c1eedd3e90f Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Wed, 16 Dec 2015 12:03:43 +0100 Subject: [PATCH 15/33] fix bug in GNUplotFormat read --- qcodes/data/format.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/qcodes/data/format.py b/qcodes/data/format.py index 0480df8471c..c078b9e35b1 100644 --- a/qcodes/data/format.py +++ b/qcodes/data/format.py @@ -254,8 +254,8 @@ def read_one_file(self, data_set, f, ids_read): set_array = DataArray(label=labels[i], array_id=array_id, set_arrays=set_arrays, size=set_size) set_array.init_data() - set_arrays = set_arrays + (set_array, ) arrays[array_id] = set_array + set_arrays = set_arrays + (set_array, ) ids_read.add(array_id) @@ -285,13 +285,14 @@ def read_one_file(self, data_set, f, ids_read): # ignore leading or trailing whitespace (including in blank lines) line = line.strip() - if not line and not first_point: + if not line: # each consecutive blank line implies one more loop to reset # when we read the next data point. Don't depend on the number # of setpoints that change, as there could be weird cases, like # bidirectional sweeps, or highly diagonal sweeps, where this # is incorrect. Anyway this really only matters for >2D sweeps. - resetting += 1 + if not first_point: + resetting += 1 continue values = tuple(map(float, line.split())) @@ -308,12 +309,15 @@ def read_one_file(self, data_set, f, ids_read): if math.isnan(stored_value): nparray[myindices] = value elif stored_value != value: - raise ValueError('inconsistent setpoint values') + raise ValueError('inconsistent setpoint values', + stored_value, value, set_array.name, + myindices, indices) for value, data_array in zip(values[ndim:], data_arrays): - data_array.data[myindices] = value + data_array.data[tuple(indices)] = value indices[-1] += 1 + first_point = False def _is_comment(self, line): return line[:self.comment_len] == self.comment_chars From b189056cd131768a17b296176bea15fe4ac52fa9 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Wed, 16 Dec 2015 12:07:53 +0100 Subject: [PATCH 16/33] make NoData work with DataSet.is_on_server check --- qcodes/data/manager.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/qcodes/data/manager.py b/qcodes/data/manager.py index 541b12ea62f..bc9beb98504 100644 --- a/qcodes/data/manager.py +++ b/qcodes/data/manager.py @@ -19,6 +19,8 @@ def get_data_manager(): class NoData(object): + location = None + def store(self, *args, **kwargs): raise RuntimeError('no DataSet to add to') From fc476b4e9e2cd68dd709aeb2af25d7d562220009 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Wed, 16 Dec 2015 17:12:38 +0100 Subject: [PATCH 17/33] reload_code: helper to reload all user modules (or matching a pattern) --- qcodes/utils/helpers.py | 74 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/qcodes/utils/helpers.py b/qcodes/utils/helpers.py index b34db07a517..51546c076d8 100644 --- a/qcodes/utils/helpers.py +++ b/qcodes/utils/helpers.py @@ -1,10 +1,14 @@ from asyncio import iscoroutinefunction from collections import Iterable from datetime import datetime +import imp from inspect import getargspec, ismethod import logging import math import multiprocessing as mp +import sys +import os +from traceback import format_exc def is_sequence(obj): @@ -158,3 +162,73 @@ def safe_getattr(obj, key, attr_dict): msg = "'{}' object has no attribute or {} item '{}'".format( obj.__class__.__name__, attr_dict, key) raise AttributeError(msg) from None + + +# see http://stackoverflow.com/questions/22195382/ +# how-to-check-if-a-module-library-package-is-part-of-the-python-standard-library +syspaths = [os.path.abspath(p) for p in sys.path] +stdlib = tuple(p for p in syspaths + if p.startswith((sys.prefix, sys.base_prefix)) + and 'site-packages' not in p) +# a few things in site-packages we will consider part of the standard lib +# it causes problems if we reload some of these, others are just stable +# dependencies - this is mainly for reloading our own code. +# could even whitelist site-packages items to allow, rather than to ignore? +otherlib = ('jupyter', 'ipy', 'IPy', 'matplotlib', 'numpy', 'scipy', 'pyvisa', + 'traitlets', 'zmq', 'tornado', 'dateutil', 'pkg-resources', 'six', + 'pexpect') +otherpattern = tuple('site-packages/' + n for n in otherlib) + + +def reload_code(pattern=None, lib=False): + ''' + reload all modules matching a given pattern + or all (non-built-in) modules if pattern is omitted + lib says whether to include lib files (default False) + ''' + reloaded_files = [] + + for module in sys.modules.values(): + if (pattern is None or pattern in module.__name__): + reload_recurse(module, reloaded_files, lib) + + return reloaded_files + + +def is_good_module(module, lib): + # take out non-modules and underscore modules + name = getattr(module, '__name__', '_') + if name[0] == '_' or not isinstance(module, type(sys)): + return False + + # take out modules we can't find and built-ins + if name in sys.builtin_module_names or not hasattr(module, '__file__'): + return False + + if not lib: + path = os.path.abspath(module.__file__) + if path.startswith(stdlib) and 'site-packages' not in path: + return False + + for pattern in otherpattern: + if pattern in path: + return False + + return True + + +def reload_recurse(module, reloaded_files, lib): + if not is_good_module(module, lib) or module.__file__ in reloaded_files: + return + + reloaded_files.append(module.__file__) + + try: + for name in dir(module): + module2 = getattr(module, name) + reload_recurse(module2, reloaded_files, lib) + imp.reload(module) + + except: + print('error reloading "{}"'.format(getattr(module, '__name__', '?'))) + print(format_exc()) From 0d246b6dd3c073f3de70cbc4a87530ef26dd4b7d Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Thu, 17 Dec 2015 21:50:21 +0100 Subject: [PATCH 18/33] docstrings!!! doc..doc..doc..GOOSE! --- qcodes/data/data_array.py | 8 ++- qcodes/data/data_set.py | 42 +++++++++++++- qcodes/data/format.py | 93 ++++++++++++++++++++----------- qcodes/data/io.py | 6 ++ qcodes/data/manager.py | 52 +++++++++++++++++ qcodes/instrument/base.py | 24 ++++++++ qcodes/instrument/function.py | 3 + qcodes/instrument/mock.py | 32 +++++------ qcodes/instrument/parameter.py | 15 +++++ qcodes/instrument/sweep_values.py | 10 +++- qcodes/loops.py | 34 +++++++++++ qcodes/station.py | 25 +++++++++ qcodes/utils/helpers.py | 21 ++++++- qcodes/utils/sync_async.py | 7 +++ qcodes/utils/validators.py | 3 + 15 files changed, 318 insertions(+), 57 deletions(-) diff --git a/qcodes/data/data_array.py b/qcodes/data/data_array.py index f3c2de689fa..af0a63155b9 100644 --- a/qcodes/data/data_array.py +++ b/qcodes/data/data_array.py @@ -106,6 +106,9 @@ def _set_index_bounds(self): self._max_indices = tuple(d - 1 for d in self.size) def clear(self): + ''' + Fill the (already existing) data array with nan + ''' self.data.fill(float('nan')) def __setitem__(self, loop_indices, value): @@ -174,5 +177,6 @@ def clear_save(self): self.last_saved_index = None def __repr__(self): - return '{}: {}\n{}'.format(self.__class__.__name__, self.name, - repr(self.data)) + return '{}[{}]: {}\n{}'.format(self.__class__.__name__, + ','.join(map(str, self.size)), + self.array_id, repr(self.data)) diff --git a/qcodes/data/data_set.py b/qcodes/data/data_set.py index 981c8755a52..733dc80ee1b 100644 --- a/qcodes/data/data_set.py +++ b/qcodes/data/data_set.py @@ -46,6 +46,8 @@ class DataSet(object): def __init__(self, location=None, mode=None, arrays=None, data_manager=None, formatter=None, io=None): self.location = location + # TODO: when you change formatter or io (and there's data present) + # make it all look unsaved self.formatter = formatter or self.default_formatter self.io = io or self.default_io @@ -109,6 +111,10 @@ def _init_push_to_server(self, data_manager): self.data_manager = data_manager def init_on_server(self): + ''' + Configure this DataSet as the DataServer copy + Should be run only by the DataServer itself. + ''' if not self.arrays: raise RuntimeError('A server-side DataSet needs DataArrays.') @@ -134,8 +140,8 @@ def is_live_mode(self): @property def is_on_server(self): ''' - check whether this DataSet really *is* the one in the DataServer - and if it thought it was but isn't, convert it to mode=LOCAL + Check whether this DataSet is being mirrored in the DataServer + If it thought it was but isn't, convert it to mode=LOCAL ''' if not self.is_live_mode: return False @@ -150,6 +156,16 @@ def is_on_server(self): return self.location == live_location def sync(self): + ''' + synchronize this data set with a possibly newer version either + in storage or on the DataServer, depending on its mode + ''' + # TODO: sync implies bidirectional... and it could be! + # we should keep track of last sync timestamp and last modification + # so we can tell whether this one, the other one, or both copies have + # changed (and I guess throw an error if both did? Would be cool if we + # could find a robust and intuitive way to make modifications to the + # version on the DataServer from the main copy) if not self.is_live_mode: # LOCAL DataSet - just read it in # TODO: compare timestamps to know if we need to read? @@ -181,6 +197,12 @@ def sync(self): self.read() def add_array(self, data_array): + ''' + add one DataArray to this DataSet + ''' + if data_array.array_id in self.arrays: + raise ValueError('array_id {} already exists in this ' + 'DataSet'.format(data_array.array_id)) self.arrays[data_array.array_id] = data_array def _clean_array_ids(self, arrays): @@ -216,7 +238,8 @@ def _clean_array_ids(self, arrays): def store(self, loop_indices, ids_values): ''' - set some collection of data points + Set some collection of data points + loop_indices: the indices within whatever loops we are inside values: a dict of action_index:value or array_id:value where value may be an arbitrarily nested list, to record @@ -229,9 +252,16 @@ def store(self, loop_indices, ids_values): self.arrays[array_id][loop_indices] = value def read(self): + ''' + Read the whole DataSet from storage, overwriting the local data + ''' self.formatter.read(self) def write(self): + ''' + Write the whole (or only changed parts) DataSet to storage, + overwriting the existing storage if any. + ''' if self.mode != DataMode.LOCAL: raise RuntimeError('This object is connected to a DataServer ' 'and should be saved from there.') @@ -239,9 +269,15 @@ def write(self): self.formatter.write(self) def close(self): + ''' + Tell the DataServer that the measurement is done + ''' if self.mode == DataMode.PUSH_TO_SERVER: self.data_manager.ask('end_data') + def plot(self, cut=None): + pass # TODO + def __getattr__(self, key): ''' alias arrays items as attributes diff --git a/qcodes/data/format.py b/qcodes/data/format.py index c078b9e35b1..315a2fece34 100644 --- a/qcodes/data/format.py +++ b/qcodes/data/format.py @@ -1,29 +1,3 @@ -''' -Data file formatters - -Formatters translate between DataSets and data files. - -Each Formatter is expected to implement a write method: - write(self, data_set) - -and either read or read_one_file: - read(self, data_set) - read_one_file(data_set, f, ids_read) - f: a file-like object supporting .readline() and for ... in - ids_read: a set of array_id's we've already encountered, so - read_one_file can check for duplication and consistency - -data_set is a DataSet object, which is expected to have attributes: - io: an IO manager (see qcodes.io) - location: a string, like a file path, that identifies the DataSet and - tells the IO manager where to store it - arrays: a dict of {array_id:DataArray} to read into. - - read will create DataArrays that don't yet exist. - - write will write ALL DataArrays in the DataSet, using - last_saved_index and modified_range, as well as whether or not - it found the specified file, to determine how much to write. -''' - from collections import namedtuple import numpy as np import re @@ -34,9 +8,39 @@ class Formatter(object): + ''' + Data file formatters + + Formatters translate between DataSets and data files. + + Each Formatter is expected to implement a write method: + write(self, data_set) + + and either read or read_one_file: + read(self, data_set) + read_one_file(data_set, f, ids_read) + f: a file-like object supporting .readline() and for ... in + ids_read: a set of array_id's we've already encountered, so + read_one_file can check for duplication and consistency + + data_set is a DataSet object, which is expected to have attributes: + io: an IO manager (see qcodes.io) + location: a string, like a file path, that identifies the DataSet and + tells the IO manager where to store it + arrays: a dict of {array_id:DataArray} to read into. + - read will create DataArrays that don't yet exist. + - write will write ALL DataArrays in the DataSet, using + last_saved_index and modified_range, as well as whether or not + it found the specified file, to determine how much to write. + ''' ArrayGroup = namedtuple('ArrayGroup', 'size set_arrays data name') def find_changes(self, arrays): + ''' + Collect changes made to any of these arrays and determine whether + the WHOLE group is elligible for appending or not. + Subclasses may choose to use or ignore this information. + ''' new_data = {} can_append = True @@ -51,13 +55,26 @@ def find_changes(self, arrays): return new_data, can_append def mark_saved(self, arrays): + ''' + Mark all DataArrays in this group as saved + ''' for array in arrays.values(): array.mark_saved() def write(self, data_set): + ''' + Write the DataSet to storage. It is up to the Formatter to decide + when to overwrite completely, and when to just append or otherwise + update the file(s). + ''' raise NotImplementedError def read(self, data_set): + ''' + Read the entire DataSet by finding all files matching its location + (using io_manager.list) and calling read_one_file from the Formatter + subclass. Subclasses may alternatively override this entire method. + ''' io_manager = data_set.io location = data_set.location @@ -83,14 +100,17 @@ def read_one_file(self, data_set, f, ids_read): raise NotImplementedError def match_save_range(self, group, file_exists): - # match all full-sized arrays, which are the data arrays plus - # the inner loop setpoint array + ''' + Find the save range that will capture all changes in an array group. + matches all full-sized arrays: the data arrays plus the inner loop + setpoint array - # note: if an outer loop has changed values (without the inner - # loop or measured data changing) we won't notice it here + note: if an outer loop has changed values (without the inner + loop or measured data changing) we won't notice it here - # use the inner setpoint as a base and look for differences - # in last_saved_index and modified_range in the data arrays + use the inner setpoint as a base and look for differences + in last_saved_index and modified_range in the data arrays + ''' inner_setpoint = group.set_arrays[-1] last_saved_index = (inner_setpoint.last_saved_index if file_exists else None) @@ -226,6 +246,11 @@ def __init__(self, extension='dat', terminator='\n', separator='\t', self.number_format = '{:' + number_format + '}' def read_one_file(self, data_set, f, ids_read): + ''' + Called by Formatter.read to bring one data file into + a DataSet. Setpoint data may be duplicated across multiple files, + but each measured DataArray must only map to one file. + ''' arrays = data_set.arrays ids = self._read_comment_line(f).split() labels = self._get_labels(self._read_comment_line(f)) @@ -339,6 +364,10 @@ def _get_labels(self, labelstr): return [l.replace('\\"', '"').replace('\\\\', '\\') for l in parts] def write(self, data_set): + ''' + Write updates in this DataSet to storage. Will choose append if + possible, overwrite if not. + ''' io_manager = data_set.io location = data_set.location arrays = data_set.arrays diff --git a/qcodes/data/io.py b/qcodes/data/io.py index 4aa99ec087c..ca8ae92d6e4 100644 --- a/qcodes/data/io.py +++ b/qcodes/data/io.py @@ -89,9 +89,15 @@ def __repr__(self): return '<DiskIO, base_location={}>'.format(self.base_location) def join(self, *args): + ''' + the context-dependent version of os.path.join for this io manager + ''' return os.path.join(*args) def isfile(self, location): + ''' + does `location` match a file? + ''' path = self._add_base(location) return os.path.isfile(path) diff --git a/qcodes/data/manager.py b/qcodes/data/manager.py index bc9beb98504..2821fcbbf77 100644 --- a/qcodes/data/manager.py +++ b/qcodes/data/manager.py @@ -19,6 +19,10 @@ def get_data_manager(): class NoData(object): + ''' + A placeholder object for DataServer to hold + when there is no loop running. + ''' location = None def store(self, *args, **kwargs): @@ -63,6 +67,9 @@ def _run_server(self): DataServer(self._query_queue, self._response_queue, self._error_queue) def write(self, *query): + ''' + Send a query to the DataServer that does not expect a response. + ''' self._query_queue.put(query) self._check_for_errors() @@ -74,6 +81,9 @@ def _check_for_errors(self): raise RuntimeError(errhead) def ask(self, *query, timeout=None): + ''' + Send a query to the DataServer and wait for a response + ''' timeout = timeout or self.query_timeout with self.query_lock: @@ -89,11 +99,18 @@ def ask(self, *query, timeout=None): return res def halt(self): + ''' + Halt the DataServer and end its process + ''' if self._server.is_alive(): self.ask('halt') self._server.join() def restart(self, force=False): + ''' + Restart the DataServer + Use force=True to abort a running measurement. + ''' if (not force) and self.ask('get_data', 'location'): raise RuntimeError('A measurement is running. Use ' 'restart(force=True) to override.') @@ -106,6 +123,18 @@ class DataServerProcess(PrintableProcess): class DataServer(object): + ''' + Running in its own process, receives, holds, and returns current `Loop` and + monitor data, and writes it to disk (or other storage) + + When a `Loop` is *not* running, the DataServer also calls the monitor + routine. But when a `Loop` *is* running, *it* calls the monitor so that it + can avoid conflicts. Also while a `Loop` is running, there are + complementary `DataSet` objects in the loop and `DataServer` processes - + they are nearly identical objects, but are configured differently so that + the loop `DataSet` doesn't hold any data itself, it only passes that data + on to the `DataServer` + ''' default_storage_period = 1 # seconds between data storage calls queries_per_store = 5 default_monitor_period = 60 # seconds between monitoring storage calls @@ -168,13 +197,22 @@ def _post_error(self, e): # All except store_data return something, so should be used with ask # # rather than write. That way they wait for the queue to flush and # # will receive errors right anyway # + # # + # TODO: make a command that lists all available query handlers # ###################################################################### def handle_halt(self): + ''' + Quit this DataServer + ''' self._running = False self._reply(True) def handle_new_data(self, data_set): + ''' + Load a new (normally empty) DataSet into the DataServer, and + prepare it to start receiving and storing data + ''' if self._measuring: raise RuntimeError('Already executing a measurement') @@ -184,15 +222,29 @@ def handle_new_data(self, data_set): self._reply(True) def handle_end_data(self): + ''' + Mark this DataSet as complete and write its final changes to storage + ''' self._data.write() self._measuring = False self._reply(True) def handle_store_data(self, *args): + ''' + Put some data into the DataSet + This is the only query that does not return a value, so the measurement + loop does not need to wait for a reply. + ''' self._data.store(*args) def handle_get_measuring(self): + ''' + Is a measurement loop presently running? + ''' self._reply(self._measuring) def handle_get_data(self, attr=None): + ''' + Return the active DataSet or some attribute of it + ''' self._reply(getattr(self._data, attr) if attr else self._data) diff --git a/qcodes/instrument/base.py b/qcodes/instrument/base.py index c5af7678e9e..9aa89c277a7 100644 --- a/qcodes/instrument/base.py +++ b/qcodes/instrument/base.py @@ -78,10 +78,18 @@ def snapshot_base(self): ########################################################################## def write(self, cmd): + ''' + The Instrument base class has no hardware connection. This .write + converts to the async version if the subclass supplies one. + ''' wait_for_async(self.write_async, cmd) @asyncio.coroutine def write_async(self, cmd): + ''' + The Instrument base class has no hardware connection. This .write_async + converts to the sync version if the subclass supplies one. + ''' # check if the paired function is still from the base class (so we'd # have a recursion loop) notice that we only have to do this in one # of the pair, because the other will call this one. @@ -91,20 +99,36 @@ def write_async(self, cmd): self.write(cmd) def read(self): + ''' + The Instrument base class has no hardware connection. This .read + converts to the async version if the subclass supplies one. + ''' return wait_for_async(self.read_async) @asyncio.coroutine def read_async(self): + ''' + The Instrument base class has no hardware connection. This .read_async + converts to the sync version if the subclass supplies one. + ''' if self.read.__func__ is Instrument.read: raise NotImplementedError( 'instrument {} has no read method defined'.format(self.name)) return self.read() def ask(self, cmd): + ''' + The Instrument base class has no hardware connection. This .ask + converts to the async version if the subclass supplies one. + ''' return wait_for_async(self.ask_async, cmd) @asyncio.coroutine def ask_async(self, cmd): + ''' + The Instrument base class has no hardware connection. This .ask_async + converts to the sync version if the subclass supplies one. + ''' if self.ask.__func__ is Instrument.ask: raise NotImplementedError( 'instrument {} has no ask method defined'.format(self.name)) diff --git a/qcodes/instrument/function.py b/qcodes/instrument/function.py index fcdcc385d03..ea39a7830d2 100644 --- a/qcodes/instrument/function.py +++ b/qcodes/instrument/function.py @@ -52,6 +52,9 @@ def _set_call(self, call_cmd, async_call_cmd, parse_function): ask_or_write, ask_or_write_async, parse_function) def validate(self, args): + ''' + check that all arguments to this Function are allowed + ''' if len(args) != self._param_count: raise TypeError( '{} called with {} parameters but requires {}'.format( diff --git a/qcodes/instrument/mock.py b/qcodes/instrument/mock.py index c870a6ec339..1d7e86e8026 100644 --- a/qcodes/instrument/mock.py +++ b/qcodes/instrument/mock.py @@ -6,24 +6,24 @@ class MockInstrument(Instrument): + ''' + Creates a software instrument, for modeling or testing + inputs: + name: (string) the name of this instrument + delay: the time (in seconds) to wait after any operation + to simulate communication delay + model: an object with write and ask methods, taking 2 or 3 args: + instrument: the name of the instrument + parameter: the name of the parameter + value (write only): the value to write, as a string + + parameters to pass to model should be declared with: + get_cmd = param_name + '?' + set_cmd = param_name + ' {:.3f}' (specify the format & precision) + alternatively independent functions may still be provided. + ''' def __init__(self, name, delay=0, model=None, keep_history=True, use_async=False, read_response=None, **kwargs): - ''' - Creates a software instrument, for modeling or testing - inputs: - name: (string) the name of this instrument - delay: the time (in seconds) to wait after any operation - to simulate communication delay - model: an object with write and ask methods, taking 2 or 3 args: - instrument: the name of the instrument - parameter: the name of the parameter - value (write only): the value to write, as a string - - parameters to pass to model should be declared with: - get_cmd = param_name + '?' - set_cmd = param_name + ' {:.3f}' (specify the format & precision) - alternatively independent functions may still be provided. - ''' super().__init__(name, **kwargs) if not isinstance(delay, (int, float)) or delay < 0: diff --git a/qcodes/instrument/parameter.py b/qcodes/instrument/parameter.py index d4a79a0c553..411614ce294 100644 --- a/qcodes/instrument/parameter.py +++ b/qcodes/instrument/parameter.py @@ -138,6 +138,9 @@ def _set_vals(self, vals): raise TypeError('vals must be a Validator') def validate(self, value): + ''' + raises a ValueError if this value is not allowed for this Parameter + ''' if not self._vals.is_valid(value): raise ValueError( '{} is not a valid value for {}'.format(value, self.name)) @@ -203,6 +206,9 @@ def __init__(self, instrument, name, ' Parameter {}'.format(self.name)) def snapshot_base(self): + ''' + json state of the Parameter + ''' snap = {} if self._last_value is not None: snap['value'] = self._last_value @@ -302,6 +308,15 @@ def _validate_and_sweep_async(self, value): self._save_val(value) def set_sweep(self, sweep_step, sweep_delay, max_val_age=None): + ''' + configure this Parameter to set using a stair-step sweep + + This means a single .set call will generate many instrument writes + so that the value only changes at most sweep_step in a time sweep_delay + + max_val_age: max time (in seconds) to trust a saved value. Important + since we need to know what value we're starting from in this sweep. + ''' if sweep_step is not None or sweep_delay is not None: if not self._vals.is_numeric: raise TypeError('you can only sweep numeric parameters') diff --git a/qcodes/instrument/sweep_values.py b/qcodes/instrument/sweep_values.py index afae320b868..14f28ff4dea 100644 --- a/qcodes/instrument/sweep_values.py +++ b/qcodes/instrument/sweep_values.py @@ -52,11 +52,18 @@ def __init__(self, parameter): self.set_async = mock_async(parameter.set) def validate(self, values): + ''' + check that all values are allowed for this Parameter + ''' if hasattr(self.parameter, 'validate'): for value in values: self.parameter.validate(value) def __iter__(self): + ''' + must be overridden (along with __next__ if this returns self) + by a subclass to tell how to iterate over these values + ''' raise NotImplementedError @@ -98,7 +105,6 @@ class SweepFixedValues(SweepValues): ''' def __init__(self, parameter, keys): super().__init__(parameter) - self._values = [] keyset = keys if is_sequence(keys) else (keys,) for key in keyset: @@ -175,7 +181,7 @@ class AdaptiveSweep(SweepValues): an example class to show how adaptive sampling might be implemented usage: - measurement.sweep(AdaptiveSweep(param, start, end, target_delta)) + Loop(AdaptiveSweep(param, start, end, target_delta), delay).run() inputs: start: initial parameter value diff --git a/qcodes/loops.py b/qcodes/loops.py index 5430c8a9af3..2c2c3d5209c 100644 --- a/qcodes/loops.py +++ b/qcodes/loops.py @@ -50,6 +50,10 @@ def get_bg(): + ''' + find the active background measurement process, if any + returns None otherwise + ''' processes = mp.active_children() loops = [p for p in processes if isinstance(p, MeasurementProcess)] @@ -63,6 +67,9 @@ def get_bg(): def halt_bg(self, timeout=5): + ''' + Stop the active background measurement process, if any + ''' loop = get_bg() if not loop: print('No loop running') @@ -84,6 +91,19 @@ def halt_bg(self, timeout=5): class Loop(object): + ''' + The entry point for creating measurement loops + + Describes a sequence of `Parameter` settings to loop over. When you attach + `action`s to a `Loop`, it becomes an `ActiveLoop` that you can `.run()`, or + you can run a `Loop` directly, in which case it takes the default `action`s + from the default `Station` + + `actions` are a sequence of things to do at each `Loop` step: they can be + `Parameter`s to measure, `Task`s to do (any callable that does not yield + data), `Wait` times, other `ActiveLoop`s to nest inside this one, or + `Loop`s to nest using the default `actions`. + ''' def __init__(self, sweep_values, delay): self.sweep_values = sweep_values self.delay = delay @@ -142,6 +162,14 @@ def run(self, *args, **kwargs): class ActiveLoop(object): + ''' + Created by attaching actions to a `Loop`, this is the object that actually + runs a measurement loop. An `ActiveLoop` can no longer be nested, only run, + or used as an action inside another `Loop` which will run the whole thing. + + The `ActiveLoop` determines what `DataArray`s it will need to hold the data + it collects, and it creates a `DataSet` holding these `DataArray`s + ''' HALT = 'HALT LOOP' def __init__(self, sweep_values, delay, *actions): @@ -167,6 +195,12 @@ def __init__(self, sweep_values, delay, *actions): self._monitor = None # TODO: how to specify this? def containers(self): + ''' + Finds the data arrays that will be created by the actions in this + loop, and nests them inside this level of the loop. + + Recursively calls `.containers` on any enclosed actions. + ''' loop_size = len(self.sweep_values) loop_array = DataArray(parameter=self.sweep_values.parameter) loop_array.nest(size=loop_size) diff --git a/qcodes/station.py b/qcodes/station.py index 1b4987a6099..c04e642e1ca 100644 --- a/qcodes/station.py +++ b/qcodes/station.py @@ -3,6 +3,14 @@ class Station(Metadatable): + ''' + A representation of the entire physical setup. + + Lists all the connected `Instrument`s and the current default + measurement (a list of actions). Contains a convenience method + `.measure()` to measure these defaults right now, but this is separate + from the code used by `Loop`. + ''' default = None def __init__(self, *instruments, monitor=None, default=True): @@ -22,6 +30,12 @@ def __init__(self, *instruments, monitor=None, default=True): self.monitor = monitor def add_instrument(self, instrument, name=None): + ''' + Record one instrument as part of this Station + + Returns the name assigned this instrument, which may have + been changed to make it unique among previously added instruments. + ''' if name is None: name = getattr(instrument, 'name', 'instrument{}'.format(len(self.instruments))) @@ -30,9 +44,20 @@ def add_instrument(self, instrument, name=None): return name def set_measurement(self, *actions): + ''' + Save a set *actions as the default measurement for this Station + + These actions will be executed by default by a Loop if this is the + default Station, and any measurements among them can be done once + by .measure + ''' self.default_measurement = actions def measure(self, *actions): + ''' + Measure any parameters in *actions, or the default measurement + for this station if none are provided. + ''' if not actions: actions = self.default_measurement diff --git a/qcodes/utils/helpers.py b/qcodes/utils/helpers.py index 51546c076d8..4ee22a1d911 100644 --- a/qcodes/utils/helpers.py +++ b/qcodes/utils/helpers.py @@ -72,6 +72,10 @@ def permissive_range(start, stop, step): def wait_secs(finish_datetime): + ''' + calculate the number of seconds until a given datetime + Does NOT wait for this time. + ''' delay = (finish_datetime - datetime.now()).total_seconds() if delay < 0: logging.warning('negative delay {} sec'.format(delay)) @@ -80,6 +84,10 @@ def wait_secs(finish_datetime): def make_unique(s, existing): + ''' + make string s unique, able to be added to a sequence `existing` of + existing names without duplication, by appending _<int> to it if needed + ''' n = 1 s_out = s existing = set(existing) @@ -184,7 +192,7 @@ def reload_code(pattern=None, lib=False): ''' reload all modules matching a given pattern or all (non-built-in) modules if pattern is omitted - lib says whether to include lib files (default False) + if lib is False (default), ignore the standard library and major packages ''' reloaded_files = [] @@ -195,7 +203,11 @@ def reload_code(pattern=None, lib=False): return reloaded_files -def is_good_module(module, lib): +def is_good_module(module, lib=False): + ''' + is an object (module) a module we can reload? + if lib is False (default), ignore the standard library and major packages + ''' # take out non-modules and underscore modules name = getattr(module, '__name__', '_') if name[0] == '_' or not isinstance(module, type(sys)): @@ -218,6 +230,11 @@ def is_good_module(module, lib): def reload_recurse(module, reloaded_files, lib): + ''' + recursively search module for its own dependencies to reload, + ignoring those already in reloaded_files + if lib is False (default), ignore the standard library and major packages + ''' if not is_good_module(module, lib) or module.__file__ in reloaded_files: return diff --git a/qcodes/utils/sync_async.py b/qcodes/utils/sync_async.py index db05435cdf2..cfee4b52a39 100644 --- a/qcodes/utils/sync_async.py +++ b/qcodes/utils/sync_async.py @@ -107,6 +107,13 @@ def syncable_command(param_count, cmd=None, acmd=None, class _SyncableCommand(object): + ''' + Creates sync and async versions of the same callable + + This should not be constructed directly, only by syncable_command. + Structured as a class because we can't use closures with spawn + multiprocessing. + ''' def __init__(self, param_count, cmd, acmd, exec_str, aexec_str, parse_function, no_cmd_function): self.param_count = param_count diff --git a/qcodes/utils/validators.py b/qcodes/utils/validators.py index 2670e0c85a8..80d8f31faa5 100644 --- a/qcodes/utils/validators.py +++ b/qcodes/utils/validators.py @@ -5,6 +5,9 @@ def range_str(min_val, max_val, name): + ''' + utility to represent ranges in Validator repr's + ''' if max_val is not None: if min_val is not None: if max_val == min_val: From 405f3cada7253167f080646decd5c6760fd3d2dd Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Thu, 17 Dec 2015 21:51:11 +0100 Subject: [PATCH 19/33] reload_code in main namespace --- qcodes/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qcodes/__init__.py b/qcodes/__init__.py index 92dcb322254..f688e463633 100644 --- a/qcodes/__init__.py +++ b/qcodes/__init__.py @@ -19,7 +19,7 @@ from qcodes.instrument.parameter import Parameter, InstrumentParameter from qcodes.instrument.sweep_values import SweepFixedValues, AdaptiveSweep -from qcodes.utils.helpers import set_mp_method +from qcodes.utils.helpers import set_mp_method, reload_code # just for convenience in debugging, so we don't have to # separately import multiprocessing From ed0889139132c4a1a13ad10262799a9c11890681 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 18 Dec 2015 12:56:56 +0100 Subject: [PATCH 20/33] clean up notebook --- Qcodes example.ipynb | 3833 +----------------------------------------- test2d.dat | 2 +- 2 files changed, 80 insertions(+), 3755 deletions(-) diff --git a/Qcodes example.ipynb b/Qcodes example.ipynb index 80b77b6d05b..310d1219b3d 100644 --- a/Qcodes example.ipynb +++ b/Qcodes example.ipynb @@ -6,19 +6,12 @@ "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/IPython/kernel/__init__.py:13: ShimWarning: The `IPython.kernel` package has been deprecated. You should import from ipykernel or jupyter_client instead.\n", - " \"You should import from ipykernel or jupyter_client instead.\", ShimWarning)\n" - ] - } - ], + "outputs": [], "source": [ - "%matplotlib nbagg\n", + "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", + "import time\n", + "from IPython import display\n", "\n", "# load the qcodes path, until we have this installed as a package\n", "import sys\n", @@ -138,9 +131,9 @@ "output_type": "stream", "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='testsweep'\n", - " chan0: chan0\n", " amplitude: amplitude\n", - "started at 2015-12-12 22:38:09\n" + " chan0: chan0\n", + "started at 2015-12-18 12:52:56\n" ] } ], @@ -171,7 +164,7 @@ } ], "source": [ - "# now there should be two processes running, DataServer and a sweep\n", + "# now there should be two extra processes running, DataServer and a sweep\n", "q.active_children()" ] }, @@ -186,13 +179,13 @@ { "data": { "text/plain": [ - "{'amplitude': DataArray: amplitude\n", + "{'amplitude': DataArray[400]: amplitude\n", " array([ 0.117, 0.117, 0.115, 0.111, 0.106, 0.099, 0.092, 0.085,\n", " 0.077, 0.071, 0.064, 0.058, 0.053, 0.048, 0.044, 0.04 ,\n", " 0.037, 0.034, 0.031, 0.029, 0.027, 0.025, 0.023, 0.022,\n", - " 0.02 , 0.019, 0.018, 0.017, 0.016, 0.015, 0.014, 0.013,\n", - " 0.013, 0.012, 0.011, 0.011, 0.01 , 0.01 , 0.01 , 0.009,\n", - " 0.009, nan, nan, nan, nan, nan, nan, nan,\n", + " 0.02 , 0.019, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -237,12 +230,12 @@ " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan]),\n", - " 'chan0': DataArray: chan0\n", + " 'chan0': DataArray[400]: chan0\n", " array([-20. , -19.9, -19.8, -19.7, -19.6, -19.5, -19.4, -19.3, -19.2,\n", " -19.1, -19. , -18.9, -18.8, -18.7, -18.6, -18.5, -18.4, -18.3,\n", " -18.2, -18.1, -18. , -17.9, -17.8, -17.7, -17.6, -17.5, -17.4,\n", - " -17.3, -17.2, -17.1, -17. , -16.9, -16.8, -16.7, -16.6, -16.5,\n", - " -16.4, -16.3, -16.2, -16.1, -16. , -15.9, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -298,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "metadata": { "collapsed": false, "scrolled": false @@ -306,747 +299,9 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " fig.waiting = false;\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'];\n", - " var y0 = fig.canvas.height - msg['y0'];\n", - " var x1 = msg['x1'];\n", - " var y1 = fig.canvas.height - msg['y1'];\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x;\n", - " var y = canvas_pos.y;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", - " fig.send_message('closing', {});\n", - " fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Close figure', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], - "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\">" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAE4CAYAAABPOqWIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text/plain": [ - "<IPython.core.display.HTML object>" + "<matplotlib.figure.Figure at 0x105a4ecc0>" ] }, "metadata": {}, @@ -1054,20 +309,25 @@ } ], "source": [ + "fig = plt.figure(figsize=(12, 5))\n", + "ax = fig.add_subplot(1,1,1)\n", + "\n", "# plot (can also be done repeatedly while the sweep is running)\n", "# next up: create an active plot that will update itself automatically\n", "# (via javascript, so the main python stays accessible) as long as the sweep is running\n", "# as well as provide some nicer styling and labeling defaults\n", - "data.sync()\n", - "plt.figure(figsize=(12, 5))\n", - "# because we pass through the ndarray attributes, matplotlib can plot DataArrays directly\n", - "plt.plot(data.chan0, data.amplitude)\n", - "plt.show()" + "while data.is_live_mode:\n", + " data.sync()\n", + " ax.clear()\n", + " ax.plot(data.chan0, data.amplitude)\n", + " display.display(fig)\n", + " display.clear_output(wait=True)\n", + " time.sleep(1)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "metadata": { "collapsed": false }, @@ -1078,19 +338,18 @@ "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='test2d'\n", " chan1: chan1\n", - " amplitude_4: amplitude\n", - " chan0: chan0\n", " amplitude_0: amplitude\n", - "started at 2015-12-12 22:39:06\n" + " amplitude_3: amplitude\n", + " chan0: chan0\n", + "started at 2015-12-18 12:54:00\n" ] } ], "source": [ "data2 = q.Loop(c1[-15:15:1], 0.1).loop(c0[-15:12:.5], 0.01).each(\n", " meter.amplitude, # first measurement, at c2=0 -> amplitude_0 bcs it's action 0\n", - " q.Task(c2.set, 1), # action 1 -> \n", + " q.Task(c2.set, 1), # action 1 -> c2.set(1)\n", " q.Wait(0.001),\n", - " q.Task(print, '!'), # Loop runs in the background, so ! gets printed in the notebook server terminal\n", " meter.amplitude, # second measurement, at c2=1 -> amplitude_4 bcs it's action 4\n", " q.Task(c2.set, 0)\n", " ).run(location='test2d')" @@ -1098,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 10, "metadata": { "collapsed": false, "scrolled": false @@ -1106,747 +365,9 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " fig.waiting = false;\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'];\n", - " var y0 = fig.canvas.height - msg['y0'];\n", - " var x1 = msg['x1'];\n", - " var y1 = fig.canvas.height - msg['y1'];\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x;\n", - " var y = canvas_pos.y;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", - " fig.send_message('closing', {});\n", - " fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Close figure', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAE4CAYAAACt5r7xAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAGdNJREFUeJzt3V+M9mdZJ/DvxUv7JrCkSgW66upuw2pZk4UlWTBxs6nZ\nVehR0RiDHqyCMSSGE9wDIR5QjIl/DurBGhKj2HCgIe4BFswWW6OzCdnsStKlSGixbrcKLO2ylK3Y\nTUop9x68I4z1vdu5Zuae+T1PP59k0plnrrl/V57nueZ3vb/+5r5qjBEAAODve8FFJwAAAFulWQYA\ngAnNMgAATGiWAQBgQrMMAAATmmUAAJg4k2a5qt5XVY9W1SeOPPbuqvpsVd17+PHGszgWAACcl7O6\nsnxHkjdc5fHbxxivPfz4yBkdCwAAzsWZNMtjjI8m+dJVvlVnsT4AAFyE1fcsv72qPl5Vv1VV1y0+\nFgAAnKmVzfJ7k9w4xnhNkkeS3L7wWAAAcOZeuGrhMcYXjnz5m0k+fLW4qhqrcgAAgKPGGK3bhM+y\nWa4cuUe5qm4YYzxy+OUPJ/nk7AfH0C/vqttuuy233XbbRafBCXn9dpfXbrd5/XaX1263VfX/nO5M\nmuWq+t0kNye5vqr+Ksm7k3x/Vb0mydeSPJzkbWdxLAAAOC9n0iyPMX78Kg/fcRZrAwDARTHBj1O5\n+eabLzoFTsHrt7u8drvN67e7vHbPP3XR9wtX1bjoHAAA2H9V1f4DP1eWAQBgQrMMAAATmmUAAJhY\nNpSk4+Un2PPuuVzTiL22EXu5mUdn7U7OL1m0bifflb7SiH2qEfvlRet28k2SJxet3cl5lc77LVlX\nf2rvZHat9pJezvtce8k2zn1bqL3u2luov+555B5/73VuXFkGAIAJzTIAAExolgEAYEKzDAAAE5pl\nAACY0CwDAMCEZhkAACY0ywAAMKFZBgCAiU1M8DuuVdN4Vk3kSpKXNmKvb8Re14i9oRHbybc78agz\nneixRuwjjdjHG7FfbMR28k16z11n8llHZ+LYyklYq+pvn2sv6T3P+1x7SS/nfa69ZBvnvi3UXrKN\nc9+q2uN8ubIMAAATmmUAAJjQLAMAwIRmGQAAJjTLAAAwoVkGAIAJzTIAAExolgEAYGITQ0mOu9l5\nZyPwywuOn/QHB3Q2Rb+xEfvqRuytjdhLtzSCb2rEJskDxw99+q7jx97ZSOG+RuxDjdiuzubznffy\nKqtqL1lXf3tde0mv/tTe1+1z7SXbOPdtofaSjZz7FtUe58uVZQAAmNAsAwDAhGYZAAAmNMsAADCh\nWQYAgAnNMgAATGiWAQBgQrMMAAATmxhKskJnI/fOxuzdDeJf1IjtbOT++kbspXc0gm9/SyP4txux\nSfLWY0de+tk7jh37+l87fgaPHj80jzRiu++LVe+5J5t5rLCV52K/ay/p1d/+1l6yjd/3W6i9ZBvP\nxRZqL9nKuW9N7XG+XFkGAIAJzTIAAExolgEAYEKzDAAAE2fSLFfV+6rq0ar6xJHHvrmq7q6qT1fV\nH1bVdWdxLAAAOC9ndWX5jiRveMZj70zyR2OM707yx0nedUbHAgCAc3EmzfIY46NJvvSMh29N8v7D\nz9+f5E1ncSwAADgvK+9ZfvkY49EkGWM8kuTlC48FAABn7jyHkozZN/76yOeXDz8AAOA0Dg4OcnBw\ncKo1aoxpD9tbqOo7k3x4jPHPD7++P8nNY4xHq+qGJH8yxnjVVX5ufOsxj9GZINRpuF/ciH1pIzbp\nTSe6sRH76kbsrY3YS7c0gm9qxCbJA8cPffqu48fe2UjhvkbsQ43Y7sSxxxqxTzRiO1PEvtKIXVV7\nybr62+vaS3r1t8e1l/Tqb59rL9nGuW8LtZds5Ny3qPaS5NIZ9W/PN1WVMUZ1fuYsb8Oow4+/9aEk\nP3n4+U+k93sVAAAu3FltHfe7Sf5Lku+qqr+qqrck+eUkP1BVn07ybw6/BgCAnXEm9yyPMX588q1/\nexbrAwDARTDBDwAAJjTLAAAwoVkGAIAJzTIAAExolgEAYOLMhpKcOIGq8bJjxl7TWLezkftLGrGd\nHJLeRu7XN2Kva8R2Nojv5NvdLL+zEX9ncEBnIMHjjdgvNmI7+SbJU43YLzdiO89xJ4dVtZesq799\nrr2k9zzvc+0lvZz3ufaSbZz7tlB7yTbOfatqL0neYyjJiVz0UBIAANgrmmUAAJjQLAMAwIRmGQAA\nJjTLAAAwoVkGAIAJzTIAAExolgEAYGKnhpJ0rBqicLmZR2ftTs6rNpPvDpRYZdUG/50hA511O/km\nyZOL1u7kvMrKIQqd+lN7J7NrtZf0ct7n2ku2ce7bQu11195C/XXPI/cYSnIihpIAAMAZ0iwDAMCE\nZhkAACY0ywAAMKFZBgCACc0yAABMaJYBAGBCswwAABOaZQAAmHjhRSeQXPzko5WT2lZNBXpi0bpb\nmGKU9J/n4+pM7+ro5rvqPX/RtXQSq+pP7Z3MrtVeso1Je2rvG3at9pJt1N+q2uP0XFkGAIAJzTIA\nAExolgEAYEKzDAAAE5plAACY0CwDAMCEZhkAACY0ywAAMLFTQ0muWbDmaqvysHn5yez7+6Kjk4Pa\n+wa1dzL7/r7oWFV73bVXUXvsG1eWAQBgQrMMAAATmmUAAJhYfs9yVT2c5PEkX0vy1BjjdauPCQAA\nZ+E8/sDva0luHmN86RyOBQAAZ+Y8bsOoczoOAACcqfNoYkeSe6rqY1X10+dwPAAAOBPncRvG940x\nPl9VL8uVpvn+McZHz+G4AABwKsub5THG5w//+4Wq+mCS1yX5O83yV5+RUHcT9qs5izXOYt1rl2SR\nXF607qp8u1ZtPv/konW3sln+ymEHF71ud221dzK7VnvJNupvC7W3cu19rr1kG/W3hffxPjo4OMjB\nwcGp1qgxxtlkc7XFq16U5AVjjL+pqhcnuTvJe8YYdx+JGd+04Nhb+IWR7N4vjS38wkh274TdzXfV\nhKstTO/aSiOg9k5m12ov6eW8z7WXbOPct2u1l2yj/rq198DC/m2fVVXGGNX5mdVXll+R5INVNQ6P\n9TtHG2UAANiypc3yGON/JnnNymMAAMAqtnQDAIAJzTIAAExolgEAYEKzDAAAE5plAACY0CwDAMDE\neYy7fk4rNlFftYF6d1P0ztqdnF+yaN0tbMyerBsy8OVF63Y3k+8MaNi1qU4rB/d06k/tncyu1V7S\ny3mfay/ZxrlvC7XXXXsL9beL77fnC1eWAQBgQrMMAAATmmUAAJjQLAMAwIRmGQAAJjTLAAAwoVkG\nAIAJzTIAAExsYijJca3aYHzVkIEkeWkj9vpG7HWN2BsasZ18u5u4dzZcf6wR+0gj9vFG7BcbsZ18\nk95z1xnm0NEZ/LByc/9V9bfPtZf0nud9rr2kl/M+116yjXPfFmov2ca5b1Xtcb5cWQYAgAnNMgAA\nTGiWAQBgQrMMAAATmmUAAJjQLAMAwIRmGQAAJjTLAAAwsYmhJMfd7LyzEfjlBcdP+oMDOpui39iI\nfXUj9tZG7KVbGsE3NWKT5IHjhz591/Fj72ykcF8j9qFGbFdn8/nOe3mVVbWXrKu/va69pFd/au/r\n9rn2km2c+7ZQe8lGzn2Lao/z5coyAABMaJYBAGBCswwAABOaZQAAmNAsAwDAhGYZAAAmNMsAADCh\nWQYAgIlNDCVZobORe2dj9u4G8S9qxHY2cn99I/bSOxrBt7+lEfzbjdgkeeuxIy/97B3Hjn39rx0/\ng0ePH5pHGrHd98Wq99yTzTxW2Mpzsd+1l/Tqb39rL9nG7/st1F6yjediC7WXbOXct6b2OF+uLAMA\nwIRmGQAAJjTLAAAwoVkGAICJ5c1yVb2xqh6oqj+vqp9bfTwAADgrS5vlqnpBkl9P8oYk35Pkx6rq\nppXHBACAs7L6yvLrkjw4xvjLMcZTST6Q5NbFxwQAgDOxuln+tiSfOfL1Zw8fAwCAzdvEUJK/PvL5\n5cMPAAA4jYODgxwcHJxqjRpjnE02V1u86nuT3DbGeOPh1+9MMsYYv3IkZnzrMdfrTBDqNNwvbsS+\ntBGb9KYT3diIfXUjtnPfy6VbGsHdu88fOH7o03cdP/bORgr3NWIfasR2J4491oh9ohHbmSL2lUbs\nqtpL1tXfXtde0qu/Pa69pFd/+1x7yTbOfVuovWQj575FtZcklxb2b/usqjLGqM7PrL4N42NJXllV\n31lV1yZ5c5IPLT4mAACciaW3YYwxnq6qtye5O1ca8/eNMe5feUwAADgry+9ZHmN8JMl3rz4OAACc\nNRP8AABgQrMMAAATmmUAAJjQLAMAwIRmGQAAJpYOJTlWAlXjZceMvaaxbmcj95c0Yjs5JL2N3K9v\nxF7XiO1sEN/Jt7tZfmcj/s7ggM5AgscbsV9sxHbyTZKnGrFfbsR2nuNODqtqL1lXf/tce0nved7n\n2kt6Oe9z7SXbOPdtofaSbZz7VtVekrzHUJIT2eJQEgAA2FmaZQAAmNAsAwDAhGYZAAAmNMsAADCh\nWQYAgAnNMgAATGiWAQBgYqeGknSsGqJwuZlHZ+1Ozqs2k+8OlFhl1Qb/nSEDnXU7+SbJk4vW7uS8\nysohCp36U3sns2u1l/Ry3ufaS7Zx7ttC7XXX3kL9dc8j9xhKciKGkgAAwBnSLAMAwIRmGQAAJjTL\nAAAwoVkGAIAJzTIAAExolgEAYEKzDAAAE5plAACYeOFFJ5Bc/OSjlZPaVk0FemLRuluYYpT0n+fj\n6kzv6ujmu+o9f9G1dBKr6k/tncyu1V6yjUl7au8bdq32km3U36ra4/RcWQYAgAnNMgAATGiWAQBg\nQrMMAAATmmUAAJjQLAMAwIRmGQAAJjTLAAAwsVNDSa5ZsOZqq/KwefnJ7Pv7oqOTg9r7BrV3Mvv+\nvuhYVXvdtVdRe+wbV5YBAGBCswwAABOaZQAAmFjWLFfVu6vqs1V17+HHG1cdCwAAVlj9B363jzFu\nX3wMAABYYvVtGLV4fQAAWGZ1s/z2qvp4Vf1WVV23+FgAAHCmaoxx8h+uuifJK44+lGQk+fkk/zXJ\n/xljjKr6xST/cIzxU1dZY7z4mMfr7je5whZySLaTx67Zwh6kyTbyWLnX6ypbyGMLOeyiLbznk23k\nofZOZgs5bMnnTtG/PZ9VVcYYrTsfTnXP8hjjB44Z+ptJPjz75lefkdBZFMSqouque+2SLJLLi9Zd\nlW/Xqs3nn1y07lY2y9/CSXjlCa2ztto7mV2rvWQb9beF2lu59j7XXrKN+tvC+3gfHRwc5ODg4FRr\nnOrK8rMuXHXDGOORw8/fkeRfjjF+/Cpx45sWHH8LvzCS3fulsYVfGMnunbC7+a66urWFq2ZbaQTU\n3snsWu0lvZz3ufaSbZz7dq32km3UX7f2HnBl+UTO/cryc/jVqnpNkq8leTjJ2xYeCwAAztyyZnmM\n8e9WrQ0AAOfBBD8AAJjQLAMAwIRmGQAAJjTLAAAwoVkGAIAJzTIAAEys3Gf52FZsor5qA/Xupuid\ntTs5v2TRulvYmD1ZN2Tgy4vW7W4m3xnQsGtTnVYO7unUn9o7mV2rvaSX8z7XXrKNc98Waq+79hbq\nbxffb88XriwDAMCEZhkAACY0ywAAMKFZBgCACc0yAABMaJYBAGBCswwAABOaZQAAmNjEUJLjWrXB\n+KohA0ny0kbs9Y3Y6xqxNzRiO/l2N3HvbLj+WCP2kUbs443YLzZiO/kmveeuM8yhozP4YeXm/qvq\nb59rL+k9z/tce0kv532uvWQb574t1F6yjXPfqtrjfLmyDAAAE5plAACY0CwDAMCEZhkAACY0ywAA\nMKFZBgCACc0yAABMaJYBAGBiE0NJjrvZeWcj8MsLjp/0Bwd0NkW/sRH76kbsrY3YS7c0gm9qxCbJ\nA8cPffqu48fe2UjhvkbsQ43Yrs7m85338iqrai9ZV397XXtJr/7U3tftc+0l2zj3baH2ko2c+xbV\nHufLlWUAAJjQLAMAwIRmGQAAJjTLAAAwoVkGAIAJzTIAAExolgEAYEKzDAAAE5sYSrJCZyP3zsbs\n3Q3iX9SI7Wzk/vpG7KV3NIJvf0sj+LcbsUny1mNHXvrZO44d+/pfO34Gjx4/NI80Yrvvi1XvuSeb\neaywlediv2sv6dXf/tZeso3f91uovWQbz8UWai/ZyrlvTe1xvlxZBgCACc0yAABMaJYBAGBCswwA\nABOnapar6keq6pNV9XRVvfYZ33tXVT1YVfdX1Q+eLk0AADh/p90N48+S/FCS3zj6YFW9KsmPJnlV\nkm9P8kdV9U/HGOOUxwMAgHNzqivLY4xPjzEeTFLP+NatST4wxvjqGOPhJA8med1pjgUAAOdt1T3L\n35bkM0e+/tzhYwAAsDOe8zaMqronySuOPpRkJPn5McaHzyKJvz7y+eXDDwAAOI2Dg4McHBycao06\ni9uIq+pPkvz7Mca9h1+/M8kYY/zK4dcfSfLuMcZ/u8rPjm895nE6E4Q6DfeLG7EvbcQmvelENzZi\nX92IvbURe+mWRvBNjdgkeeD4oU/fdfzYOxsp3NeIfagR25049lgj9olGbGeK2FcasatqL1lXf3td\ne0mv/va49pJe/e1z7SXbOPdtofaSjZz7FtVeklzyZ2AnUlUZYzzz9uFndZa3YRw98IeSvLmqrq2q\nf5LklUn+9AyPBQAAy51267g3VdVnknxvkj+oqruSZIzxqSS/l+RTSf5Tkp+xEwYAALvmVFvHjTF+\nP8nvT773S0l+6TTrAwDARTLBDwAAJjTLAAAwoVkGAIAJzTIAAExolgEAYOJMhpKcKoGq8bJjxl7T\nWLezkftLGrGdHJLeRu7XN2Kva8R2Nojv5NvdLL+zEX9ncEBnIMHjjdgvNmI7+SbJU43YLzdiO89x\nJ4dVtZesq799rr2k9zzvc+0lvZz3ufaSbZz7tlB7yTbOfatqL0neY0feE7nooSQAALBXNMsAADCh\nWQYAgAnNMgAATGiWAQBgQrMMAAATmmUAAJjQLAMAwMRODSXpWDVE4XIzj87anZxXbSbfHSixyqoN\n/jtDBjrrdvJNkicXrd3JeZWVQxQ69af2TmbXai/p5bzPtZds49y3hdrrrr2F+uueR+4xlOREDCUB\nAIAzpFkGAIAJzTIAAExolgEAYEKzDAAAE5plAACY0CwDAMCEZhkAACY0ywAAMPHCi04gufjJRysn\nta2aCvTEonW3MMUo6T/Px9WZ3tXRzXfVe/6ia+kkVtWf2juZXau9ZBuT9tTeN+xa7SXbqL9Vtcfp\nubIMAAATmmUAAJjQLAMAwIRmGQAAJjTLAAAwoVkGAIAJzTIAAExolgEAYGKnhpJcs2DN1VblYfPy\nk9n390VHJwe19w1q72T2/X3Rsar2umuvovbYN64sAwDAhGYZAAAmNMsAADBxqma5qn6kqj5ZVU9X\n1WuPPP6dVfX/qurew4/3nj5VAAA4X6f9A78/S/JDSX7jKt/7izHGa6/yOHvkySSXLzoJTuzpJJcu\nOglORO3tNrW3u9Te88+pmuUxxqeTpKrqKt++2mPsGb80dpsT9u5Se7tN7e0utff8s/Ke5X98eAvG\nn1TVv1p4HAAAWOI5ryxX1T1JXnH0oSQjyc+PMT48+bH/leQ7xhhfOryX+fer6p+NMf7m1BkDAMA5\nec5meYzxA91FxxhPJfnS4ef3VtX/SPJdSe69WvwT3QOwKf4FtNu2MMSAk1F7u03t7a4t1N7V74Bl\nhbOc4Pf1V62qviXJY2OMr1XVjUlemeShq/3QGMOrDQDAJp1267g3VdVnknxvkj+oqrsOv/Wvk3yi\nqu5N8ntJ3jbG+L+nSxUAAM5XjTEuOgcAANikC5vgZ6DJ7pq9doffe1dVPVhV91fVD15UjhxPVb27\nqj57pN7eeNE58dyq6o1V9UBV/XlV/dxF58PxVdXDVXVfVf33qvrTi86HZ1dV76uqR6vqE0ce++aq\nuruqPl1Vf1hV111kjsxNXr/2ee8ix13/7UCT/3yV7/3FGOO1hx8/c8558dyu+tpV1auS/GiSVyW5\nJcl7J3twsy23H6m3j1x0Mjy7qnpBkl9P8oYk35Pkx6rqpovNioavJbl5jPEvxhivu+hkeE535Eqt\nHfXOJH80xvjuJH+c5F3nnhXHdbXXL2me9y6sWR5jfHqM8WCuPrxEg7Vhz/La3ZrkA2OMr44xHk7y\nYBIng+1Tb7vldUkeHGP85eHOQx/IldpjN1Qu9kIVDWOMj+Zwd68jbk3y/sPP35/kTeeaFMc2ef2S\n5nlvqwVroMlu+rYknzny9ecOH2Pb3l5VH6+q3/K/E3fCM+vss1Fnu2QkuaeqPlZVP33RyXAiLx9j\nPJokY4xHkrz8gvOhr3XeO8ut4/4eA0121wlfOzbo2V7LJO9N8gtjjFFVv5jk9iQ/df5ZwvPG940x\nPl9VL8uVpvn+w6tf7C47JeyW9nlvabN8HgNNWOMkr12uXEn+R0e+/vbDx7hAjdfyN5P4h9D2fS7J\ndxz5Wp3tkDHG5w//+4Wq+mCu3FajWd4tj1bVK8YYj1bVDUn+90UnxPGNMb5w5Mtjnfe2chvG3xlo\ncvgHLHmugSZswtH7fj6U5M1VdW1V/ZNcee38tfeGHf6i/1s/nOSTF5ULx/axJK883Dno2iRvzpXa\nY+Oq6kVV9Q8OP39xkh+MmtsFlb9/rvvJw89/Ismd550QLX/n9TvJeW/pleVnU1VvSvIfknxLrgw0\n+fgY45ZcGWjyC1X1lVz5q2EDTTZm9tqNMT5VVb+X5FO5Msn1Z4aNvLfuV6vqNblSaw8nedvFpsNz\nGWM8XVVvT3J3rlzweN8Y4/4LTovjeUWSD1bVyJXz7++MMe6+4Jx4FlX1u0luTnJ9Vf1Vkncn+eUk\n/7Gq3prkL3NlFyg2aPL6fX/3vGcoCQAATGzlNgwAANgczTIAAExolgEAYEKzDAAAE5plAACY0CwD\nAMCEZhkAACY0ywAAMPH/Aepzu1Z7lMBjAAAAAElFTkSuQmCC\n", "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" + "<matplotlib.figure.Figure at 0x105e9b0f0>" ] }, "metadata": {}, @@ -1854,770 +375,40 @@ } ], "source": [ - "# again, can call this repeatedly while the plot is running\n", - "# this plot shows the first array collected, amplitude_0 (at c2=0)\n", - "data2.sync()\n", "import numpy.ma as ma\n", - "plt.figure(figsize=(12, 5))\n", - "# pcolormesh needs NaN masked out or it barfs\n", - "plt.pcolormesh(ma.masked_invalid(data2.chan0),\n", - " ma.masked_invalid(data2.chan1),\n", - " ma.masked_invalid(data2.amplitude_0),\n", - " cmap=plt.cm.hot)\n", - "plt.colorbar()\n", - "plt.show()" + "\n", + "fig = plt.figure(figsize=(12, 5))\n", + "ax = fig.add_subplot(1,1,1)\n", + "\n", + "# next up: create an active plot that will update itself automatically\n", + "# (via javascript, so the main python stays accessible) as long as the sweep is running\n", + "# as well as provide some nicer styling and labeling defaults\n", + "while True:\n", + " data2.sync()\n", + " ax.clear()\n", + " ax.pcolormesh(ma.masked_invalid(data2.chan0),\n", + " ma.masked_invalid(data2.chan1),\n", + " ma.masked_invalid(data2.amplitude_0),\n", + " cmap=plt.cm.hot)\n", + " display.display(fig)\n", + " display.clear_output(wait=True)\n", + " if not data2.is_live_mode:\n", + " break\n", + " time.sleep(1)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " fig.waiting = false;\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'];\n", - " var y0 = fig.canvas.height - msg['y0'];\n", - " var x1 = msg['x1'];\n", - " var y1 = fig.canvas.height - msg['y1'];\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x;\n", - " var y = canvas_pos.y;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", - " fig.send_message('closing', {});\n", - " fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Close figure', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nP/Vza4LvKwXJAAAAAElFTkSuQmCC\n", "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" + "<matplotlib.figure.Figure at 0x10605b240>" ] }, "metadata": {}, @@ -2632,7 +423,7 @@ "# pcolormesh needs NaN masked out or it barfs\n", "plt.pcolormesh(ma.masked_invalid(data2.chan0),\n", " ma.masked_invalid(data2.chan1),\n", - " ma.masked_invalid(data2.amplitude_4),\n", + " ma.masked_invalid(data2.amplitude_3),\n", " cmap=plt.cm.hot)\n", "plt.colorbar()\n", "plt.show()" @@ -2640,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 13, "metadata": { "collapsed": false }, @@ -2654,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": { "collapsed": false }, @@ -2664,13 +455,13 @@ "output_type": "stream", "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='test_multi_d'\n", - " amplitude_5_0: amplitude\n", " chan2: chan2\n", - " amplitude_2: amplitude\n", - " chan0: chan0\n", " chan1: chan1\n", + " amplitude_5_0: amplitude\n", + " amplitude_2: amplitude\n", " amplitude_3_0: amplitude\n", - "started at 2015-12-12 22:51:20\n" + " chan0: chan0\n", + "started at 2015-12-18 12:55:06\n" ] } ], @@ -2690,754 +481,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " fig.waiting = false;\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'];\n", - " var y0 = fig.canvas.height - msg['y0'];\n", - " var x1 = msg['x1'];\n", - " var y1 = fig.canvas.height - msg['y1'];\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x;\n", - " var y = canvas_pos.y;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", - " fig.send_message('closing', {});\n", - " fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Close figure', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], - "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\">" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUZIkSZ1ZPEqSJKkzi0dJkiR19v8BUNlV5ljvTycAAAAASUVORK5CYII=\n", "text/plain": [ - "<IPython.core.display.HTML object>" + "<matplotlib.figure.Figure at 0x105ecaac8>" ] }, "metadata": {}, @@ -3465,747 +518,9 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " fig.waiting = false;\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'];\n", - " var y0 = fig.canvas.height - msg['y0'];\n", - " var x1 = msg['x1'];\n", - " var y1 = fig.canvas.height - msg['y1'];\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x;\n", - " var y = canvas_pos.y;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n", - " fig.send_message('closing', {});\n", - " fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-danger\" href=\"#\" title=\"Close figure\"><i class=\"fa fa-times icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Close figure', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAE4CAYAAADPSZKbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" + "<matplotlib.figure.Figure at 0x10674d1d0>" ] }, "metadata": {}, @@ -4222,6 +537,16 @@ "plt.colorbar()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/test2d.dat b/test2d.dat index 15981098b06..f0ab5ac7f61 100644 --- a/test2d.dat +++ b/test2d.dat @@ -1,4 +1,4 @@ -# chan1 chan0 amplitude_4 amplitude_0 +# chan1 chan0 amplitude_3 amplitude_0 # "chan1" "chan0" "amplitude" "amplitude" # 30 54 -15 -15 0.009 0.003 From 4c600f1a428bbfe24da850add31768141b69c0bd Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 18 Dec 2015 12:58:38 +0100 Subject: [PATCH 21/33] add the talk I just gave about qcodes structure --- Delft_talk_151218.pptx | Bin 0 -> 80897 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Delft_talk_151218.pptx diff --git a/Delft_talk_151218.pptx b/Delft_talk_151218.pptx new file mode 100644 index 0000000000000000000000000000000000000000..2e8a37ca6996905b71f9e6320ff454c01c0d9291 GIT binary patch literal 80897 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 RH$}~cuXZRGj_#0|)PIqzqOJe{ literal 0 HcmV?d00001 From 4f64165c25a1fec1d103b371e3e6aa3ec0f57e9a Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 18 Dec 2015 22:50:25 +0100 Subject: [PATCH 22/33] site flag in reload_code --- qcodes/utils/helpers.py | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/qcodes/utils/helpers.py b/qcodes/utils/helpers.py index 4ee22a1d911..22f5d194ba5 100644 --- a/qcodes/utils/helpers.py +++ b/qcodes/utils/helpers.py @@ -183,27 +183,28 @@ def safe_getattr(obj, key, attr_dict): # dependencies - this is mainly for reloading our own code. # could even whitelist site-packages items to allow, rather than to ignore? otherlib = ('jupyter', 'ipy', 'IPy', 'matplotlib', 'numpy', 'scipy', 'pyvisa', - 'traitlets', 'zmq', 'tornado', 'dateutil', 'pkg-resources', 'six', - 'pexpect') + 'traitlets', 'zmq', 'tornado', 'dateutil', 'six', 'pexpect') otherpattern = tuple('site-packages/' + n for n in otherlib) -def reload_code(pattern=None, lib=False): +def reload_code(pattern=None, lib=False, site=False): ''' reload all modules matching a given pattern or all (non-built-in) modules if pattern is omitted if lib is False (default), ignore the standard library and major packages + if site is False (default), ignore everything in site-packages, only reload + files in nonstandard paths ''' reloaded_files = [] for module in sys.modules.values(): if (pattern is None or pattern in module.__name__): - reload_recurse(module, reloaded_files, lib) + reload_recurse(module, reloaded_files, lib, site) return reloaded_files -def is_good_module(module, lib=False): +def is_good_module(module, lib=False, site=False): ''' is an object (module) a module we can reload? if lib is False (default), ignore the standard library and major packages @@ -217,8 +218,12 @@ def is_good_module(module, lib=False): if name in sys.builtin_module_names or not hasattr(module, '__file__'): return False + path = os.path.abspath(module.__file__) + + if 'site-packages' in path and not site: + return False + if not lib: - path = os.path.abspath(module.__file__) if path.startswith(stdlib) and 'site-packages' not in path: return False @@ -229,13 +234,14 @@ def is_good_module(module, lib=False): return True -def reload_recurse(module, reloaded_files, lib): +def reload_recurse(module, reloaded_files, lib, site): ''' recursively search module for its own dependencies to reload, ignoring those already in reloaded_files if lib is False (default), ignore the standard library and major packages ''' - if not is_good_module(module, lib) or module.__file__ in reloaded_files: + if (not is_good_module(module, lib, site) or + module.__file__ in reloaded_files): return reloaded_files.append(module.__file__) @@ -243,7 +249,7 @@ def reload_recurse(module, reloaded_files, lib): try: for name in dir(module): module2 = getattr(module, name) - reload_recurse(module2, reloaded_files, lib) + reload_recurse(module2, reloaded_files, lib, site) imp.reload(module) except: From 99ea312014c98776510ee33fb87746d155a3fa84 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 18 Dec 2015 22:51:24 +0100 Subject: [PATCH 23/33] unsaved local DataSet option for composite parameters --- Qcodes example.ipynb | 91 +++++++++++++++++++++++++++-------------- qcodes/data/data_set.py | 15 ++++++- qcodes/loops.py | 10 +++-- test_multi_d/chan1.dat | 64 ++++++++++++++--------------- toymodel.py | 17 +++++++- 5 files changed, 129 insertions(+), 68 deletions(-) diff --git a/Qcodes example.ipynb b/Qcodes example.ipynb index 310d1219b3d..a7477bbf16c 100644 --- a/Qcodes example.ipynb +++ b/Qcodes example.ipynb @@ -46,7 +46,7 @@ "source": [ "# spawn doesn't like function or class definitions in the interpreter\n", "# session - had to move them to a file.\n", - "from toymodel import AModel, MockGates, MockSource, MockMeter\n", + "from toymodel import AModel, MockGates, MockSource, MockMeter, AverageGetter\n", "\n", "# no extra processes running yet\n", "q.active_children()" @@ -131,9 +131,9 @@ "output_type": "stream", "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='testsweep'\n", - " amplitude: amplitude\n", " chan0: chan0\n", - "started at 2015-12-18 12:52:56\n" + " amplitude: amplitude\n", + "started at 2015-12-18 22:21:29\n" ] } ], @@ -142,7 +142,7 @@ "# the sweep values are defined by slicing the parameter object\n", "# but more complicated sweeps (eg nonlinear, or adaptive) can\n", "# easily be used instead\n", - "data = q.Loop(c0[-20:20:0.1], 0.1).run(location='testsweep')" + "data = q.Loop(c0[-20:20:0.1], 0.03).run(location='testsweep')" ] }, { @@ -183,10 +183,10 @@ " array([ 0.117, 0.117, 0.115, 0.111, 0.106, 0.099, 0.092, 0.085,\n", " 0.077, 0.071, 0.064, 0.058, 0.053, 0.048, 0.044, 0.04 ,\n", " 0.037, 0.034, 0.031, 0.029, 0.027, 0.025, 0.023, 0.022,\n", - " 0.02 , 0.019, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " 0.02 , 0.019, 0.018, 0.017, 0.016, 0.015, 0.014, 0.013,\n", + " 0.013, 0.012, 0.011, 0.011, 0.01 , 0.01 , 0.01 , 0.009,\n", + " 0.009, 0.008, 0.008, 0.008, 0.007, 0.007, 0.007, 0.007,\n", + " 0.006, 0.006, 0.006, 0.006, 0.006, 0.007, 0.007, 0.007,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -234,10 +234,10 @@ " array([-20. , -19.9, -19.8, -19.7, -19.6, -19.5, -19.4, -19.3, -19.2,\n", " -19.1, -19. , -18.9, -18.8, -18.7, -18.6, -18.5, -18.4, -18.3,\n", " -18.2, -18.1, -18. , -17.9, -17.8, -17.7, -17.6, -17.5, -17.4,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " -17.3, -17.2, -17.1, -17. , -16.9, -16.8, -16.7, -16.6, -16.5,\n", + " -16.4, -16.3, -16.2, -16.1, -16. , -15.9, -15.8, -15.7, -15.6,\n", + " -15.5, -15.4, -15.3, -15.2, -15.1, -15. , -14.9, -14.8, -14.7,\n", + " -14.6, -14.5, -14.4, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -301,7 +301,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAE4CAYAAABPOqWIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105a4ecc0>" + "<matplotlib.figure.Figure at 0x105a406a0>" ] }, "metadata": {}, @@ -338,10 +338,10 @@ "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='test2d'\n", " chan1: chan1\n", - " amplitude_0: amplitude\n", " amplitude_3: amplitude\n", " chan0: chan0\n", - "started at 2015-12-18 12:54:00\n" + " amplitude_0: amplitude\n", + "started at 2015-12-18 22:21:46\n" ] } ], @@ -367,7 +367,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAE4CAYAAACt5r7xAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAMCEZhkAACY0ywAAMPH/Aepzu1Z7lMBjAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105e9b0f0>" + "<matplotlib.figure.Figure at 0x105d56e48>" ] }, "metadata": {}, @@ -399,7 +399,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": { "collapsed": false }, @@ -408,7 +408,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nP/Vza4LvKwXJAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x10605b240>" + "<matplotlib.figure.Figure at 0x105d8c048>" ] }, "metadata": {}, @@ -431,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": { "collapsed": false }, @@ -445,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 77, "metadata": { "collapsed": false }, @@ -455,13 +455,14 @@ "output_type": "stream", "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='test_multi_d'\n", + " avg_amplitude: avg_amplitude\n", " chan2: chan2\n", - " chan1: chan1\n", - " amplitude_5_0: amplitude\n", + " chan0: chan0\n", " amplitude_2: amplitude\n", " amplitude_3_0: amplitude\n", - " chan0: chan0\n", - "started at 2015-12-18 12:55:06\n" + " chan1: chan1\n", + " amplitude_5_0: amplitude\n", + "started at 2015-12-18 22:43:52\n" ] } ], @@ -472,16 +473,17 @@ " # a 1D measurement\n", " meter.amplitude,\n", " # a 2D sweep, .each is actually unnecessary bcs this is the default measurement\n", - " q.Loop(c0[-15:15:1], 0.01).each(meter.amplitude),\n", + " q.Loop(c0[-15:15:1], 0.001).each(meter.amplitude),\n", " q.Task(c0.set, -10),\n", " # a 2D sweep with the same outer but different inner loop\n", - " q.Loop(c2[-10:10:0.2], 0.01)\n", + " q.Loop(c2[-10:10:0.2], 0.003),\n", + " AverageGetter(meter.amplitude, c2[-10:10:0.2], 0.001)\n", ").run(location='test_multi_d')" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 80, "metadata": { "collapsed": false }, @@ -490,7 +492,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUZIkSZ1ZPEqSJKkzi0dJkiR19v8BUNlV5ljvTycAAAAASUVORK5CYII=\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105ecaac8>" + "<matplotlib.figure.Figure at 0x105a796d8>" ] }, "metadata": {}, @@ -511,7 +513,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 81, "metadata": { "collapsed": false }, @@ -520,7 +522,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAE4CAYAAADPSZKbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x10674d1d0>" + "<matplotlib.figure.Figure at 0x1069658d0>" ] }, "metadata": {}, @@ -528,6 +530,7 @@ } ], "source": [ + "data3.sync()\n", "plt.figure(figsize=(12, 5))\n", "# pcolormesh needs NaN masked out or it barfs\n", "plt.pcolormesh(ma.masked_invalid(data3.chan2),\n", @@ -540,11 +543,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": { "collapsed": false, "scrolled": false }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAE4CAYAAABYGDVBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x105d51320>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data3.sync()\n", + "fig = plt.figure(figsize=(12, 5))\n", + "ax = fig.add_subplot(1,1,1)\n", + "ax.plot(data3.chan1, data3.avg_amplitude)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [] } diff --git a/qcodes/data/data_set.py b/qcodes/data/data_set.py index 733dc80ee1b..221f91282ea 100644 --- a/qcodes/data/data_set.py +++ b/qcodes/data/data_set.py @@ -22,6 +22,8 @@ class DataSet(object): what exactly this means depends on io and formatter if you omit *everything*, will try to pull location (and mode) from the live measurement + location=False means this is a temporary DataSet and + cannot be stored or read. arrays: a dict of array_id: DataArray's contained in this DataSet @@ -34,6 +36,10 @@ class DataSet(object): on calling sync(). Reverts to local if and when this DataSet stops being the live measurement + data_manager: usually omitted (default None) to get the default + DataManager. But False is different: that means do NOT connect + to any DataManager (implies mode=LOCAL) + formatter: knows how to read and write the file format io: knows how to connect to the storage (disk vs cloud etc) @@ -51,6 +57,9 @@ def __init__(self, location=None, mode=None, arrays=None, self.formatter = formatter or self.default_formatter self.io = io or self.default_io + if data_manager is False: + # you cannot set any other mode without a DataManager + mode = DataMode.LOCAL if mode is None: if arrays: # no mode but arrays provided - assume the user is doing @@ -68,7 +77,7 @@ def __init__(self, location=None, mode=None, arrays=None, for array in arrays: self.add_array(array) - if not data_manager: + if data_manager is None: data_manager = get_data_manager() if mode == DataMode.LOCAL: @@ -255,6 +264,8 @@ def read(self): ''' Read the whole DataSet from storage, overwriting the local data ''' + if self.location is False: + return self.formatter.read(self) def write(self): @@ -266,6 +277,8 @@ def write(self): raise RuntimeError('This object is connected to a DataServer ' 'and should be saved from there.') + if self.location is False: + return self.formatter.write(self) def close(self): diff --git a/qcodes/loops.py b/qcodes/loops.py index 2c2c3d5209c..1b66a6d2a32 100644 --- a/qcodes/loops.py +++ b/qcodes/loops.py @@ -355,7 +355,8 @@ def run(self, location=None, formatter=None, io=None, data_manager=None, depends on formatter and io formatter: knows how to read and write the file format io: knows how to connect to the storage (disk vs cloud etc) - data_manager: a DataManager instance (omit to use default) + data_manager: a DataManager instance (omit to use default, + False to store locally and not write to disk) background: (default True) run this sweep in a separate process so we can have live plotting and other analysis in the main process use_async: (default True): execute the sweep asynchronously as much @@ -374,9 +375,12 @@ def run(self, location=None, formatter=None, io=None, data_manager=None, else: raise RuntimeError( 'a loop is already running in the background') + if data_manager is False: + data_mode = DataMode.LOCAL + else: + data_mode = DataMode.PUSH_TO_SERVER - data_set = DataSet(arrays=self.containers(), - mode=DataMode.PUSH_TO_SERVER, + data_set = DataSet(arrays=self.containers(), mode=data_mode, data_manager=data_manager, location=location, formatter=formatter, io=io) signal_queue = mp.Queue() diff --git a/test_multi_d/chan1.dat b/test_multi_d/chan1.dat index 9924c59e9a7..70acf2e9915 100644 --- a/test_multi_d/chan1.dat +++ b/test_multi_d/chan1.dat @@ -1,33 +1,33 @@ -# chan1 amplitude_2 -# "chan1" "amplitude" +# chan1 avg_amplitude amplitude_2 +# "chan1" "Average: amplitude" "amplitude" # 30 --15 0.006 --14 0.009 --13 0.014 --12 0.027 --11 0.064 --10 0.117 --9 0.064 --8 0.027 --7 0.014 --6 0.009 --5 0.006 --4 0.009 --3 0.014 --2 0.027 --1 0.064 -0 0.117 -1 0.064 -2 0.027 -3 0.014 -4 0.009 -5 0.006 -6 0.009 -7 0.014 -8 0.027 -9 0.064 -10 0.117 -11 0.064 -12 0.027 -13 0.014 -14 0.009 +-15 1.63366 0.006 +-14 1.48254 0.009 +-13 1.3513 0.014 +-12 1.24736 0.027 +-11 1.17375 0.064 +-10 1.12666 0.117 +-9 1.17375 0.064 +-8 1.24736 0.027 +-7 1.3513 0.014 +-6 1.48254 0.009 +-5 1.63366 0.006 +-4 1.48254 0.009 +-3 1.3513 0.014 +-2 1.24736 0.027 +-1 1.17375 0.064 +0 1.12666 0.117 +1 1.17375 0.064 +2 1.24736 0.027 +3 1.3513 0.014 +4 1.48254 0.009 +5 1.63366 0.006 +6 1.48254 0.009 +7 1.3513 0.014 +8 1.24736 0.027 +9 1.17375 0.064 +10 1.12666 0.117 +11 1.17375 0.064 +12 1.24736 0.027 +13 1.3513 0.014 +14 1.48254 0.009 diff --git a/toymodel.py b/toymodel.py index ccb4feb4c9a..cc9585c1cde 100644 --- a/toymodel.py +++ b/toymodel.py @@ -2,7 +2,7 @@ import math -from qcodes import MockInstrument +from qcodes import MockInstrument, Parameter, Loop from qcodes.utils.validators import Numbers @@ -104,3 +104,18 @@ def __init__(self, name, model): self.add_parameter('amplitude', get_cmd='ampl?', parse_function=float) + + +class AverageGetter(Parameter): + def __init__(self, measured_param, sweep_values, delay): + super().__init__(name='avg_' + measured_param.name) + self.measured_param = measured_param + self.sweep_values = sweep_values + self.delay = delay + if hasattr(measured_param, 'label'): + self.label = 'Average: ' + measured_param.label + + def get(self): + loop = Loop(self.sweep_values, self.delay).each(self.measured_param) + data = loop.run(background=False, data_manager=False, location=False) + return list(data.arrays.values())[0].mean() From 1334be6256ad8a375155af1caadbd049646c678c Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 18 Dec 2015 23:48:06 +0100 Subject: [PATCH 24/33] allow __call__ for Functions --- qcodes/instrument/function.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/qcodes/instrument/function.py b/qcodes/instrument/function.py index ea39a7830d2..251ccb8322b 100644 --- a/qcodes/instrument/function.py +++ b/qcodes/instrument/function.py @@ -12,6 +12,9 @@ def __init__(self, instrument, name, call_cmd=None, async_call_cmd=None, defines a function (with arbitrary parameters) that this instrument can execute. + You execute this function object like a normal function, or use its + .call method; or call it async with the .call_async method. + instrument: an instrument that handles this function name: the local name of this parameter call_cmd: command to execute on instrument @@ -68,6 +71,10 @@ def validate(self, args): '{} is not a valid value for parameter {} of {}'.format( value, i, self.name)) + def __call__(self, *args): + self.validate(args) + return self._call(*args) + def call(self, *args): self.validate(args) return self._call(*args) From e7738e6f675098979517fb03e91c742a80c95162 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Sat, 19 Dec 2015 23:42:12 +0100 Subject: [PATCH 25/33] cleaner AverageGetter (fixes bug at very short delay times) --- toymodel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/toymodel.py b/toymodel.py index cc9585c1cde..4bbf62fe1bb 100644 --- a/toymodel.py +++ b/toymodel.py @@ -118,4 +118,4 @@ def __init__(self, measured_param, sweep_values, delay): def get(self): loop = Loop(self.sweep_values, self.delay).each(self.measured_param) data = loop.run(background=False, data_manager=False, location=False) - return list(data.arrays.values())[0].mean() + return data.arrays[self.measured_param.name].mean() From 3d13474d564694564088cfa38d4733d257399e12 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 15:54:20 +0100 Subject: [PATCH 26/33] remove method in io manager --- qcodes/data/io.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/qcodes/data/io.py b/qcodes/data/io.py index ca8ae92d6e4..98d40bd3acc 100644 --- a/qcodes/data/io.py +++ b/qcodes/data/io.py @@ -35,10 +35,14 @@ IO managers should also implement: - a join method, ala os.path.join(*args). - a list method, that returns all objects matching location +- a remove method, ala os.remove(path) except that it will remove directories + as well as files, since we're allowing "locations" to be directories + or files. ''' from contextlib import contextmanager import os +import shutil ALLOWED_OPEN_MODES = ('r', 'w', 'a') @@ -135,6 +139,13 @@ def list(self, location, maxdepth=1): return out + def remove(self, filename): + path = self._add_base(filename) + if(os.path.isdir(path)): + shutil.rmtree(path) + else: + os.remove(path) + class FileWrapper(object): def read(self, size=None): From 7153b3fbb7bd2b94c050b4ff03865d17ae527d6f Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 15:56:26 +0100 Subject: [PATCH 27/33] gnuplotformat: remove data files that shouldn't be there on write --- qcodes/data/format.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/qcodes/data/format.py b/qcodes/data/format.py index 315a2fece34..5245efff3ab 100644 --- a/qcodes/data/format.py +++ b/qcodes/data/format.py @@ -415,10 +415,9 @@ def write(self, data_set): extra_files = existing_files - written_files if extra_files: - # TODO log this? Doesn't seem like it should raise, but we want - # to know about it somehow. If this data set is read back in, it - # will get the extra files included. - pass + print('removing obsolete files: ' + ','.join(extra_files)) + for fn in extra_files: + io_manager.remove(fn) def _make_header(self, group): ids, labels = [], [] From 33300f8d332be4ff113ebf1f4a146f69732d6ce8 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 15:57:43 +0100 Subject: [PATCH 28/33] more robust handling of writing into multi-dimensional datasets --- qcodes/data/format.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/qcodes/data/format.py b/qcodes/data/format.py index 5245efff3ab..0a6f78718a6 100644 --- a/qcodes/data/format.py +++ b/qcodes/data/format.py @@ -151,23 +151,27 @@ def group_arrays(self, arrays): ''' find the sets of arrays which share all the same setpoint arrays so each set can be grouped together into one file - returns dimension list, set_array list, and data_array list + returns ArrayGroup namedtuples ''' - all_set_arrays = tuple(set(array.set_arrays + set_array_sets = tuple(set(array.set_arrays for array in arrays.values())) - grouped_data = [[] for _ in all_set_arrays] + all_set_arrays = set() + for set_array_set in set_array_sets: + all_set_arrays.update(set_array_set) + + grouped_data = [[] for _ in set_array_sets] for array in arrays.values(): - i = all_set_arrays.index(array.set_arrays) - if array.set_arrays[-1] != array: + i = set_array_sets.index(array.set_arrays) + if array not in all_set_arrays: # array.set_arrays[-1] != array: # don't include the setpoint array itself in the data grouped_data[i].append(array) out = [] - for set_arrays, data in zip(all_set_arrays, grouped_data): + for set_arrays, data in zip(set_array_sets, grouped_data): leni = len(set_arrays) - if not data and any(1 for other_set_arrays in all_set_arrays if + if not data and any(1 for other_set_arrays in set_array_sets if len(other_set_arrays) > leni and other_set_arrays[:leni] == set_arrays): # this is an outer loop that doesn't have any data of its own, From f1b0af13236ca334ca6e44107d922e5700092456 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 15:59:14 +0100 Subject: [PATCH 29/33] always reload twice --- qcodes/utils/helpers.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/qcodes/utils/helpers.py b/qcodes/utils/helpers.py index 22f5d194ba5..821ae7c73e2 100644 --- a/qcodes/utils/helpers.py +++ b/qcodes/utils/helpers.py @@ -197,9 +197,13 @@ def reload_code(pattern=None, lib=False, site=False): ''' reloaded_files = [] - for module in sys.modules.values(): - if (pattern is None or pattern in module.__name__): - reload_recurse(module, reloaded_files, lib, site) + for i in range(2): + # sometimes we need to reload twice to propagate all links, + # even though we reload the deepest modules first. Not sure if + # twice is always sufficient, but we'll try it. + for module in sys.modules.values(): + if (pattern is None or pattern in module.__name__): + reload_recurse(module, reloaded_files, lib, site) return reloaded_files From 4d42167ac3c7ff1e4e1e1cc3142d74765fce1c8a Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 16:04:19 +0100 Subject: [PATCH 30/33] close data_set even if there's an error in the loop --- qcodes/loops.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/qcodes/loops.py b/qcodes/loops.py index 1b66a6d2a32..69bae179114 100644 --- a/qcodes/loops.py +++ b/qcodes/loops.py @@ -388,7 +388,9 @@ def run(self, location=None, formatter=None, io=None, data_manager=None, if use_async: raise NotImplementedError # TODO - loop_fn = mock_sync(self._async_loop) if use_async else self._run_loop + loop_fn = mock_sync(self._async_loop) + else: + loop_fn = self._run_wrapper if background: # TODO: in notebooks, errors in a background sweep will just appear @@ -439,6 +441,13 @@ def _compile_one(self, action, new_action_indices): else: raise TypeError('unrecognized action', action) + def _run_wrapper(self, *args, **kwargs): + try: + self._run_loop(*args, **kwargs) + finally: + if(hasattr(self, 'data_set') and hasattr(self.data_set, 'close')): + self.data_set.close() + def _run_loop(self, first_delay=0, action_indices=(), loop_indices=(), current_values=(), **ignore_kwargs): @@ -482,9 +491,6 @@ def _run_loop(self, first_delay=0, action_indices=(), # after the first setpoint, delay reverts to the loop delay delay = self.delay - if not current_values: - self.data_set.close() - def _wait(self, delay): finish_datetime = datetime.now() + timedelta(seconds=delay) From 35ee49b17695b99ff4a9aca77cd0eb22e688ebb2 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 16:05:03 +0100 Subject: [PATCH 31/33] support varying dimensions & sizes returned by a single parameter --- Qcodes example.ipynb | 164 +- decorators.py | 32 + qcodes/data/data_array.py | 33 +- qcodes/instrument/base.py | 2 +- qcodes/instrument/parameter.py | 36 +- qcodes/loops.py | 124 +- test_complex_param/chan1.dat | 33 + test_complex_param/chan1_chan2.dat | 3032 ++++++++++++++++++++++++++++ test_multi_d/chan1.dat | 64 +- test_multi_d/chan1_chan0.dat | 2 +- toymodel.py | 28 +- 11 files changed, 3398 insertions(+), 152 deletions(-) create mode 100644 decorators.py create mode 100644 test_complex_param/chan1.dat create mode 100644 test_complex_param/chan1_chan2.dat diff --git a/Qcodes example.ipynb b/Qcodes example.ipynb index a7477bbf16c..6b3e96fefba 100644 --- a/Qcodes example.ipynb +++ b/Qcodes example.ipynb @@ -12,6 +12,7 @@ "import matplotlib.pyplot as plt\n", "import time\n", "from IPython import display\n", + "import numpy.ma as ma\n", "\n", "# load the qcodes path, until we have this installed as a package\n", "import sys\n", @@ -46,7 +47,7 @@ "source": [ "# spawn doesn't like function or class definitions in the interpreter\n", "# session - had to move them to a file.\n", - "from toymodel import AModel, MockGates, MockSource, MockMeter, AverageGetter\n", + "from toymodel import AModel, MockGates, MockSource, MockMeter, AverageGetter, AverageAndRaw\n", "\n", "# no extra processes running yet\n", "q.active_children()" @@ -133,7 +134,7 @@ "DataSet: DataMode.PULL_FROM_SERVER, location='testsweep'\n", " chan0: chan0\n", " amplitude: amplitude\n", - "started at 2015-12-18 22:21:29\n" + "started at 2016-01-08 15:48:47\n" ] } ], @@ -187,16 +188,16 @@ " 0.013, 0.012, 0.011, 0.011, 0.01 , 0.01 , 0.01 , 0.009,\n", " 0.009, 0.008, 0.008, 0.008, 0.007, 0.007, 0.007, 0.007,\n", " 0.006, 0.006, 0.006, 0.006, 0.006, 0.007, 0.007, 0.007,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan,\n", + " 0.007, 0.008, 0.008, 0.008, 0.009, 0.009, 0.01 , 0.01 ,\n", + " 0.01 , 0.011, 0.011, 0.012, 0.013, 0.013, 0.014, 0.015,\n", + " 0.016, 0.017, 0.018, 0.019, 0.02 , 0.022, 0.023, 0.025,\n", + " 0.027, 0.029, 0.031, 0.034, 0.037, 0.04 , 0.044, 0.048,\n", + " 0.053, 0.058, 0.064, 0.071, 0.077, 0.085, 0.092, 0.099,\n", + " 0.106, 0.111, 0.115, 0.117, 0.117, 0.117, 0.115, 0.111,\n", + " 0.106, 0.099, 0.092, 0.085, 0.077, 0.071, 0.064, 0.058,\n", + " 0.053, 0.048, 0.044, 0.04 , 0.037, 0.034, 0.031, 0.029,\n", + " 0.027, 0.025, 0.023, 0.022, 0.02 , 0.019, 0.018, 0.017,\n", + " 0.016, 0.015, 0.014, 0.013, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -237,15 +238,15 @@ " -17.3, -17.2, -17.1, -17. , -16.9, -16.8, -16.7, -16.6, -16.5,\n", " -16.4, -16.3, -16.2, -16.1, -16. , -15.9, -15.8, -15.7, -15.6,\n", " -15.5, -15.4, -15.3, -15.2, -15.1, -15. , -14.9, -14.8, -14.7,\n", - " -14.6, -14.5, -14.4, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " -14.6, -14.5, -14.4, -14.3, -14.2, -14.1, -14. , -13.9, -13.8,\n", + " -13.7, -13.6, -13.5, -13.4, -13.3, -13.2, -13.1, -13. , -12.9,\n", + " -12.8, -12.7, -12.6, -12.5, -12.4, -12.3, -12.2, -12.1, -12. ,\n", + " -11.9, -11.8, -11.7, -11.6, -11.5, -11.4, -11.3, -11.2, -11.1,\n", + " -11. , -10.9, -10.8, -10.7, -10.6, -10.5, -10.4, -10.3, -10.2,\n", + " -10.1, -10. , -9.9, -9.8, -9.7, -9.6, -9.5, -9.4, -9.3,\n", + " -9.2, -9.1, -9. , -8.9, -8.8, -8.7, -8.6, -8.5, -8.4,\n", + " -8.3, -8.2, -8.1, -8. , -7.9, -7.8, -7.7, -7.6, -7.5,\n", + " -7.4, -7.3, -7.2, -7.1, -7. , -6.9, -6.8, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", " nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", @@ -301,7 +302,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAE4CAYAAABPOqWIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105a406a0>" + "<matplotlib.figure.Figure at 0x105a3da90>" ] }, "metadata": {}, @@ -337,11 +338,11 @@ "output_type": "stream", "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='test2d'\n", - " chan1: chan1\n", - " amplitude_3: amplitude\n", " chan0: chan0\n", " amplitude_0: amplitude\n", - "started at 2015-12-18 22:21:46\n" + " chan1: chan1\n", + " amplitude_3: amplitude\n", + "started at 2016-01-08 15:49:10\n" ] } ], @@ -367,7 +368,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAE4CAYAAACt5r7xAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAMCEZhkAACY0ywAAMPH/Aepzu1Z7lMBjAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105d56e48>" + "<matplotlib.figure.Figure at 0x105a80710>" ] }, "metadata": {}, @@ -375,8 +376,6 @@ } ], "source": [ - "import numpy.ma as ma\n", - "\n", "fig = plt.figure(figsize=(12, 5))\n", "ax = fig.add_subplot(1,1,1)\n", "\n", @@ -408,7 +407,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nP/Vza4LvKwXJAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105d8c048>" + "<matplotlib.figure.Figure at 0x105c7d470>" ] }, "metadata": {}, @@ -445,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 13, "metadata": { "collapsed": false }, @@ -455,14 +454,14 @@ "output_type": "stream", "text": [ "DataSet: DataMode.PULL_FROM_SERVER, location='test_multi_d'\n", + " amplitude_5_0: amplitude\n", + " amplitude_2: amplitude\n", " avg_amplitude: avg_amplitude\n", " chan2: chan2\n", - " chan0: chan0\n", - " amplitude_2: amplitude\n", " amplitude_3_0: amplitude\n", + " chan0: chan0\n", " chan1: chan1\n", - " amplitude_5_0: amplitude\n", - "started at 2015-12-18 22:43:52\n" + "started at 2016-01-08 15:49:54\n" ] } ], @@ -476,23 +475,23 @@ " q.Loop(c0[-15:15:1], 0.001).each(meter.amplitude),\n", " q.Task(c0.set, -10),\n", " # a 2D sweep with the same outer but different inner loop\n", - " q.Loop(c2[-10:10:0.2], 0.003),\n", + " q.Loop(c2[-10:10:0.2], 0.001),\n", " AverageGetter(meter.amplitude, c2[-10:10:0.2], 0.001)\n", ").run(location='test_multi_d')" ] }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUZIkSZ1ZPEqSJKkzi0dJkiR19v8BUNlV5ljvTycAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAE4CAYAAAA6txkrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105a796d8>" + "<matplotlib.figure.Figure at 0x105c90278>" ] }, "metadata": {}, @@ -513,7 +512,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 17, "metadata": { "collapsed": false }, @@ -522,7 +521,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAE4CAYAAADPSZKbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x1069658d0>" + "<matplotlib.figure.Figure at 0x105c797f0>" ] }, "metadata": {}, @@ -543,7 +542,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 18, "metadata": { "collapsed": false, "scrolled": false @@ -553,7 +552,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAE4CAYAAABYGDVBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", "text/plain": [ - "<matplotlib.figure.Figure at 0x105d51320>" + "<matplotlib.figure.Figure at 0x10639f470>" ] }, "metadata": {}, @@ -570,12 +569,85 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { - "collapsed": true + "collapsed": false, + "scrolled": false }, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet: DataMode.PUSH_TO_SERVER, location='test_complex_param'\n", + " avg_amplitude: avg_amplitude\n", + " amplitude: amplitude\n", + " chan1: chan1\n", + " chan2: chan2\n", + "started at 2016-01-08 15:50:32\n" + ] + } + ], + "source": [ + "# An example of a parameter that returns several values of different dimension\n", + "# This produces the last two arrays from data3, but only takes the data once.\n", + "data4 = q.Loop(c1[-15:15:1], 0.1).each(\n", + " AverageAndRaw(meter.amplitude, c2[-10:10:0.2], 0.001)\n", + ").run(location='test_complex_param', background=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAE4CAYAAADPSZKbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x10667c278>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 5))\n", + "plt.pcolormesh(ma.masked_invalid(data4.chan2),\n", + " ma.masked_invalid(data4.chan1),\n", + " ma.masked_invalid(data4.amplitude),\n", + " cmap=plt.cm.hot)\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAE4CAYAAABYGDVBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x105cc1470>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(12, 5))\n", + "ax = fig.add_subplot(1,1,1)\n", + "ax.plot(data4.chan1, data4.avg_amplitude)\n", + "plt.show()" + ] } ], "metadata": { diff --git a/decorators.py b/decorators.py new file mode 100644 index 00000000000..99f66778293 --- /dev/null +++ b/decorators.py @@ -0,0 +1,32 @@ +import numpy as np + +class printout(object): + ''' + a class-based decorator - so it's picklable. + ''' + def __init__(self, header): + self.header = header + + def _out(self, *args, **kwargs): + out = self.f(*args, **kwargs) + print(self.header, out) + return out + + def __call__(self, f): + self.f = f + return self._out + + +@printout('???') +def mult(a, b): + return a * b + + +def add_to_numpy(key, val): + np.edited_by_aj = True + setattr(np, key, val) + + +if __name__ == '__main__': + ret = mult(4, 4) + print(ret) diff --git a/qcodes/data/data_array.py b/qcodes/data/data_array.py index af0a63155b9..a32d66c05cd 100644 --- a/qcodes/data/data_array.py +++ b/qcodes/data/data_array.py @@ -1,4 +1,7 @@ import numpy as np +import collections + +import qcodes class DataArray(object): @@ -15,12 +18,13 @@ class DataArray(object): when it's first created, a DataArray has no dimensionality, you must call .nest for each dimension. - if preset_data is provided (a numpy array matching size) it is used to - initialize the data, and the array can still be nested around it. + if preset_data is provided it is used to initialize the data, and the array + can still be nested around it (making many copies of the data). Otherwise it is an error to nest an array that already has data. ''' def __init__(self, parameter=None, name=None, label=None, array_id=None, - set_arrays=(), size=(), action_indices=(), preset_data=None): + set_arrays=(), size=None, action_indices=(), + preset_data=None): if parameter is not None: self.name = parameter.name self.label = getattr(parameter, 'label', self.name) @@ -34,8 +38,10 @@ def __init__(self, parameter=None, name=None, label=None, array_id=None, self._preset = False self.data = None - if size: + if preset_data is not None: self.init_data(preset_data) + elif size is None: + self.size = () self.action_indices = action_indices self.last_saved_index = None @@ -54,7 +60,7 @@ def nest(self, size, action_index=None, set_array=None): ''' if self.data is not None and not self._preset: raise RuntimeError('Only preset arrays can be nested after data ' - 'is initialized.') + 'is initialized! {}'.format(self)) if set_array is None: if self.set_arrays: @@ -86,9 +92,20 @@ def init_data(self, data=None): meaning it can still be nested around this data. ''' if data is not None: - if data.shape != self.size: - raise ValueError('preset data must be a numpy array ' - 'with size matching the array size') + if not isinstance(data, np.ndarray): + if isinstance(data, collections.Iterator): + # faster than np.array(tuple(data)) (or via list) + # but requires us to assume float + data = np.fromiter(data, float) + else: + data = np.array(data) + + if self.size is None: + self.size = data.shape + elif data.shape != self.size: + raise ValueError('preset data must be a sequence ' + 'with size matching the array size', + data.shape, self.size) self.data = data self._preset = True elif self.data is not None: diff --git a/qcodes/instrument/base.py b/qcodes/instrument/base.py index 9aa89c277a7..14e94ef414a 100644 --- a/qcodes/instrument/base.py +++ b/qcodes/instrument/base.py @@ -31,7 +31,7 @@ def add_parameter(self, name, **kwargs): anything the user can set and/or get `name` is how the InstrumentParameter will be stored within - instrument.parameters and also how you address it using the + instrument.parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc. diff --git a/qcodes/instrument/parameter.py b/qcodes/instrument/parameter.py index 411614ce294..936ad04d95e 100644 --- a/qcodes/instrument/parameter.py +++ b/qcodes/instrument/parameter.py @@ -53,8 +53,8 @@ class Parameter(Metadatable): def __init__(self, name=None, names=None, label=None, labels=None, - size=None, setpoints=None, - setpoint_names=None, setpoint_labels=None, + size=None, sizes=None, + setpoints=None, setpoint_names=None, setpoint_labels=None, vals=None, **kwargs): ''' defines one generic parameter, not necessarily part of @@ -73,6 +73,7 @@ def __init__(self, was acquired in the hardware and all sent to the computer at once) 4. 2 & 3 together: a sequence of arrays. All arrays should be the same size. + 5. a sequence of differently sized items Because .set only supports a single value, if a Parameter is both gettable AND settable, .get should return a single value too (case 1) @@ -81,27 +82,36 @@ def __init__(self, name: (1&3) the local name of this parameter, should be a valid identifier, ie no spaces or special characters - names: (2&4) a tuple of names + names: (2,4,5) a tuple of names label: (1&3) string to use as an axis label for this parameter defaults to name - labels: (2&4) a tuple of labels + labels: (2,4,5) a tuple of labels size: (3&4) an integer or tuple of integers for the size of array returned by .get(). Can be an integer only if the array is 1D, but as a tuple it can describe any dimensionality (including 1D) If size is an integer then setpoints, setpoint_names, and setpoint_labels should also not be wrapped in tuples. - setpoints: (3&4) the setpoints for the returned array of values. - The first array should be 1D, the second 2D, etc. + sizes: (5) a tuple of integers or tuples, each one as in `size`. + + setpoints: (3,4,5) the setpoints for the returned array of values. + 3&4 - This should be an array if `size` is an integer, or a + tuple of arrays if `size` is a tuple + The first array should be 1D, the second 2D, etc. + 5 - This should be a tuple of arrays or tuples, each item as above + Single values should be denoted by None or (), not 1 (because 1 + would be a length-1 array) Defaults to integers from zero in each respective direction Each may be either a DataArray, a numpy array, or a sequence (sequences will be converted to numpy arrays) NOTE: if the setpoints will be different each measurement, leave this out and return the setpoints (with extra names) in the get. - setpoint_names: (3&4) one identifier (like name) per setpoint array. - Ignored if setpoints are DataArrays, which already have names. - setpoint_labels: (3&4) one label (like label above) per setpoint array. + setpoint_names: (3,4,5) one identifier (like `name`) per setpoint + array. + Ignored if `setpoints` are DataArrays, which already have names. + setpoint_labels: (3&4) one label (like `label`) per setpoint array. + Overridden if `setpoints` are DataArrays and already have labels. vals: allowed values for setting this parameter (only relevant if it has a setter) @@ -123,8 +133,12 @@ def __init__(self, else: raise ValueError('either name or names is required') - if size is not None: - self.size = size + if size is not None or sizes is not None: + if size is not None: + self.size = size + else: + self.sizes = sizes + self.setpoints = setpoints self.setpoint_names = setpoint_names self.setpoint_labels = setpoint_labels diff --git a/qcodes/loops.py b/qcodes/loops.py index 69bae179114..1c271e9cf0f 100644 --- a/qcodes/loops.py +++ b/qcodes/loops.py @@ -230,62 +230,87 @@ def containers(self): def _parameter_arrays(self, action): out = [] - size = getattr(action, 'size', ()) - if isinstance(size, int): - size = (size,) - sp_blank = None - else: - size = tuple(size) - sp_blank = (None,) * len(size) - - ndim = len(size) - if ndim: - for dim in self.size: - if not isinstance(dim, int) or dim <= 0: - raise ValueError('size must consist of positive ' - 'integers, not ' + repr(dim)) - sp_vals = getattr(action, 'setpoints', sp_blank) - sp_names = getattr(action, 'sp_names', sp_blank) - sp_labels = getattr(action, 'sp_labels', sp_blank) - - if sp_blank is None: - sp_vals = (sp_vals,) - sp_names = (sp_names,) - sp_labels = (sp_labels,) - - if (len(sp_vals) != ndim or len(sp_names) != ndim or - len(sp_labels) != ndim): - raise ValueError('Wrong number of setpoint, setpoint names, ' - 'or setpoint labels provided') - - for i, sp in enumerate(zip(sp_vals, sp_names, sp_labels)): - out.append(self._make_setpoint_array(size, i, tuple(out), *sp)) - else: - setpoints = () - + # first massage all the input parameters to the general multi-name form if hasattr(action, 'names'): names = action.names labels = getattr(action, 'labels', names) - for i, (name, label) in enumerate(zip(names, labels)): - out.append(DataArray(name=name, label=label, size=size, - action_indices=(i,), set_arrays=setpoints)) - + if len(labels) != len(names): + raise ValueError('must have equal number of names and labels') + action_indices = tuple((i,) for i in range(len(names))) elif hasattr(action, 'name'): - name = action.name - label = getattr(action, 'label', name) - out.append(DataArray(name=name, label=label, size=size, - action_indices=(), set_arrays=setpoints)) - + names = (action.name,) + labels = (getattr(action, 'label', action.name),) + action_indices = ((),) else: raise ValueError('a gettable parameter must have .name or .names') + num_arrays = len(names) + sizes = getattr(action, 'sizes', None) + sp_vals = getattr(action, 'setpoints', None) + sp_names = getattr(action, 'setpoint_names', None) + sp_labels = getattr(action, 'setpoint_labels', None) + + if sizes is None: + sizes = (getattr(action, 'size', ()),) * num_arrays + sp_vals = (sp_vals,) * num_arrays + sp_names = (sp_names,) * num_arrays + sp_labels = (sp_labels,) * num_arrays + else: + sp_blank = (None,) * num_arrays + # _fill_blank both supplies defaults and tests length + # if values are supplied (for sizes it ONLY tests length) + sizes = self._fill_blank(sizes, sp_blank) + sp_vals = self._fill_blank(sp_vals, sp_blank) + sp_names = self._fill_blank(sp_names, sp_blank) + sp_labels = self._fill_blank(sp_labels, sp_blank) + + # now loop through these all, to make the DataArrays + # record which setpoint arrays we've made, so we don't duplicate + all_setpoints = {} + for name, label, size, i, sp_vi, sp_ni, sp_li in zip( + names, labels, sizes, action_indices, + sp_vals, sp_names, sp_labels): + + # convert the integer form of each size etc. to the tuple form + if isinstance(size, int): + size = (size,) + sp_vi = (sp_vi,) + sp_ni = (sp_ni,) + sp_li = (sp_li,) + elif size is None or size == (): + size, sp_vi, sp_ni, sp_li = (), (), (), () + else: + sp_blank = (None,) * len(size) + sp_vi = self._fill_blank(sp_vi, sp_blank) + sp_ni = self._fill_blank(sp_ni, sp_blank) + sp_li = self._fill_blank(sp_li, sp_blank) + + setpoints = () + # loop through dimensions of size to make the setpoint arrays + for j, (vij, nij, lij) in enumerate(zip(sp_vi, sp_ni, sp_li)): + sp_def = (size[: 1 + j], j, setpoints, vij, nij, lij) + if sp_def not in all_setpoints: + all_setpoints[sp_def] = self._make_setpoint_array(*sp_def) + out.append(all_setpoints[sp_def]) + setpoints = setpoints + (all_setpoints[sp_def],) + + # finally, make the output data array with these setpoints + out.append(DataArray(name=name, label=label, size=size, + action_indices=i, set_arrays=setpoints)) + return out - def _make_setpoint_array(self, size, i, prev_setpoints, vals, name, label): - this_size = size[: i + 1] + def _fill_blank(self, inputs, blanks): + if inputs is None: + return blanks + elif len(inputs) == len(blanks): + return inputs + else: + raise ValueError('Wrong number of inputs supplied') + def _make_setpoint_array(self, size, i, prev_setpoints, vals, name, label): if vals is None: - vals = self._default_setpoints(this_size) + vals = self._default_setpoints(size) elif isinstance(vals, DataArray): # can't simply use the DataArray, even though that's # what we're going to return here, because it will @@ -303,18 +328,15 @@ def _make_setpoint_array(self, size, i, prev_setpoints, vals, name, label): # turn any sequence into a (new) numpy array vals = np.array(vals) - if vals.shape != this_size: + if vals.shape != size: raise ValueError('nth setpoint array should have size matching ' 'the first n dimensions of size.') if name is None: - if len(size) > 1: - name = 'index{}'.format(i + 1) - else: - name = 'index' + name = 'index{}'.format(i) return DataArray(name=name, label=label, set_arrays=prev_setpoints, - size=this_size, preset_data=vals) + size=size, preset_data=vals) def _default_setpoints(self, size): if len(size) == 1: diff --git a/test_complex_param/chan1.dat b/test_complex_param/chan1.dat new file mode 100644 index 00000000000..95bee0aa8df --- /dev/null +++ b/test_complex_param/chan1.dat @@ -0,0 +1,33 @@ +# chan1 avg_amplitude +# "chan1" "Average: amplitude" +# 30 +-15 1.63366 +-14 1.48254 +-13 1.3513 +-12 1.24736 +-11 1.17375 +-10 1.12666 +-9 1.17375 +-8 1.24736 +-7 1.3513 +-6 1.48254 +-5 1.63366 +-4 1.48254 +-3 1.3513 +-2 1.24736 +-1 1.17375 +0 1.12666 +1 1.17375 +2 1.24736 +3 1.3513 +4 1.48254 +5 1.63366 +6 1.48254 +7 1.3513 +8 1.24736 +9 1.17375 +10 1.12666 +11 1.17375 +12 1.24736 +13 1.3513 +14 1.48254 diff --git a/test_complex_param/chan1_chan2.dat b/test_complex_param/chan1_chan2.dat new file mode 100644 index 00000000000..dc37b2602a3 --- /dev/null +++ b/test_complex_param/chan1_chan2.dat @@ -0,0 +1,3032 @@ +# chan1 chan2 amplitude +# "chan1" "chan2" "amplitude" +# 30 100 +-15 -10 3.362 +-15 -9.8 3.253 +-15 -9.6 3.148 +-15 -9.4 3.047 +-15 -9.2 2.95 +-15 -9 2.858 +-15 -8.8 2.771 +-15 -8.6 2.689 +-15 -8.4 2.613 +-15 -8.2 2.544 +-15 -8 2.483 +-15 -7.8 2.43 +-15 -7.6 2.388 +-15 -7.4 2.357 +-15 -7.2 2.339 +-15 -7 2.339 +-15 -6.8 2.359 +-15 -6.6 2.402 +-15 -6.4 2.475 +-15 -6.2 2.581 +-15 -6 2.721 +-15 -5.8 2.889 +-15 -5.6 3.062 +-15 -5.4 3.188 +-15 -5.2 3.192 +-15 -5 3.01 +-15 -4.8 2.644 +-15 -4.6 2.177 +-15 -4.4 1.709 +-15 -4.2 1.306 +-15 -4 0.985 +-15 -3.8 0.741 +-15 -3.6 0.559 +-15 -3.4 0.424 +-15 -3.2 0.323 +-15 -3 0.247 +-15 -2.8 0.19 +-15 -2.6 0.146 +-15 -2.4 0.112 +-15 -2.2 0.086 +-15 -2 0.066 +-15 -1.8 0.051 +-15 -1.6 0.039 +-15 -1.4 0.029 +-15 -1.2 0.022 +-15 -1 0.017 +-15 -0.8 0.013 +-15 -0.6 0.01 +-15 -0.4 0.008 +-15 -0.2 0.007 +-15 0 0.006 +-15 0.2 0.007 +-15 0.4 0.008 +-15 0.6 0.01 +-15 0.8 0.013 +-15 1 0.017 +-15 1.2 0.022 +-15 1.4 0.029 +-15 1.6 0.039 +-15 1.8 0.051 +-15 2 0.066 +-15 2.2 0.086 +-15 2.4 0.112 +-15 2.6 0.146 +-15 2.8 0.19 +-15 3 0.247 +-15 3.2 0.323 +-15 3.4 0.424 +-15 3.6 0.559 +-15 3.8 0.741 +-15 4 0.985 +-15 4.2 1.306 +-15 4.4 1.709 +-15 4.6 2.177 +-15 4.8 2.644 +-15 5 3.01 +-15 5.2 3.192 +-15 5.4 3.188 +-15 5.6 3.062 +-15 5.8 2.889 +-15 6 2.721 +-15 6.2 2.581 +-15 6.4 2.475 +-15 6.6 2.402 +-15 6.8 2.359 +-15 7 2.339 +-15 7.2 2.339 +-15 7.4 2.357 +-15 7.6 2.388 +-15 7.8 2.43 +-15 8 2.483 +-15 8.2 2.544 +-15 8.4 2.613 +-15 8.6 2.689 +-15 8.8 2.771 +-15 9 2.858 +-15 9.2 2.95 +-15 9.4 3.047 +-15 9.6 3.148 +-15 9.8 3.253 + +-14 -10 3.279 +-14 -9.8 3.163 +-14 -9.6 3.05 +-14 -9.4 2.94 +-14 -9.2 2.833 +-14 -9 2.73 +-14 -8.8 2.63 +-14 -8.6 2.533 +-14 -8.4 2.44 +-14 -8.2 2.351 +-14 -8 2.265 +-14 -7.8 2.184 +-14 -7.6 2.108 +-14 -7.4 2.036 +-14 -7.2 1.97 +-14 -7 1.91 +-14 -6.8 1.857 +-14 -6.6 1.811 +-14 -6.4 1.773 +-14 -6.2 1.746 +-14 -6 1.731 +-14 -5.8 1.73 +-14 -5.6 1.745 +-14 -5.4 1.779 +-14 -5.2 1.835 +-14 -5 1.912 +-14 -4.8 2.005 +-14 -4.6 2.097 +-14 -4.4 2.152 +-14 -4.2 2.122 +-14 -4 1.968 +-14 -3.8 1.699 +-14 -3.6 1.372 +-14 -3.4 1.055 +-14 -3.2 0.788 +-14 -3 0.58 +-14 -2.8 0.425 +-14 -2.6 0.311 +-14 -2.4 0.228 +-14 -2.2 0.168 +-14 -2 0.124 +-14 -1.8 0.091 +-14 -1.6 0.067 +-14 -1.4 0.049 +-14 -1.2 0.036 +-14 -1 0.027 +-14 -0.8 0.02 +-14 -0.6 0.015 +-14 -0.4 0.012 +-14 -0.2 0.01 +-14 0 0.009 +-14 0.2 0.01 +-14 0.4 0.012 +-14 0.6 0.015 +-14 0.8 0.02 +-14 1 0.027 +-14 1.2 0.036 +-14 1.4 0.049 +-14 1.6 0.067 +-14 1.8 0.091 +-14 2 0.124 +-14 2.2 0.168 +-14 2.4 0.228 +-14 2.6 0.311 +-14 2.8 0.425 +-14 3 0.58 +-14 3.2 0.788 +-14 3.4 1.055 +-14 3.6 1.372 +-14 3.8 1.699 +-14 4 1.968 +-14 4.2 2.122 +-14 4.4 2.152 +-14 4.6 2.097 +-14 4.8 2.005 +-14 5 1.912 +-14 5.2 1.835 +-14 5.4 1.779 +-14 5.6 1.745 +-14 5.8 1.73 +-14 6 1.731 +-14 6.2 1.746 +-14 6.4 1.773 +-14 6.6 1.811 +-14 6.8 1.857 +-14 7 1.91 +-14 7.2 1.97 +-14 7.4 2.036 +-14 7.6 2.108 +-14 7.8 2.184 +-14 8 2.265 +-14 8.2 2.351 +-14 8.4 2.44 +-14 8.6 2.533 +-14 8.8 2.63 +-14 9 2.73 +-14 9.2 2.833 +-14 9.4 2.94 +-14 9.6 3.05 +-14 9.8 3.163 + +-13 -10 3.232 +-13 -9.8 3.113 +-13 -9.6 2.996 +-13 -9.4 2.882 +-13 -9.2 2.771 +-13 -9 2.663 +-13 -8.8 2.557 +-13 -8.6 2.454 +-13 -8.4 2.355 +-13 -8.2 2.258 +-13 -8 2.164 +-13 -7.8 2.073 +-13 -7.6 1.986 +-13 -7.4 1.901 +-13 -7.2 1.82 +-13 -7 1.743 +-13 -6.8 1.669 +-13 -6.6 1.599 +-13 -6.4 1.533 +-13 -6.2 1.471 +-13 -6 1.414 +-13 -5.8 1.361 +-13 -5.6 1.315 +-13 -5.4 1.275 +-13 -5.2 1.242 +-13 -5 1.216 +-13 -4.8 1.2 +-13 -4.6 1.195 +-13 -4.4 1.201 +-13 -4.2 1.22 +-13 -4 1.25 +-13 -3.8 1.288 +-13 -3.6 1.321 +-13 -3.4 1.328 +-13 -3.2 1.28 +-13 -3 1.158 +-13 -2.8 0.973 +-13 -2.6 0.763 +-13 -2.4 0.569 +-13 -2.2 0.41 +-13 -2 0.291 +-13 -1.8 0.204 +-13 -1.6 0.143 +-13 -1.4 0.1 +-13 -1.2 0.07 +-13 -1 0.05 +-13 -0.8 0.035 +-13 -0.6 0.026 +-13 -0.4 0.02 +-13 -0.2 0.016 +-13 0 0.014 +-13 0.2 0.016 +-13 0.4 0.02 +-13 0.6 0.026 +-13 0.8 0.035 +-13 1 0.05 +-13 1.2 0.07 +-13 1.4 0.1 +-13 1.6 0.143 +-13 1.8 0.204 +-13 2 0.291 +-13 2.2 0.41 +-13 2.4 0.569 +-13 2.6 0.763 +-13 2.8 0.973 +-13 3 1.158 +-13 3.2 1.28 +-13 3.4 1.328 +-13 3.6 1.321 +-13 3.8 1.288 +-13 4 1.25 +-13 4.2 1.22 +-13 4.4 1.201 +-13 4.6 1.195 +-13 4.8 1.2 +-13 5 1.216 +-13 5.2 1.242 +-13 5.4 1.275 +-13 5.6 1.315 +-13 5.8 1.361 +-13 6 1.414 +-13 6.2 1.471 +-13 6.4 1.533 +-13 6.6 1.599 +-13 6.8 1.669 +-13 7 1.743 +-13 7.2 1.82 +-13 7.4 1.901 +-13 7.6 1.986 +-13 7.8 2.073 +-13 8 2.164 +-13 8.2 2.258 +-13 8.4 2.355 +-13 8.6 2.454 +-13 8.8 2.557 +-13 9 2.663 +-13 9.2 2.771 +-13 9.4 2.882 +-13 9.6 2.996 +-13 9.8 3.113 + +-12 -10 3.203 +-12 -9.8 3.082 +-12 -9.6 2.964 +-12 -9.4 2.848 +-12 -9.2 2.735 +-12 -9 2.624 +-12 -8.8 2.516 +-12 -8.6 2.411 +-12 -8.4 2.308 +-12 -8.2 2.208 +-12 -8 2.111 +-12 -7.8 2.016 +-12 -7.6 1.924 +-12 -7.4 1.835 +-12 -7.2 1.748 +-12 -7 1.665 +-12 -6.8 1.584 +-12 -6.6 1.506 +-12 -6.4 1.431 +-12 -6.2 1.359 +-12 -6 1.29 +-12 -5.8 1.224 +-12 -5.6 1.161 +-12 -5.4 1.102 +-12 -5.2 1.046 +-12 -5 0.993 +-12 -4.8 0.945 +-12 -4.6 0.901 +-12 -4.4 0.861 +-12 -4.2 0.825 +-12 -4 0.795 +-12 -3.8 0.771 +-12 -3.6 0.753 +-12 -3.4 0.741 +-12 -3.2 0.736 +-12 -3 0.736 +-12 -2.8 0.738 +-12 -2.6 0.735 +-12 -2.4 0.715 +-12 -2.2 0.666 +-12 -2 0.58 +-12 -1.8 0.468 +-12 -1.6 0.351 +-12 -1.4 0.25 +-12 -1.2 0.172 +-12 -1 0.117 +-12 -0.8 0.08 +-12 -0.6 0.055 +-12 -0.4 0.04 +-12 -0.2 0.031 +-12 0 0.027 +-12 0.2 0.031 +-12 0.4 0.04 +-12 0.6 0.055 +-12 0.8 0.08 +-12 1 0.117 +-12 1.2 0.172 +-12 1.4 0.25 +-12 1.6 0.351 +-12 1.8 0.468 +-12 2 0.58 +-12 2.2 0.666 +-12 2.4 0.715 +-12 2.6 0.735 +-12 2.8 0.738 +-12 3 0.736 +-12 3.2 0.736 +-12 3.4 0.741 +-12 3.6 0.753 +-12 3.8 0.771 +-12 4 0.795 +-12 4.2 0.825 +-12 4.4 0.861 +-12 4.6 0.901 +-12 4.8 0.945 +-12 5 0.993 +-12 5.2 1.046 +-12 5.4 1.102 +-12 5.6 1.161 +-12 5.8 1.224 +-12 6 1.29 +-12 6.2 1.359 +-12 6.4 1.431 +-12 6.6 1.506 +-12 6.8 1.584 +-12 7 1.665 +-12 7.2 1.748 +-12 7.4 1.835 +-12 7.6 1.924 +-12 7.8 2.016 +-12 8 2.111 +-12 8.2 2.208 +-12 8.4 2.308 +-12 8.6 2.411 +-12 8.8 2.516 +-12 9 2.624 +-12 9.2 2.735 +-12 9.4 2.848 +-12 9.6 2.964 +-12 9.8 3.082 + +-11 -10 3.185 +-11 -9.8 3.063 +-11 -9.6 2.943 +-11 -9.4 2.827 +-11 -9.2 2.712 +-11 -9 2.601 +-11 -8.8 2.491 +-11 -8.6 2.385 +-11 -8.4 2.281 +-11 -8.2 2.179 +-11 -8 2.08 +-11 -7.8 1.984 +-11 -7.6 1.89 +-11 -7.4 1.799 +-11 -7.2 1.71 +-11 -7 1.624 +-11 -6.8 1.54 +-11 -6.6 1.459 +-11 -6.4 1.381 +-11 -6.2 1.305 +-11 -6 1.232 +-11 -5.8 1.161 +-11 -5.6 1.094 +-11 -5.4 1.029 +-11 -5.2 0.966 +-11 -5 0.906 +-11 -4.8 0.849 +-11 -4.6 0.795 +-11 -4.4 0.744 +-11 -4.2 0.695 +-11 -4 0.65 +-11 -3.8 0.607 +-11 -3.6 0.567 +-11 -3.4 0.531 +-11 -3.2 0.498 +-11 -3 0.468 +-11 -2.8 0.442 +-11 -2.6 0.419 +-11 -2.4 0.399 +-11 -2.2 0.382 +-11 -2 0.368 +-11 -1.8 0.354 +-11 -1.6 0.337 +-11 -1.4 0.313 +-11 -1.2 0.279 +-11 -1 0.233 +-11 -0.8 0.182 +-11 -0.6 0.135 +-11 -0.4 0.099 +-11 -0.2 0.075 +-11 0 0.064 +-11 0.2 0.075 +-11 0.4 0.099 +-11 0.6 0.135 +-11 0.8 0.182 +-11 1 0.233 +-11 1.2 0.279 +-11 1.4 0.313 +-11 1.6 0.337 +-11 1.8 0.354 +-11 2 0.368 +-11 2.2 0.382 +-11 2.4 0.399 +-11 2.6 0.419 +-11 2.8 0.442 +-11 3 0.468 +-11 3.2 0.498 +-11 3.4 0.531 +-11 3.6 0.567 +-11 3.8 0.607 +-11 4 0.65 +-11 4.2 0.695 +-11 4.4 0.744 +-11 4.6 0.795 +-11 4.8 0.849 +-11 5 0.906 +-11 5.2 0.966 +-11 5.4 1.029 +-11 5.6 1.094 +-11 5.8 1.161 +-11 6 1.232 +-11 6.2 1.305 +-11 6.4 1.381 +-11 6.6 1.459 +-11 6.8 1.54 +-11 7 1.624 +-11 7.2 1.71 +-11 7.4 1.799 +-11 7.6 1.89 +-11 7.8 1.984 +-11 8 2.08 +-11 8.2 2.179 +-11 8.4 2.281 +-11 8.6 2.385 +-11 8.8 2.491 +-11 9 2.601 +-11 9.2 2.712 +-11 9.4 2.827 +-11 9.6 2.943 +-11 9.8 3.063 + +-10 -10 3.173 +-10 -9.8 3.05 +-10 -9.6 2.93 +-10 -9.4 2.813 +-10 -9.2 2.698 +-10 -9 2.586 +-10 -8.8 2.476 +-10 -8.6 2.368 +-10 -8.4 2.264 +-10 -8.2 2.161 +-10 -8 2.062 +-10 -7.8 1.964 +-10 -7.6 1.869 +-10 -7.4 1.777 +-10 -7.2 1.687 +-10 -7 1.6 +-10 -6.8 1.515 +-10 -6.6 1.433 +-10 -6.4 1.353 +-10 -6.2 1.276 +-10 -6 1.202 +-10 -5.8 1.129 +-10 -5.6 1.06 +-10 -5.4 0.993 +-10 -5.2 0.928 +-10 -5 0.866 +-10 -4.8 0.806 +-10 -4.6 0.749 +-10 -4.4 0.694 +-10 -4.2 0.642 +-10 -4 0.593 +-10 -3.8 0.546 +-10 -3.6 0.501 +-10 -3.4 0.459 +-10 -3.2 0.419 +-10 -3 0.382 +-10 -2.8 0.348 +-10 -2.6 0.316 +-10 -2.4 0.286 +-10 -2.2 0.259 +-10 -2 0.234 +-10 -1.8 0.212 +-10 -1.6 0.192 +-10 -1.4 0.175 +-10 -1.2 0.16 +-10 -1 0.147 +-10 -0.8 0.137 +-10 -0.6 0.129 +-10 -0.4 0.123 +-10 -0.2 0.119 +-10 0 0.117 +-10 0.2 0.119 +-10 0.4 0.123 +-10 0.6 0.129 +-10 0.8 0.137 +-10 1 0.147 +-10 1.2 0.16 +-10 1.4 0.175 +-10 1.6 0.192 +-10 1.8 0.212 +-10 2 0.234 +-10 2.2 0.259 +-10 2.4 0.286 +-10 2.6 0.316 +-10 2.8 0.348 +-10 3 0.382 +-10 3.2 0.419 +-10 3.4 0.459 +-10 3.6 0.501 +-10 3.8 0.546 +-10 4 0.593 +-10 4.2 0.642 +-10 4.4 0.694 +-10 4.6 0.749 +-10 4.8 0.806 +-10 5 0.866 +-10 5.2 0.928 +-10 5.4 0.993 +-10 5.6 1.06 +-10 5.8 1.129 +-10 6 1.202 +-10 6.2 1.276 +-10 6.4 1.353 +-10 6.6 1.433 +-10 6.8 1.515 +-10 7 1.6 +-10 7.2 1.687 +-10 7.4 1.777 +-10 7.6 1.869 +-10 7.8 1.964 +-10 8 2.062 +-10 8.2 2.161 +-10 8.4 2.264 +-10 8.6 2.368 +-10 8.8 2.476 +-10 9 2.586 +-10 9.2 2.698 +-10 9.4 2.813 +-10 9.6 2.93 +-10 9.8 3.05 + +-9 -10 3.185 +-9 -9.8 3.063 +-9 -9.6 2.943 +-9 -9.4 2.827 +-9 -9.2 2.712 +-9 -9 2.601 +-9 -8.8 2.491 +-9 -8.6 2.385 +-9 -8.4 2.281 +-9 -8.2 2.179 +-9 -8 2.08 +-9 -7.8 1.984 +-9 -7.6 1.89 +-9 -7.4 1.799 +-9 -7.2 1.71 +-9 -7 1.624 +-9 -6.8 1.54 +-9 -6.6 1.459 +-9 -6.4 1.381 +-9 -6.2 1.305 +-9 -6 1.232 +-9 -5.8 1.161 +-9 -5.6 1.094 +-9 -5.4 1.029 +-9 -5.2 0.966 +-9 -5 0.906 +-9 -4.8 0.849 +-9 -4.6 0.795 +-9 -4.4 0.744 +-9 -4.2 0.695 +-9 -4 0.65 +-9 -3.8 0.607 +-9 -3.6 0.567 +-9 -3.4 0.531 +-9 -3.2 0.498 +-9 -3 0.468 +-9 -2.8 0.442 +-9 -2.6 0.419 +-9 -2.4 0.399 +-9 -2.2 0.382 +-9 -2 0.368 +-9 -1.8 0.354 +-9 -1.6 0.337 +-9 -1.4 0.313 +-9 -1.2 0.279 +-9 -1 0.233 +-9 -0.8 0.182 +-9 -0.6 0.135 +-9 -0.4 0.099 +-9 -0.2 0.075 +-9 0 0.064 +-9 0.2 0.075 +-9 0.4 0.099 +-9 0.6 0.135 +-9 0.8 0.182 +-9 1 0.233 +-9 1.2 0.279 +-9 1.4 0.313 +-9 1.6 0.337 +-9 1.8 0.354 +-9 2 0.368 +-9 2.2 0.382 +-9 2.4 0.399 +-9 2.6 0.419 +-9 2.8 0.442 +-9 3 0.468 +-9 3.2 0.498 +-9 3.4 0.531 +-9 3.6 0.567 +-9 3.8 0.607 +-9 4 0.65 +-9 4.2 0.695 +-9 4.4 0.744 +-9 4.6 0.795 +-9 4.8 0.849 +-9 5 0.906 +-9 5.2 0.966 +-9 5.4 1.029 +-9 5.6 1.094 +-9 5.8 1.161 +-9 6 1.232 +-9 6.2 1.305 +-9 6.4 1.381 +-9 6.6 1.459 +-9 6.8 1.54 +-9 7 1.624 +-9 7.2 1.71 +-9 7.4 1.799 +-9 7.6 1.89 +-9 7.8 1.984 +-9 8 2.08 +-9 8.2 2.179 +-9 8.4 2.281 +-9 8.6 2.385 +-9 8.8 2.491 +-9 9 2.601 +-9 9.2 2.712 +-9 9.4 2.827 +-9 9.6 2.943 +-9 9.8 3.063 + +-8 -10 3.203 +-8 -9.8 3.082 +-8 -9.6 2.964 +-8 -9.4 2.848 +-8 -9.2 2.735 +-8 -9 2.624 +-8 -8.8 2.516 +-8 -8.6 2.411 +-8 -8.4 2.308 +-8 -8.2 2.208 +-8 -8 2.111 +-8 -7.8 2.016 +-8 -7.6 1.924 +-8 -7.4 1.835 +-8 -7.2 1.748 +-8 -7 1.665 +-8 -6.8 1.584 +-8 -6.6 1.506 +-8 -6.4 1.431 +-8 -6.2 1.359 +-8 -6 1.29 +-8 -5.8 1.224 +-8 -5.6 1.161 +-8 -5.4 1.102 +-8 -5.2 1.046 +-8 -5 0.993 +-8 -4.8 0.945 +-8 -4.6 0.901 +-8 -4.4 0.861 +-8 -4.2 0.825 +-8 -4 0.795 +-8 -3.8 0.771 +-8 -3.6 0.753 +-8 -3.4 0.741 +-8 -3.2 0.736 +-8 -3 0.736 +-8 -2.8 0.738 +-8 -2.6 0.735 +-8 -2.4 0.715 +-8 -2.2 0.666 +-8 -2 0.58 +-8 -1.8 0.468 +-8 -1.6 0.351 +-8 -1.4 0.25 +-8 -1.2 0.172 +-8 -1 0.117 +-8 -0.8 0.08 +-8 -0.6 0.055 +-8 -0.4 0.04 +-8 -0.2 0.031 +-8 0 0.027 +-8 0.2 0.031 +-8 0.4 0.04 +-8 0.6 0.055 +-8 0.8 0.08 +-8 1 0.117 +-8 1.2 0.172 +-8 1.4 0.25 +-8 1.6 0.351 +-8 1.8 0.468 +-8 2 0.58 +-8 2.2 0.666 +-8 2.4 0.715 +-8 2.6 0.735 +-8 2.8 0.738 +-8 3 0.736 +-8 3.2 0.736 +-8 3.4 0.741 +-8 3.6 0.753 +-8 3.8 0.771 +-8 4 0.795 +-8 4.2 0.825 +-8 4.4 0.861 +-8 4.6 0.901 +-8 4.8 0.945 +-8 5 0.993 +-8 5.2 1.046 +-8 5.4 1.102 +-8 5.6 1.161 +-8 5.8 1.224 +-8 6 1.29 +-8 6.2 1.359 +-8 6.4 1.431 +-8 6.6 1.506 +-8 6.8 1.584 +-8 7 1.665 +-8 7.2 1.748 +-8 7.4 1.835 +-8 7.6 1.924 +-8 7.8 2.016 +-8 8 2.111 +-8 8.2 2.208 +-8 8.4 2.308 +-8 8.6 2.411 +-8 8.8 2.516 +-8 9 2.624 +-8 9.2 2.735 +-8 9.4 2.848 +-8 9.6 2.964 +-8 9.8 3.082 + +-7 -10 3.232 +-7 -9.8 3.113 +-7 -9.6 2.996 +-7 -9.4 2.882 +-7 -9.2 2.771 +-7 -9 2.663 +-7 -8.8 2.557 +-7 -8.6 2.454 +-7 -8.4 2.355 +-7 -8.2 2.258 +-7 -8 2.164 +-7 -7.8 2.073 +-7 -7.6 1.986 +-7 -7.4 1.901 +-7 -7.2 1.82 +-7 -7 1.743 +-7 -6.8 1.669 +-7 -6.6 1.599 +-7 -6.4 1.533 +-7 -6.2 1.471 +-7 -6 1.414 +-7 -5.8 1.361 +-7 -5.6 1.315 +-7 -5.4 1.275 +-7 -5.2 1.242 +-7 -5 1.216 +-7 -4.8 1.2 +-7 -4.6 1.195 +-7 -4.4 1.201 +-7 -4.2 1.22 +-7 -4 1.25 +-7 -3.8 1.288 +-7 -3.6 1.321 +-7 -3.4 1.328 +-7 -3.2 1.28 +-7 -3 1.158 +-7 -2.8 0.973 +-7 -2.6 0.763 +-7 -2.4 0.569 +-7 -2.2 0.41 +-7 -2 0.291 +-7 -1.8 0.204 +-7 -1.6 0.143 +-7 -1.4 0.1 +-7 -1.2 0.07 +-7 -1 0.05 +-7 -0.8 0.035 +-7 -0.6 0.026 +-7 -0.4 0.02 +-7 -0.2 0.016 +-7 0 0.014 +-7 0.2 0.016 +-7 0.4 0.02 +-7 0.6 0.026 +-7 0.8 0.035 +-7 1 0.05 +-7 1.2 0.07 +-7 1.4 0.1 +-7 1.6 0.143 +-7 1.8 0.204 +-7 2 0.291 +-7 2.2 0.41 +-7 2.4 0.569 +-7 2.6 0.763 +-7 2.8 0.973 +-7 3 1.158 +-7 3.2 1.28 +-7 3.4 1.328 +-7 3.6 1.321 +-7 3.8 1.288 +-7 4 1.25 +-7 4.2 1.22 +-7 4.4 1.201 +-7 4.6 1.195 +-7 4.8 1.2 +-7 5 1.216 +-7 5.2 1.242 +-7 5.4 1.275 +-7 5.6 1.315 +-7 5.8 1.361 +-7 6 1.414 +-7 6.2 1.471 +-7 6.4 1.533 +-7 6.6 1.599 +-7 6.8 1.669 +-7 7 1.743 +-7 7.2 1.82 +-7 7.4 1.901 +-7 7.6 1.986 +-7 7.8 2.073 +-7 8 2.164 +-7 8.2 2.258 +-7 8.4 2.355 +-7 8.6 2.454 +-7 8.8 2.557 +-7 9 2.663 +-7 9.2 2.771 +-7 9.4 2.882 +-7 9.6 2.996 +-7 9.8 3.113 + +-6 -10 3.279 +-6 -9.8 3.163 +-6 -9.6 3.05 +-6 -9.4 2.94 +-6 -9.2 2.833 +-6 -9 2.73 +-6 -8.8 2.63 +-6 -8.6 2.533 +-6 -8.4 2.44 +-6 -8.2 2.351 +-6 -8 2.265 +-6 -7.8 2.184 +-6 -7.6 2.108 +-6 -7.4 2.036 +-6 -7.2 1.97 +-6 -7 1.91 +-6 -6.8 1.857 +-6 -6.6 1.811 +-6 -6.4 1.773 +-6 -6.2 1.746 +-6 -6 1.731 +-6 -5.8 1.73 +-6 -5.6 1.745 +-6 -5.4 1.779 +-6 -5.2 1.835 +-6 -5 1.912 +-6 -4.8 2.005 +-6 -4.6 2.097 +-6 -4.4 2.152 +-6 -4.2 2.122 +-6 -4 1.968 +-6 -3.8 1.699 +-6 -3.6 1.372 +-6 -3.4 1.055 +-6 -3.2 0.788 +-6 -3 0.58 +-6 -2.8 0.425 +-6 -2.6 0.311 +-6 -2.4 0.228 +-6 -2.2 0.168 +-6 -2 0.124 +-6 -1.8 0.091 +-6 -1.6 0.067 +-6 -1.4 0.049 +-6 -1.2 0.036 +-6 -1 0.027 +-6 -0.8 0.02 +-6 -0.6 0.015 +-6 -0.4 0.012 +-6 -0.2 0.01 +-6 0 0.009 +-6 0.2 0.01 +-6 0.4 0.012 +-6 0.6 0.015 +-6 0.8 0.02 +-6 1 0.027 +-6 1.2 0.036 +-6 1.4 0.049 +-6 1.6 0.067 +-6 1.8 0.091 +-6 2 0.124 +-6 2.2 0.168 +-6 2.4 0.228 +-6 2.6 0.311 +-6 2.8 0.425 +-6 3 0.58 +-6 3.2 0.788 +-6 3.4 1.055 +-6 3.6 1.372 +-6 3.8 1.699 +-6 4 1.968 +-6 4.2 2.122 +-6 4.4 2.152 +-6 4.6 2.097 +-6 4.8 2.005 +-6 5 1.912 +-6 5.2 1.835 +-6 5.4 1.779 +-6 5.6 1.745 +-6 5.8 1.73 +-6 6 1.731 +-6 6.2 1.746 +-6 6.4 1.773 +-6 6.6 1.811 +-6 6.8 1.857 +-6 7 1.91 +-6 7.2 1.97 +-6 7.4 2.036 +-6 7.6 2.108 +-6 7.8 2.184 +-6 8 2.265 +-6 8.2 2.351 +-6 8.4 2.44 +-6 8.6 2.533 +-6 8.8 2.63 +-6 9 2.73 +-6 9.2 2.833 +-6 9.4 2.94 +-6 9.6 3.05 +-6 9.8 3.163 + +-5 -10 3.362 +-5 -9.8 3.253 +-5 -9.6 3.148 +-5 -9.4 3.047 +-5 -9.2 2.95 +-5 -9 2.858 +-5 -8.8 2.771 +-5 -8.6 2.689 +-5 -8.4 2.613 +-5 -8.2 2.544 +-5 -8 2.483 +-5 -7.8 2.43 +-5 -7.6 2.388 +-5 -7.4 2.357 +-5 -7.2 2.339 +-5 -7 2.339 +-5 -6.8 2.359 +-5 -6.6 2.402 +-5 -6.4 2.475 +-5 -6.2 2.581 +-5 -6 2.721 +-5 -5.8 2.889 +-5 -5.6 3.062 +-5 -5.4 3.188 +-5 -5.2 3.192 +-5 -5 3.01 +-5 -4.8 2.644 +-5 -4.6 2.177 +-5 -4.4 1.709 +-5 -4.2 1.306 +-5 -4 0.985 +-5 -3.8 0.741 +-5 -3.6 0.559 +-5 -3.4 0.424 +-5 -3.2 0.323 +-5 -3 0.247 +-5 -2.8 0.19 +-5 -2.6 0.146 +-5 -2.4 0.112 +-5 -2.2 0.086 +-5 -2 0.066 +-5 -1.8 0.051 +-5 -1.6 0.039 +-5 -1.4 0.029 +-5 -1.2 0.022 +-5 -1 0.017 +-5 -0.8 0.013 +-5 -0.6 0.01 +-5 -0.4 0.008 +-5 -0.2 0.007 +-5 0 0.006 +-5 0.2 0.007 +-5 0.4 0.008 +-5 0.6 0.01 +-5 0.8 0.013 +-5 1 0.017 +-5 1.2 0.022 +-5 1.4 0.029 +-5 1.6 0.039 +-5 1.8 0.051 +-5 2 0.066 +-5 2.2 0.086 +-5 2.4 0.112 +-5 2.6 0.146 +-5 2.8 0.19 +-5 3 0.247 +-5 3.2 0.323 +-5 3.4 0.424 +-5 3.6 0.559 +-5 3.8 0.741 +-5 4 0.985 +-5 4.2 1.306 +-5 4.4 1.709 +-5 4.6 2.177 +-5 4.8 2.644 +-5 5 3.01 +-5 5.2 3.192 +-5 5.4 3.188 +-5 5.6 3.062 +-5 5.8 2.889 +-5 6 2.721 +-5 6.2 2.581 +-5 6.4 2.475 +-5 6.6 2.402 +-5 6.8 2.359 +-5 7 2.339 +-5 7.2 2.339 +-5 7.4 2.357 +-5 7.6 2.388 +-5 7.8 2.43 +-5 8 2.483 +-5 8.2 2.544 +-5 8.4 2.613 +-5 8.6 2.689 +-5 8.8 2.771 +-5 9 2.858 +-5 9.2 2.95 +-5 9.4 3.047 +-5 9.6 3.148 +-5 9.8 3.253 + +-4 -10 3.279 +-4 -9.8 3.163 +-4 -9.6 3.05 +-4 -9.4 2.94 +-4 -9.2 2.833 +-4 -9 2.73 +-4 -8.8 2.63 +-4 -8.6 2.533 +-4 -8.4 2.44 +-4 -8.2 2.351 +-4 -8 2.265 +-4 -7.8 2.184 +-4 -7.6 2.108 +-4 -7.4 2.036 +-4 -7.2 1.97 +-4 -7 1.91 +-4 -6.8 1.857 +-4 -6.6 1.811 +-4 -6.4 1.773 +-4 -6.2 1.746 +-4 -6 1.731 +-4 -5.8 1.73 +-4 -5.6 1.745 +-4 -5.4 1.779 +-4 -5.2 1.835 +-4 -5 1.912 +-4 -4.8 2.005 +-4 -4.6 2.097 +-4 -4.4 2.152 +-4 -4.2 2.122 +-4 -4 1.968 +-4 -3.8 1.699 +-4 -3.6 1.372 +-4 -3.4 1.055 +-4 -3.2 0.788 +-4 -3 0.58 +-4 -2.8 0.425 +-4 -2.6 0.311 +-4 -2.4 0.228 +-4 -2.2 0.168 +-4 -2 0.124 +-4 -1.8 0.091 +-4 -1.6 0.067 +-4 -1.4 0.049 +-4 -1.2 0.036 +-4 -1 0.027 +-4 -0.8 0.02 +-4 -0.6 0.015 +-4 -0.4 0.012 +-4 -0.2 0.01 +-4 0 0.009 +-4 0.2 0.01 +-4 0.4 0.012 +-4 0.6 0.015 +-4 0.8 0.02 +-4 1 0.027 +-4 1.2 0.036 +-4 1.4 0.049 +-4 1.6 0.067 +-4 1.8 0.091 +-4 2 0.124 +-4 2.2 0.168 +-4 2.4 0.228 +-4 2.6 0.311 +-4 2.8 0.425 +-4 3 0.58 +-4 3.2 0.788 +-4 3.4 1.055 +-4 3.6 1.372 +-4 3.8 1.699 +-4 4 1.968 +-4 4.2 2.122 +-4 4.4 2.152 +-4 4.6 2.097 +-4 4.8 2.005 +-4 5 1.912 +-4 5.2 1.835 +-4 5.4 1.779 +-4 5.6 1.745 +-4 5.8 1.73 +-4 6 1.731 +-4 6.2 1.746 +-4 6.4 1.773 +-4 6.6 1.811 +-4 6.8 1.857 +-4 7 1.91 +-4 7.2 1.97 +-4 7.4 2.036 +-4 7.6 2.108 +-4 7.8 2.184 +-4 8 2.265 +-4 8.2 2.351 +-4 8.4 2.44 +-4 8.6 2.533 +-4 8.8 2.63 +-4 9 2.73 +-4 9.2 2.833 +-4 9.4 2.94 +-4 9.6 3.05 +-4 9.8 3.163 + +-3 -10 3.232 +-3 -9.8 3.113 +-3 -9.6 2.996 +-3 -9.4 2.882 +-3 -9.2 2.771 +-3 -9 2.663 +-3 -8.8 2.557 +-3 -8.6 2.454 +-3 -8.4 2.355 +-3 -8.2 2.258 +-3 -8 2.164 +-3 -7.8 2.073 +-3 -7.6 1.986 +-3 -7.4 1.901 +-3 -7.2 1.82 +-3 -7 1.743 +-3 -6.8 1.669 +-3 -6.6 1.599 +-3 -6.4 1.533 +-3 -6.2 1.471 +-3 -6 1.414 +-3 -5.8 1.361 +-3 -5.6 1.315 +-3 -5.4 1.275 +-3 -5.2 1.242 +-3 -5 1.216 +-3 -4.8 1.2 +-3 -4.6 1.195 +-3 -4.4 1.201 +-3 -4.2 1.22 +-3 -4 1.25 +-3 -3.8 1.288 +-3 -3.6 1.321 +-3 -3.4 1.328 +-3 -3.2 1.28 +-3 -3 1.158 +-3 -2.8 0.973 +-3 -2.6 0.763 +-3 -2.4 0.569 +-3 -2.2 0.41 +-3 -2 0.291 +-3 -1.8 0.204 +-3 -1.6 0.143 +-3 -1.4 0.1 +-3 -1.2 0.07 +-3 -1 0.05 +-3 -0.8 0.035 +-3 -0.6 0.026 +-3 -0.4 0.02 +-3 -0.2 0.016 +-3 0 0.014 +-3 0.2 0.016 +-3 0.4 0.02 +-3 0.6 0.026 +-3 0.8 0.035 +-3 1 0.05 +-3 1.2 0.07 +-3 1.4 0.1 +-3 1.6 0.143 +-3 1.8 0.204 +-3 2 0.291 +-3 2.2 0.41 +-3 2.4 0.569 +-3 2.6 0.763 +-3 2.8 0.973 +-3 3 1.158 +-3 3.2 1.28 +-3 3.4 1.328 +-3 3.6 1.321 +-3 3.8 1.288 +-3 4 1.25 +-3 4.2 1.22 +-3 4.4 1.201 +-3 4.6 1.195 +-3 4.8 1.2 +-3 5 1.216 +-3 5.2 1.242 +-3 5.4 1.275 +-3 5.6 1.315 +-3 5.8 1.361 +-3 6 1.414 +-3 6.2 1.471 +-3 6.4 1.533 +-3 6.6 1.599 +-3 6.8 1.669 +-3 7 1.743 +-3 7.2 1.82 +-3 7.4 1.901 +-3 7.6 1.986 +-3 7.8 2.073 +-3 8 2.164 +-3 8.2 2.258 +-3 8.4 2.355 +-3 8.6 2.454 +-3 8.8 2.557 +-3 9 2.663 +-3 9.2 2.771 +-3 9.4 2.882 +-3 9.6 2.996 +-3 9.8 3.113 + +-2 -10 3.203 +-2 -9.8 3.082 +-2 -9.6 2.964 +-2 -9.4 2.848 +-2 -9.2 2.735 +-2 -9 2.624 +-2 -8.8 2.516 +-2 -8.6 2.411 +-2 -8.4 2.308 +-2 -8.2 2.208 +-2 -8 2.111 +-2 -7.8 2.016 +-2 -7.6 1.924 +-2 -7.4 1.835 +-2 -7.2 1.748 +-2 -7 1.665 +-2 -6.8 1.584 +-2 -6.6 1.506 +-2 -6.4 1.431 +-2 -6.2 1.359 +-2 -6 1.29 +-2 -5.8 1.224 +-2 -5.6 1.161 +-2 -5.4 1.102 +-2 -5.2 1.046 +-2 -5 0.993 +-2 -4.8 0.945 +-2 -4.6 0.901 +-2 -4.4 0.861 +-2 -4.2 0.825 +-2 -4 0.795 +-2 -3.8 0.771 +-2 -3.6 0.753 +-2 -3.4 0.741 +-2 -3.2 0.736 +-2 -3 0.736 +-2 -2.8 0.738 +-2 -2.6 0.735 +-2 -2.4 0.715 +-2 -2.2 0.666 +-2 -2 0.58 +-2 -1.8 0.468 +-2 -1.6 0.351 +-2 -1.4 0.25 +-2 -1.2 0.172 +-2 -1 0.117 +-2 -0.8 0.08 +-2 -0.6 0.055 +-2 -0.4 0.04 +-2 -0.2 0.031 +-2 0 0.027 +-2 0.2 0.031 +-2 0.4 0.04 +-2 0.6 0.055 +-2 0.8 0.08 +-2 1 0.117 +-2 1.2 0.172 +-2 1.4 0.25 +-2 1.6 0.351 +-2 1.8 0.468 +-2 2 0.58 +-2 2.2 0.666 +-2 2.4 0.715 +-2 2.6 0.735 +-2 2.8 0.738 +-2 3 0.736 +-2 3.2 0.736 +-2 3.4 0.741 +-2 3.6 0.753 +-2 3.8 0.771 +-2 4 0.795 +-2 4.2 0.825 +-2 4.4 0.861 +-2 4.6 0.901 +-2 4.8 0.945 +-2 5 0.993 +-2 5.2 1.046 +-2 5.4 1.102 +-2 5.6 1.161 +-2 5.8 1.224 +-2 6 1.29 +-2 6.2 1.359 +-2 6.4 1.431 +-2 6.6 1.506 +-2 6.8 1.584 +-2 7 1.665 +-2 7.2 1.748 +-2 7.4 1.835 +-2 7.6 1.924 +-2 7.8 2.016 +-2 8 2.111 +-2 8.2 2.208 +-2 8.4 2.308 +-2 8.6 2.411 +-2 8.8 2.516 +-2 9 2.624 +-2 9.2 2.735 +-2 9.4 2.848 +-2 9.6 2.964 +-2 9.8 3.082 + +-1 -10 3.185 +-1 -9.8 3.063 +-1 -9.6 2.943 +-1 -9.4 2.827 +-1 -9.2 2.712 +-1 -9 2.601 +-1 -8.8 2.491 +-1 -8.6 2.385 +-1 -8.4 2.281 +-1 -8.2 2.179 +-1 -8 2.08 +-1 -7.8 1.984 +-1 -7.6 1.89 +-1 -7.4 1.799 +-1 -7.2 1.71 +-1 -7 1.624 +-1 -6.8 1.54 +-1 -6.6 1.459 +-1 -6.4 1.381 +-1 -6.2 1.305 +-1 -6 1.232 +-1 -5.8 1.161 +-1 -5.6 1.094 +-1 -5.4 1.029 +-1 -5.2 0.966 +-1 -5 0.906 +-1 -4.8 0.849 +-1 -4.6 0.795 +-1 -4.4 0.744 +-1 -4.2 0.695 +-1 -4 0.65 +-1 -3.8 0.607 +-1 -3.6 0.567 +-1 -3.4 0.531 +-1 -3.2 0.498 +-1 -3 0.468 +-1 -2.8 0.442 +-1 -2.6 0.419 +-1 -2.4 0.399 +-1 -2.2 0.382 +-1 -2 0.368 +-1 -1.8 0.354 +-1 -1.6 0.337 +-1 -1.4 0.313 +-1 -1.2 0.279 +-1 -1 0.233 +-1 -0.8 0.182 +-1 -0.6 0.135 +-1 -0.4 0.099 +-1 -0.2 0.075 +-1 0 0.064 +-1 0.2 0.075 +-1 0.4 0.099 +-1 0.6 0.135 +-1 0.8 0.182 +-1 1 0.233 +-1 1.2 0.279 +-1 1.4 0.313 +-1 1.6 0.337 +-1 1.8 0.354 +-1 2 0.368 +-1 2.2 0.382 +-1 2.4 0.399 +-1 2.6 0.419 +-1 2.8 0.442 +-1 3 0.468 +-1 3.2 0.498 +-1 3.4 0.531 +-1 3.6 0.567 +-1 3.8 0.607 +-1 4 0.65 +-1 4.2 0.695 +-1 4.4 0.744 +-1 4.6 0.795 +-1 4.8 0.849 +-1 5 0.906 +-1 5.2 0.966 +-1 5.4 1.029 +-1 5.6 1.094 +-1 5.8 1.161 +-1 6 1.232 +-1 6.2 1.305 +-1 6.4 1.381 +-1 6.6 1.459 +-1 6.8 1.54 +-1 7 1.624 +-1 7.2 1.71 +-1 7.4 1.799 +-1 7.6 1.89 +-1 7.8 1.984 +-1 8 2.08 +-1 8.2 2.179 +-1 8.4 2.281 +-1 8.6 2.385 +-1 8.8 2.491 +-1 9 2.601 +-1 9.2 2.712 +-1 9.4 2.827 +-1 9.6 2.943 +-1 9.8 3.063 + +0 -10 3.173 +0 -9.8 3.05 +0 -9.6 2.93 +0 -9.4 2.813 +0 -9.2 2.698 +0 -9 2.586 +0 -8.8 2.476 +0 -8.6 2.368 +0 -8.4 2.264 +0 -8.2 2.161 +0 -8 2.062 +0 -7.8 1.964 +0 -7.6 1.869 +0 -7.4 1.777 +0 -7.2 1.687 +0 -7 1.6 +0 -6.8 1.515 +0 -6.6 1.433 +0 -6.4 1.353 +0 -6.2 1.276 +0 -6 1.202 +0 -5.8 1.129 +0 -5.6 1.06 +0 -5.4 0.993 +0 -5.2 0.928 +0 -5 0.866 +0 -4.8 0.806 +0 -4.6 0.749 +0 -4.4 0.694 +0 -4.2 0.642 +0 -4 0.593 +0 -3.8 0.546 +0 -3.6 0.501 +0 -3.4 0.459 +0 -3.2 0.419 +0 -3 0.382 +0 -2.8 0.348 +0 -2.6 0.316 +0 -2.4 0.286 +0 -2.2 0.259 +0 -2 0.234 +0 -1.8 0.212 +0 -1.6 0.192 +0 -1.4 0.175 +0 -1.2 0.16 +0 -1 0.147 +0 -0.8 0.137 +0 -0.6 0.129 +0 -0.4 0.123 +0 -0.2 0.119 +0 0 0.117 +0 0.2 0.119 +0 0.4 0.123 +0 0.6 0.129 +0 0.8 0.137 +0 1 0.147 +0 1.2 0.16 +0 1.4 0.175 +0 1.6 0.192 +0 1.8 0.212 +0 2 0.234 +0 2.2 0.259 +0 2.4 0.286 +0 2.6 0.316 +0 2.8 0.348 +0 3 0.382 +0 3.2 0.419 +0 3.4 0.459 +0 3.6 0.501 +0 3.8 0.546 +0 4 0.593 +0 4.2 0.642 +0 4.4 0.694 +0 4.6 0.749 +0 4.8 0.806 +0 5 0.866 +0 5.2 0.928 +0 5.4 0.993 +0 5.6 1.06 +0 5.8 1.129 +0 6 1.202 +0 6.2 1.276 +0 6.4 1.353 +0 6.6 1.433 +0 6.8 1.515 +0 7 1.6 +0 7.2 1.687 +0 7.4 1.777 +0 7.6 1.869 +0 7.8 1.964 +0 8 2.062 +0 8.2 2.161 +0 8.4 2.264 +0 8.6 2.368 +0 8.8 2.476 +0 9 2.586 +0 9.2 2.698 +0 9.4 2.813 +0 9.6 2.93 +0 9.8 3.05 + +1 -10 3.185 +1 -9.8 3.063 +1 -9.6 2.943 +1 -9.4 2.827 +1 -9.2 2.712 +1 -9 2.601 +1 -8.8 2.491 +1 -8.6 2.385 +1 -8.4 2.281 +1 -8.2 2.179 +1 -8 2.08 +1 -7.8 1.984 +1 -7.6 1.89 +1 -7.4 1.799 +1 -7.2 1.71 +1 -7 1.624 +1 -6.8 1.54 +1 -6.6 1.459 +1 -6.4 1.381 +1 -6.2 1.305 +1 -6 1.232 +1 -5.8 1.161 +1 -5.6 1.094 +1 -5.4 1.029 +1 -5.2 0.966 +1 -5 0.906 +1 -4.8 0.849 +1 -4.6 0.795 +1 -4.4 0.744 +1 -4.2 0.695 +1 -4 0.65 +1 -3.8 0.607 +1 -3.6 0.567 +1 -3.4 0.531 +1 -3.2 0.498 +1 -3 0.468 +1 -2.8 0.442 +1 -2.6 0.419 +1 -2.4 0.399 +1 -2.2 0.382 +1 -2 0.368 +1 -1.8 0.354 +1 -1.6 0.337 +1 -1.4 0.313 +1 -1.2 0.279 +1 -1 0.233 +1 -0.8 0.182 +1 -0.6 0.135 +1 -0.4 0.099 +1 -0.2 0.075 +1 0 0.064 +1 0.2 0.075 +1 0.4 0.099 +1 0.6 0.135 +1 0.8 0.182 +1 1 0.233 +1 1.2 0.279 +1 1.4 0.313 +1 1.6 0.337 +1 1.8 0.354 +1 2 0.368 +1 2.2 0.382 +1 2.4 0.399 +1 2.6 0.419 +1 2.8 0.442 +1 3 0.468 +1 3.2 0.498 +1 3.4 0.531 +1 3.6 0.567 +1 3.8 0.607 +1 4 0.65 +1 4.2 0.695 +1 4.4 0.744 +1 4.6 0.795 +1 4.8 0.849 +1 5 0.906 +1 5.2 0.966 +1 5.4 1.029 +1 5.6 1.094 +1 5.8 1.161 +1 6 1.232 +1 6.2 1.305 +1 6.4 1.381 +1 6.6 1.459 +1 6.8 1.54 +1 7 1.624 +1 7.2 1.71 +1 7.4 1.799 +1 7.6 1.89 +1 7.8 1.984 +1 8 2.08 +1 8.2 2.179 +1 8.4 2.281 +1 8.6 2.385 +1 8.8 2.491 +1 9 2.601 +1 9.2 2.712 +1 9.4 2.827 +1 9.6 2.943 +1 9.8 3.063 + +2 -10 3.203 +2 -9.8 3.082 +2 -9.6 2.964 +2 -9.4 2.848 +2 -9.2 2.735 +2 -9 2.624 +2 -8.8 2.516 +2 -8.6 2.411 +2 -8.4 2.308 +2 -8.2 2.208 +2 -8 2.111 +2 -7.8 2.016 +2 -7.6 1.924 +2 -7.4 1.835 +2 -7.2 1.748 +2 -7 1.665 +2 -6.8 1.584 +2 -6.6 1.506 +2 -6.4 1.431 +2 -6.2 1.359 +2 -6 1.29 +2 -5.8 1.224 +2 -5.6 1.161 +2 -5.4 1.102 +2 -5.2 1.046 +2 -5 0.993 +2 -4.8 0.945 +2 -4.6 0.901 +2 -4.4 0.861 +2 -4.2 0.825 +2 -4 0.795 +2 -3.8 0.771 +2 -3.6 0.753 +2 -3.4 0.741 +2 -3.2 0.736 +2 -3 0.736 +2 -2.8 0.738 +2 -2.6 0.735 +2 -2.4 0.715 +2 -2.2 0.666 +2 -2 0.58 +2 -1.8 0.468 +2 -1.6 0.351 +2 -1.4 0.25 +2 -1.2 0.172 +2 -1 0.117 +2 -0.8 0.08 +2 -0.6 0.055 +2 -0.4 0.04 +2 -0.2 0.031 +2 0 0.027 +2 0.2 0.031 +2 0.4 0.04 +2 0.6 0.055 +2 0.8 0.08 +2 1 0.117 +2 1.2 0.172 +2 1.4 0.25 +2 1.6 0.351 +2 1.8 0.468 +2 2 0.58 +2 2.2 0.666 +2 2.4 0.715 +2 2.6 0.735 +2 2.8 0.738 +2 3 0.736 +2 3.2 0.736 +2 3.4 0.741 +2 3.6 0.753 +2 3.8 0.771 +2 4 0.795 +2 4.2 0.825 +2 4.4 0.861 +2 4.6 0.901 +2 4.8 0.945 +2 5 0.993 +2 5.2 1.046 +2 5.4 1.102 +2 5.6 1.161 +2 5.8 1.224 +2 6 1.29 +2 6.2 1.359 +2 6.4 1.431 +2 6.6 1.506 +2 6.8 1.584 +2 7 1.665 +2 7.2 1.748 +2 7.4 1.835 +2 7.6 1.924 +2 7.8 2.016 +2 8 2.111 +2 8.2 2.208 +2 8.4 2.308 +2 8.6 2.411 +2 8.8 2.516 +2 9 2.624 +2 9.2 2.735 +2 9.4 2.848 +2 9.6 2.964 +2 9.8 3.082 + +3 -10 3.232 +3 -9.8 3.113 +3 -9.6 2.996 +3 -9.4 2.882 +3 -9.2 2.771 +3 -9 2.663 +3 -8.8 2.557 +3 -8.6 2.454 +3 -8.4 2.355 +3 -8.2 2.258 +3 -8 2.164 +3 -7.8 2.073 +3 -7.6 1.986 +3 -7.4 1.901 +3 -7.2 1.82 +3 -7 1.743 +3 -6.8 1.669 +3 -6.6 1.599 +3 -6.4 1.533 +3 -6.2 1.471 +3 -6 1.414 +3 -5.8 1.361 +3 -5.6 1.315 +3 -5.4 1.275 +3 -5.2 1.242 +3 -5 1.216 +3 -4.8 1.2 +3 -4.6 1.195 +3 -4.4 1.201 +3 -4.2 1.22 +3 -4 1.25 +3 -3.8 1.288 +3 -3.6 1.321 +3 -3.4 1.328 +3 -3.2 1.28 +3 -3 1.158 +3 -2.8 0.973 +3 -2.6 0.763 +3 -2.4 0.569 +3 -2.2 0.41 +3 -2 0.291 +3 -1.8 0.204 +3 -1.6 0.143 +3 -1.4 0.1 +3 -1.2 0.07 +3 -1 0.05 +3 -0.8 0.035 +3 -0.6 0.026 +3 -0.4 0.02 +3 -0.2 0.016 +3 0 0.014 +3 0.2 0.016 +3 0.4 0.02 +3 0.6 0.026 +3 0.8 0.035 +3 1 0.05 +3 1.2 0.07 +3 1.4 0.1 +3 1.6 0.143 +3 1.8 0.204 +3 2 0.291 +3 2.2 0.41 +3 2.4 0.569 +3 2.6 0.763 +3 2.8 0.973 +3 3 1.158 +3 3.2 1.28 +3 3.4 1.328 +3 3.6 1.321 +3 3.8 1.288 +3 4 1.25 +3 4.2 1.22 +3 4.4 1.201 +3 4.6 1.195 +3 4.8 1.2 +3 5 1.216 +3 5.2 1.242 +3 5.4 1.275 +3 5.6 1.315 +3 5.8 1.361 +3 6 1.414 +3 6.2 1.471 +3 6.4 1.533 +3 6.6 1.599 +3 6.8 1.669 +3 7 1.743 +3 7.2 1.82 +3 7.4 1.901 +3 7.6 1.986 +3 7.8 2.073 +3 8 2.164 +3 8.2 2.258 +3 8.4 2.355 +3 8.6 2.454 +3 8.8 2.557 +3 9 2.663 +3 9.2 2.771 +3 9.4 2.882 +3 9.6 2.996 +3 9.8 3.113 + +4 -10 3.279 +4 -9.8 3.163 +4 -9.6 3.05 +4 -9.4 2.94 +4 -9.2 2.833 +4 -9 2.73 +4 -8.8 2.63 +4 -8.6 2.533 +4 -8.4 2.44 +4 -8.2 2.351 +4 -8 2.265 +4 -7.8 2.184 +4 -7.6 2.108 +4 -7.4 2.036 +4 -7.2 1.97 +4 -7 1.91 +4 -6.8 1.857 +4 -6.6 1.811 +4 -6.4 1.773 +4 -6.2 1.746 +4 -6 1.731 +4 -5.8 1.73 +4 -5.6 1.745 +4 -5.4 1.779 +4 -5.2 1.835 +4 -5 1.912 +4 -4.8 2.005 +4 -4.6 2.097 +4 -4.4 2.152 +4 -4.2 2.122 +4 -4 1.968 +4 -3.8 1.699 +4 -3.6 1.372 +4 -3.4 1.055 +4 -3.2 0.788 +4 -3 0.58 +4 -2.8 0.425 +4 -2.6 0.311 +4 -2.4 0.228 +4 -2.2 0.168 +4 -2 0.124 +4 -1.8 0.091 +4 -1.6 0.067 +4 -1.4 0.049 +4 -1.2 0.036 +4 -1 0.027 +4 -0.8 0.02 +4 -0.6 0.015 +4 -0.4 0.012 +4 -0.2 0.01 +4 0 0.009 +4 0.2 0.01 +4 0.4 0.012 +4 0.6 0.015 +4 0.8 0.02 +4 1 0.027 +4 1.2 0.036 +4 1.4 0.049 +4 1.6 0.067 +4 1.8 0.091 +4 2 0.124 +4 2.2 0.168 +4 2.4 0.228 +4 2.6 0.311 +4 2.8 0.425 +4 3 0.58 +4 3.2 0.788 +4 3.4 1.055 +4 3.6 1.372 +4 3.8 1.699 +4 4 1.968 +4 4.2 2.122 +4 4.4 2.152 +4 4.6 2.097 +4 4.8 2.005 +4 5 1.912 +4 5.2 1.835 +4 5.4 1.779 +4 5.6 1.745 +4 5.8 1.73 +4 6 1.731 +4 6.2 1.746 +4 6.4 1.773 +4 6.6 1.811 +4 6.8 1.857 +4 7 1.91 +4 7.2 1.97 +4 7.4 2.036 +4 7.6 2.108 +4 7.8 2.184 +4 8 2.265 +4 8.2 2.351 +4 8.4 2.44 +4 8.6 2.533 +4 8.8 2.63 +4 9 2.73 +4 9.2 2.833 +4 9.4 2.94 +4 9.6 3.05 +4 9.8 3.163 + +5 -10 3.362 +5 -9.8 3.253 +5 -9.6 3.148 +5 -9.4 3.047 +5 -9.2 2.95 +5 -9 2.858 +5 -8.8 2.771 +5 -8.6 2.689 +5 -8.4 2.613 +5 -8.2 2.544 +5 -8 2.483 +5 -7.8 2.43 +5 -7.6 2.388 +5 -7.4 2.357 +5 -7.2 2.339 +5 -7 2.339 +5 -6.8 2.359 +5 -6.6 2.402 +5 -6.4 2.475 +5 -6.2 2.581 +5 -6 2.721 +5 -5.8 2.889 +5 -5.6 3.062 +5 -5.4 3.188 +5 -5.2 3.192 +5 -5 3.01 +5 -4.8 2.644 +5 -4.6 2.177 +5 -4.4 1.709 +5 -4.2 1.306 +5 -4 0.985 +5 -3.8 0.741 +5 -3.6 0.559 +5 -3.4 0.424 +5 -3.2 0.323 +5 -3 0.247 +5 -2.8 0.19 +5 -2.6 0.146 +5 -2.4 0.112 +5 -2.2 0.086 +5 -2 0.066 +5 -1.8 0.051 +5 -1.6 0.039 +5 -1.4 0.029 +5 -1.2 0.022 +5 -1 0.017 +5 -0.8 0.013 +5 -0.6 0.01 +5 -0.4 0.008 +5 -0.2 0.007 +5 0 0.006 +5 0.2 0.007 +5 0.4 0.008 +5 0.6 0.01 +5 0.8 0.013 +5 1 0.017 +5 1.2 0.022 +5 1.4 0.029 +5 1.6 0.039 +5 1.8 0.051 +5 2 0.066 +5 2.2 0.086 +5 2.4 0.112 +5 2.6 0.146 +5 2.8 0.19 +5 3 0.247 +5 3.2 0.323 +5 3.4 0.424 +5 3.6 0.559 +5 3.8 0.741 +5 4 0.985 +5 4.2 1.306 +5 4.4 1.709 +5 4.6 2.177 +5 4.8 2.644 +5 5 3.01 +5 5.2 3.192 +5 5.4 3.188 +5 5.6 3.062 +5 5.8 2.889 +5 6 2.721 +5 6.2 2.581 +5 6.4 2.475 +5 6.6 2.402 +5 6.8 2.359 +5 7 2.339 +5 7.2 2.339 +5 7.4 2.357 +5 7.6 2.388 +5 7.8 2.43 +5 8 2.483 +5 8.2 2.544 +5 8.4 2.613 +5 8.6 2.689 +5 8.8 2.771 +5 9 2.858 +5 9.2 2.95 +5 9.4 3.047 +5 9.6 3.148 +5 9.8 3.253 + +6 -10 3.279 +6 -9.8 3.163 +6 -9.6 3.05 +6 -9.4 2.94 +6 -9.2 2.833 +6 -9 2.73 +6 -8.8 2.63 +6 -8.6 2.533 +6 -8.4 2.44 +6 -8.2 2.351 +6 -8 2.265 +6 -7.8 2.184 +6 -7.6 2.108 +6 -7.4 2.036 +6 -7.2 1.97 +6 -7 1.91 +6 -6.8 1.857 +6 -6.6 1.811 +6 -6.4 1.773 +6 -6.2 1.746 +6 -6 1.731 +6 -5.8 1.73 +6 -5.6 1.745 +6 -5.4 1.779 +6 -5.2 1.835 +6 -5 1.912 +6 -4.8 2.005 +6 -4.6 2.097 +6 -4.4 2.152 +6 -4.2 2.122 +6 -4 1.968 +6 -3.8 1.699 +6 -3.6 1.372 +6 -3.4 1.055 +6 -3.2 0.788 +6 -3 0.58 +6 -2.8 0.425 +6 -2.6 0.311 +6 -2.4 0.228 +6 -2.2 0.168 +6 -2 0.124 +6 -1.8 0.091 +6 -1.6 0.067 +6 -1.4 0.049 +6 -1.2 0.036 +6 -1 0.027 +6 -0.8 0.02 +6 -0.6 0.015 +6 -0.4 0.012 +6 -0.2 0.01 +6 0 0.009 +6 0.2 0.01 +6 0.4 0.012 +6 0.6 0.015 +6 0.8 0.02 +6 1 0.027 +6 1.2 0.036 +6 1.4 0.049 +6 1.6 0.067 +6 1.8 0.091 +6 2 0.124 +6 2.2 0.168 +6 2.4 0.228 +6 2.6 0.311 +6 2.8 0.425 +6 3 0.58 +6 3.2 0.788 +6 3.4 1.055 +6 3.6 1.372 +6 3.8 1.699 +6 4 1.968 +6 4.2 2.122 +6 4.4 2.152 +6 4.6 2.097 +6 4.8 2.005 +6 5 1.912 +6 5.2 1.835 +6 5.4 1.779 +6 5.6 1.745 +6 5.8 1.73 +6 6 1.731 +6 6.2 1.746 +6 6.4 1.773 +6 6.6 1.811 +6 6.8 1.857 +6 7 1.91 +6 7.2 1.97 +6 7.4 2.036 +6 7.6 2.108 +6 7.8 2.184 +6 8 2.265 +6 8.2 2.351 +6 8.4 2.44 +6 8.6 2.533 +6 8.8 2.63 +6 9 2.73 +6 9.2 2.833 +6 9.4 2.94 +6 9.6 3.05 +6 9.8 3.163 + +7 -10 3.232 +7 -9.8 3.113 +7 -9.6 2.996 +7 -9.4 2.882 +7 -9.2 2.771 +7 -9 2.663 +7 -8.8 2.557 +7 -8.6 2.454 +7 -8.4 2.355 +7 -8.2 2.258 +7 -8 2.164 +7 -7.8 2.073 +7 -7.6 1.986 +7 -7.4 1.901 +7 -7.2 1.82 +7 -7 1.743 +7 -6.8 1.669 +7 -6.6 1.599 +7 -6.4 1.533 +7 -6.2 1.471 +7 -6 1.414 +7 -5.8 1.361 +7 -5.6 1.315 +7 -5.4 1.275 +7 -5.2 1.242 +7 -5 1.216 +7 -4.8 1.2 +7 -4.6 1.195 +7 -4.4 1.201 +7 -4.2 1.22 +7 -4 1.25 +7 -3.8 1.288 +7 -3.6 1.321 +7 -3.4 1.328 +7 -3.2 1.28 +7 -3 1.158 +7 -2.8 0.973 +7 -2.6 0.763 +7 -2.4 0.569 +7 -2.2 0.41 +7 -2 0.291 +7 -1.8 0.204 +7 -1.6 0.143 +7 -1.4 0.1 +7 -1.2 0.07 +7 -1 0.05 +7 -0.8 0.035 +7 -0.6 0.026 +7 -0.4 0.02 +7 -0.2 0.016 +7 0 0.014 +7 0.2 0.016 +7 0.4 0.02 +7 0.6 0.026 +7 0.8 0.035 +7 1 0.05 +7 1.2 0.07 +7 1.4 0.1 +7 1.6 0.143 +7 1.8 0.204 +7 2 0.291 +7 2.2 0.41 +7 2.4 0.569 +7 2.6 0.763 +7 2.8 0.973 +7 3 1.158 +7 3.2 1.28 +7 3.4 1.328 +7 3.6 1.321 +7 3.8 1.288 +7 4 1.25 +7 4.2 1.22 +7 4.4 1.201 +7 4.6 1.195 +7 4.8 1.2 +7 5 1.216 +7 5.2 1.242 +7 5.4 1.275 +7 5.6 1.315 +7 5.8 1.361 +7 6 1.414 +7 6.2 1.471 +7 6.4 1.533 +7 6.6 1.599 +7 6.8 1.669 +7 7 1.743 +7 7.2 1.82 +7 7.4 1.901 +7 7.6 1.986 +7 7.8 2.073 +7 8 2.164 +7 8.2 2.258 +7 8.4 2.355 +7 8.6 2.454 +7 8.8 2.557 +7 9 2.663 +7 9.2 2.771 +7 9.4 2.882 +7 9.6 2.996 +7 9.8 3.113 + +8 -10 3.203 +8 -9.8 3.082 +8 -9.6 2.964 +8 -9.4 2.848 +8 -9.2 2.735 +8 -9 2.624 +8 -8.8 2.516 +8 -8.6 2.411 +8 -8.4 2.308 +8 -8.2 2.208 +8 -8 2.111 +8 -7.8 2.016 +8 -7.6 1.924 +8 -7.4 1.835 +8 -7.2 1.748 +8 -7 1.665 +8 -6.8 1.584 +8 -6.6 1.506 +8 -6.4 1.431 +8 -6.2 1.359 +8 -6 1.29 +8 -5.8 1.224 +8 -5.6 1.161 +8 -5.4 1.102 +8 -5.2 1.046 +8 -5 0.993 +8 -4.8 0.945 +8 -4.6 0.901 +8 -4.4 0.861 +8 -4.2 0.825 +8 -4 0.795 +8 -3.8 0.771 +8 -3.6 0.753 +8 -3.4 0.741 +8 -3.2 0.736 +8 -3 0.736 +8 -2.8 0.738 +8 -2.6 0.735 +8 -2.4 0.715 +8 -2.2 0.666 +8 -2 0.58 +8 -1.8 0.468 +8 -1.6 0.351 +8 -1.4 0.25 +8 -1.2 0.172 +8 -1 0.117 +8 -0.8 0.08 +8 -0.6 0.055 +8 -0.4 0.04 +8 -0.2 0.031 +8 0 0.027 +8 0.2 0.031 +8 0.4 0.04 +8 0.6 0.055 +8 0.8 0.08 +8 1 0.117 +8 1.2 0.172 +8 1.4 0.25 +8 1.6 0.351 +8 1.8 0.468 +8 2 0.58 +8 2.2 0.666 +8 2.4 0.715 +8 2.6 0.735 +8 2.8 0.738 +8 3 0.736 +8 3.2 0.736 +8 3.4 0.741 +8 3.6 0.753 +8 3.8 0.771 +8 4 0.795 +8 4.2 0.825 +8 4.4 0.861 +8 4.6 0.901 +8 4.8 0.945 +8 5 0.993 +8 5.2 1.046 +8 5.4 1.102 +8 5.6 1.161 +8 5.8 1.224 +8 6 1.29 +8 6.2 1.359 +8 6.4 1.431 +8 6.6 1.506 +8 6.8 1.584 +8 7 1.665 +8 7.2 1.748 +8 7.4 1.835 +8 7.6 1.924 +8 7.8 2.016 +8 8 2.111 +8 8.2 2.208 +8 8.4 2.308 +8 8.6 2.411 +8 8.8 2.516 +8 9 2.624 +8 9.2 2.735 +8 9.4 2.848 +8 9.6 2.964 +8 9.8 3.082 + +9 -10 3.185 +9 -9.8 3.063 +9 -9.6 2.943 +9 -9.4 2.827 +9 -9.2 2.712 +9 -9 2.601 +9 -8.8 2.491 +9 -8.6 2.385 +9 -8.4 2.281 +9 -8.2 2.179 +9 -8 2.08 +9 -7.8 1.984 +9 -7.6 1.89 +9 -7.4 1.799 +9 -7.2 1.71 +9 -7 1.624 +9 -6.8 1.54 +9 -6.6 1.459 +9 -6.4 1.381 +9 -6.2 1.305 +9 -6 1.232 +9 -5.8 1.161 +9 -5.6 1.094 +9 -5.4 1.029 +9 -5.2 0.966 +9 -5 0.906 +9 -4.8 0.849 +9 -4.6 0.795 +9 -4.4 0.744 +9 -4.2 0.695 +9 -4 0.65 +9 -3.8 0.607 +9 -3.6 0.567 +9 -3.4 0.531 +9 -3.2 0.498 +9 -3 0.468 +9 -2.8 0.442 +9 -2.6 0.419 +9 -2.4 0.399 +9 -2.2 0.382 +9 -2 0.368 +9 -1.8 0.354 +9 -1.6 0.337 +9 -1.4 0.313 +9 -1.2 0.279 +9 -1 0.233 +9 -0.8 0.182 +9 -0.6 0.135 +9 -0.4 0.099 +9 -0.2 0.075 +9 0 0.064 +9 0.2 0.075 +9 0.4 0.099 +9 0.6 0.135 +9 0.8 0.182 +9 1 0.233 +9 1.2 0.279 +9 1.4 0.313 +9 1.6 0.337 +9 1.8 0.354 +9 2 0.368 +9 2.2 0.382 +9 2.4 0.399 +9 2.6 0.419 +9 2.8 0.442 +9 3 0.468 +9 3.2 0.498 +9 3.4 0.531 +9 3.6 0.567 +9 3.8 0.607 +9 4 0.65 +9 4.2 0.695 +9 4.4 0.744 +9 4.6 0.795 +9 4.8 0.849 +9 5 0.906 +9 5.2 0.966 +9 5.4 1.029 +9 5.6 1.094 +9 5.8 1.161 +9 6 1.232 +9 6.2 1.305 +9 6.4 1.381 +9 6.6 1.459 +9 6.8 1.54 +9 7 1.624 +9 7.2 1.71 +9 7.4 1.799 +9 7.6 1.89 +9 7.8 1.984 +9 8 2.08 +9 8.2 2.179 +9 8.4 2.281 +9 8.6 2.385 +9 8.8 2.491 +9 9 2.601 +9 9.2 2.712 +9 9.4 2.827 +9 9.6 2.943 +9 9.8 3.063 + +10 -10 3.173 +10 -9.8 3.05 +10 -9.6 2.93 +10 -9.4 2.813 +10 -9.2 2.698 +10 -9 2.586 +10 -8.8 2.476 +10 -8.6 2.368 +10 -8.4 2.264 +10 -8.2 2.161 +10 -8 2.062 +10 -7.8 1.964 +10 -7.6 1.869 +10 -7.4 1.777 +10 -7.2 1.687 +10 -7 1.6 +10 -6.8 1.515 +10 -6.6 1.433 +10 -6.4 1.353 +10 -6.2 1.276 +10 -6 1.202 +10 -5.8 1.129 +10 -5.6 1.06 +10 -5.4 0.993 +10 -5.2 0.928 +10 -5 0.866 +10 -4.8 0.806 +10 -4.6 0.749 +10 -4.4 0.694 +10 -4.2 0.642 +10 -4 0.593 +10 -3.8 0.546 +10 -3.6 0.501 +10 -3.4 0.459 +10 -3.2 0.419 +10 -3 0.382 +10 -2.8 0.348 +10 -2.6 0.316 +10 -2.4 0.286 +10 -2.2 0.259 +10 -2 0.234 +10 -1.8 0.212 +10 -1.6 0.192 +10 -1.4 0.175 +10 -1.2 0.16 +10 -1 0.147 +10 -0.8 0.137 +10 -0.6 0.129 +10 -0.4 0.123 +10 -0.2 0.119 +10 0 0.117 +10 0.2 0.119 +10 0.4 0.123 +10 0.6 0.129 +10 0.8 0.137 +10 1 0.147 +10 1.2 0.16 +10 1.4 0.175 +10 1.6 0.192 +10 1.8 0.212 +10 2 0.234 +10 2.2 0.259 +10 2.4 0.286 +10 2.6 0.316 +10 2.8 0.348 +10 3 0.382 +10 3.2 0.419 +10 3.4 0.459 +10 3.6 0.501 +10 3.8 0.546 +10 4 0.593 +10 4.2 0.642 +10 4.4 0.694 +10 4.6 0.749 +10 4.8 0.806 +10 5 0.866 +10 5.2 0.928 +10 5.4 0.993 +10 5.6 1.06 +10 5.8 1.129 +10 6 1.202 +10 6.2 1.276 +10 6.4 1.353 +10 6.6 1.433 +10 6.8 1.515 +10 7 1.6 +10 7.2 1.687 +10 7.4 1.777 +10 7.6 1.869 +10 7.8 1.964 +10 8 2.062 +10 8.2 2.161 +10 8.4 2.264 +10 8.6 2.368 +10 8.8 2.476 +10 9 2.586 +10 9.2 2.698 +10 9.4 2.813 +10 9.6 2.93 +10 9.8 3.05 + +11 -10 3.185 +11 -9.8 3.063 +11 -9.6 2.943 +11 -9.4 2.827 +11 -9.2 2.712 +11 -9 2.601 +11 -8.8 2.491 +11 -8.6 2.385 +11 -8.4 2.281 +11 -8.2 2.179 +11 -8 2.08 +11 -7.8 1.984 +11 -7.6 1.89 +11 -7.4 1.799 +11 -7.2 1.71 +11 -7 1.624 +11 -6.8 1.54 +11 -6.6 1.459 +11 -6.4 1.381 +11 -6.2 1.305 +11 -6 1.232 +11 -5.8 1.161 +11 -5.6 1.094 +11 -5.4 1.029 +11 -5.2 0.966 +11 -5 0.906 +11 -4.8 0.849 +11 -4.6 0.795 +11 -4.4 0.744 +11 -4.2 0.695 +11 -4 0.65 +11 -3.8 0.607 +11 -3.6 0.567 +11 -3.4 0.531 +11 -3.2 0.498 +11 -3 0.468 +11 -2.8 0.442 +11 -2.6 0.419 +11 -2.4 0.399 +11 -2.2 0.382 +11 -2 0.368 +11 -1.8 0.354 +11 -1.6 0.337 +11 -1.4 0.313 +11 -1.2 0.279 +11 -1 0.233 +11 -0.8 0.182 +11 -0.6 0.135 +11 -0.4 0.099 +11 -0.2 0.075 +11 0 0.064 +11 0.2 0.075 +11 0.4 0.099 +11 0.6 0.135 +11 0.8 0.182 +11 1 0.233 +11 1.2 0.279 +11 1.4 0.313 +11 1.6 0.337 +11 1.8 0.354 +11 2 0.368 +11 2.2 0.382 +11 2.4 0.399 +11 2.6 0.419 +11 2.8 0.442 +11 3 0.468 +11 3.2 0.498 +11 3.4 0.531 +11 3.6 0.567 +11 3.8 0.607 +11 4 0.65 +11 4.2 0.695 +11 4.4 0.744 +11 4.6 0.795 +11 4.8 0.849 +11 5 0.906 +11 5.2 0.966 +11 5.4 1.029 +11 5.6 1.094 +11 5.8 1.161 +11 6 1.232 +11 6.2 1.305 +11 6.4 1.381 +11 6.6 1.459 +11 6.8 1.54 +11 7 1.624 +11 7.2 1.71 +11 7.4 1.799 +11 7.6 1.89 +11 7.8 1.984 +11 8 2.08 +11 8.2 2.179 +11 8.4 2.281 +11 8.6 2.385 +11 8.8 2.491 +11 9 2.601 +11 9.2 2.712 +11 9.4 2.827 +11 9.6 2.943 +11 9.8 3.063 + +12 -10 3.203 +12 -9.8 3.082 +12 -9.6 2.964 +12 -9.4 2.848 +12 -9.2 2.735 +12 -9 2.624 +12 -8.8 2.516 +12 -8.6 2.411 +12 -8.4 2.308 +12 -8.2 2.208 +12 -8 2.111 +12 -7.8 2.016 +12 -7.6 1.924 +12 -7.4 1.835 +12 -7.2 1.748 +12 -7 1.665 +12 -6.8 1.584 +12 -6.6 1.506 +12 -6.4 1.431 +12 -6.2 1.359 +12 -6 1.29 +12 -5.8 1.224 +12 -5.6 1.161 +12 -5.4 1.102 +12 -5.2 1.046 +12 -5 0.993 +12 -4.8 0.945 +12 -4.6 0.901 +12 -4.4 0.861 +12 -4.2 0.825 +12 -4 0.795 +12 -3.8 0.771 +12 -3.6 0.753 +12 -3.4 0.741 +12 -3.2 0.736 +12 -3 0.736 +12 -2.8 0.738 +12 -2.6 0.735 +12 -2.4 0.715 +12 -2.2 0.666 +12 -2 0.58 +12 -1.8 0.468 +12 -1.6 0.351 +12 -1.4 0.25 +12 -1.2 0.172 +12 -1 0.117 +12 -0.8 0.08 +12 -0.6 0.055 +12 -0.4 0.04 +12 -0.2 0.031 +12 0 0.027 +12 0.2 0.031 +12 0.4 0.04 +12 0.6 0.055 +12 0.8 0.08 +12 1 0.117 +12 1.2 0.172 +12 1.4 0.25 +12 1.6 0.351 +12 1.8 0.468 +12 2 0.58 +12 2.2 0.666 +12 2.4 0.715 +12 2.6 0.735 +12 2.8 0.738 +12 3 0.736 +12 3.2 0.736 +12 3.4 0.741 +12 3.6 0.753 +12 3.8 0.771 +12 4 0.795 +12 4.2 0.825 +12 4.4 0.861 +12 4.6 0.901 +12 4.8 0.945 +12 5 0.993 +12 5.2 1.046 +12 5.4 1.102 +12 5.6 1.161 +12 5.8 1.224 +12 6 1.29 +12 6.2 1.359 +12 6.4 1.431 +12 6.6 1.506 +12 6.8 1.584 +12 7 1.665 +12 7.2 1.748 +12 7.4 1.835 +12 7.6 1.924 +12 7.8 2.016 +12 8 2.111 +12 8.2 2.208 +12 8.4 2.308 +12 8.6 2.411 +12 8.8 2.516 +12 9 2.624 +12 9.2 2.735 +12 9.4 2.848 +12 9.6 2.964 +12 9.8 3.082 + +13 -10 3.232 +13 -9.8 3.113 +13 -9.6 2.996 +13 -9.4 2.882 +13 -9.2 2.771 +13 -9 2.663 +13 -8.8 2.557 +13 -8.6 2.454 +13 -8.4 2.355 +13 -8.2 2.258 +13 -8 2.164 +13 -7.8 2.073 +13 -7.6 1.986 +13 -7.4 1.901 +13 -7.2 1.82 +13 -7 1.743 +13 -6.8 1.669 +13 -6.6 1.599 +13 -6.4 1.533 +13 -6.2 1.471 +13 -6 1.414 +13 -5.8 1.361 +13 -5.6 1.315 +13 -5.4 1.275 +13 -5.2 1.242 +13 -5 1.216 +13 -4.8 1.2 +13 -4.6 1.195 +13 -4.4 1.201 +13 -4.2 1.22 +13 -4 1.25 +13 -3.8 1.288 +13 -3.6 1.321 +13 -3.4 1.328 +13 -3.2 1.28 +13 -3 1.158 +13 -2.8 0.973 +13 -2.6 0.763 +13 -2.4 0.569 +13 -2.2 0.41 +13 -2 0.291 +13 -1.8 0.204 +13 -1.6 0.143 +13 -1.4 0.1 +13 -1.2 0.07 +13 -1 0.05 +13 -0.8 0.035 +13 -0.6 0.026 +13 -0.4 0.02 +13 -0.2 0.016 +13 0 0.014 +13 0.2 0.016 +13 0.4 0.02 +13 0.6 0.026 +13 0.8 0.035 +13 1 0.05 +13 1.2 0.07 +13 1.4 0.1 +13 1.6 0.143 +13 1.8 0.204 +13 2 0.291 +13 2.2 0.41 +13 2.4 0.569 +13 2.6 0.763 +13 2.8 0.973 +13 3 1.158 +13 3.2 1.28 +13 3.4 1.328 +13 3.6 1.321 +13 3.8 1.288 +13 4 1.25 +13 4.2 1.22 +13 4.4 1.201 +13 4.6 1.195 +13 4.8 1.2 +13 5 1.216 +13 5.2 1.242 +13 5.4 1.275 +13 5.6 1.315 +13 5.8 1.361 +13 6 1.414 +13 6.2 1.471 +13 6.4 1.533 +13 6.6 1.599 +13 6.8 1.669 +13 7 1.743 +13 7.2 1.82 +13 7.4 1.901 +13 7.6 1.986 +13 7.8 2.073 +13 8 2.164 +13 8.2 2.258 +13 8.4 2.355 +13 8.6 2.454 +13 8.8 2.557 +13 9 2.663 +13 9.2 2.771 +13 9.4 2.882 +13 9.6 2.996 +13 9.8 3.113 + +14 -10 3.279 +14 -9.8 3.163 +14 -9.6 3.05 +14 -9.4 2.94 +14 -9.2 2.833 +14 -9 2.73 +14 -8.8 2.63 +14 -8.6 2.533 +14 -8.4 2.44 +14 -8.2 2.351 +14 -8 2.265 +14 -7.8 2.184 +14 -7.6 2.108 +14 -7.4 2.036 +14 -7.2 1.97 +14 -7 1.91 +14 -6.8 1.857 +14 -6.6 1.811 +14 -6.4 1.773 +14 -6.2 1.746 +14 -6 1.731 +14 -5.8 1.73 +14 -5.6 1.745 +14 -5.4 1.779 +14 -5.2 1.835 +14 -5 1.912 +14 -4.8 2.005 +14 -4.6 2.097 +14 -4.4 2.152 +14 -4.2 2.122 +14 -4 1.968 +14 -3.8 1.699 +14 -3.6 1.372 +14 -3.4 1.055 +14 -3.2 0.788 +14 -3 0.58 +14 -2.8 0.425 +14 -2.6 0.311 +14 -2.4 0.228 +14 -2.2 0.168 +14 -2 0.124 +14 -1.8 0.091 +14 -1.6 0.067 +14 -1.4 0.049 +14 -1.2 0.036 +14 -1 0.027 +14 -0.8 0.02 +14 -0.6 0.015 +14 -0.4 0.012 +14 -0.2 0.01 +14 0 0.009 +14 0.2 0.01 +14 0.4 0.012 +14 0.6 0.015 +14 0.8 0.02 +14 1 0.027 +14 1.2 0.036 +14 1.4 0.049 +14 1.6 0.067 +14 1.8 0.091 +14 2 0.124 +14 2.2 0.168 +14 2.4 0.228 +14 2.6 0.311 +14 2.8 0.425 +14 3 0.58 +14 3.2 0.788 +14 3.4 1.055 +14 3.6 1.372 +14 3.8 1.699 +14 4 1.968 +14 4.2 2.122 +14 4.4 2.152 +14 4.6 2.097 +14 4.8 2.005 +14 5 1.912 +14 5.2 1.835 +14 5.4 1.779 +14 5.6 1.745 +14 5.8 1.73 +14 6 1.731 +14 6.2 1.746 +14 6.4 1.773 +14 6.6 1.811 +14 6.8 1.857 +14 7 1.91 +14 7.2 1.97 +14 7.4 2.036 +14 7.6 2.108 +14 7.8 2.184 +14 8 2.265 +14 8.2 2.351 +14 8.4 2.44 +14 8.6 2.533 +14 8.8 2.63 +14 9 2.73 +14 9.2 2.833 +14 9.4 2.94 +14 9.6 3.05 +14 9.8 3.163 diff --git a/test_multi_d/chan1.dat b/test_multi_d/chan1.dat index 70acf2e9915..db26202bc98 100644 --- a/test_multi_d/chan1.dat +++ b/test_multi_d/chan1.dat @@ -1,33 +1,33 @@ -# chan1 avg_amplitude amplitude_2 -# "chan1" "Average: amplitude" "amplitude" +# chan1 amplitude_2 avg_amplitude +# "chan1" "amplitude" "Average: amplitude" # 30 --15 1.63366 0.006 --14 1.48254 0.009 --13 1.3513 0.014 --12 1.24736 0.027 --11 1.17375 0.064 --10 1.12666 0.117 --9 1.17375 0.064 --8 1.24736 0.027 --7 1.3513 0.014 --6 1.48254 0.009 --5 1.63366 0.006 --4 1.48254 0.009 --3 1.3513 0.014 --2 1.24736 0.027 --1 1.17375 0.064 -0 1.12666 0.117 -1 1.17375 0.064 -2 1.24736 0.027 -3 1.3513 0.014 -4 1.48254 0.009 -5 1.63366 0.006 -6 1.48254 0.009 -7 1.3513 0.014 -8 1.24736 0.027 -9 1.17375 0.064 -10 1.12666 0.117 -11 1.17375 0.064 -12 1.24736 0.027 -13 1.3513 0.014 -14 1.48254 0.009 +-15 0.006 1.63366 +-14 0.009 1.48254 +-13 0.014 1.3513 +-12 0.027 1.24736 +-11 0.064 1.17375 +-10 0.117 1.12666 +-9 0.064 1.17375 +-8 0.027 1.24736 +-7 0.014 1.3513 +-6 0.009 1.48254 +-5 0.006 1.63366 +-4 0.009 1.48254 +-3 0.014 1.3513 +-2 0.027 1.24736 +-1 0.064 1.17375 +0 0.117 1.12666 +1 0.064 1.17375 +2 0.027 1.24736 +3 0.014 1.3513 +4 0.009 1.48254 +5 0.006 1.63366 +6 0.009 1.48254 +7 0.014 1.3513 +8 0.027 1.24736 +9 0.064 1.17375 +10 0.117 1.12666 +11 0.064 1.17375 +12 0.027 1.24736 +13 0.014 1.3513 +14 0.009 1.48254 diff --git a/test_multi_d/chan1_chan0.dat b/test_multi_d/chan1_chan0.dat index dc0912eab98..f66102672ce 100644 --- a/test_multi_d/chan1_chan0.dat +++ b/test_multi_d/chan1_chan0.dat @@ -478,7 +478,7 @@ 0 -6 0.009 0 -5 0.006 0 -4 0.009 -0 -3 0.014 +0 -3 0.027 0 -2 0.027 0 -1 0.064 0 0 0.117 diff --git a/toymodel.py b/toymodel.py index 4bbf62fe1bb..ebc386dc45f 100644 --- a/toymodel.py +++ b/toymodel.py @@ -2,7 +2,7 @@ import math -from qcodes import MockInstrument, Parameter, Loop +from qcodes import MockInstrument, Parameter, Loop, DataArray from qcodes.utils.validators import Numbers @@ -117,5 +117,29 @@ def __init__(self, measured_param, sweep_values, delay): def get(self): loop = Loop(self.sweep_values, self.delay).each(self.measured_param) - data = loop.run(background=False, data_manager=False, location=False) + data = loop.run(background=False, data_manager=False, location=False, + quiet=True) return data.arrays[self.measured_param.name].mean() + + +class AverageAndRaw(Parameter): + def __init__(self, measured_param, sweep_values, delay): + name = measured_param.name + super().__init__(names=(name, 'avg_' + name)) + self.measured_param = measured_param + self.sweep_values = sweep_values + self.delay = delay + self.sizes = (len(sweep_values), None) + set_array = DataArray(parameter=sweep_values.parameter, + preset_data=sweep_values) + self.setpoints = (set_array, None) + if hasattr(measured_param, 'label'): + self.labels = (measured_param.label, + 'Average: ' + measured_param.label) + + def get(self): + loop = Loop(self.sweep_values, self.delay).each(self.measured_param) + data = loop.run(background=False, data_manager=False, location=False, + quiet=True) + array = data.arrays[self.measured_param.name] + return (array, array.mean()) From 76ebd7d383e103dd7e0558e62c85c7ced49c6988 Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 16:33:02 +0100 Subject: [PATCH 32/33] clearer Loop docstring --- qcodes/loops.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/qcodes/loops.py b/qcodes/loops.py index 1c271e9cf0f..ed304902671 100644 --- a/qcodes/loops.py +++ b/qcodes/loops.py @@ -94,15 +94,19 @@ class Loop(object): ''' The entry point for creating measurement loops - Describes a sequence of `Parameter` settings to loop over. When you attach - `action`s to a `Loop`, it becomes an `ActiveLoop` that you can `.run()`, or - you can run a `Loop` directly, in which case it takes the default `action`s - from the default `Station` + sweep_values - a SweepValues or compatible object describing what + parameter to set in the loop and over what values + delay - a number of seconds to wait after setting a value before + continuing. + + After creating a Loop, you attach `action`s to it, making an `ActiveLoop` + that you can `.run()`, or you can `.run()` a `Loop` directly, in which + case it takes the default `action`s from the default `Station` `actions` are a sequence of things to do at each `Loop` step: they can be `Parameter`s to measure, `Task`s to do (any callable that does not yield - data), `Wait` times, other `ActiveLoop`s to nest inside this one, or - `Loop`s to nest using the default `actions`. + data), `Wait` times, or other `ActiveLoop`s or `Loop`s to nest inside + this one. ''' def __init__(self, sweep_values, delay): self.sweep_values = sweep_values From 95cfc7ab4bdddaa189dae88ac9248aae71d79daf Mon Sep 17 00:00:00 2001 From: alexcjohnson <alex@plot.ly> Date: Fri, 8 Jan 2016 16:45:12 +0100 Subject: [PATCH 33/33] didn't really mean to commit that file... --- decorators.py | 32 -------------------------------- 1 file changed, 32 deletions(-) delete mode 100644 decorators.py diff --git a/decorators.py b/decorators.py deleted file mode 100644 index 99f66778293..00000000000 --- a/decorators.py +++ /dev/null @@ -1,32 +0,0 @@ -import numpy as np - -class printout(object): - ''' - a class-based decorator - so it's picklable. - ''' - def __init__(self, header): - self.header = header - - def _out(self, *args, **kwargs): - out = self.f(*args, **kwargs) - print(self.header, out) - return out - - def __call__(self, f): - self.f = f - return self._out - - -@printout('???') -def mult(a, b): - return a * b - - -def add_to_numpy(key, val): - np.edited_by_aj = True - setattr(np, key, val) - - -if __name__ == '__main__': - ret = mult(4, 4) - print(ret)