From f0f9ddca855906ed7da75a6edb9c73522569c497 Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 8 Nov 2017 14:54:28 +0100 Subject: [PATCH 01/22] Changes to ATS,py transtered from other PR --- qcodes/instrument_drivers/AlazarTech/ATS.py | 475 +++++++++++++------- 1 file changed, 304 insertions(+), 171 deletions(-) diff --git a/qcodes/instrument_drivers/AlazarTech/ATS.py b/qcodes/instrument_drivers/AlazarTech/ATS.py index 98ba18443e95..b18855aa771e 100644 --- a/qcodes/instrument_drivers/AlazarTech/ATS.py +++ b/qcodes/instrument_drivers/AlazarTech/ATS.py @@ -1,23 +1,26 @@ import ctypes import logging import numpy as np +import time import os from qcodes.instrument.base import Instrument from qcodes.instrument.parameter import Parameter from qcodes.utils import validators +logger = logging.getLogger(__name__) + # TODO(damazter) (C) logging # these items are important for generalizing this code to multiple alazar cards -# TODO(damazter) (W) remove 8 bits per sample requirement # TODO(damazter) (W) some alazar cards have a different number of channels :( -# this driver only works with 2-channel cards # TODO(damazter) (S) tests to do: # acquisition that would overflow the board if measurement is not stopped # quickly enough. can this be solved by not reposting the buffers? +# TODO (natalie) make logging vs print vs nothing decisions + class AlazarTech_ATS(Instrument): """ @@ -33,7 +36,7 @@ class AlazarTech_ATS(Instrument): name: name for this instrument, passed to the base instrument system_id: target system id for this instrument board_id: target board id within the system for this instrument - dll_path: string contianing the path of the ATS driver dll + dll_path: string containing the path of the ATS driver dll """ # override dll_path in your init script or in the board constructor @@ -193,13 +196,14 @@ def find_boards(cls, dll_path=None): boards.append(cls.get_board_info(dll, system_id, board_id)) return boards + # TODO(nataliejpg) this needs fixing..., dll can't be a string @classmethod def get_board_info(cls, dll, system_id, board_id): """ Get the information from a connected Alazar board Args: - dll (string): path of the Alazar driver dll + dll (CDLL): CTypes CDLL system_id: id of the Alazar system board_id: id of the board within the alazar system @@ -213,7 +217,6 @@ def get_board_info(cls, dll, system_id, board_id): - max_samples - bits_per_sample """ - # make a temporary instrument for this board, to make it easier # to get its info board = cls('temp', system_id=system_id, board_id=board_id, @@ -232,7 +235,15 @@ def get_board_info(cls, dll, system_id, board_id): def __init__(self, name, system_id=1, board_id=1, dll_path=None, **kwargs): super().__init__(name, **kwargs) - self._ATS_dll = ctypes.cdll.LoadLibrary(dll_path or self.dll_path) + self._ATS_dll = None + + if os.name == 'nt': + self._ATS_dll = ctypes.cdll.LoadLibrary(dll_path or self.dll_path) + else: + raise Exception("Unsupported OS") + + # TODO (W) make the board id more general such that more than one card + # per system configurations are supported self._handle = self._ATS_dll.AlazarGetBoardBySystemID(system_id, board_id) @@ -266,56 +277,60 @@ def get_idn(self): board_kind = self._board_names[ self._ATS_dll.AlazarGetBoardKind(self._handle)] - major = np.array([0], dtype=np.uint8) - minor = np.array([0], dtype=np.uint8) - revision = np.array([0], dtype=np.uint8) + max_s, bps = self._get_channel_info(self._handle) + + major = ctypes.c_uint8(0) + minor = ctypes.c_uint8(0) + revision = ctypes.c_uint8(0) self._call_dll('AlazarGetCPLDVersion', self._handle, - major.ctypes.data, - minor.ctypes.data) - cpld_ver = str(major[0])+"."+str(minor[0]) + ctypes.byref(major), + ctypes.byref(minor)) + cpld_ver = str(major.value) + "." + str(minor.value) self._call_dll('AlazarGetDriverVersion', - major.ctypes.data, - minor.ctypes.data, - revision.ctypes.data) - driver_ver = str(major[0])+"."+str(minor[0])+"."+str(revision[0]) + ctypes.byref(major), + ctypes.byref(minor), + ctypes.byref(revision)) + driver_ver = str(major.value)+"."+str(minor.value)+"."+str(revision.value) self._call_dll('AlazarGetSDKVersion', - major.ctypes.data, - minor.ctypes.data, - revision.ctypes.data) - sdk_ver = str(major[0])+"."+str(minor[0])+"."+str(revision[0]) + ctypes.byref(major), + ctypes.byref(minor), + ctypes.byref(revision)) + sdk_ver = str(major.value)+"."+str(minor.value)+"."+str(revision.value) - value = np.array([0], dtype=np.uint32) + value = ctypes.c_uint32(0) self._call_dll('AlazarQueryCapability', - self._handle, 0x10000024, 0, value.ctypes.data) - serial = str(value[0]) + self._handle, 0x10000024, 0, ctypes.byref(value)) + serial = str(value.value) self._call_dll('AlazarQueryCapability', - self._handle, 0x10000026, 0, value.ctypes.data) - latest_cal_date = (str(value[0])[0:2] + "-" + - str(value[0])[2:4] + "-" + - str(value[0])[4:6]) + self._handle, 0x10000026, 0, ctypes.byref(value)) + Capabilitystring = str(value.value) + latest_cal_date = (Capabilitystring[0:2] + "-" + + Capabilitystring[2:4] + "-" + + Capabilitystring[4:6]) self._call_dll('AlazarQueryCapability', - self._handle, 0x1000002A, 0, value.ctypes.data) - memory_size = str(value[0]) + self._handle, 0x1000002A, 0, ctypes.byref(value)) + memory_size = str(value.value) self._call_dll('AlazarQueryCapability', - self._handle, 0x1000002C, 0, value.ctypes.data) - asopc_type = str(value[0]) + self._handle, 0x1000002C, 0, ctypes.byref(value)) + asopc_type = str(value.value) # see the ATS-SDK programmer's guide # about the encoding of the link speed self._call_dll('AlazarQueryCapability', - self._handle, 0x10000030, 0, value.ctypes.data) - pcie_link_speed = str(value[0]*2.5/10)+"GB/s" + self._handle, 0x10000030, 0, ctypes.byref(value)) + pcie_link_speed = str(value.value * 2.5 / 10) + "GB/s" self._call_dll('AlazarQueryCapability', - self._handle, 0x10000031, 0, value.ctypes.data) - pcie_link_width = str(value[0]) - + self._handle, 0x10000031, 0, ctypes.byref(value)) + pcie_link_width = str(value.value) return {'firmware': None, 'model': board_kind, + 'max_samples': max_s, + 'bits_per_sample': bps, 'serial': serial, 'vendor': 'AlazarTech', 'CPLD_version': cpld_ver, @@ -328,6 +343,7 @@ def get_idn(self): 'pcie_link_width': pcie_link_width} def config(self, clock_source=None, sample_rate=None, clock_edge=None, + external_sample_rate=None, decimation=None, coupling=None, channel_range=None, impedance=None, bwlimit=None, trigger_operation=None, trigger_engine1=None, trigger_source1=None, @@ -335,7 +351,8 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None, trigger_engine2=None, trigger_source2=None, trigger_slope2=None, trigger_level2=None, external_trigger_coupling=None, external_trigger_range=None, - trigger_delay=None, timeout_ticks=None): + trigger_delay=None, timeout_ticks=None, aux_io_mode=None, + aux_io_param=None): """ configure the ATS board and set the corresponding parameters to the appropriate values. @@ -371,6 +388,7 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None, self._set_if_present('clock_source', clock_source) self._set_if_present('sample_rate', sample_rate) + self._set_if_present('external_sample_rate', external_sample_rate) self._set_if_present('clock_edge', clock_edge) self._set_if_present('decimation', decimation) @@ -396,10 +414,26 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None, external_trigger_range) self._set_if_present('trigger_delay', trigger_delay) self._set_if_present('timeout_ticks', timeout_ticks) + self._set_if_present('aux_io_mode', aux_io_mode) + self._set_if_present('aux_io_param', aux_io_param) # endregion + # handle that external clock and internal clock uses + # two different ways of setting the sample rate. + # We use the matching one and mark the order one + # as up to date since it's not being pushed to + # the instrument at any time and is never used + if clock_source == 'EXTERNAL_CLOCK_10MHz_REF': + sample_rate = self.external_sample_rate + if 'sample_rate' in self.parameters: + self.parameters['sample_rate']._set_updated() + elif clock_source == 'INTERNAL_CLOCK': + sample_rate = self.sample_rate + if 'external_sample_rate' in self.parameters: + self.parameters['external_sample_rate']._set_updated() + self._call_dll('AlazarSetCaptureClock', - self._handle, self.clock_source, self.sample_rate, + self._handle, self.clock_source, sample_rate, self.clock_edge, self.decimation) for i in range(1, self.channels + 1): @@ -408,9 +442,10 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None, self.parameters['coupling' + str(i)], self.parameters['channel_range' + str(i)], self.parameters['impedance' + str(i)]) - self._call_dll('AlazarSetBWLimit', - self._handle, i, - self.parameters['bwlimit' + str(i)]) + if bwlimit is not None: + self._call_dll('AlazarSetBWLimit', + self._handle, i, + self.parameters['bwlimit' + str(i)]) self._call_dll('AlazarSetTriggerOperation', self._handle, self.trigger_operation, @@ -429,14 +464,18 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None, self._call_dll('AlazarSetTriggerTimeOut', self._handle, self.timeout_ticks) - # TODO(damazter) (W) config AUXIO + self._call_dll('AlazarConfigureAuxIO', + self._handle, self.aux_io_mode, + self.aux_io_param) def _get_channel_info(self, handle): - bps = np.array([0], dtype=np.uint8) # bps bits per sample - max_s = np.array([0], dtype=np.uint32) # max_s memory size in samples + bps = ctypes.c_uint8(0) # bps bits per sample + max_s = ctypes.c_uint32(0) # max_s memory size in samples self._call_dll('AlazarGetChannelInfo', - handle, max_s.ctypes.data, bps.ctypes.data) - return max_s[0], bps[0] + handle, + ctypes.byref(max_s), + ctypes.byref(bps)) + return max_s.value, bps.value def acquire(self, mode=None, samples_per_record=None, records_per_buffer=None, buffers_per_acquisition=None, @@ -501,11 +540,6 @@ def acquire(self, mode=None, samples_per_record=None, # Abort any previous measurement self._call_dll('AlazarAbortAsyncRead', self._handle) - # get channel info - max_s, bps = self._get_channel_info(self._handle) - if bps != 8: - raise Exception('Only 8 bits per sample supported at this moment') - # Set record size for NPT mode if mode == 'NPT': pretriggersize = 0 # pretriggersize is 0 for NPT always @@ -535,7 +569,13 @@ def acquire(self, mode=None, samples_per_record=None, records_per_acquisition = ( records_per_buffer * buffers_per_acquisition) samples_per_buffer = samples_per_record * records_per_buffer - + self._ATS_dll.AlazarBeforeAsyncRead.argtypes = [ctypes.c_uint32, + ctypes.c_uint32, + ctypes.c_long, + ctypes.c_uint32, + ctypes.c_uint32, + ctypes.c_uint32, + ctypes.c_uint32] self._call_dll('AlazarBeforeAsyncRead', self._handle, self.channel_selection, self.transfer_offset, samples_per_record, @@ -544,14 +584,14 @@ def acquire(self, mode=None, samples_per_record=None, elif mode == 'TS': if (samples_per_record % buffers_per_acquisition != 0): - logging.warning('buffers_per_acquisition is not a divisor of ' + logger.warning('buffers_per_acquisition is not a divisor of ' 'samples per record which it should be in ' - 'TS mode, rounding down in samples per buffer ' + 'Ts mode, rounding down in samples per buffer ' 'calculation') samples_per_buffer = int(samples_per_record / buffers_per_acquisition) if self.records_per_buffer._get_byte() != 1: - logging.warning('records_per_buffer should be 1 in TS mode, ' + logger.warning('records_per_buffer should be 1 in TS mode, ' 'defauling to 1') self.records_per_buffer._set(1) records_per_buffer = self.records_per_buffer._get_byte() @@ -574,14 +614,37 @@ def acquire(self, mode=None, samples_per_record=None, self.interleave_samples._set_updated() self.get_processed_data._set_updated() + # bytes per sample + max_s, bps = self._get_channel_info(self._handle) + # TODO(JHN) Why +7 I guess its to do ceil division? + bytes_per_sample = (bps + 7) // 8 + # bytes per record + bytes_per_record = bytes_per_sample * samples_per_record + + # channels + if self.channel_selection._get_byte() == 3: + number_of_channels = 2 + else: + number_of_channels = 1 + + # bytes per buffer + bytes_per_buffer = (bytes_per_record * + records_per_buffer * number_of_channels) + # create buffers for acquisition + # TODO(nataliejpg) should this be > 1 (as intuitive) or > 8 as in alazar sample code? + # the alazar code probably uses bits per sample? + sample_type = ctypes.c_uint8 + if bytes_per_sample > 1: + sample_type = ctypes.c_uint16 + self.clear_buffers() # make sure that allocated_buffers <= buffers_per_acquisition if (self.allocated_buffers._get_byte() > self.buffers_per_acquisition._get_byte()): - print("'allocated_buffers' should be smaller than or equal to" - "'buffers_per_acquisition'. Defaulting 'allocated_buffers' to" - "" + str(self.buffers_per_acquisition._get_byte())) + logger.warning("'allocated_buffers' should be <= " + "'buffers_per_acquisition'. Defaulting 'allocated_buffers'" + " to " + str(self.buffers_per_acquisition._get_byte())) self.allocated_buffers._set( self.buffers_per_acquisition._get_byte()) @@ -589,68 +652,108 @@ def acquire(self, mode=None, samples_per_record=None, for k in range(allocated_buffers): try: - self.buffer_list.append(Buffer(bps, samples_per_buffer, - number_of_channels)) + self.buffer_list.append(Buffer(sample_type, bytes_per_buffer)) except: self.clear_buffers() raise # post buffers to Alazar - for buf in self.buffer_list: - self._call_dll('AlazarPostAsyncBuffer', - self._handle, buf.addr, buf.size_bytes) - self.allocated_buffers._set_updated() - - # -----start capture here----- - acquisition_controller.pre_start_capture() - # call the startcapture method - self._call_dll('AlazarStartCapture', self._handle) - - acquisition_controller.pre_acquire() - # buffer handling from acquisition - buffers_completed = 0 - buffer_timeout = self.buffer_timeout._get_byte() - self.buffer_timeout._set_updated() - - buffer_recycling = (self.buffers_per_acquisition._get_byte() > - self.allocated_buffers._get_byte()) - - while buffers_completed < self.buffers_per_acquisition._get_byte(): - buf = self.buffer_list[buffers_completed % allocated_buffers] - - self._call_dll('AlazarWaitAsyncBufferComplete', - self._handle, buf.addr, buffer_timeout) - - # TODO(damazter) (C) last series of buffers must be handled - # exceptionally - # (and I want to test the difference) by changing buffer - # recycling for the last series of buffers - - # if buffers must be recycled, extract data and repost them - # otherwise continue to next buffer - - if buffer_recycling: - acquisition_controller.handle_buffer(buf.buffer) + logger.info("made buffer list length {}".format(len(self.buffer_list))) + try: + for buf in self.buffer_list: + self._ATS_dll.AlazarPostAsyncBuffer.argtypes = [ctypes.c_uint32, ctypes.c_void_p, ctypes.c_uint32] self._call_dll('AlazarPostAsyncBuffer', - self._handle, buf.addr, buf.size_bytes) - buffers_completed += 1 - - # stop measurement here - self._call_dll('AlazarAbortAsyncRead', self._handle) - + self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buf.size_bytes) + self.allocated_buffers._set_updated() + + # -----start capture here----- + acquisition_controller.pre_start_capture() + start = time.clock() # Keep track of when acquisition started + # call the startcapture method + self._call_dll('AlazarStartCapture', self._handle) + logger.info("Capturing %d buffers." % buffers_per_acquisition) + + acquisition_controller.pre_acquire() + + # buffer handling from acquisition + buffers_completed = 0 + bytes_transferred = 0 + buffer_timeout = self.buffer_timeout._get_byte() + self.buffer_timeout._set_updated() + + buffer_recycling = (self.buffers_per_acquisition._get_byte() > + self.allocated_buffers._get_byte()) + done_setup = time.clock() + while (buffers_completed < self.buffers_per_acquisition._get_byte()): + # Wait for the buffer at the head of the list of available + # buffers to be filled by the board. + buf = self.buffer_list[buffers_completed % allocated_buffers] + self._ATS_dll.AlazarWaitAsyncBufferComplete.argtypes = [ctypes.c_uint32, ctypes.c_void_p, ctypes.c_uint32] + self._call_dll('AlazarWaitAsyncBufferComplete', + self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buffer_timeout) + + # TODO(damazter) (C) last series of buffers must be handled + # exceptionally + # (and I want to test the difference) by changing buffer + # recycling for the last series of buffers + + # if buffers must be recycled, extract data and repost them + # otherwise continue to next buffer + if buffer_recycling: + acquisition_controller.handle_buffer(buf.buffer, buffers_completed) + self._call_dll('AlazarPostAsyncBuffer', + self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buf.size_bytes) + buffers_completed += 1 + bytes_transferred += buf.size_bytes + finally: + # stop measurement here + done_capture = time.clock() + self._call_dll('AlazarAbortAsyncRead', self._handle) + time_done_abort = time.clock() # -----cleanup here----- # extract data if not yet done if not buffer_recycling: - for buf in self.buffer_list: - acquisition_controller.handle_buffer(buf.buffer) - + for i, buf in enumerate(self.buffer_list): + acquisition_controller.handle_buffer(buf.buffer, i) + time_done_handling = time.clock() # free up memory self.clear_buffers() + time_done_free_mem = time.clock() # check if all parameters are up to date - for p in self.parameters.values(): - p.get() - + # Getting IDN is very slow so skip that + for name, p in self.parameters.items(): + if name != 'IDN': + p.get() + + # Compute the total transfer time, and display performance information. + end_time = time.clock() + transfer_time_sec = end_time - start + setup_time = done_setup - start + capture_time = done_capture - done_setup + abort_time = time_done_abort - done_capture + handling_time = time_done_handling - time_done_abort + free_mem_time = time_done_free_mem - time_done_handling + # print("Capture completed in %f sec" % transfer_time_sec) + buffers_per_sec = 0 + bytes_per_sec = 0 + records_per_sec = 0 + if transfer_time_sec > 0: + buffers_per_sec = buffers_completed / transfer_time_sec + bytes_per_sec = bytes_transferred / transfer_time_sec + records_per_sec = (records_per_buffer * + buffers_completed / transfer_time_sec) + logger.info("Captured %d buffers (%f buffers per sec)" % + (buffers_completed, buffers_per_sec)) + logger.info("Captured %d records (%f records per sec)" % + (records_per_buffer * buffers_completed, records_per_sec)) + logger.info("Transferred {:g} bytes ({:g} " + "bytes per sec)".format(bytes_transferred, bytes_per_sec)) + logger.info("Pre capture setup took {}".format(setup_time)) + logger.info("Capture took {}".format(capture_time)) + logger.info("abort took {}".format(abort_time)) + logger.info("handling took {}".format(handling_time)) + logger.info("free mem took {}".format(free_mem_time)) # return result return acquisition_controller.post_acquire() @@ -678,18 +781,22 @@ def _call_dll(self, func_name, *args): args_out = [] update_params = [] for arg in args: - if isinstance(arg,AlazarParameter): + if isinstance(arg, AlazarParameter): args_out.append(arg._get_byte()) update_params.append(arg) else: args_out.append(arg) - + logger.debug("calling dll func {} with args: \n {}".format(func_name, args_out)) # run the function func = getattr(self._ATS_dll, func_name) - return_code = func(*args_out) + try: + return_code = func(*args_out) + except Exception as e: + logger.error(e) + raise # check for errors - if (return_code != self._success) and (return_code !=518): + if (return_code != self._success) and (return_code != 518): # TODO(damazter) (C) log error argrepr = repr(args_out) @@ -714,10 +821,14 @@ def clear_buffers(self): This method uncommits all buffers that were committed by the driver. This method only has to be called when the acquistion crashes, otherwise the driver will uncommit the buffers itself - :return: None + + Returns: + None + """ for b in self.buffer_list: b.free_mem() + logger.info("buffers cleared") self.buffer_list = [] def signal_to_volt(self, channel, signal): @@ -793,7 +904,7 @@ def __init__(self, name=None, label=None, unit=None, instrument=None, # TODO(damazter) (S) test this validator vals = validators.Enum(*byte_to_value_dict.values()) - super().__init__(name=name, label=label, units=unit, vals=vals, + super().__init__(name=name, label=label, unit=unit, vals=vals, instrument=instrument) self.instrument = instrument self._byte = None @@ -810,10 +921,13 @@ def __init__(self, name=None, label=None, unit=None, instrument=None, self._set(value) - def get(self): + def get_raw(self): """ This method returns the name of the value set for this parameter - :return: value + + Returns: + value + """ # TODO(damazter) (S) test this exception if self._uptodate_flag is False: @@ -829,7 +943,10 @@ def get(self): def _get_byte(self): """ this method gets the byte representation of the value of the parameter - :return: byte representation + + Returns: + byte representation + """ return self._byte @@ -838,8 +955,12 @@ def _set(self, value): This method sets the value of this parameter This method is private to ensure that all values in the instruments are up to date always - :param value: the new value (e.g. 'NPT', 0.5, ...) - :return: None + + Args: + value: the new value (e.g. 'NPT', 0.5, ...) + Returns: + None + """ # TODO(damazter) (S) test this validation @@ -856,67 +977,80 @@ def _set_updated(self): can go wrong. Do not use this function if you do not know what you are doing - :return: None + + Returns: + None """ self._uptodate_flag = True class Buffer: - """ - This class represents a single buffer used for the data acquisition + """Buffer suitable for DMA transfers. - Args: - bits_per_sample: the number of bits needed to store a sample - samples_per_buffer: the number of samples needed per buffer(per channel) - number_of_channels: the number of channels that will be stored in the - buffer - """ - def __init__(self, bits_per_sample, samples_per_buffer, - number_of_channels): - if bits_per_sample != 8: - raise Exception("Buffer: only 8 bit per sample supported") - if os.name != 'nt': - raise Exception("Buffer: only Windows supported at this moment") - self._allocated = True + AlazarTech digitizers use direct memory access (DMA) to transfer + data from digitizers to the computer's main memory. This class + abstracts a memory buffer on the host, and ensures that all the + requirements for DMA transfers are met. - # try to allocate memory - mem_commit = 0x1000 - page_readwrite = 0x4 + Buffer export a 'buffer' member, which is a NumPy array view + of the underlying memory buffer - self.size_bytes = samples_per_buffer * number_of_channels + Args: + c_sample_type (ctypes type): The datatype of the buffer to create. + size_bytes (int): The size of the buffer to allocate, in bytes. + """ + def __init__(self, c_sample_type, size_bytes): + self.size_bytes = size_bytes + + npSampleType = { + ctypes.c_uint8: np.uint8, + ctypes.c_uint16: np.uint16, + ctypes.c_uint32: np.uint32, + ctypes.c_int32: np.int32, + ctypes.c_float: np.float32 + }.get(c_sample_type, 0) + + bytes_per_sample = { + ctypes.c_uint8: 1, + ctypes.c_uint16: 2, + ctypes.c_uint32: 4, + ctypes.c_int32: 4, + ctypes.c_float: 4 + }.get(c_sample_type, 0) - # for documentation please see: - # https://msdn.microsoft.com/en-us/library/windows/desktop/aa366887(v=vs.85).aspx - ctypes.windll.kernel32.VirtualAlloc.argtypes = [ - ctypes.c_void_p, ctypes.c_long, ctypes.c_long, ctypes.c_long] - ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_void_p - self.addr = ctypes.windll.kernel32.VirtualAlloc( - 0, ctypes.c_long(self.size_bytes), mem_commit, page_readwrite) - if self.addr is None: + self._allocated = True + self.addr = None + if os.name == 'nt': + MEM_COMMIT = 0x1000 + PAGE_READWRITE = 0x4 + ctypes.windll.kernel32.VirtualAlloc.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_long, ctypes.c_long] + ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_void_p + self.addr = ctypes.windll.kernel32.VirtualAlloc( + 0, ctypes.c_long(size_bytes), MEM_COMMIT, PAGE_READWRITE) + else: self._allocated = False - e = ctypes.windll.kernel32.GetLastError() - raise Exception("Memory allocation error: " + str(e)) + raise Exception("Unsupported OS") - ctypes_array = (ctypes.c_uint8 * - self.size_bytes).from_address(self.addr) - self.buffer = np.frombuffer(ctypes_array, dtype=np.uint8) + ctypes_array = (c_sample_type * + (size_bytes // bytes_per_sample)).from_address(self.addr) + self.buffer = np.frombuffer(ctypes_array, dtype=npSampleType) + self.ctypes_buffer = ctypes_array pointer, read_only_flag = self.buffer.__array_interface__['data'] def free_mem(self): """ uncommit memory allocated with this buffer object - :return: None """ - mem_release = 0x8000 - - # for documentation please see: - # https://msdn.microsoft.com/en-us/library/windows/desktop/aa366892(v=vs.85).aspx - ctypes.windll.kernel32.VirtualFree.argtypes = [ - ctypes.c_void_p, ctypes.c_long, ctypes.c_long] - ctypes.windll.kernel32.VirtualFree.restype = ctypes.c_int - ctypes.windll.kernel32.VirtualFree(ctypes.c_void_p(self.addr), 0, - mem_release) + self._allocated = False + if os.name == 'nt': + MEM_RELEASE = 0x8000 + ctypes.windll.kernel32.VirtualFree.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_long] + ctypes.windll.kernel32.VirtualFree.restype = ctypes.c_int + ctypes.windll.kernel32.VirtualFree(ctypes.c_void_p(self.addr), 0, MEM_RELEASE); + else: + self._allocated = True + raise Exception("Unsupported OS") def __del__(self): """ @@ -924,11 +1058,10 @@ def __del__(self): is the last chance to uncommit the memory to prevent a memory leak. This method is not very reliable so users should not rely on this functionality - :return: """ if self._allocated: self.free_mem() - logging.warning( + logger.warning( 'Buffer prevented memory leak; Memory released to Windows.\n' 'Memory should have been released before buffer was deleted.') @@ -941,24 +1074,24 @@ class AcquisitionController(Instrument): The basic structure of an acquisition is: - - call to AlazarTech_ATS.acquire internal configuration - - call to acquisitioncontroller.pre_start_capture + - Call to AlazarTech_ATS.acquire internal configuration + - Call to acquisitioncontroller.pre_start_capture - Call to the start capture of the Alazar board - - call to acquisitioncontroller.pre_acquire - - loop over all buffers that need to be acquired + - Call to acquisitioncontroller.pre_acquire + - Loop over all buffers that need to be acquired dump each buffer to acquisitioncontroller.handle_buffer (only if buffers need to be recycled to finish the acquisiton) - - dump remaining buffers to acquisitioncontroller.handle_buffer + - Dump remaining buffers to acquisitioncontroller.handle_buffer alazar internals - - return acquisitioncontroller.post_acquire + - Return acquisitioncontroller.post_acquire Attributes: _alazar: a reference to the alazar instrument driver """ def __init__(self, name, alazar_name, **kwargs): """ - :param alazar_name: The name of the alazar instrument on the server - :return: nothing + Args: + alazar_name: The name of the alazar instrument on the server """ super().__init__(name, **kwargs) self._alazar = self.find_instrument(alazar_name, From dcc4514bb6d0299e93830dabb1fce276ea9ec7af Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Thu, 9 Nov 2017 16:14:21 +0100 Subject: [PATCH 02/22] updates to 9870 driver --- .../instrument_drivers/AlazarTech/ATS9870.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/qcodes/instrument_drivers/AlazarTech/ATS9870.py b/qcodes/instrument_drivers/AlazarTech/ATS9870.py index eebda1985496..ba9c0acb307c 100644 --- a/qcodes/instrument_drivers/AlazarTech/ATS9870.py +++ b/qcodes/instrument_drivers/AlazarTech/ATS9870.py @@ -7,7 +7,7 @@ class AlazarTech_ATS9870(AlazarTech_ATS): This class is the driver for the ATS9870 board it inherits from the ATS base class - it creates all necessary parameters for the Alazar card + It creates all necessary parameters for the Alazar card """ def __init__(self, name, **kwargs): dll_path = 'C:\\WINDOWS\\System32\\ATSApi.dll' @@ -150,6 +150,23 @@ def __init__(self, name, **kwargs): unit='10 us', value=0, vals=validators.Ints(min_value=0)) + self.add_parameter(name='aux_io_mode', + parameter_class=AlazarParameter, + label='AUX I/O Mode', + unit=None, + value='AUX_IN_AUXILIARY', + byte_to_value_dict={0: 'AUX_OUT_TRIGGER', + 1: 'AUX_IN_TRIGGER_ENABLE', + 13: 'AUX_IN_AUXILIARY'}) + + self.add_parameter(name='aux_io_param', + parameter_class=AlazarParameter, + unit=None, + value='NONE', + byte_to_value_dict={0: 'NONE', + 1: 'TRIG_SLOPE_POSITIVE', + 2: 'TRIG_SLOPE_NEGATIVE'}) + # ----- Parameters for the acquire function ----- self.add_parameter(name='mode', From ff021e5438c6e96a76b4619c26d338d6e5d9979a Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Thu, 9 Nov 2017 16:14:46 +0100 Subject: [PATCH 03/22] Alazar 9360 driver --- .../instrument_drivers/AlazarTech/ATS9360.py | 336 ++++++++++++++++++ 1 file changed, 336 insertions(+) create mode 100644 qcodes/instrument_drivers/AlazarTech/ATS9360.py diff --git a/qcodes/instrument_drivers/AlazarTech/ATS9360.py b/qcodes/instrument_drivers/AlazarTech/ATS9360.py new file mode 100644 index 000000000000..9ded066f68cb --- /dev/null +++ b/qcodes/instrument_drivers/AlazarTech/ATS9360.py @@ -0,0 +1,336 @@ +from .ATS import AlazarTech_ATS, AlazarParameter +from .acquisition_parameters import EffectiveSampleRateParameter +from qcodes.utils import validators + + +class AlazarTech_ATS9360(AlazarTech_ATS): + """ + This class is the driver for the ATS9360 board + it inherits from the ATS base class + + TODO(nataliejpg): + - add clock source options and sample rate options + (problem being that byte_to_value_dict of + sample_rate relies on value of clock_source) + + """ + samples_divisor = 128 + + def __init__(self, name, **kwargs): + dll_path = 'C:\\WINDOWS\\System32\\ATSApi.dll' + super().__init__(name, dll_path=dll_path, **kwargs) + + # add parameters + + # ----- Parameters for the configuration of the board ----- + self.add_parameter(name='clock_source', + parameter_class=AlazarParameter, + label='Clock Source', + unit=None, + value='INTERNAL_CLOCK', + byte_to_value_dict={1: 'INTERNAL_CLOCK', + 2: 'FAST_EXTERNAL_CLOCK', + 7: 'EXTERNAL_CLOCK_10MHz_REF'}) + self.add_parameter(name='external_sample_rate', + parameter_class=AlazarParameter, + label='External Sample Rate', + unit='S/s', + value=500000000) + self.add_parameter(name='sample_rate', + parameter_class=AlazarParameter, + label='Internal Sample Rate', + unit='S/s', + value=500000000, + byte_to_value_dict={0x00000001: 1000, + 0x00000002: 2000, + 0x00000004: 5000, + 0x00000008: 10000, + 0x0000000A: 20000, + 0x0000000C: 50000, + 0x0000000E: 100000, + 0x00000010: 200000, + 0x00000012: 500000, + 0x00000014: 1000000, + 0x00000018: 2000000, + 0x0000001A: 5000000, + 0x0000001C: 10000000, + 0x0000001E: 20000000, + 0x00000021: 25000000, + 0x00000022: 50000000, + 0x00000024: 100000000, + 0x00000025: 125000000, + 0x00000026: 160000000, + 0x00000027: 180000000, + 0x00000028: 200000000, + 0x0000002B: 250000000, + 0x00000030: 500000000, + 0x00000032: 800000000, + 0x00000035: 1000000000, + 0x00000037: 1200000000, + 0x0000003A: 1500000000, + 0x0000003D: 1800000000, + 0x0000003F: 2000000000, + 0x0000006A: 2400000000, + 0x00000075: 3000000000, + 0x0000007B: 3600000000, + 0x00000080: 4000000000, + }) + self.add_parameter(name='clock_edge', + parameter_class=AlazarParameter, + label='Clock Edge', + unit=None, + value='CLOCK_EDGE_RISING', + byte_to_value_dict={0: 'CLOCK_EDGE_RISING', + 1: 'CLOCK_EDGE_FALLING'}) + self.add_parameter(name='decimation', + parameter_class=AlazarParameter, + label='Decimation', + unit=None, + value=1, + vals=validators.Ints(0, 100000)) + + for i in ['1', '2']: + self.add_parameter(name='coupling' + i, + parameter_class=AlazarParameter, + label='Coupling channel ' + i, + unit=None, + value='DC', + byte_to_value_dict={1: 'AC', 2: 'DC'}) + self.add_parameter(name='channel_range' + i, + parameter_class=AlazarParameter, + label='Range channel ' + i, + unit='V', + value=0.4, + byte_to_value_dict={7: 0.4}) + self.add_parameter(name='impedance' + i, + parameter_class=AlazarParameter, + label='Impedance channel ' + i, + unit='Ohm', + value=50, + byte_to_value_dict={2: 50}) + + self.add_parameter(name='trigger_operation', + parameter_class=AlazarParameter, + label='Trigger Operation', + unit=None, + value='TRIG_ENGINE_OP_J', + byte_to_value_dict={ + 0: 'TRIG_ENGINE_OP_J', + 1: 'TRIG_ENGINE_OP_K', + 2: 'TRIG_ENGINE_OP_J_OR_K', + 3: 'TRIG_ENGINE_OP_J_AND_K', + 4: 'TRIG_ENGINE_OP_J_XOR_K', + 5: 'TRIG_ENGINE_OP_J_AND_NOT_K', + 6: 'TRIG_ENGINE_OP_NOT_J_AND_K'}) + for i in ['1', '2']: + self.add_parameter(name='trigger_engine' + i, + parameter_class=AlazarParameter, + label='Trigger Engine ' + i, + unit=None, + value='TRIG_ENGINE_' + ('J' if i == 0 else 'K'), + byte_to_value_dict={0: 'TRIG_ENGINE_J', + 1: 'TRIG_ENGINE_K'}) + self.add_parameter(name='trigger_source' + i, + parameter_class=AlazarParameter, + label='Trigger Source ' + i, + unit=None, + value='EXTERNAL', + byte_to_value_dict={0: 'CHANNEL_A', + 1: 'CHANNEL_B', + 2: 'EXTERNAL', + 3: 'DISABLE'}) + self.add_parameter(name='trigger_slope' + i, + parameter_class=AlazarParameter, + label='Trigger Slope ' + i, + unit=None, + value='TRIG_SLOPE_POSITIVE', + byte_to_value_dict={1: 'TRIG_SLOPE_POSITIVE', + 2: 'TRIG_SLOPE_NEGATIVE'}) + self.add_parameter(name='trigger_level' + i, + parameter_class=AlazarParameter, + label='Trigger Level ' + i, + unit=None, + value=140, + vals=validators.Ints(0, 255)) + + self.add_parameter(name='external_trigger_coupling', + parameter_class=AlazarParameter, + label='External Trigger Coupling', + unit=None, + value='DC', + byte_to_value_dict={1: 'AC', 2: 'DC'}) + self.add_parameter(name='external_trigger_range', + parameter_class=AlazarParameter, + label='External Trigger Range', + unit=None, + value='ETR_2V5', + byte_to_value_dict={0: 'ETR_5V', 1: 'ETR_1V', + 2: 'ETR_TTL', 3: 'ETR_2V5'}) + self.add_parameter(name='trigger_delay', + parameter_class=AlazarParameter, + label='Trigger Delay', + unit='Sample clock cycles', + value=0, + vals=validators.Ints(min_value=0)) + + # NOTE: The board will wait for a for this amount of time for a + # trigger event. If a trigger event does not arrive, then the + # board will automatically trigger. Set the trigger timeout value + # to 0 to force the board to wait forever for a trigger event. + # + # IMPORTANT: The trigger timeout value should be set to zero after + # appropriate trigger parameters have been determined, otherwise + # the board may trigger if the timeout interval expires before a + # hardware trigger event arrives. + self.add_parameter(name='timeout_ticks', + parameter_class=AlazarParameter, + label='Timeout Ticks', + unit='10 us', + value=0, + vals=validators.Ints(min_value=0)) + + self.add_parameter(name='aux_io_mode', + parameter_class=AlazarParameter, + label='AUX I/O Mode', + unit=None, + value='AUX_IN_AUXILIARY', + byte_to_value_dict={0: 'AUX_OUT_TRIGGER', + 1: 'AUX_IN_TRIGGER_ENABLE', + 13: 'AUX_IN_AUXILIARY'}) + + self.add_parameter(name='aux_io_param', + parameter_class=AlazarParameter, + unit=None, + value='NONE', + byte_to_value_dict={0: 'NONE', + 1: 'TRIG_SLOPE_POSITIVE', + 2: 'TRIG_SLOPE_NEGATIVE'}) + + # ----- Parameters for the acquire function ----- + self.add_parameter(name='mode', + parameter_class=AlazarParameter, + label='Acquisition mode', + unit=None, + value='NPT', + byte_to_value_dict={0x200: 'NPT', 0x400: 'TS'}) + self.add_parameter(name='samples_per_record', + parameter_class=AlazarParameter, + label='Samples per Record', + unit=None, + value=1024, + vals=validators.Multiples( + divisor=self.samples_divisor, min_value=256)) + self.add_parameter(name='records_per_buffer', + parameter_class=AlazarParameter, + label='Records per Buffer', + unit=None, + value=10, + vals=validators.Ints(min_value=0)) + self.add_parameter(name='buffers_per_acquisition', + parameter_class=AlazarParameter, + label='Buffers per Acquisition', + unit=None, + value=10, + vals=validators.Ints(min_value=0)) + self.add_parameter(name='channel_selection', + parameter_class=AlazarParameter, + label='Channel Selection', + unit=None, + value='AB', + byte_to_value_dict={1: 'A', 2: 'B', 3: 'AB'}) + self.add_parameter(name='transfer_offset', + parameter_class=AlazarParameter, + label='Transfer Offset', + unit='Samples', + value=0, + vals=validators.Ints(min_value=0)) + self.add_parameter(name='external_startcapture', + parameter_class=AlazarParameter, + label='External Startcapture', + unit=None, + value='ENABLED', + byte_to_value_dict={0x0: 'DISABLED', + 0x1: 'ENABLED'}) + self.add_parameter(name='enable_record_headers', + parameter_class=AlazarParameter, + label='Enable Record Headers', + unit=None, + value='DISABLED', + byte_to_value_dict={0x0: 'DISABLED', + 0x8: 'ENABLED'}) + self.add_parameter(name='alloc_buffers', + parameter_class=AlazarParameter, + label='Alloc Buffers', + unit=None, + value='DISABLED', + byte_to_value_dict={0x0: 'DISABLED', + 0x20: 'ENABLED'}) + self.add_parameter(name='fifo_only_streaming', + parameter_class=AlazarParameter, + label='Fifo Only Streaming', + unit=None, + value='DISABLED', + byte_to_value_dict={0x0: 'DISABLED', + 0x800: 'ENABLED'}) + self.add_parameter(name='interleave_samples', + parameter_class=AlazarParameter, + label='Interleave Samples', + unit=None, + value='DISABLED', + byte_to_value_dict={0x0: 'DISABLED', + 0x1000: 'ENABLED'}) + self.add_parameter(name='get_processed_data', + parameter_class=AlazarParameter, + label='Get Processed Data', + unit=None, + value='DISABLED', + byte_to_value_dict={0x0: 'DISABLED', + 0x2000: 'ENABLED'}) + self.add_parameter(name='allocated_buffers', + parameter_class=AlazarParameter, + label='Allocated Buffers', + unit=None, + value=4, + vals=validators.Ints(min_value=0)) + + self.add_parameter(name='buffer_timeout', + parameter_class=AlazarParameter, + label='Buffer Timeout', + unit='ms', + value=1000, + vals=validators.Ints(min_value=0)) + + self.add_parameter(name='effective_sample_rate', + unit='Hz', + alternative='decimation and sample_rate or external_sample_rate depending on clock_source', + parameter_class=EffectiveSampleRateParameter) + + model = self.get_idn()['model'] + if model != 'ATS9360': + raise Exception("The Alazar board kind is not 'ATS9360'," + " found '" + str(model) + "' instead.") + + + def get_sample_rate(self): + """ + Obtain the effective sampling rate of the acquisition + based on clock type, clock speed and decimation + + Returns: + the number of samples (per channel) per second + """ + if self.clock_source.get() == 'EXTERNAL_CLOCK_10MHz_REF': + rate = self.external_sample_rate.get() + elif self.clock_source.get() == 'INTERNAL_CLOCK': + rate = self.sample_rate.get() + else: + raise Exception("Don't know how to get sample rate with {}".format(self.clock_source.get())) + + if rate == '1GHz_REFERENCE_CLOCK': + rate = 1e9 + + decimation = self.decimation.get() + if decimation > 0: + return rate / decimation + else: + return rate From b53b4429893a1d6ff46cb0a1ba4cba78462db95d Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Thu, 9 Nov 2017 17:23:47 +0100 Subject: [PATCH 04/22] remove out of date todo --- qcodes/instrument_drivers/AlazarTech/ATS.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/qcodes/instrument_drivers/AlazarTech/ATS.py b/qcodes/instrument_drivers/AlazarTech/ATS.py index b18855aa771e..746b3d9028d9 100644 --- a/qcodes/instrument_drivers/AlazarTech/ATS.py +++ b/qcodes/instrument_drivers/AlazarTech/ATS.py @@ -242,9 +242,6 @@ def __init__(self, name, system_id=1, board_id=1, dll_path=None, **kwargs): else: raise Exception("Unsupported OS") - # TODO (W) make the board id more general such that more than one card - # per system configurations are supported - self._handle = self._ATS_dll.AlazarGetBoardBySystemID(system_id, board_id) if not self._handle: From 686524006c176c11a692bc704e498fa867a6111b Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Thu, 9 Nov 2017 17:24:22 +0100 Subject: [PATCH 05/22] Move ctypes argtypes to init --- qcodes/instrument_drivers/AlazarTech/ATS.py | 31 +++++++++++++-------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/qcodes/instrument_drivers/AlazarTech/ATS.py b/qcodes/instrument_drivers/AlazarTech/ATS.py index 746b3d9028d9..357b93b72e04 100644 --- a/qcodes/instrument_drivers/AlazarTech/ATS.py +++ b/qcodes/instrument_drivers/AlazarTech/ATS.py @@ -250,6 +250,26 @@ def __init__(self, name, system_id=1, board_id=1, dll_path=None, **kwargs): self.buffer_list = [] + self._ATS_dll.AlazarWaitAsyncBufferComplete.argtypes = [ + ctypes.c_uint32, ctypes.c_void_p, ctypes.c_uint32] + self._ATS_dll.AlazarBeforeAsyncRead.argtypes = [ctypes.c_uint32, + ctypes.c_uint32, + ctypes.c_long, + ctypes.c_uint32, + ctypes.c_uint32, + ctypes.c_uint32, + ctypes.c_uint32] + self._ATS_dll.AlazarPostAsyncBuffer.argtypes = [ctypes.c_uint32, + ctypes.c_void_p, + ctypes.c_uint32] + ctypes.windll.kernel32.VirtualAlloc.argtypes = [ctypes.c_void_p, + ctypes.c_long, + ctypes.c_long, + ctypes.c_long] + ctypes.windll.kernel32.VirtualFree.argtypes = [ctypes.c_void_p, + ctypes.c_long, + ctypes.c_long] + def get_idn(self): """ This methods gets the most relevant information of this instrument @@ -566,13 +586,6 @@ def acquire(self, mode=None, samples_per_record=None, records_per_acquisition = ( records_per_buffer * buffers_per_acquisition) samples_per_buffer = samples_per_record * records_per_buffer - self._ATS_dll.AlazarBeforeAsyncRead.argtypes = [ctypes.c_uint32, - ctypes.c_uint32, - ctypes.c_long, - ctypes.c_uint32, - ctypes.c_uint32, - ctypes.c_uint32, - ctypes.c_uint32] self._call_dll('AlazarBeforeAsyncRead', self._handle, self.channel_selection, self.transfer_offset, samples_per_record, @@ -658,7 +671,6 @@ def acquire(self, mode=None, samples_per_record=None, logger.info("made buffer list length {}".format(len(self.buffer_list))) try: for buf in self.buffer_list: - self._ATS_dll.AlazarPostAsyncBuffer.argtypes = [ctypes.c_uint32, ctypes.c_void_p, ctypes.c_uint32] self._call_dll('AlazarPostAsyncBuffer', self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buf.size_bytes) self.allocated_buffers._set_updated() @@ -685,7 +697,6 @@ def acquire(self, mode=None, samples_per_record=None, # Wait for the buffer at the head of the list of available # buffers to be filled by the board. buf = self.buffer_list[buffers_completed % allocated_buffers] - self._ATS_dll.AlazarWaitAsyncBufferComplete.argtypes = [ctypes.c_uint32, ctypes.c_void_p, ctypes.c_uint32] self._call_dll('AlazarWaitAsyncBufferComplete', self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buffer_timeout) @@ -1020,7 +1031,6 @@ def __init__(self, c_sample_type, size_bytes): if os.name == 'nt': MEM_COMMIT = 0x1000 PAGE_READWRITE = 0x4 - ctypes.windll.kernel32.VirtualAlloc.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_long, ctypes.c_long] ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_void_p self.addr = ctypes.windll.kernel32.VirtualAlloc( 0, ctypes.c_long(size_bytes), MEM_COMMIT, PAGE_READWRITE) @@ -1042,7 +1052,6 @@ def free_mem(self): self._allocated = False if os.name == 'nt': MEM_RELEASE = 0x8000 - ctypes.windll.kernel32.VirtualFree.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_long] ctypes.windll.kernel32.VirtualFree.restype = ctypes.c_int ctypes.windll.kernel32.VirtualFree(ctypes.c_void_p(self.addr), 0, MEM_RELEASE); else: From 5a870fcb920a0f273c5546b973a6c8fb98bc1625 Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Thu, 9 Nov 2017 17:48:11 +0100 Subject: [PATCH 06/22] add missing file --- .../AlazarTech/acquisition_parameters.py | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 qcodes/instrument_drivers/AlazarTech/acquisition_parameters.py diff --git a/qcodes/instrument_drivers/AlazarTech/acquisition_parameters.py b/qcodes/instrument_drivers/AlazarTech/acquisition_parameters.py new file mode 100644 index 000000000000..ef0af1ab6046 --- /dev/null +++ b/qcodes/instrument_drivers/AlazarTech/acquisition_parameters.py @@ -0,0 +1,63 @@ +from qcodes import Parameter + +class NonSettableDerivedParameter(Parameter): + """ + Parameter of an AcquisitionController which cannot be updated directly + as it's value is derived from other parameters. This is intended to be + used in high level APIs where Alazar parameters such as 'samples_per_record' + are not set directly but are parameters of the actual instrument anyway. + + This assumes that the parameter is stored via a call to '_save_val' by + any set of parameter that this parameter depends on. + + Args: + name: name for this parameter + instrument: acquisition controller instrument this parameter belongs to + alternative (str): name of parameter(s) that controls the value of this + parameter and can be set directly. + """ + + def __init__(self, name, instrument, alternative: str, **kwargs): + self._alternative = alternative + super().__init__(name, instrument=instrument, **kwargs) + + def set_raw(self, value): + """ + It's not possible to directly set this parameter as it's derived from other + parameters. + """ + raise NotImplementedError("Cannot directly set {}. To control this parameter" + "set {}".format(self.name, self._alternative)) + + def get_raw(self): + return self.get_latest() + + +class EffectiveSampleRateParameter(NonSettableDerivedParameter): + + + def get_raw(self): + """ + Obtain the effective sampling rate of the acquisition + based on clock type, clock speed and decimation + + Returns: + the number of samples (per channel) per second + """ + if self._instrument.clock_source.get() == 'EXTERNAL_CLOCK_10MHz_REF': + rate = self._instrument.external_sample_rate.get() + elif self._instrument.clock_source.get() == 'INTERNAL_CLOCK': + rate = self._instrument.sample_rate.get() + else: + raise Exception("Don't know how to get sample rate with" + " {}".format(self._instrument.clock_source.get())) + + if rate == '1GHz_REFERENCE_CLOCK': + rate = 1e9 + + decimation = self._instrument.decimation.get() + if decimation > 0: + rate = rate / decimation + + self._save_val(rate) + return rate From b1f05e8a8a1e0b7e57ca1384c64a16bb3ed1a36d Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Thu, 9 Nov 2017 17:51:37 +0100 Subject: [PATCH 07/22] Reunify buffer calling --- qcodes/instrument_drivers/AlazarTech/ATS.py | 2 +- .../AlazarTech/ATS_acquisition_controllers.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/qcodes/instrument_drivers/AlazarTech/ATS.py b/qcodes/instrument_drivers/AlazarTech/ATS.py index 357b93b72e04..27c2291a648e 100644 --- a/qcodes/instrument_drivers/AlazarTech/ATS.py +++ b/qcodes/instrument_drivers/AlazarTech/ATS.py @@ -1127,7 +1127,7 @@ def pre_acquire(self): raise NotImplementedError( 'This method should be implemented in a subclass') - def handle_buffer(self, buffer): + def handle_buffer(self, buffer, buffer_number=None): """ This method should store or process the information that is contained in the buffers obtained during the acquisition. diff --git a/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py b/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py index a90269a85030..69d1affa0991 100644 --- a/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py +++ b/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py @@ -88,7 +88,7 @@ def pre_acquire(self): # Alazar card starts listening for a trigger pulse pass - def handle_buffer(self, data): + def handle_buffer(self, data, buffer_number=None): """ See AcquisitionController :return: From 423e3b0ccf1e1994e4115203eea5d4d23721e2b5 Mon Sep 17 00:00:00 2001 From: "Jens H. Nielsen" Date: Thu, 9 Nov 2017 18:03:24 +0100 Subject: [PATCH 08/22] Add work in progress notebook --- .../Qcodes example with Alazar ATS9360.ipynb | 5646 +++++++++++++++++ 1 file changed, 5646 insertions(+) create mode 100644 docs/examples/driver_examples/Qcodes example with Alazar ATS9360.ipynb diff --git a/docs/examples/driver_examples/Qcodes example with Alazar ATS9360.ipynb b/docs/examples/driver_examples/Qcodes example with Alazar ATS9360.ipynb new file mode 100644 index 000000000000..b63611579cf1 --- /dev/null +++ b/docs/examples/driver_examples/Qcodes example with Alazar ATS9360.ipynb @@ -0,0 +1,5646 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Qcodes example notebook for Alazar card ATS9360 and acq controllers" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "User schema at C:\\Users\\Jens/qcodesrc_schema.json not found.User settings won't be validated\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import qcodes as qc\n", + "import qcodes.instrument.parameter as parameter\n", + "import qcodes.instrument_drivers.AlazarTech.ATS9360 as ATSdriver\n", + "from qcodes.instrument_drivers.AlazarTech.acq_controllers import ATS9360Controller\n", + "from qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_channel import AlazarChannel\n", + "import qcodes.instrument_drivers.AlazarTech.acq_helpers as helpers\n", + "from qcodes.station import Station\n", + "\n", + "import logging\n", + "logging.basicConfig(level=logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from qcodes.instrument.parameter import ManualParameter\n", + "import qcodes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NB: See ATS9360 example notebook for general commands " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'CPLD_version': '25.16',\n", + " 'SDK_version': '6.0.0',\n", + " 'asopc_type': '1779729248',\n", + " 'bits_per_sample': 12,\n", + " 'driver_version': '6.0.0',\n", + " 'firmware': None,\n", + " 'latest_cal_date': '25-01-17',\n", + " 'max_samples': 4294967294,\n", + " 'memory_size': '4294967294',\n", + " 'model': 'ATS9360',\n", + " 'pcie_link_speed': '0.5GB/s',\n", + " 'pcie_link_width': '8',\n", + " 'serial': '970396',\n", + " 'vendor': 'AlazarTech'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create the ATS9360 instrument\n", + "alazar = ATSdriver.AlazarTech_ATS9360(name='Alazar')\n", + "# Print all information about this Alazar card\n", + "alazar.get_idn()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true, + "scrolled": false + }, + "outputs": [], + "source": [ + "# Configure all settings in the Alazar card\n", + "alazar.config(clock_source='INTERNAL_CLOCK',\n", + " sample_rate=1_000_000_000,\n", + " clock_edge='CLOCK_EDGE_RISING',\n", + " decimation=1,\n", + " coupling=['DC','DC'],\n", + " channel_range=[.4,.4],\n", + " impedance=[50,50],\n", + " trigger_operation='TRIG_ENGINE_OP_J',\n", + " trigger_engine1='TRIG_ENGINE_J',\n", + " trigger_source1='EXTERNAL',\n", + " trigger_slope1='TRIG_SLOPE_POSITIVE',\n", + " trigger_level1=160,\n", + " trigger_engine2='TRIG_ENGINE_K',\n", + " trigger_source2='DISABLE',\n", + " trigger_slope2='TRIG_SLOPE_POSITIVE',\n", + " trigger_level2=128,\n", + " external_trigger_coupling='DC',\n", + " external_trigger_range='ETR_2V5',\n", + " trigger_delay=0,\n", + " timeout_ticks=0,\n", + " aux_io_mode='AUX_IN_AUXILIARY', # AUX_IN_TRIGGER_ENABLE for seq mode on\n", + " aux_io_param='NONE' # TRIG_SLOPE_POSITIVE for seq mode on\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1\n", + "\n", + "Pulls the raw data the alazar acquires averaged over records and buffers." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true, + "scrolled": false + }, + "outputs": [], + "source": [ + "# Create the acquisition controller which will take care of the data handling and tell it which \n", + "# alazar instrument to talk to. Explicitly pass the default options to the Alazar.\n", + "# Dont integrate over samples but avarage over records\n", + "myctrl = ATS9360Controller(name='my_controller', alazar_name='Alazar')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Put the Alazar and the controller in a station so we ensure that all parameters are captured" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Snapshot: Could not update parameter: mode\n", + "INFO:root:Snapshot: Could not update parameter: samples_per_record\n", + "INFO:root:Snapshot: Could not update parameter: records_per_buffer\n", + "INFO:root:Snapshot: Could not update parameter: buffers_per_acquisition\n", + "INFO:root:Snapshot: Could not update parameter: channel_selection\n", + "INFO:root:Snapshot: Could not update parameter: transfer_offset\n", + "INFO:root:Snapshot: Could not update parameter: external_startcapture\n", + "INFO:root:Snapshot: Could not update parameter: enable_record_headers\n", + "INFO:root:Snapshot: Could not update parameter: alloc_buffers\n", + "INFO:root:Snapshot: Could not update parameter: fifo_only_streaming\n", + "INFO:root:Snapshot: Could not update parameter: interleave_samples\n", + "INFO:root:Snapshot: Could not update parameter: get_processed_data\n", + "INFO:root:Snapshot: Could not update parameter: allocated_buffers\n", + "INFO:root:Snapshot: Could not update parameter: buffer_timeout\n" + ] + } + ], + "source": [ + "station = qc.Station(alazar, myctrl)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This controller is designed to be highlevel and it is not possible to directly set number of records, buffers and samples. The number of samples is indirecly controlled by the integration time and integration delay and the number of averages controls the number of buffers and records acquired" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "myctrl.int_time.set?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'raw_value': None,\n", + " 'ts': datetime.datetime(2017, 11, 3, 15, 33, 15, 479504),\n", + " 'value': None}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myctrl.int_time._latest" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.ATS9360Controller:need 200.0 samples round up to 256\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.ATS9360Controller:need 2200.0 samples round up to 4096\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4096\n" + ] + } + ], + "source": [ + "myctrl.int_delay(2e-7)\n", + "myctrl.int_time(2e-6)\n", + "print(myctrl.samples_per_record())\n", + "#myctrl.num_avg(1000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Per default the controller does not have any channels assiated with it." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ChannelList(, AlazarChannel, [])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myctrl.channels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1D samples trace" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets define a channel were we avarege over buffers and records but not over samples. This will give us a time series with a x axis defined by int_time, int_delay and the sampling rate. First we create a channel and set the relevant parameters. We may choose to append the channel to the controllers build in list of channels for future reference." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan1 = AlazarChannel(myctrl, 'mychan', demod=False, integrate_samples=False)\n", + "myctrl.channels.append(chan1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (15.136053 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (15136.052731 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (2.47989e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.001065665086155576\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.004508109347677092\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.02264318371696561\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.03520096467029887\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.002499943549661765\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-11-03/#003_{name}_15-33-23'\n", + " | | | \n", + " Measured | my_controller_mychan_data | data | (4096,)\n", + "acquired at 2017-11-03 15:33:23\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan1.num_averages(1000)\n", + "\n", + "chan1.alazar_channel('A')\n", + "chan1.prepare_channel()\n", + "\n", + "# Measure this \n", + "data1 = qc.Measure(chan1.data).run()\n", + "qc.MatPlot(data1.my_controller_mychan_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can measure the time taken to do a measurement" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (15.969266 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (15969.265711 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (2.6164e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0015357424480431092\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.004052107914279901\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.022754324902340528\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.031586090284765334\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.002537479358970529\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-11-03/#004_{name}_15-33-24'\n", + " | | | \n", + " Measured | my_controller_mychan_data | data | (4096,)\n", + "acquired at 2017-11-03 15:33:24\n", + "Wall time: 226 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "DataSet:\n", + " location = 'data/2017-11-03/#004_{name}_15-33-24'\n", + " | | | \n", + " Measured | my_controller_mychan_data | data | (4096,)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "qc.Measure(chan1.data).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demodulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We may optionally chose to demodulate the data that we acquire using a software demodulator" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan1d = AlazarChannel(myctrl, 'mychan_demod_1', demod=True, integrate_samples=False)\n", + "myctrl.channels.append(chan1d)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (12.159587 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (12159.586797 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (1.99223e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.002284409914047103\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.003913994752601013\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.034137998886240695\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.03860740729445311\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.003117823646487494\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#048_{name}_10-56-03'\n", + " | | | \n", + " Measured | my_controller_mychan_demod_1_data | data | (4096,)\n", + "acquired at 2017-10-25 10:56:03\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan1d.num_averages(1000)\n", + "\n", + "chan1d.alazar_channel('A')\n", + "chan1d.demod_freq(1e6)\n", + "chan1d.demod_type('magnitude')\n", + "\n", + "chan1d.prepare_channel()\n", + "\n", + "# Measure this \n", + "data1d = qc.Measure(chan1d.data).run()\n", + "qc.MatPlot(data1d.my_controller_mychan_demod_1_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are free to add more demodulators with different frequencies" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan1d2 = AlazarChannel(myctrl, 'mychan_demod_2', demod=True, integrate_samples=False)\n", + "myctrl.channels.append(chan1d2)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (11.295441 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (11295.440844 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (1.85065e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0013169813766324978\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.0042931657434728265\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03142046016050415\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.04751865870241545\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.003820155064218511\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#049_{name}_10-56-04'\n", + " | | | \n", + " Measured | my_controller_mychan_demod_2_data | data | (4096,)\n", + "acquired at 2017-10-25 10:56:04\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan1d2.num_averages(1000)\n", + "\n", + "chan1d2.alazar_channel('A')\n", + "chan1d2.demod_freq(2e6)\n", + "chan1d2.demod_type('magnitude')\n", + "\n", + "chan1d2.prepare_channel()\n", + "\n", + "# Measure this \n", + "data1d = qc.Measure(chan1d2.data).run()\n", + "qc.MatPlot(data1d.my_controller_mychan_demod_2_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ChannelList(, AlazarChannel, [, , ])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myctrl.channels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can get the data from multiple chanels in one provided that the shape (buffers,records,samples) is the same, The time overhead is fairly small as we are only capturing the data once." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\jens\\qcodes\\qcodes\\instrument\\parameter.py:1092: UserWarning: MultiParameters do not support set at this time.\n", + " warnings.warn('MultiParameters do not support set at this time.')\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (10.871801 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (10871.801493 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (1.78124e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0023673993884578692\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.0032832160972624536\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03982790974146866\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.04307740220071565\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.003267673898871948\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#050_{name}_10-56-05'\n", + " | | | \n", + " Setpoint | time_set | time | (4096,)\n", + " Measured | my_controller_mychan_data | my_controller_mychan_data | (4096,)\n", + " Measured | my_controller_mychan_demod_1_data | my_controller_mychan_demod_1_data | (4096,)\n", + " Measured | my_controller_mychan_demod_2_data | my_controller_mychan_demod_2_data | (4096,)\n", + "acquired at 2017-10-25 10:56:06\n", + "Wall time: 330 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "data = qc.Measure(myctrl.channels.data).run()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\jens\\qcodes\\qcodes\\instrument\\parameter.py:1092: UserWarning: MultiParameters do not support set at this time.\n", + " warnings.warn('MultiParameters do not support set at this time.')\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (10.402711 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (10402.710750 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (1.70438e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0023879268202904314\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.003274711875501879\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03432714450813634\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.05176343835655928\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.004050648798809675\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#051_{name}_10-56-06'\n", + " | | | \n", + " Setpoint | time_set | time | (4096,)\n", + " Measured | my_controller_mychan_data | my_controller_mychan_data | (4096,)\n", + " Measured | my_controller_mychan_demod_1_data | my_controller_mychan_demod_1_data | (4096,)\n", + " Measured | my_controller_mychan_demod_2_data | my_controller_mychan_demod_2_data | (4096,)\n", + "acquired at 2017-10-25 10:56:07\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAErCAYAAABJplMyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data1 = qc.Measure(myctrl.channels.data).run()\n", + "plot = qc.MatPlot()\n", + "plot.add(data.my_controller_mychan_data)\n", + "plot.add(data.my_controller_mychan_demod_1_data)\n", + "plot.add(data.my_controller_mychan_demod_2_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1D records trace" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also do a 1D trace of records" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan2 = AlazarChannel(myctrl, 'myrecchan', demod=False, average_records=False)\n", + "myctrl.channels.append(chan2)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 55, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (798.129233 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 5500 records (43897.107836 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 9.0112e+07 bytes (7.1921e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0022369035718021735\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.08474193059323198\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03586758164273007\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 8.797470769650317e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.002131333922374523\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#052_{name}_10-56-09'\n", + " | | | \n", + " Measured | my_controller_myrecchan_data | data | (55,)\n", + "acquired at 2017-10-25 10:56:09\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan2.num_averages(100)\n", + "chan2.records_per_buffer(55)\n", + "chan2.alazar_channel('A')\n", + "\n", + "chan2.prepare_channel()\n", + "\n", + "# Measure this \n", + "data2 = qc.Measure(myctrl.channels[-1].data).run()\n", + "qc.MatPlot(data2.my_controller_myrecchan_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again it is posssible to demodulate the data" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan2d = AlazarChannel(myctrl, 'myrecchan_D', demod=True, average_records=False)\n", + "myctrl.channels.append(chan2d)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2e-07\n", + "2e-06\n" + ] + } + ], + "source": [ + "print(myctrl.int_delay())\n", + "print(myctrl.int_time())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'raw_value': 2e-06,\n", + " 'ts': datetime.datetime(2017, 10, 25, 10, 56, 10, 645745),\n", + " 'value': 2e-06}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myctrl.int_time._latest" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan2d.alazar_channel('A')\n", + "chan2d.demod_freq(1e6)\n", + "chan2d.demod_type('magnitude')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 55, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (744.386331 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 5500 records (40941.248185 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 9.0112e+07 bytes (6.70781e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0020943845450744902\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.09148519195054661\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.037805371207813465\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 8.797470805177454e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.002615781313643595\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#053_{name}_10-56-12'\n", + " | | | \n", + " Measured | my_controller_myrecchan_D_data | data | (55,)\n", + "acquired at 2017-10-25 10:56:12\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan2d.num_averages(100)\n", + "chan2d.records_per_buffer(55)\n", + "chan2d.alazar_channel('A')\n", + "\n", + "chan2d.prepare_channel()\n", + "\n", + "# Measure this \n", + "data2d = qc.Measure(myctrl.channels[-1].data).run()\n", + "qc.MatPlot(data2d.my_controller_myrecchan_D_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ChannelList(, AlazarChannel, [, , , , ])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myctrl.channels" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ChannelList(, AlazarChannel, (, ))" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myctrl.channels[-2:]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\jens\\qcodes\\qcodes\\instrument\\parameter.py:1092: UserWarning: MultiParameters do not support set at this time.\n", + " warnings.warn('MultiParameters do not support set at this time.')\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 55, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (793.327579 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 5500 records (43633.016862 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 9.0112e+07 bytes (7.14883e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0020741503622687674\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.08058072691154905\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.04062642683979334\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 8.797470769650317e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0024577200885289585\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#054_{name}_10-56-13'\n", + " | | | \n", + " Setpoint | records_set | records | (55,)\n", + " Measured | my_controller_myrecchan_data | my_controller_myrecchan_data | (55,)\n", + " Measured | my_controller_myrecchan_D_data | my_controller_myrecchan_D_data | (55,)\n", + "acquired at 2017-10-25 10:56:13\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcUAAAErCAYAAACvj5h2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = qc.Measure(myctrl.channels[-2:].data).run()\n", + "plot = qc.MatPlot()\n", + "plot.add(data.my_controller_myrecchan_data )\n", + "plot.add(data.my_controller_myrecchan_D_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1D Buffer trace" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also do a 1D trace over buffers in the same way" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": true, + "scrolled": false + }, + "outputs": [], + "source": [ + "chan3 = AlazarChannel(myctrl, 'myrecchan', demod=False, average_buffers=False)\n", + "myctrl.channels.append(chan3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 100, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (283.733270 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 10000 records (28373.326965 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+08 bytes (4.64869e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.002692319309481661\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.31399228931010015\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03245885496225753\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 5.864980536784969e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0029738383746291674\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#055_{name}_10-56-16'\n", + " | | | \n", + " Measured | my_controller_myrecchan_data | data | (100,)\n", + "acquired at 2017-10-25 10:56:16\n", + "10000\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngDLGGJOXLEAZY4zJSxagjDHG5KX/Dy5fc3nNuhmyAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan3.num_averages(100)\n", + "chan3.buffers_per_acquisition(100)\n", + "chan3.alazar_channel('A')\n", + "alazar.buffer_timeout._set(10000)\n", + "alazar.buffer_timeout._set_updated()\n", + "chan3.prepare_channel()\n", + "\n", + "# Measure this \n", + "data3 = qc.Measure(chan3.data).run()\n", + "qc.MatPlot(data3.my_controller_myrecchan_data)\n", + "print(alazar.buffer_timeout())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And demodulate this" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan3d = AlazarChannel(myctrl, 'myrecchan_d', demod=True, average_buffers=False)\n", + "myctrl.channels.append(chan3d)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 100, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (357.711887 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 10000 records (35771.188743 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+08 bytes (5.86075e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0013322303259926116\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.23545697435625357\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.039621462427028575\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 8.797470769650317e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0028178298926917478\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#056_{name}_10-56-18'\n", + " | | | \n", + " Measured | my_controller_myrecchan_d_data | data | (100,)\n", + "acquired at 2017-10-25 10:56:18\n", + "10000\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsvXmYXFd1r/2umrp6Vk+SLMmSbMnz\ngI3NZDMkNnBtg3ESHMBAgMQE7k0gl4TcEEIghDj54D5hCBe4XMIYM4fRiQ1mMuApNpJsy5YHjdZg\nTT13V9dctb4/9tnVp6qrqqu6q3pQ7/d5+lHr1Dmndp0+ddZea/32WqKqOBwOh8Ox1Ags9gAcDofD\n4SiHM1AOh8PhWJI4A+VwOByOJYkzUA6Hw+FYkjgD5XA4HI4liTNQDofD4ViSOAPlcDgcjiWJM1AL\niIh8WURuWexxOJYHYviKiIyIyKcWezyliMg6EZkUkadE5KrFHo/j1MMZqCWIiPxSRN46h+N+IiIv\nF5E3i8h2EZkQkSMi8r9FJOTbr1dEvi8iUyJyUERe73vtNBG5TUSOioiKyOaS99glIjHfT1ZE/qPK\nmF4jIveJSFxEflnm9Uu8sca9fy+pcq7ni8hPvQf2oIj8u4ic5nv9gyKSKRnfmSXneL2IfL1kW4eI\nHPZ+/yMR+VitY5ztPUUkKCK3eNdzUkQeEpFVlT5jCRcCrwXOU9V31HjMgqGqR1W1E/gP4M9qPa7B\n98Rm7z71X//3l+zzUhHZ4d3vh0XkNfMY21XeuSZEZL+IvK3Wz+2oH2egThFEpB24DPgV0Aa8C+gH\nngdcDfylb/dPA2lgDfAG4P+KyAXea3ngx8Cry72Pql6gqh2q2gF0AoeAf68ytBHgE8CHy4w5AvwQ\n+CrQA3wF+KG3vRw9wOeAzcAmYBL4Usk+37Lj8372l7x+HXBHybZLgYe83y8DdtQ5xmrv+ffAFcAL\ngC7gD4Bkhc9XSi8wpKonatx/sXgM6Ktj/0beE5ZVvuv/D77znQ98HXgf0A1cAmyf49jCwPeB/+ed\n67XAx0TkWbOMzTFXVNX9NOkH8+DbgXmQfgv4JnAL5ov3n8AgMOr9vsE75h+BHOYhFgM+5W3/F+Aw\nMIH5gr2o5L1eBdxWYRx/AfyH93s7xjid7Xv9VuDDJceEAAU2V/l8L/HG2F7DtXgr8MuSbS8HngHE\nt+0QcE2N1/fZwKTv/x8Evlpl/wBwAugv2f7nwN95vz8AnF/rGKu9p/d3jgFb5nj/XA0cKrP9l8A/\nAPd699ZP/J8JM2E4DowDvwYu8L32ZeAzwI+8sd0LrMU8lEeBJ4FLffuvA77r3asHgD8rM543AffP\n4fPN+57ATFYUCFV4/evAPzRobGu892rzbfsNcNNc/r7uZ/Yf50E1CW/G9wPMw78X89CwXkkAM/Pf\nBGwEEsCnAFT1fcDdwDvUzAZtaOc3mNlfL+ZL9+8iEvW95XXA7RWG82Jgl/f72UBOVXf7Xn8EuGDG\nUbPzZuA7qjo1h2Px3nOnet90j511jMX/uSzXeyHAXSLyP0peey6wX1WHAETkCyIyBnwE+F/e75cD\n94mIPW8tY6z0nhcBWeBGETkuIrtF5E9r+WAiEsAzUBV2eT3wh8BqIEKxh/wj4CzvtR3A10qOfQ3w\ntxgPOwXc7+3XD3wH+JhvDP+BuT/We+N5l4j8t5LzHQbOFZGNtXy2WZjrPXHQC2d/SUT6fdufDyAi\nj4rIMRH5qoj0zmVgajzZbwB/6IVuX4D5Dt8zl/M5ZscZqObxfCAMfEJVM6r6HYyRQVWHVfW7qhpX\n1UmM1/SSaidT1a96x2VV9aNAC3COb5drmRm6QkT+EPPQ/WdvUwdmZu1nHBOuqxkRaQNuxMzI58qc\nxyIiFwMfAP6Xb/O3gfOAAeCPgQ+IyE2+11+B7xqp6s3AGcDTmIfznwCfVdVVqmofiLONsdp7bsCE\ngs723udG4IMi8rJZPlsvZtLyzpLP5+dLqrpbVRPeGAp5GlX9oqpOqmoK4+E9S0S6fcd+X1W3q2oS\nE7JKquq/qWoO4+lf6u33HGBAVT+kqmk1oct/BV7nH4iq3gX8DGMkPlHts9VAvffEkDfOTZjwbCfF\nBnkDJqz6aozRbgX+zzzG9w3MfZfCTCTfp6qH53E+RxWcgWoe64BnSmaCB8E83EXk/4kRKExgwjCr\nRCRY6WQi8m4ReUJExr2ZfjfmoYqIXARMlH5RROR3MLH0a63XgAnrdJWcvgsTKqqH38PE63/le7/P\n+hLVf1PDOSqORUQ2+hPf/h1EZCvGS/ifqnq33a6qj6tJ3OdU9T5MWPRG36GF/JOIvMq7jkcwD7fj\nmHzHm0RkTEQun22MNbxnwvv3Q6qaUNWdmDDvddUuiqqOYEKxX8HkTspx3Pd7HPNgt6KMD4vIPu/e\netrbx+9V+HNaiTL/7/B+3wSs867HmHe9/gYT6iogIs/2PtO5qvquap+tBuq6J1Q1pqrbvInbCeAd\nwMtFxJ4jwbQxjwH/5I217vtVRM7FGPA3YbzWC4C/EpFXzPMzOyrgDFTzOAasFxHxbbMhkHdjvJ/n\nqWoXJlQFYPct6oEiIi8C3oMJzfSo6irMrNLuPyO8JyLXYGa716vqo76XdgMhETnLt+1ZzAyVzcab\ngX/zG2BV/e86naj+pxrOsQu4uOQaXQzsUtVDvnPZByYisgkzW/8HVb11lvMr3jUSkbXAaXgCCFW9\nzbuOtwJv8X4fwXgMq1R122xjnO09MaEpu60uVDWLCa+dX+ehrwduAF6KmcRs9rZLpQOqcBg44F0P\n+9OpqqUG9jzgcVV9ag7vUUrd90QJ9lr7/wZlr/8c7tcLgadU9U5VzXuf93ZM9MLRBJyBah73Y/IP\nfyYiIRH5PUwOBEwYIgGMeeGcvys59gTgl0d3eucaxBiXD1A8yywKXYlZk/I14NWq+qD/xF6+6HvA\nh0SkXUSuxDzQbvUdH8WEEAFaSnJdiMgG4LcxM/yqeDP6KEZ0ERCRqKeGApPsz2GuUYuI2HzbLyqc\na7332qdV9bNlXr9BRHrE8FyM9PmH3svXAT8u8WjBU+2JyBnAMS/s5afqGKu9p6ruwwsDeceeh1F+\n/WeVS+YnhZmp10Ond9wwRs1Zy4O3Eg8CEyLyHhFp9f6WF4rIc0r2C3vvWRMNvieeJyLniEhARPqA\nT2LEDTZM+CVMzuhMLyz9Hqpc/1nG9hBwlhipuYjIFuCVmBydoxk0Qmnhfsr/YHI/DzGt4vsWRsW3\nDvNFjGE8mrfjUyJhJMm7MaqqTwJB4AsYBd8x4K8woRs7Sx7Ep2IC7sIYtJjv50e+13sxAo4pTBL+\n9SXj1tKfktffC9xd4zV4S5nzfdn3+qUYVWIC491cWuVcf+cd7/9cMd/r38A8mGMYNdqf+V77DnBj\nyfnC3rUTTI7iCxXet+IYq72n9/p6jGw/BuwH3l7H/fNi4GiZ7b8E3lpyje/xfu/AGMhJTEj5Td41\n2+q9/mXgFt+xRWo1YCuQ9f1/nfcZj3v3438BLy0Zz83Ar+v4XI28J27CqAunMN+NfwPWluzz997f\neRAzEeuZx9heg5HVT2LCwx8BAgv1TFlpP+JddMcyRcyiwxtVteLiw5WOmEXKxzFy79IE/JJFRM7G\nhLzOVtUDiz2ecohR+n0SWO3uQUejcSG+5c8Y8PHFHsQSpxd4/3IyTgBqlgJ8GrhbRD652OMpRUTW\nYbyS5wMfXeThOE5BnAflcCwCIvIj4EVlXvonrS1hv6QpVV76uFZ9ykuHoxrOQDkcDodjSeJCfA6H\nw+FYkjgD5XA4HI4liTNQDofD4ViSOAPlcDgcjiWJM1AOh8PhWJI4A+VwOByOJYkzUA6Hw+FYkoQW\newBLkf7+ft28efNiD8PhcDhOSbZv3z6kqgOz7ecMVBk2b97Mtm3bZt/R4XA4HHUjIgdr2c+F+BwO\nh8OxJHEGyuFwOBxLEmegHA6Hw7EkcQbK4XA4HEsSZ6AcDofDsSRxBsrhcDgcSxJnoBwOh8OxJHEG\nyuFwOJYg8XSWL95zgHx+5TaVdQbK4XA4liC/3j3Ih/7zcR47Or7YQ1k0nIFyOByOJUgslQNgPJFZ\n5JEsHs5AORwOxxIkkXEGyhkoh8PhWIIk0lkAJhLZRR7J4uEMlMPhWHBUldt3HmNkKr3YQ1myJNJ5\nwHlQDofDsaDsODTGn359B6//1/9iLO6MVDniGc+DSjoD5XA4HAvGvXuHEIH9g1O8+Uu/YXIFP4Qr\nkUi7HJQzUA6HY8G5Z+8QF6zr4tNveDaPPTPOzV/ZVnggOwz2ekw4A+VwOBwLQzyd5aFDo1y5tZ+X\nnb+Gj7/2Eh48MMIX7tm/2ENbUsQ9Fd9E0okkHA6HY0F48MAImZzywq39ALzqWesY6GzhyGhikUe2\ntEi6EJ8zUA6HY2G5d+8QkWCAyzf1Frb1tkUYdWKJIuKegZp0BsrhcDgWhnv2DnPZph5aI8HCtlVt\nYUbjK/dBXA63UNcZKIfDsYAMx1I8cWyCF57VX7S9py3i5OYlFEQSyQyqK7NgrDNQDodjwbhv3zAA\nV2zpK9re0+48qFKsB5XJaeH3lYYzUA6Ho2kMxVJ8e9thkt4D9t69Q3RGQ1y0vrtov1VtEUan0ivW\nUyhHPJ0jGBBg5ZY7cgbK4XA0je9sP8JffWcn13zi19y7d4h79g7xgjP7CAWLHz09bWGyeSWWWpkP\n4nIkMzkGOlqAlZuHaqqBEpFrROQpEdkrIn9d5vUWEfmW9/oDIrLZ2/4yEdkuIo96/17lbW8TkdtF\n5EkR2SUiH/ada6OI3CUiD4nIThG5ztseEZEveed6RER+q5mf2eFwTDOVyiLGCeANn3+AI6MJrtza\nP2O/nrYIAGMuzAeYWoXxdJY13VFg5ZY7apqBEpEg8GngWuB84CYROb9kt5uBUVXdCnwc+Ii3fQi4\nXlUvAt4M3Oo75p9V9VzgUuBKEbnW2/63wLdV9VLgdcBnvO1/DOCd62XAR0XEeY4OxwKQSOdoDQf5\n8btezDuv2sqmvjZeev6aGftZA+Wk5oZ0Lk9eYW2X50GtUMPdzAf1c4G9qrpfVdPAN4EbSva5AfiK\n9/t3gKtFRFT1IVU96m3fBURFpEVV46p6F4B3zh3ABm8/Bbq837sBe/z5wM+9Y04CY8DlDfycDoej\nAsmsMVDRcJB3v/wcfvW/fpv1q1pn7NfTHgZwQgkPq+Bb2+U8qGaxHjjs+/8Rb1vZfVQ1C4wDfSX7\nvBp4SFVT/o0isgq4Hs/4AB8E3igiR4A7gHd62x8BbhCRkIicAVwGnF46WBF5m4hsE5Ftg4OD9XxO\nh2PFE0tlC0IIP4l0nmg4WOaIYlYVQnzOg4JpBZ8N8bkcVOORMttKJTpV9xGRCzBhv7cXHSQSAr4B\nfFJVbQGvm4Avq+oG4DrgVi+U90WMcdwGfAK4D5iRiVXVz6nq5ap6+cDAQA0fz+FwWP7wSw/yN99/\ndMb2ZDZHNDz7Y8aG+Fx/KIOtIrGm0/OgVqiKL9TEcx+h2FPZwHTYrXSfI57R6QZGAERkA/B94E2q\nuq/kuM8Be1T1E75tNwPXAKjq/SISBfq9sN6f251E5D5gzzw/m8Ph8BidSrPt4Cjh4ExDlEznavKg\nulvDiLgQn8WG+DqiITpaQi7E1wR+A5wlImeISAQjXLitZJ/bMCIIgBuBX6iqeuG724H3quq9/gNE\n5BaMIXtXybkOAVd7+5wHRIFBT/nX7m1/GZBV1ccb9SEdjpXOAweGUZ2e9fuxOajZCAaE7tawC/F5\n2BBfWyRIVzS0YkN8TfOgVDUrIu8A7gSCwBdVdZeIfAjYpqq3AV/AhOL2Yjyn13mHvwPYCrxfRN7v\nbXs5EAHeBzwJ7BCjX/2Uqn4eeDfwryLy55gw4Vs8Y7cauFNE8sAzwB806zM7HCsRWx2ifA4qR1uk\ntsdMT1vEeVAe1oNqiwTpag2v2J5QzQzxoap3YAQL/m0f8P2eBH6/zHG3ALdUOG25vBWeV3Rlme1P\nA+fUPGiHw1EX93sGqlw5nmQmT2/77B4UmIKxzoMyWG80GjYGaqV6UG49kMPhmDMnJ5PsORkjIJTt\niJvM1CaSAONBOZGEIVkI8YXoioZXbNNCZ6AcDsecsd7TZZt6KnhQteWgwHpQK9NTKMV6UK3hIN0r\nOMTnDJTD4Zgz9+8bpjMa4rJNveVzUJnaVHxgc1DOg4LpcGlrJEhXa8gZKIfD4ZiNk5PJoorj9+0b\n5nln9NHREiSTUzK5fNH+yUy+qDFhNXrbI8TTOVLZldlawk8ibUJ61oOaTGXJ5VdepXdnoBwOR018\n48FDPPcff857v/coqsqR0TiHRuJcsaWv4CX5w3yqWpcHtarNlDtyYT5zHUMBIRIK0BU112VyBa6F\naqqKz+FwnBp86zeHeO/3HmVjbxvf/M1h2iIhzj2tE4Artvax/eAoYBbm2gdqKmu8qXpEEmCqSazx\natCtVOLp6dxdd6u5nuOJTKEk1ErBGSiHw1GVb//mMH/9vUf5rXMG+OwbL+MjP36SL957gP6OCH3t\nEc5e3cnjRyeAYg/K5qTqEUmAq2gOXhV4LzTa5RmolVjuyIX4HA5HRXYdHec939vJi84yxikaDvKB\nV57Pay8/naFYmudv6SMQkIIR8hso+3s9IglwIT4w184aKL8HtdJwHpTD4ajIk8cmUYW/f9UFBUMj\nIvzT713EltXtvOTs1QCFh6m/3FEyY0J8tXpQve2uJ5TFH+LrajWP6ZVYj88ZKIfDUZGhmOlyM9DZ\nUrQ9GBDe9uIthf/bh2nSZ6AShWoItQVqnEhimqTzoAAX4nM4HFUYnEzRGg7SPotU3D5Mi3JQ2fpC\nfC2hIG2RoKsmgfGg2mwOKmpzUM5AORwOR4GhWIr+zgheYeaKlMtBJdP1GShwi3UtCV+Iry0SJBSQ\nFRnicwbK4XBUZCiWpr+jZdb9Cuug0jM9qFpzUODKHVmMSMJkYERkxRaMdQbK4XBUZHAyxUANBsqG\n+PzljhJpuw7KeVD1Yjyo6cezqcfnZOYOh8NRwIT4ZjdQbWVVfPV7UD3tEedBAfF0tqiP1kptWugM\nlMPhKEs2l2ckXmOIL1RtHVTtj5metrDzoDASfb/n2dUadjkoh8PhsIxMpVGdKTEvRyAgtIQCZStJ\nRGssFguwqi3CeCKzIgujWrK5POlcvuCVAi4H5XA4HH4G7Rqojtrqv7VGgkXroAoGKlRPDiqM6spc\n82NJlAmNuhyUw+Fw+BiKmVBbLSE+MA/UYg8qTzAghIPVJep+bLmjlRzms0pIf5uSrqhpWuhvdbIS\ncAbK4XCUZXDSeFD1GajpflCJTI5oKDDrGio/09UkVrCBquBBpXP5QoX4lYIzUA6HoyyVyhxVojUS\nLDTag+JyPbVSqMc3tfRCfCcnkowuQJULq4QszkEZRd9KC3021UCJyDUi8pSI7BWRvy7zeouIfMt7\n/QER2extf5mIbBeRR71/r/K2t4nI7SLypIjsEpEP+861UUTuEpGHRGSniFznbQ+LyFe8cz0hIu9t\n5md2OE4VhmyZo5baSnaWhvgSmRwtdeSfwNcTagl6UH/ytR383W27mv4+iTLikpVa7qhpBkpEgsCn\ngWuB84GbROT8kt1uBkZVdSvwceAj3vYh4HpVvQh4M3Cr75h/VtVzgUuBK0XkWm/73wLfVtVLgdcB\nn/G2/z7Q4p3rMuDt1hA6HI7KDHpljmrFeFDFIol6PailHOI7Opbg2Hii6e9jr2FbSYgPnAfVSJ4L\n7FXV/aqaBr4J3FCyzw3AV7zfvwNcLSKiqg+p6lFv+y4gKiItqhpX1bsAvHPuADZ4+ynQ5f3eDRz1\nbW8XkRDQCqSBiUZ+UIfjVGQoVlsVCUu0JAeVzOTrWqQL0NESIhQQRpfgYt3xRGZBlHRlRRK2aeEK\nWwvVTAO1Hjjs+/8Rb1vZfVQ1C4wDfSX7vBp4SFVT/o0isgq4Hvi5t+mDwBtF5AhwB/BOb/t3gCng\nGHAI44GNzPlTOebEiYkk3952mHd+4yGe908/4xsPHlrsITlmYWiytkW6ltZwsKTUUa6uRbpg6s6t\naossOQ8qk8szlc41zIPJ5PJkc+UFD/HMzBxUrxf6tMrKlUIz+0GVk+6UaiSr7iMiF2DCfi8vOsh4\nQ98APqmq+73NNwFfVtWPisgLgFtF5EKMJ5cD1gE9wN0i8jPfcfacbwPeBrBx48baPqGjJiaSGV78\nv+8ilc0z0NnCeDzDziNj3PRcd52XMkOxFJdt7ql5/9ZwcEax2I4a81d+etvDfP+hZ7h7zxCRYIAX\nnz3AB191Qd3naSTWMDXKg3nj5x8gk8tz683Pm5HjK1cFft2qKOGgcGBoqiHvv1xopgd1BDjd9/8N\nTIfdZuzjGZ1uYMT7/wbg+8CbVHVfyXGfA/ao6id8224Gvg2gqvcDUaAfeD3wY1XNqOpJ4F7g8tLB\nqurnVPVyVb18YGBgDh/XUYmhyRSpbJ73v/J8Hvybq1nf00oslZv9QMeiYcsc1RPia40EiftUfMaD\nqi/EB/DnLz2b37lkPc89o5e8Krc/eqzuczQaa6Di6RyZCp5PrUylsmw7OMqOQ2P8j6/tIF0iHbfX\n0F+LLxQMsLmvnX0nY/N67+VGMw3Ub4CzROQMEYlghAu3lexzG0YEAXAj8AtVVS98dzvwXlW913+A\niNyCMWTvKjnXIeBqb5/zMAZq0Nt+lRjagecDTzboMzpqwMpmT+9pRURobwkST628VfHLCVvmqJZC\nsZbWSLDQ5h0gla0/BwVw7UWn8eFXX8zHXnMJL79gLZNLIO/iL2A7XyXdI0fGyOWVGy5Zx693D/KX\n//4IeV9pJ5vHK712WwY62DfoDFRD8HJK7wDuBJ7AKOx2iciHRORV3m5fAPpEZC/wF4CVor8D2Aq8\nX0Qe9n5We17V+zCqwB3e9rd6x7wb+GMReQQT/nuLmmXXnwY6gMcwRvNLqrqzWZ/bMZMpzxjZcE97\nJETMGaglTb1ljsA8UNO+3MpcclCldLSESGby8/Za5ovfKM03D7Xj4CgAH7rhQt5zzbnc9shRPnLn\n9Jw5kc4iMrPI7pbV7Rwcji/6tVhImpmDQlXvwAgW/Ns+4Ps9iZGBlx53C3BLhdOWXZauqo8DV5bZ\nHiv3Ho6FY8qGLKyBaglxcjK5mENyzIKtIlHrIl2YnvEns3k6ggGS2dycPCg/nVFzz0wms4VFvIuB\n3yhNJOc3udp+cJSz13TQ3Rrmv7/kTHYeGeM7247w3mvPA0zEoTUcnFGBY8tAB9m8cmgkzpaBjnmN\nYbngKkk4ms6Ul29q91RJ7S2hwjbH0qTeOnwwvbDUCiXmmoPy0+ktUI3N0yjMF7+qcD4eVD6v7Dg0\nxmWbjPhERLh4wyqGp9KFqEIiU96wW6O0kvJQzkA5mk68xIPqaAm6EN8Sx5Y5qldmDsYw5fNKKptv\ngIEy98xir/8Z961/mo+B2j8UYzyR4dkbp9WRm/raADg4bBR6iXT5Bc5nDrQDsG9w5Sj5nIFyNB2r\n2OuITOegppyBWtIMTqZoi9Re5gh8BiqTKxQ1bZSBmlxkD6ooxDcPA7Xdyz9ZDwpgY68xUIeG40Bl\nD6ozGmZNV8uKEko4A+VoOlax1+oL8cW9WbZjaTIUS9XlPcH0wtJEJudr9z6/R0xniwnxLbaSbyyR\npt8TjMzHg9p+cJSetjBn9LcXthU8qBFjoOLpXNEiXT8rTcnnDJSj6Uylc0SCASIhc7u1t5gvXzzj\n8lBLFWOg6hMlRH0hvul2743xoBY7JDyRyLC6M0okFJhXuHH7wVEu29RTJIDojIbpbY9w0OdBVbpu\nWwY62HcytmL6QjkD5Wg6U6lswSgBhbCRC/MtXQYn6/egrIec9HtQdRaLLWUphfi6W8NeZ9u5GajR\nqTT7Bqd49qaZ1Tk29rZxaGQ6B1XZg2pnIpldMSWPnIFyNJ2pdLZoVbxdD7XYs2JHZYZi6bok5lCc\ng7IeVL3tNkrpKBioRQ7xxY2B6oqG5lww9qHDXv5p40wDtamvrciDqmTYt6z2lHwrJMznDJSj6cRT\nuWIPKuI8qKVMJpdnNF5foViYNlDxdK5QUWK+HlRLKEgkFFgSHtSqNuNBzTUHtf3gKKGAkZWXsqm3\njaNjCdLZvFHxhcuLUwpSc2egHI7GMJXOFqnB2p0HtaSZS5kjgGjEPE78IoloaP6PmK5oaN6LY+fL\nmBfi62oNzzkHtf3gKBes6yprtDf2tZNXeGYs4XlQ5a/b2q4obZEg+06uDKm5M1COpjOVyha8JpgO\n8bnFukuTQhWJulV85u+aTOfK9jSaK53R8KJOZpKZHOlsnq7W+XlQjx4Z55LTZ3pPULwWKl4SEvcT\nCAhnDrQ7D8rhaBSlstk2q+JLOw9qKWIX6Q7U0U0Xpr2lRCZHMmtl5o0wUKFFzUFZg7SqLUxXdG4i\niVxemUrn6G0vb/Q39VoDFSeZqb7AeSVJzZ2BWobsH4zx4R89SW6ZrCOKpbJFfYGcSGJpM5cyR2Ba\nQkSCASOSKNPTaK4YA7V494qtZF5Q8SWzdcu8U57BbqmwLmygs4XWcJCnTkwCVFTxAZzZ32FCgelT\nPwLhDNQy5LO/2sdnf7WP+/YNLfZQaiKezhW8JnAy86XOiQlTyLdeFR+YCtyJdI5kgypJgJnQLAkP\nqjVCV2uo4A3VQ8oTjVTKyYkIG3vbePLYBFDd89yyuh1VVkTzQmegmshQLMUT3g3XKNLZPD9+7DgA\nP3iotP/j0qQ0B9Xmfflc08Klyd6TMU7rjlbMg1SjNWK66k53hZ3/I6YzGl5UD8oaKOtB+bfVSrLg\nQVU2PBv72th9woTuquXurJLvvn1D3LdviB889Eyhjl8jSWVziz6JdAaqifyfn+/hdz9zL6NTjVtU\nd/eeQSaSWTb1tXHnruMFtdRSJZvLk8rmi1R8gYDQHgku+s3vKM/uE5OctaZzTse2hoPFKr4GhfgW\ns5q5rWRu1kEZA1VvHqrgQVUx2Jt62wph72oe1Bn97QQDwi23P8Hr//UB3vWth/nH25+oazy18E+3\nP8EbPv9Aw89bD85ANZETEymSmTxff/BQw875nzuP0d0a5kM3XEgsleVnT5xo2LmbgQ2FlMbUTcuN\npWugvnDPAb7RwL/bciGXV/Y+rFO8AAAgAElEQVSejHH26rn1G4p6BiqRyREKCOFgYzyoWDq7aLUb\nCx5U29w9KFs8t9rCZavkg+o5qGg4yOfffDkfe82z+Ppbn8ezN64qNJhsJEdGEzx+dGJGrjuZyS1Y\ndXlnoJrIiDfz+rf7n25IF8xkJsdPdh3nmgvW8sKt/azpalnyYT6r1Cutit3eEqo7jm8ZjqWa/rD6\n5oOH+MFDzzT1PZYih0fipLJ5zp6jB9UWCXqljubW7r0cXdEQqhBbJNXnRCKDCHS2hOhqnZsHlSxU\n1qj8yN3YN11AdrZr99vnrOb3nr2BK7b2s6GnjZEGRmks8XSOdC7P8Yni5qJ37xni4g/+hJ1Hxhr+\nnqU4A9VExuJpetrCnJhIccejx+Z9vl8+dZKpdI5XPus0ggHhVc9ax692nyxqprbUsF7STAM1txDf\neDzDFR/+BT95/HhDxleJwVhqRaoM93jN8LaumZsHZXNQiUyuar6lHqzqc7HyUGOJDF3RMIGAzNuD\nqhbytFJzqG/9WG97pDkGyjOqB0vEGAeGzD2yyWdQm4UzUE1kNJ7hZeev4cyBdr5wz4F5VyD+j53H\n6GuP8IIz+wC44ZL1ZHLK7Q0wfs2itJuupT0SmpMBGJpKkcrmOTKaaMj4ypHK5hiLZ1akgdrtyZzP\nmmOIrzUcJJ7OkapSDaFebFfdxVLy2TJHwHQOqk5jWZCZV/Gg1ve0EgyYKuf1GqjJZJZ0dv5RGj8J\nz2O1bUAs+wen6O+IFIx1M6l6B4nIC0Tk0yKyU0QGReSQiNwhIn8qIt1NH90yRlUZi6fpbW/hj648\ng51HxtnmNSubC1OpLD9/4gTXXrSWkBfXv2BdF1tXd/DDJRzmm7LddEsUYR1zzEHZtR/NnE0Pe+uA\nFrvN+GKw58Qk67qjBaNQL9GwCfElMjmi8ywUaym03Fikv4etZG7HIjIHFV9m9hxUOBhg3aooAG0V\navGVo6fdLKhudCTFTi5tEVvL/sGpon5WzaSigRKRHwFvBe4ErgFOA84H/haIAj8UkVctxCCXI1Pp\nHJmc0tMW5veevZ7u1jBfvOfAnM/38ydPkszkuf7idYVtIsLvXLKOB58e4Zmx5nkU8yFuu+mWy0HN\nwUDFPQPVTO/GlvqZXJEeVGzOCj4oVvE1oswRLH7LDVvJHIwCtaMlVL+KL1ub7H5Tr3nwR+vwPvs8\nAzXSYANlK9LbNiCW/UMxzuyfm4ddL9Wuwh+o6s2qepuqHlXVrKrGVHWHqn5UVX8LuG9BRrkMsdLy\nnrYIbZEQr3vu6dy56zjj8bmFKe7fN0x3a5jnbO4t2v7S89cA8OCB4fkNuEkUPKiWmSq+uayDsqKL\nZs6mrYFKZ/OFB8upQiKdq1iBJJdX9g3G5hzeAy8H1XAPyobVFifEN+HzoIA59YSqxYMCsxYKZkYc\nqtHT5hmoBveIst81vwc1nsgwFEtz5sAie1DAB0XkimoHq2rVUgYico2IPCUie0Xkr8u83iIi3/Je\nf0BENnvbXyYi20XkUe/fq7ztbSJyu4g8KSK7ROTDvnNtFJG7ROQhLyR5nbf9DSLysO8nLyKXVBt3\nI7DlUWzs+tLTe8grHCqJ59bKRCJDX0eEQECKtm8d6CAaDrDzyPj8BtwkpnNQJR5UJDinWnyJhfCg\nfJLdU6mgrapy9Ud/yWd/ta/s6/NV8IFvoW4mT/RU8aBKDFRXtP6CsbV6UFds6ePctZ2Fxey10NfR\neA8qn9eCUT00HC/kz231ijMHFt+D2gN8VESeFpGP1PtQF5Eg8GngWkxo8CYROb9kt5uBUVXdCnwc\n+Ii3fQi4XlUvAt4M3Oo75p9V9VzgUuBKEbnW2/63wLdV9VLgdcBnAFT1a6p6iapeAvwB8LSqPlzP\nZ5kL9max8eENPa0APDM2RwOVzJTNC4SCAS5Y182jS9RATcvMZ3pQ8XSubrn4Qob44NTKQ52cTHF0\nPMlDh8rLgwsCiTkq+MCE+FLZPPF0tiGtNmBx276rapFIAjwPqk5vLlWjB/XKi9fx43e9eMZEtBrW\ng2pkQQAb3lvbFWUylS2oBPd7RWoXPQelqv+iqi8AXgKMAF8SkSdE5AMicnYN534usFdV96tqGvgm\ncEPJPjcAX/F+/w5wtYiIqj6kqjbzvwuIikiLqsZV9S5vfGlgB7DBDhno8n7vBsopB24CvlHD2OeN\nTVj2eDf2+lXGQM1VfTaZzNIVLe/2X7S+m11lFtQtBexDpZxIAqZDgLVipa8LZaAmU4vbybWR7B+c\n8v4tXwnbSsznm4MCo2BtVA6qNRwkGJAZKr5sA9YWzsaUFxIt8qBaQ/ModdR44bQ1nsMNNFD2e3nu\naeZesEq+/YNTBAOmbuBCMOvVUtWDqvoRzzN5PfC7QC11NdYDh33/P+JtK7uPqmaBcaCvZJ9XAw+p\natFSaRFZBVwP/Nzb9EHgjSJyBLgDeGeZMb2WCgZKRN4mIttEZNvg4GD1T1YD/hwUmJuoPRKcs5hh\nMpkpzCRLuWh9N4lMbkmW4I+nc0TDgYJ81tI+x55QiQXIQZ2cnF6YeCp5UE979doOjsTLSpJ3n5hk\n/arWGYKWerBGaXQq3bAclIjMqGj+8OExzv/AnRwZnVtEolb8ZY4sJgdVp8y84EE13kCFgwG6W8ON\n9aC8SMV5p5k5/yEvD7V/KMbG3jYiTfgc5Zj1XUQkLCLXi8jXgB8BuzFGY9ZDy2wrneJX3UdELsCE\n/d5eMqYQxtB8UlX3e5tvAr6sqhuA64BbRSTgO+Z5QFxVHys3WFX9nKperqqXDwwMVP9kNTDqK9Hv\nvT/re1rn6UGVl/5evMEo/pdimG+qpNWGxYb86vWEFirEt5hhpWZh8we5vM5QZgHsORFj6zwEEjC9\nEDWb14Z5UGArmk//LXYeGSOdy7NvsPYiqQ/sH+Zbv6mvfNV0odjp3lhzyUElszkioQAitYfu6qG3\nPdJQD8p+z85Z04nItFBiISXmUF1m/jIR+SLG83kbxivZoqqvVdUf1HDuI8Dpvv9vYGbYrbCPZ3S6\nMeFERGQD8H3gTapamtX9HLBHVT/h23Yz8G0AVb0fI4Xv973+OhYovAdm5tUVDRXWLIEJ8z0zDwNV\nyYM6c6CDtkiQR59ZmgaqnCKpY44tN6bXQTUv9DYYS3Gm9yU8lQzU/sEpwkHzgCx9sFsF39nzyD9B\ncYmeRoazTEXz6b/5YS/k5A/HzsYX7jnAe7/3aOHYWvBXMrd0t4ZJeF12ayWVyTcsJ1eO3vYIow0U\nSVgDtaotzNquKAdHpsjnlQNDU4XvxkJQ7Yr9DfBfwHmqer0nNqinpvtvgLNE5AwRiWAMxG0l+9yG\nEUEA3Aj8QlXVC9/dDrxXVe/1HyAit2AM2btKznUIuNrb5zyMgRr0/h8Afh+TB1sQRuOZgkDCsqGn\nbU4hvkwuTyKTq7h4MhgQLljXtSC1seplqqSbrsUarXpzUAlfDmq+lTnKoaoMTqYKs8TFbPPQaA4M\nxXjeGSaCXhoOPuQp+OaTf4LiIqeNqsUHM5sW2kjEUB1FUk9MJMkrfPHe2tcjjpeocYHpenx1TJJS\n2XzDSj+Vo6ctwshU4yZtiUKR5xAbe9s4NBzn6HiCVDa/YAo+qG6gXuWFvUYq7SAiFUfq5ZTegVno\n+wRGYbdLRD7kW+D7BaBPRPYCfwFYKfo7gK3A+33y8NWeV/U+jCpwh7f9rd4x7wb+WEQewXhKb9Hp\nJ9iLgSO+cGDTGY2nWdVWbKDW97QynsjUPfu3X8xKHhTARetX8fixiQVJHNdDPF0+xNcxxxyUndnl\ndXptSSOJpbIkM3nO8BYinioeVDaX59BInIs2dLOmq4V9J4vnmlbBNx+JORQbpUYaqK4KBqoeD+rE\nhNn3W785XPN6xEoeFJQvGHt0LMHb/m3bjPsmlck1Jf9k6W0PMzLVuIrm0xVggmzqa+PgSLwgslmo\nNVAA1bKhPxCRh4EfAtut9yQiZwK/DbwG+FeM+q4sqnoHJjTo3/YB3+9JjGdTetwtwC0VTls2iKuq\njwNXVnjtl8DzK42zGYzG0wyUtMy2Sr5nxhKcu7b2UjLWoFUrP3Pxhm6+eG+evYMxzl3bVXG/hSaW\nypWt2WVzUHMN8YFR2DUyzwHTD7zTe01dtFNFJPHMWIJMTjmjr50tAx0zPKi9tkjsfHNQvr9HI3pB\nWTqjYSZTk4X/W3FErR5ULq8MxlK89LzV/OyJk3ztwYP8yW9tnfW4cgaqqzVU9JqfBw+M8JPHT7Dn\nxCSXbuwpbE9l8w29HqX0trcwOpVBVRuS57Lfs9ZIkE197QxOHuGxoyaFsCRCfKp6NUYh93Zgl4iM\ni8gw8FVgLfBmVa1onFY6o1OZgoLPUlgLVWceqhYP6sL1S1MoEU9lZxSKhWkPqn6RxPT+zTAe1kCt\n7oyaRnmniAe13xNInDEwbaD8IdLHnhlnQ8/8FHzQPA/KL5KIpbIFEVKtHtRQLEUur7zknNW86Kx+\nvnzv0zVVCRlLZAgHpSh0WfCgytx/1mglSlrJJBfAg0rn8g27X22koj0SKvSp+uVTg3S0hBjobKl2\naEOpesVU9Q5VfYOqblbVblXtU9UrVPUfVbW5/Q6WOWMVQnxQ/1qoiYIHVfnhcWZ/O+1LUCgRT+dm\ntNoAv8x8bio+aE74zVaRGOhsmaEcW848bQ1UfztbBtqZTGYLnzWXV+7dO1Sokj8fmieSMH8LVS14\nT6GA1OxBnfB6Gq3pbOFtLz6Tk5Mpbnt49iLLtlCs3yuxatpyHpStIJMo6XS9EB4UmIlxI7ATwdZI\nsFAfcPvBUc4caG+aErEcrt1GE0hn80ylc4VFupb+9hYioUDdQgn7kKwkMwdTxPKC9d1LruRRrIIH\nZR9kdYf4MrnCsc30oKyBip0iC3UPDE3RGQ3R1x5hixfGszmFR46MMZHM8uKz57+8orVpIokwOa/8\nzpER8/0577Sumj2o4+PGQK3tjvLCrf2cu7aTf717/6xCm/F4piCKsFTLQY0ljJIuni41UM33oKBx\n5Y4Svk7Ytj5gLq8LGt4DZ6Cagl3ct6pExRcICBvmIDWvJcQHcPH6bp44NtGQ7r2NIp7O0lbGgwoE\nhPZIsO6uuvF0jtVdZrbYjGrjg5MpQgFhVWv4lArxWXmwiLDFU2HZPNTdu4cQgRdu7a92iprwewmN\nzUHZenwZDnse1CWnr2I0nqnpfrce1NquKCLC9c9ax+4TsRmGpJTxRIZVJQaqq0rTQiu+mBniyzfV\nQBUKxjZIKDGVzhEOSmERsFUxnrFAVcwtzkA1gZGSMkd+zGLd+la/1yKSALhoQzepbJ49J5ZGRYl0\nNk8mpxXzGnNpuZFI51jtxcCb5UH1d7QU2iqcKiIJ/wLLtV1RWsPBgpLv13sGuXh994xlEXOhSGbe\nQAGLNVATySxHRhNEwwHOWWsUh8M1VPE+MZEiGBD6POGSPV8tBqpU5BMNB4mEAmVl5mOJSiG+XFND\nfH1eiK9RUvNEOlvkAdtuvwup4IM6DJQn895of5o5qOWOjQP3ts38wq9f1TrnEN9sHpQVSuw6ujTC\nfFOpaalqOUwIrX6RhE3S1ruGqhYGY6nC+Tui4VOiJ1Qyk+PoeKIw+w0EhDMH2tk3GGM8keHhw2O8\n6Kz5h/fAlN0JeWWtGlXqCIo9qCOjcTb0tBX+TrXkoY5PJBnoaJnuWOs9fEs9nVLGEjNzyVC55YaN\nnswM8TXZg7IhvgZ5UKW5Y9vefckZKBF5lYjsAQ4AvwKexpQ8clSgEOIrc2Nv6GllKJYmmak9tDWZ\nzNAaDhIOVv9zre0y3ThHGljyZD5YA1LaasMyFw8qns6xutN8zmYIGAYnfQbqFPGgDg7HUTUKPotV\n8t2/b4hcXhuSf7LYh3+jWr6Dv+278aBO72kt/J1qyUOdmEiypjta+L9dKB7PVP/7jsdnelBg1mWV\nq8dXyYNKZprrQXW0hAgHpWEeVLyk4eTW1R1EgoEFLXMEtXlQ/4BZQ7RbVc/AVGu4t/ohKxsrgbWz\nGj9zUfJVK3Pkpy1iqj4vVmO3UgpS1YohvmBdC3VzeSWVzbOqLUw4KM1R8U2mCuvXTpUc1IEhE/L1\nJ7i3DHTwzFiCn+w6QUdLiEs3rmrY+9m1ULO1lqgHf23EwyOeB+X9nQZr8KBOTCRZ45NHW6++Wojv\n8EiciWS2sDzET3dr+Xp80zmokoW6TfagRMSUO2rQ5DRRUgHmj154Bt/7kyvqaqTYCGq5YhlVHQYC\nIhLw2l00veHfcmY0XlzJ3M/6VSaWW0+Yr1YDJSIVZ3aLQaHVRkv5B1V7pD4DYGelbZFgU7ybXF4Z\nnkoXeVDxKh1olwsHhkzOc7PfQK1uRxX+c+cxXrClb1bvvB6mPajGqvjAVGqwRqO/o44Q33iStT4P\nyo6tWojvx4+ZlTQvP3/tjNe6yhgoVS14UKWGL5nJNbXUEZjnTaMKxk6lsrSFp585HS2hQgphIanF\nHI55JY1+DXxNRE4CS+MJuEQZi6eJhgNlXfq5LNat1KywHF1zaKbWLOIVuulaTNPC2m+l6bUZITqa\n4N2MxtPk8lpkoMAY2nJhnuXCgaEYqz3ZvMUq+dK5fEPDezBtoBoZ0rJjf/zYBACn97bR6k1UZgvx\nJdI5JpJZ1nT5Q3yze1A/euwY55/WVZBZ++luDc+oxhFLZQuTGX+IT9V4/s0sFgums26jCsYmMjl6\nGyCamS+1XLEbgDjw58CPgX3AK5s5qOXOSJkqEpY1XVFCAalLyVerBwVmrVS55O1iMFWhm66lvSVE\nrI4QX2FtRjhIe6Txi2j9a6AAOk6RlhsHhqaKvCcwC3btessXnzV/ebkf65008oFsDdQTx0y5IzvR\n6++IMDSLiq+wSLesgSr/tz0xkWTHoTGuvXCm92Tet2WGenDMV9/P75llcooqC+JBNSrEF69Q5Hmh\nqeUO+oCq5lU1q6pfUdVPAu9p9sCWM2PxdEUDFQwIa7ujdYX4JpKZqot0/XS1hsqWYJkPqsr7f/AY\nv3jyRF3HWQFEJQ+qoyVYl0gi7ls82BmtX2AxG6UGqrNlWjm2nCnXIiEaDrJ+VSub+toKCq1GYQQ9\nUtRqZr4EPdn/3pPGQJ3eY7yagc4WBn0NJstx3LcGqjBG756sFOK7c5cJ711TxUDF07mie9Af8vN7\nZoVuuk32oBrZEyqRztEaXth8UzlquWIvK7Pt2kYP5FRiNJ4uK5CwbOipb7HuYntQv9o9yK3/dZCf\nPn6yruPsItyKOaiWEIlM7Tke+6W3oZ1GezYFA9VR4kEtYyXfRDLDUCxdVn31rpeezXuuObfh79ka\nCTZFsdYZDZHJKe2RYGHhaH9HSx0elE8kEa4e4vvxY8fZMtBesf1If4eZgPrzX9ZAhQJSFOIrdNNt\nsgfV2x5hPJFpSEeDeDq7tD0oEfkfIvIocI6I7PT9HAB2LtwQlx9j8UxZibll/aq2OlV8ldu9l9IV\nbXwO6jN3mX6Rda9Z8vavtFC30HKjxjyUv0dNRzTceAMVKwnxWQ9qGYf4bImf9WWUaDdetoHrLjqt\n4e/ZGm6egQLTV83WgzMeVPUcVMFAlRNJlFnuMTKV5oEDI1x7YeVrU24Nlg3xremKFnlmdknJQnhQ\nMK0ing+V+rgtNNWeel/HrHf6/5ju0wQwWa1HlMPzoMpUkbCs72nlxGSSdDZPZJabNpPLk8zk6xBJ\nNFbF9+CBER582vy5Y3UavqlUFpHKCzYLTQtTldvZ+4n7etQ0o5Dr4GSKtkiwIIvvPAU8KPsA7e9Y\nuArU553WWZf4pVbshOH03mlj29/Rwngi49W6K3+fHR83f9dO30SpJRQgIOVzUD99/Di5vFYM79n3\nheI1WLYO39ruaFG4L+V13m3mOijwG6j0vCqO5/JKOptfcEl5OSqOQFXHgXHgJjCVJDBdajtEpENV\nDy3MEJcX+bwynqgskgAT4lM1s9tyCiE/tVaRsHRFp9tRz2b8auFTd+2lrz3Cxr62uj2WqXSOtnCQ\nQKB89ePpnlC1CSXsbLfVy0E1upCrf5EuQEeLMZrLWSRhE/k2JLUQvOOqs5pyXjtJ29Az/Z2xf6/h\nWJp1q2Z6iQAnJpOs8WrwWUSEtkiobIjvx48dZ0NPKxesq9xXzZbbGvSFF60HdVp3tOC5AoW2Hk33\noAr1+OaXh/JPBBebWipJXO8qSdTORDJDXstXkbDYBO/BkamK+1hsgr52kYRdcT//h/fOI2P8evcg\nN7/oDAY6Wur2WOLpbMVFuuDvqlvbef0iiY6WEMlMvqEdhP2LdOHUyEENex6UrdW2nJkO8RV7UFB9\nLdSJ8WRR/snSGgnOqOgSS2W5Z+8Q1164tmpbid72CCIwNFmcg4qGA/S0RYo8M9v5udkGytZSnK+B\n8jcrXGxquWK34CpJ1Iy9OXqriCTOWmPWoNRS1LVuD6p1uqjmfPn0XXvpiob4g+dvmtO6o1iqfC8o\nS709oQoGKhzyHVtfNfRq+OvwmfcJIrK8c1DDU2mCAVnW67gs5Two6xlWy0Mdn0gWKfgsbZHgDA/q\nmVHTefhZp1evrBEKGkM0WJSDSrOqNUJrJFgskvA8qGaH+PoaZKD8E8HFxlWSaDA2QVnNg+rvaKGv\nPcJTxycr7mOZqLGSucV6WvNV8h0cnuLOXSd4yxWb6YyG6ZxDzieeqq4EqrerbsLXRK0gAa8Q5ntg\n/zAf++nuutaF2ErmlkBA6Igs73p8Q7E0ve2RimHW5URXGQ9qtoKxqsrJiVTRGihLa3imgYrNIuzx\nM9DRUuRBGXFUmNZwkGQmT95Tp9ocVLM9qFUNCvFNLaEQn6sk0WDGqpQ58nP2mk6eOjG7garfg7Lt\nqOdnoL67/QgicNPzTOF660Gpas0dNadmCfG116nii6dzhAJCJBSYdRHtp+7ay917hvjKfU/zrpee\nxRufv6lqOZ9sLs94IjNj9XxHE3JdC8lwLFWYWS93VrWZsNrpRR5U9YKxo/EM6Vy+rIFqiwRnrIOy\n91Mt37f+zkixis9rzdHmUwi2t4RIZRbGg4qEAnRGQw0L8S0FkUStlSQSFFeSuL6Zg1rOFArFVlHx\nAZyztpM9JyYLs6xK1NJN18+0BzX3OUQ+r3x3xzO8cGs/p3Wb2WpHy3RH01qJp3Nlu+la7Gu1VpOI\np6crLBe8rzLeTS6vPHRojKvOXc1F67v5+/94nBs/e3/V9Va2htoMA9WE9VYLyfBUekEVfM3ktc85\nnS++5Tl0+75b0bARzFRaC+XvpFuKEUkU/20Li8tr9KD8Ib5x60GVSNgXyoMCc//Ot9zRsgrxqeqU\nqub8lSS8kN+siMg1IvKUiOwVkb8u83qLiHzLe/0BEdnsbX+ZiGwXkUe9f6/ytreJyO0i8qSI7BKR\nD/vOtVFE7hKRh7z1Wtf5XrtYRO73jnlURGberQ2iWqsNP2ev6WQqnZu1osR0s8J6c1Bzn/U/cGCE\nZ8YS3HjZhsI267FUCqmVI5Yq303XYh8C8ZpDfNPt3qfHM/PY3ScmiaWyXP+s07j15ufyp7+9hUcO\nj1X94k7/3YonAh3RxsvZF5LhWIq+BVTwNZPe9gi/fc7qGdtLDYWfE5MzF+laWsvkoOyEp5YQX39H\nC0OT6ULb+LFEmu7W8IxeU4V1UE32oMBEbhqVg1rSIgkRmRSRiUo/s51YRILApzFVJ84HbhKR80t2\nuxkYVdWtwMeBj3jbh4DrVfUi4M3Arb5j/llVzwUuBa4UEVvV4m+Bb6vqpcDrgM944wgBXwX+u6pe\nAPwW0LSYzWjcJKW7ZjEo56w1Qonds4T57MOxow6ZOcwvB/XdHUfoaAkVVXHumoOiLZ7K0VElTNAW\nMSKEmkUSmenFg51VPKjtB0cBuGxjLyLCZq+UT7XK1baPzinnQcXSp4SCrxr9VRbrnhifWYfP0lYi\nZoD6clD9nS0kMrlCxRS7QL+SB9XsYrFghBLzDvFlbA5qCYf4VLVTVbuAT2AW6q4HNmDq8N1Sw7mf\nC+xV1f2qmga+iQkX+rkB+Ir3+3eAq0VEVPUhVT3qbd8FREWkRVXjnkgD75w7vDEBKGAXLnQD9viX\nAztV9RHvuGFVbZz0qwRTKDY8a57GllCZLQ81kaitWaFlvj2hplJZ7nj0GK+46LSiGVS9ggYwuaVK\nZY7ArEUxLTdqXAeVzhZqqFVTAG4/OEp/R0thQWehOV1VA1U+d9gZXb4iiWQmx2Qqe8p4UJUY6Gip\nKJKwdfhsk0s/5VR8sTpDfGCk5slMjlQ2X5SDsudeqFJHYLy6kzU0cKyGVcYuixAf8N9U9TOqOqmq\nE6r6f4FX13DceuCw7/9HvG1l91HVLGZhcF/JPq8GHlLVoqsuIqswubCfe5s+CLxRRI4AdwDv9Laf\nDaiI3CkiO0Tkr8oNVkTeJiLbRGTb4OBgDR+vPGPx8i2iS+mKhlm/qpXdsyj56qnDB/PvCfXjx44T\nT+d4tS+8B9VzPuVQVaZS2YqFYi3tdRSM9VdYriaS2H5wlMs39RQmCbNVrgafuOUU8qCs0V3IRbqL\nQX9HpLIHNWFEIuUWrbeGQzO86qlUlpZQoKYJYb9PQThWUO+GC0VW7f1mQ3wL4UGt7Y4yFEuRzs59\nfWBiOeWggJyIvEFEgiISEJE3ALVMecu5EKVZ6qr7iMgFmLDf24sOMmG7bwCfVNX93uabgC+r6gbg\nOuBWEQlglIovBN7g/fu7InL1jDdV/ZyqXq6qlw8MzL0/zmxljvycvaaDJ2czUKna6/BZ5tMT6rs7\njrCxt43nbO4p2l4t51OOVDZPXmefibZHQsTqUPHZL401fKX5oZOTSQ6NxLls0/T4a2lON+IZqN62\nUgMVXrYelK0icaqH+AY6zSLy0kW34HXSLRPeA+tBZQs5JDD3d63fN/8aLFvayK6DgmnDlMrmCQYa\nW929EutWRVE134O5El9mKr7XA68BTng/v+9tm40jwOm+/29gOuw2Yx/P6HQDI97/NwDfB96kqvtK\njvscsEdVP+HbdjPwbX/Pq20AACAASURBVABVvR9Tlqnfe49fqeqQqsYx3tWzaxj/nPiD52/mzVds\nrmnfs9d2sn9wikyVagiTyWxBOl4rc61ofnQswf37h3n1szfMCFF2ttgKFbU9rKfVUNVnYe0ttbfN\n8IskggGhPRKc4d3s8PJPz/YZqFqa043FM7SEAjMSwx1RY0BnU1suRWzY61QP8VWrJnF0LFFWwQdm\n4pLX6RwRmPu2lvAeFK/B8otsSu+3ZCa3IAo+gLWe6vbY+DwMVCZLJBQguATWztVy1SZU9QZV7VfV\nAVX9HVV9uobjfgOcJSJniEgEI1y4rWSf2zAiCIAbgV+oqnrhu9uB96pqUdUKEbkFY8jeVXKuQ5gq\nF4jIeRgDNQjcCVzsKQBDwEuAx2sY/5x4xcWn8cqL19W07zlrOknn8hwcrlzyaCKZrXmRrmWuPaGe\nOj6JKrywTAO76bI/tRm+6Th29S/7mq5oza1H4pnihb8dZfJD2w+OEgkFuHD9dB01e0y19VYjU+my\nHUQ7W0KoGoHGcmMxCsUuBtOGolgckMsr+4em2Lq6o+xxbWU861gyW5NAAoy3LWI8KLtMwa/iK+Sg\nsvmmr4GynOYZ4/kYqMQSqWQOtRmoB0Tk30XkWql1hSaFnNI7MAbiCYzCbpeIfEhEXuXt9gWgT0T2\nAn/BdNX0dwBbgfeLyMPez2rPq3ofRhW4w9v+Vu+YdwN/LCKPYMJ/b1HDKPAxjMF8GNihqrfX+jma\nydlWKHG8csmjelptWObqQVlvpJwC0XpCteZjCt10Z7nRz1rTwYGh6l6kJZHOFUQSUD4/tP3gKBev\n7y6qbD1bczqonDtczvX4bPO6leJBleahDg5Pkc7mOWsWA+WffMTq8KBCwQB97REGY2nG/TmoGSG+\nhfOgrIE6Pl57O59SplK5WXPHC0UtozgbeCnwR8CnRORbmFzP7tkOVNU7MCE1/7YP+H5PYkKGpcfd\nQmWlYFkjqaqPA1dWeO2rGKn5kmLr6g4CYpR8r6B875nJZHZWyXopc+0JZUNt5dYutYSCREKBmnNQ\n8UK79+pj3zrQQTavHByOV5zpTp8zV+JBFfeESmZyPPbMBH945eai49prCPEZD2qmpzqtXsxgnPLl\nw3AsRWs4uCRyCc3EVjEvjUTYJRxnV2g6OD1xmb6HYqls2bp9lej3FIS21caqtgg2MjYd4ssvmIHq\njIbpaAlxdGweHlQmuyTWQEFtC3VVVX+qqjcBb8WE5B4UkV+JyAuaPsJTmGg4yOa+9qpKPuNBzSHE\nNwcVX2ENSIUHWmdL7ZJrm6ua1UB5RmnvyeqFc1WVRKbEQLUU56Aee2acdC5fJJCA6s3pLKPx8i1S\nCuKQ5ehBxdKnvPcEJsS3urOFXUeLl2fu9oox2+LMpZTrqltPDgqMgRqcNCq+kJcXtf3PEulpD2qh\nQnwws91HOR4/OlGxE0DpRHAxqaXdRp+I/E8R2Qb8JUa+3Y8JqX29yeM75TlnbWfFxbqFZoV1fGGg\nuCdUPdgvaiVhQ2cdFc2nq7pXf0Bu8QzUvsHqBiqZyaPKjLVZfoO5vYxAAiASNAnfajJzo74sn4OC\n5dkTamgqTd8pnn+yXLS+m8eeGS/a9tSJSU7vba3oQZYTz8RS2ZoXxYMxjsaDMmWORIRAQIiGA0UL\ndRfKgwIjNT82UdlA3b1nkOs+eTc/ffxE2dfjPjHSYlPLVbsfswD2d1T1Far6Pa/s0Tbgs80d3qnP\n2Ws6eXp4qqxEtt5CsZa59oSya0AqyWHLiRIqUauB6mgJsa47OqsHVWiiFvYbqOIQ37aDo2zua5sh\nChAR2spUrrbkbJPJMmNd1jmoWIr+U6RQ7GxcuL6bfYOxoknInhOTnFMhvAfllx/EUrWLJMBIza2K\nz9/SxF/nL5nJLcgiXctp3VGOVSihpqp89CcmO3OkgjhpuYkkzlHVf1DVI6UvqOpHyh3gqJ1z1naS\n1/Ihrsk6W21Y5toTarYvZz1t1oen0oSDs5d8AuNFzW6gZqoCO6OhwjXK5ZUHD4zwnM29ZY9vLVO5\n2jKeyKBavsCvvR7LsSfUSgnxgTFQeYUnjpkwXzqbZ//gVKFiSzlKK4xkvYhFPQZqoLOFZCbPM6OJ\nIpFNazhIIm0iGAvtQZ3W3cpgLFVWePTL3YM8fHgMqLxWylSAWRp5y1qu2mUi8n2vCsNOr9jqzqaP\nbIUwreSbGeabswc1x3p8s8XfO1rCNT+oR2ImZFaL8HOrZ6CqrTVK+tq9T49nugXIE8cmGE9kuHLr\nTIk8lC9rUxhrFW/Prv9abh6UqjI8lVpRIT6AR4+YMN/Tw1Nk81rVgyqtMGKXRtSbgwLYNzjFKp8H\nZZoWWg8qX6QqbTandZvFuidKwnyqysd/upsNPa2s645WrL6RSOeKIhWLSS0G6mvAlzAlh64HXolr\nt9EwbPO142VixtbA1OtB2f3rVfLFUtVd+846eiMNV1hXVI6tqztIZHIc9UljHz0yzru//UihRUa5\nFgAd0RB5NQ+Ae/cOAXDFltJKWYbWSKiigarWw6teef1SYSKZJZPTU6YX1Gys6Wqhv6OFR58xHpTN\n61YSSMBM8Yyt1F9PztcaqFgqWxLiC5aIJBY2BwXMEEr8/ImT7Dwyzp9ddRanrWqtWLNvWYkkgEFV\nvU1VD6jqQfvT9JGtEGw/m3KzmYk556DmpjyLp2cP8dWeg6q9zcPWgZlKvi/dd4Dv7jjCkdG4N7by\nHhSYB8u9+4bZurqD1bOUtSk/1soGKhQM0BqeWbFiqTO8QhbpWkSEC9d3seuo8aB2H58kILBloLKB\nKhVJzMWDsouEgRl9qvzFYhfSg7Kye/9iXVXlYz/dzaa+Nn732etNi5IqHlTrElmaUIuB+jsR+byI\n3CQiv2d/mj6yFcRAhXYBNr/SPYdSR9CEEJ+vq+5sjMYz9NZYA87mCayByuWVXz5lCvYeHjFeVbkW\nANZAjU5l+M2BEa6s4D2Z4yqH+EYLhWLLX+fF7gl1955Bjs7SN6yUlbJI189F67vZczJGMpNj94kY\nm/vaq8q7rRzc3hc2OlCPis8/AVjVOn2t/a08FsuDOuaLSNyzd4jHj03wzqvOIhwMsLqrfNXzTC5P\nOpdfVh7UHwKXANdgQns2zOdoEJVmM/NV8dUf4pvdg8rktKh2WSWGYyl6ayya29seobc9UpCaP3x4\ntODVHC7xoNrKeFB37xkkkclxRYX8E9ikdSUDZbsgl3+Ydy5iRXNV5Y//bRufv/tAXcdZD+pULxTr\n58L13eTyJh+5+8Rk1fAeMC0H9zxr2/alY5b6kX5626cX5vqbXfrvt4X2oLq8xbp+D+r+fcOEAsIr\nLjIFAQY6WhhPZEhli78TS6mbLtRWSeJZXuNAR5MYKLPIEHzNCutU1LRHggSk/rbvU6lc1eKunb4W\nF9VmpplcnolktmYPCkyYz3pQP3viJMGAIMDhkZIQX7g4BwXwk10nCAg8/8xZPKhM+esxOpUmEgpU\n/FIaeX3TelxWZSqdI5nJMzxVX48fW5fuVG+14edCTyix/eAoTw9P8cqLy1dn8dPmy01Od9OtPWIR\nDAi97WYtVJGB8nnsyWyOlgX0oMBbC+WrJrH94CgXrOsqhMhXd02Xh9rQ01bYL1FGLbuY1HLV/qtM\nJ1xHA6kW4muLBOsu0y8ic2q5MZXKVr0xO2tcEzRqVXF1PBy3rO5gz8kYqsovnjjJczb3sL6nlcPe\nWo1yPWqs4d52cISL1ndXDYW2tczs/VMYr9cipZLicDF7QtlrWW+XVNtqo9zarlOVdd1Retsj/PDh\no+SVqhJzi9/TqbUCfyl2EjBDJJHJkcsrmZwWwokLxWm+xbqZXJ5HjowVLWC3ubPS505hveES8aBq\nefK9EHhYRJ5yMvPmMNDZQiyVnZHEr7dZoZ96C8aqKlOziiRqa7lRyH/U8XDcurqDsXiGnUfGeerE\nJC89bw2n97TN8KBK10EB5JWq4T2g6kJd0wW58ljrWf9lyee1plzdbFjDZPNktTI8ZWb0tXZiPhUw\nQoluHvUqSpyzdnYD5c9N2iUUnXV4UDD9sJ+5Dmq6mstCe1Cm3JGZ3D1+dIJkJs/lm6bXCNoOw6V5\nqHJipMWklqt2DXAWpnW6k5k3genW0cUPIdOssL4vi6XelhvJzOwNBv2quWrUWkXCj604/blfm/6T\nV527mtN7WwsGKpHOIkJRstlvTCvJyy12RlvOaIzGq0viu1rDHBia4mM/eapmscI1//JrPv6zPTXt\nWw1rmEan6vOGh2PpFSMx93PhOtNmJRQQNve1z7q/Cf3Oz4Oy39/idVAhEplcQSixEN10/aztNjLy\nTC7vKwG2qvB6JQ/KjnfZeFB+abmTmTeHws1S0nBtIT2oQqHYWnJQTfKgAH702DHO7G/nzIEONvS0\nMTyVZiqVLdQH84fhrDGNBANFs8NytEZMX6dkZqbAo1IdPstbX3QGV27t5//ctZcXfuQX/OW/P1J1\nUXE+r+w5GeNzv943r86mdmz+f2tlKLZyFun6sQt2z+hvL9vmvRRTYcSKJLJEw5VLfVWiv+BBFYf4\ngEKn3YUsdQQm3Gk666bYfmiU9f9/e+ceJldd5vnPW9VV1d3V904HQjoXYoCEe0JAFBm5yAwwAvqI\nIs/wiD7gZV10HHRmZdQZxmX30R1XHdfLyHr3UZQFdTKCi66C7rosQhIIhJAhICQNgXTS3Unfqy/v\n/nHOr+pU9anuunZXut/P8+RJ1elzTp9Tp+u8571937YGVvjDDMH7borM9KDSEw2OoRyUUWXyzbPp\nHRwv+Sm42JEbmafHuT2oufIxfb6hLcaDWtFaT9KfcHrJhuUArOrwkrc9/aOMTMxsHkzURYhFhc1r\n2uYMSeSqBgTpH07lLTEH2HB8C99697n87q8v5i2bVnLPth6eP5RfmmkoNZk2hv/80POzHtdc9Pme\n00hqKlSvMR+Hh1NLqkDC4QolTi4gvAc5RRJF6vA5LjxpGRef0pVu74BMMY97sJhPqSMIlJoPjLL9\nxf4ZAsrpWVa5HlSNVfGZgaoBlod4UKrK/r6RrAqbYih25MZQIQaqvkADNTKBCKEDAPMhImll80s3\nHgfAat9A7e8b8ZsHozO2ufqsldxw/po599+Q05TpSAvFFnCsqzoa+cAbXwPAzp4jeddz+aqW+jp+\n8MiLHJxFWXou+gPFEcV4UYeHxpdUibmju72B89d18KaNywtaP6jRWMw03SAXntTFt99zHpHAiHT3\n9+au33yO2wDS3tK2F/s5cGSMc1a3zVinq7me3hwPv9bKzM1A1QAdyczoaEf/yATDqam0F1EsJXtQ\ns7j26RzUHCG+vuFx2hvjRCMFD2AG4NQVLbQ1xtiy1nvaW+XLQO3vH2EkNUljbOax/dd3nMWbzzxh\nzn2HjVYAr5l5WvP3QOXymq4mGmLRdCI+DNdg/cGL1zM5rXz1oecK2ncYfQGjVGgl3+TUNP0jE0uq\nSdchIvzofa/jrZu6C1o/WDxT7CyoWffr/70N+D128+1BrWjzPKj7njwAwJYQEeWw6uGREM3LhcQM\nVA0Q5m674gB3ky6WloYYI6mpgkapw9yzoCATUpvTgxpOhSqDz8XfXL6Be//d69OVZx3JOI3xKPv7\nRr0cVBlfmnwhvrlUJHKJRjxJnScL8KBOO6GFazd388M/7JtzgFw+BgIGqtBCCWfUlmIOqliCEliD\nJYb4wpgZ4pvfG35zoo5kPMrOniM0xKJsCAl5Lm+eqSbh8nG1MvLdDFSNsCxHTcIpKJTuQRWnx5cp\nksj/hykiNNfH5i6SGEqVFF7qSMaztNNEhFXtjezzQ3zlhB0aYm68d7YH1T+LUGw+Tl/Zyq5ZJpIG\nx6Tccsl6pqeVr/+uNC8qaOz7CgzxuR6opTILqhxctR14HlTFDFQ820DNp9QReN8dl4c6e1VbaOGH\nG7YYLPhxeoTH0sBCYx7oak5k5aCcBl3JBqqhOD2+QookwPUEzV1mXkyBxGys6migp3+kbIXlfCE+\nV4RQzPGe2d3K6MQUz/UOh/48KFG1qqORTavb0nOKiqV/eIJ1vtHuLzDEd6iEIpWlSmM8ysSUMjE1\nXfQ03dlwN/hMiG/+b/hONPacnAIJx/LmBBNTykDgHjE64ekGRooMz1cLM1A1QldzgkMBD6qnf4T2\nxljJT3QtRY7cKKRIAgpTVegbThWlIjEb3X6z7uhEeQrLLnQ5MlG+B3XGSi/hvLNnIPTnuSr0TYm6\n9JNpsfSNpDhxWTLrWOfiOV8yym1n5Cf44FLZHJS3H2eg5tuDAjjeV/Y/Z224gQrrhRpJza4mM99U\n9VMTkct9BYq9IvLxkJ8nROTH/s8fEZG1/vLLRGSbr1qxTUQu8Zc3ish9IvKMiOwSkc8E9rVaRB4U\nkR2+4sWV/vK1IjIqIo/7/2pyTL1LWLpG0v39oyV7TxD0oAoL8aVHDczhpcyl7D09rfSPVK5JdFVH\nI8OpKQ4cGS1riJozbqO5Oajh4iWB1i1LkoxHeSpPocRQuorPuwbJRF3aQy0GVaV/OMXy5gQt9XUF\ne1C7DwzSkYxnjYIwwgmOfR8cmyxqFtRsNMYXNgcFsKazkbqIsHlVPg/KqUlk8qOu37BWqJqBEpEo\n8BXgCuBU4PoQTb+bgH5VXQ98AXAj5A8BV/kitTcC3w9s8zlV3QBsAi4QkSv85Z8E7lbVTcA7ga8G\ntnlOVc/2/32gcmdZObqaEqSmptMGpadvhFUllphDcOz7TA/q/icP8Ol/fTpr2UhqkkTd3E2Kcyl7\nH/Gr4ioW4vOLRMYmpssrkoiFh/j6RyaIRWVOwxwkEvEkdXbmMVCDY94+XeVWqVp+Q+OTTE4r7Y2e\n2nvfSGHe8DOvHGXjiuaCphkvdZwhGRybYHxyumIeVH26SMI16s6/B3Xj69fykw++PmtOVZAwD2o0\nNbtg9HxTzU/tPGCvqj6vqingR8A1OetcA3zXf30PcKmIiKruUNWX/eW7gHoRSajqiKo+CODvczvg\n6kkVaPFftwJu+2OCjJrEGNPTSk//KN0dpVXwwewzoX7x1Cvc9Yd9WcsKbVJ0M6HycbgEmaPZWN2Z\nMdJlFUnkyUH1Dxc+mj7Imd2tPP3y0dAqyUG/n8bts1QD5ar22pNx2pPxgjyoqWllz6uDbDi+Zc51\njUzxjLtJV6pIojG3D2oBPKjm+hhnds/sf3K4/stgJd9wDQ0rhOoaqJXA/sD7Hn9Z6DqqOgkcAXJF\n1d4G7FDVrHpIEWnD0wT8tb/oduAGEekB7gc+FFj9RD/091sRuTDsYEXkfSLymIg81tvbW+ApVo6u\ntJpEioOD46Smpktu0oXZZ0L1DY8zOjGVVXJdaPx9rqm6fWmZo8qEl4JeZDkGKlEXISLhVXzF5J8c\np69sZXxymmdfnakoMTiWraGYTHhqBbPJI4XhqvY6kjE6GuMF9UG9cHiYsYnp0LJiYybub+pghQ1U\nukhi1A/xLYAHNRfJRB2N8WiOBzVZVii90lTzUwt7JM39hs66joichhf2e3/WRiJ1wF3Al1TVaclc\nD3xHVbuBK4Hvi0gEOACs9kN/twI/FJEZj5eqeqeqblHVLV1dXQWdYCUJ6vGlS8xL7IGC2WdCuTJk\n9z94w9oKMlD1dWnV5zD6/LlFhfYVzUUyUZf2xsp5shMRGuN1DIf0QZVyrO7J9MmXZhZK5Gooupte\n7u+ei/7AKPq2xnhBRRKuWnDjCvOgCsEZqLQHVaEqvkjEC/E67cf5btQtlOU5zbpD4+VVy1aaan5q\nPcCqwPtuZobd0uv4RqcV6PPfdwM/Bd6lqrlNJHcCz6rqFwPLbgLuBlDVh4F6YJmqjqvqYX/5NuA5\n4OSyz67CBOPB6SbdMookRITWhlj6CS6IC8MdDjyRD49PFpSHaU7UkZqcnjGJM3fflZTZcYa63C9O\nUNbGUWpJ/JqORprr60Ilj3INlDP8xYb5gqrwHclYQQbqmQODRCOSFt81Zqch7UF5hQKVykFB5u81\nXhep2XxgV3Mife6vHh1jzytHOe2E2nm4qaaBehQ4SUROFJE4XuHC1px1tuIVQQBcC/xGVdUP390H\n3Kaqvw9uICJ34Bmyj+Tsax9wqb/ORjwD1SsiXX7BBiKyDm90SHkKnlWgtSFGLCq+gfJ6oFa2le5B\ngdf8mzvCY3pa0ze+vuFg7LmwEJ8LXeUL8/WlB+VVxoMC6PYNdbkGKjj7xzEwMlGUZqAjEhHOWNka\nWsl3NCfE557Ki63kcwaprdHLQY1NTOcduujYfeAor+lKzrv227GKK6mudA4KMmG+WvWewKvkc+f+\nL4+/xLTCWzcXJhM1H1Ttk/NzSrcADwC78SrsdonIp0Xkan+1bwKdIrIXL/zmStFvAdYDnwqUhy/3\nvapP4FUFbveX3+xv81HgvSLyBF74793q1Wz/CbDTX34P8AFV7avWeZeKiNDlq0ns7x/huJZE2TeZ\n3OZf8G6eU34u5NBQtgdVUJHEHN7A4eEUzYm6ipbVujxUueWvDTlDC11JfEcJBgrgjO5Wdh8YTA+l\nc8wM8XnHPVRkL1T/SIpoRGipr0sf41xqEs+8YgUSxVCtHBRkvLNafljo8uWOVJV7t73EptVtNdU/\nV9VyDVW9H69gIbjs7wKvx4C3h2x3B3BHnt2G+sqq+jRwQcjye4F7Cz/qhcMZlPGJqbJKzB3LmhI8\nkdNMGjRKh7MMVGHlpU1zSChVsknXsarDhfjK+3P1hhZmjntwbJJpzZ7jUwxnrGwlNTXNswcHOe2E\n1sB+J7JGLzhds2I9KDfpV0TSfVr9w6m8nvWRkQleGhgtSN3d8GioUg4KMn+vtexBdTUnGBybZPu+\nAfa8Osh/fMvpC31IWdTuJ7cEcc26PWU26ebuL0iwEiwrxFdgFV/zHB7UXNNpS+H0E1qJSEahuVRc\nNZ3jkH/+pap+O0PxamCchqoyNJ7jQRWpi+joH07R4YdK3Wc6WyXfM694BRIbVlgFX6G4ijUXaWiq\nYIm18/hr3YMC+PpvnyMWFa46c8UCH1E2ZqBqiK7mBAeOjHLgyGhZFXzB/TkJF8fhQMjPeVCqynCq\n8D4oyJ+Dqsao8bNWtbHjU3+aJSRbCg2x7CIJZ7y7mkozfG7QZFaoNDXFtBJexVdCDsrlx1wp/GyF\nEq6C71Sr4CuYumiEeDSSliSqZJOq885q2YNyvVC/2v0ql244rqR8bDWp3U9uCdLVlGBgxFNi6K6E\nBxUyqddV2a1oreeQ/3p0wrupFhJCmysHVUmh2CD5uuGLIbdIwn0uy1tKqzgM82qCSuaOZKll5oH8\nmFM0n61Z95lXBmlvjKVvOkZhZHJFxY97n43GY8BAOQ9KFd66ObdNdeGp3U9uCbIscGOpSA6q2T3h\nz/Sa1i9vSntTToevqZgcVIiBUlXfQNXmDbIhXhdqoLpKnJvUGI9SH4tkeaWDOUKxMLdRz0ff8EQ6\n99TaEEOEWeWOdh84ysYVLTVb0lyrOEPSlKhc5SkcGyE+p8fX1hjj4lMKm0I8n5iBqiGCN8pVZcgc\n5e4v6EH1DY/T2hDjuJb69JN/oaM2AJoT+cvMh8YnSU1Np/MmtUZwOB14eYdY1OsXKwURoTOZyCo2\nCfOgEnUR6iIyqwLHSwOjvOPrD6evlapfYeh/lnXRCK0NsbwelEkclU5D2kBV1pAcCyG+jmScZDzK\nW85eSbwGj7N2RJeMtLsdjUhaKr8S+wuWmh8a9nJEnU1xDg+l0kl9KMxA1cciRCMSOhMq01hamx6U\nV8U3haoi4vWcLWtKlDX7ZllTPB0qhZmjNsAzZHMpmj++b4A//LGP3/5bL9ee083RsUmmfKFYR0dj\nPG+ZeVriyAokiibtQVWwgg+CfVC160FFI8LWD72h7J7LalF7JnMJ4wzKCW31FYmFdyTjRCTHgxpK\n0dkUZ1nSU08fHJ9M3zgLKZLwpuqGi59mVCRqK9HqaIhHUSUtP9M7OF72SIqOZDyrGnIwPWoj+7P0\nBGPz90Ed8UV9d+zrBzKj3oMGajbBWCuQKJ1GXzC20mPOGwO5rVrmNV1NNRuGrO1PbonhqsIqkX8C\n7+moI5nIzkENj/vSOX6CfyiVTt4XqtSQTzDWqUjU6iTXzMgN79h7B8dLzj85OpvmDvGBVx02NJ4/\nf+QM1PZ9Xt9aX4gqfPssgrHbXxwgXhcxiaMScKG45kp7UOk+qNq8+R8LmIGqIZKJOprr61jTWblO\n7txeqL7hFJ1NiXTvz+Hh8fSTfaFd9E2JcMHYjPp2jRoo/4bhCiV6h8r3oIKhUggvkoC5p+o6A7Xn\nlaMMj09mJv1mGahYuhw6l4f+7SDnr+us2SfhWsY9mFVShw+gwfecat2DqmUsB1VjfPPGc+muQA+U\nI2igpnwdvs5kPKuHZ6SIHBR4N+Vgc6rjxcPDRCNSs5Nc09NTJ6aYmlYOV8BABUOlLfUxBscmiEZk\nhixTMjH7JGJnoKYVdvYcoc+fBRWUYfKGFqbSOTTH/r4Rnu8d5obXmoJEKWSKJCod4vM9KHtoKBkz\n7TXGeSd2cEIFE5ZO3w+8vMa0ejmiYA9PMUUS4I2aePrlo4xNZHsE218c4LQTWmr2Kd49KY+kpugb\n9j6LSuSgIBPedDp8uaXeTXMUSRwZTaUfGrbv60/nmtoCFZHtyTipyekZgrcP7TkIwEWnzP+YmMWA\ne5iotIE6Fqr4ah375BY5y5rjHPJDUOlhgk2J9I318NB4OvRU6Njzc1a3MzmtWaMmJqemeXz/AJtX\nt1f4DCpHJsQ3WXYPlCMYKoXMNN1cknNM1T0yOsHqjgbWdSXZsW+A/pEUdRFJS0tBxpvKzUM9tKeX\n1R2NNSXyeSzRWCUP6ljog6p1zEAtcrqavBDU0dHJtCRPZzJOfSxKc6KOQ36RRKKu8C76zWs8I7Tt\nxf70smdeGWR0YopNq/OPmF5o3I1oNDWVLr0vO8SXI3eUO03XMdfY9yOjE7Q2xNi0qp3H9/fTN5yi\nPZk9ij4tGBsoXlFP6gAAEzdJREFUNR+bmOL/PneYi07psgbdEnHFDJXOQR0LShK1jn1yi5xML9RY\nlgcF0NEUT4f4inl67EjGWbcsmWWgXHn0OWtq2YPKhPjSHlQFiiQgo9BxNGfUhsOF+FwxRS5HRr25\nVJtWt3FoKMUTPUdmjAFxTbtBD+rRF/oYnZiy8F4ZVK0Pyhko86BKxgzUIsfdgA8OjqfDUC6815mM\nc3h4nJEClcyDbF7TzvZ9/ekb7rYX+1nenKjZhj/I3DCCIb5lZYb4Mrm8TIgvtwcKvKfz6UAPVi4D\nI54H5UKkuw8cnTEGxPVEBSv5HtrTSzwa4fx1nWWdx1KmaiE+86DKxj65RU5XIAR1eCiFSEZ41PXw\nDI1PFW2gzlnTTt9wihcOe+Ppt+8b4Jw17TUdZgqWmfcOjpOMR8sO6yTqMqFSgKHxfCE+72Y1GNIL\nNTWtnmFriHHycU3pG2ZuuX57SA7qoT0Hee26jrJnZS1lqlUksbKtgfXLm9ho8lMlYwZqkZMO8fke\nVFtDLJ1rWtYU5/Bwyp+mW1wYwoXyHnuhj97Bcfb1jdR0gQTkhPgqUGLu6PQ/R5g5TdeRGfs+sxfK\nNfe2+tfmzG5v+GF7joFqaYgRkUwOan/fCM/1DvPGky28Vw6NVcpBNdfH+F+3vpEzulvnXtkIxQzU\nIqe1IUYs6unOuSZdhyfT4+Wgiv1yru9qorm+ju37+tnu558213D+CbxQi4hfJDE4VkEDlaBv2Bub\nnc9AzTZV1/VAtfmitc7Q5+agohGhzVeTGElN8j+29QBwUQ2qUB9LnL+ug+u2rDKZqBrE4gKLHBFJ\n90IdGsqe1dSZTDA1rbw8MMrqIudPRSLC5tXtbHuxn5b6GPFohNNX1vYXXERojEXTIb5Tjq+MsGpH\nMs7+vpF0A3C+Kj4In6rrckpOVX2Tb6DCRtG3N8b42Y6X+PGj+5mcVk5f2cJruqy8vBw6mxJ89toz\nF/owjBDMQC0BljV7enx9wylOPi6j1Zbp4UmVNEn0nDXtfP5XvQjCaStbjgnNsYZ4HaMTXpHEG9Yv\nq8g+lzXF2bFvIK/MEQSGFs7iQbmhjOeubWdNZyNnds8s2b/yjBU88nwf557YzrlrOzjvxI6azvsZ\nRjmYgVoCdDUlOHBkjMND43Ss60gv7wyMxSgl/u7yUHteHeTmN5xY/oHOA43xKP3DExwdm6xciC+Z\noH8klTY0oR6Uy0GFTNVNGyjfg2prjPPbv7449Hd99E9PqcgxG8axQFVzUCJyuYjsEZG9IvLxkJ8n\nROTH/s8fEZG1/vLLRGSbiDzp/3+Jv7xRRO4TkWdEZJeIfCawr9Ui8qCI7BCRnSJyZc7vWi0iQyLy\nsWqecy3S1ZzglaNjDIxOZBkl50FBaRVMZ61qw41SqvX8k6MxHmVfn1d56KaJlktnU5ypaaWn39tv\nvj4oCJ+qm5uDMgzDo2oGSkSiwFeAK4BTgetF5NSc1W4C+lV1PfAF4LP+8kPAVap6BnAj8P3ANp9T\n1Q3AJuACEbnCX/5J4G5V3QS8E/hqzu/6AvCLipzcMUZXc4K+4RSq2UYp+LoUD6opUZee4FrLDbpB\nggaqUh6Uy+v98ZC333x9UBA+idgZqBYzUIaRRTVDfOcBe1X1eQAR+RFwDfB0YJ1rgNv91/cAXxYR\nUdUdgXV2AfUiklDVEeBBAFVNich2oNtfTwGXpW8FXnY7EJG3AM8Dw5U7vWOHYDNq0IMKDsMrVIcv\nlzedehyRCBxXgQnA80FjPCM5VCkD5T7fFw55f15hIT43iypfDipRFzHNNsPIoZohvpXA/sD7Hn9Z\n6DqqOgkcAXJb4t8G7FDV8eBCEWkDrgJ+7S+6HbhBRHqA+4EP+eslgf8A/MNsBysi7xORx0Tksd7e\n3kLO75gheCMOek2xaCRdKVZqD8itl53Mzz90YXkHOI80BAxxJfugwBu7DuEhvkhE8k7VPeKrSBiG\nkU01DVRYaVGuENms64jIaXhhv/dnbSRSB9wFfMl5aMD1wHdUtRu4Evi+iETwDNMXVHVotoNV1TtV\ndYuqbunqWlyNj1kGKqf5072vdJNireKadUUqN1jReaUZAxVubJKJaF4PKqyk3DCWOtW8K/UAqwLv\nuwmE3XLW6fGNTivQByAi3cBPgXep6nM5290JPKuqXwwsuwm4HEBVHxaRemAZ8FrgWhH5L0AbMC0i\nY6r65Qqc4zFBcKREZ472XGdTgud6hysu81KrpGWEGuPEClRvnwsnHfVS/ygRyR8uzTdywymZG4aR\nTTU9qEeBk0TkRBGJ4xUubM1ZZyteEQTAtcBvVFX98N19wG2q+vvgBiJyB54h+0jOvvYBl/rrbATq\ngV5VvVBV16rqWuCLwH9eSsYJvD4ogIjMrBRbah5UQ8w7z0pO/a2LRmhvjDGtXuFIvr6kfCM3BsxA\nGUYoVTNQfk7pFuABYDdehd0uEfm0iFztr/ZNoFNE9gK3Aq4U/RZgPfApEXnc/7fc96o+gVcVuN1f\nfrO/zUeB94rIE3jhv3drvtkGS4xkPEpDLEpHMk4kkn3zdPmTYrX4jlWcB1XpsfTOM80X3oP8U3WP\njk5YBZ9hhFDVx2ZVvR+vYCG47O8Cr8eAt4dsdwdwR57dhj6equrTwAVzHM/tsx/x4kRE6GpOUB+b\n+Tzi8idLRQ3bFUmUO0k3l85knL2EF0g4kok6+oZHZiw/MjpBW0Nl8mGGsZhYGnclg9UdjcRD5tKc\n2d3KyraGihUM1DrV86C8z282AxUW4puYmmZofNJCfIYRghmoJcLnrzuLSEhu5NKNx3HpxuMW4IgW\nBqcqXnEDlZw7xBdWxXc0LXNkX0XDyMW+FUuESsn6HOs0LKgHFZsxDypXKNYwjAw2D8pYUjjV9orn\noNJFErMZqCipqWnGJzNGKqPDtzRCrIZRDGagjCXF69Yt49bLTmbL2o65Vy4CV64/e4hv5lRd0+Ez\njPyYgTKWFA3xKB++9KTQgpFyyBio2av4IFuPL3fUhmEYGcxAGUYFKKQPqjlk5IYZKMPIjxkow6gA\n65YlueXi9Vw2S0VkMsxAjZiBMox8WBWfYVSASET42J/NPu021ECNTtAYj1Y85GgYiwH7VhjGPNGU\nJwdl3pNhhGMGyjDmiab6mVN1TSjWMPJjBsow5ommeHiIzwyUYYRjBsow5gnXJBzsgzpqBsow8mIG\nyjDmibpohERdhOGUeVCGUQhmoAxjHmmur2MwmIMaMQNlGPkwA2UY80gyMLQwNTnN6MQUbSYUaxih\nmIEyjHkkGc8YKFORMIzZMQNlGPNIcGihCcUaxuyYgTKMeaSpPmigUoB5UIaRDzNQhjGPJBN19A6O\nMzCSysyCarRZUIYRhhkow5hHLtnQxaGhcS763EP86A/7AfOgDCMfVTVQInK5iOwRkb0i8vGQnydE\n5Mf+zx8RkbX+8stEZJuIPOn/f4m/vFFE7hORZ0Rkl4h8JrCv1SLyoIjsEJGdInKlv/w8EXnc//eE\niLy1mudsGLPx1k3d3PfhC9l4fAu/fPpVwAyUYeSjamrmIhIFvgJcBvQAj4rIVlV9OrDaTUC/qq4X\nkXcCnwWuAw4BV6nqyyJyOvAAsNLf5nOq+qCIxIFfi8gVqvoL4JPA3ar6NRE5FbgfWAs8BWxR1UkR\nWQE8ISL/qqqTGMYCsHFFCz9872t5YNer7D04SLuVmRtGKNUct3EesFdVnwcQkR8B1wBBA3UNcLv/\n+h7gyyIiqrojsM4uoF5EEqo6AjwIoKopEdkOdPvrKdDiv24FXvbXGwnsq95fzzAWFBHh8tOPB45f\n6EMxjJqlmiG+lcD+wPseMl7QjHV8j+YI0JmzztuAHao6HlwoIm3AVcCv/UW3AzeISA+e9/ShwLqv\nFZFdwJPAB8K8JxF5n4g8JiKP9fb2FnOehmEYRhWopoGSkGW53sus64jIaXhhv/dnbSRSB9wFfMl5\naMD1wHdUtRu4Evi+iEQAVPURVT0NOBe4TUTqZ/xS1TtVdYuqbunq6iroBA3DMIzqUU0D1QOsCrzv\nxg+7ha3jG51WoM9/3w38FHiXqj6Xs92dwLOq+sXAspuAuwFU9WG8cN6y4EaquhsYBk4v+awMwzCM\neaGaBupR4CQROdEvaHgnsDVnna3Ajf7ra4HfqKr64bv7gNtU9ffBDUTkDjxD9pGcfe0DLvXX2Yhn\noHr931/nL18DnAK8UJlTNAzDMKpF1QyUn+e5Ba8Cbzdehd0uEfm0iFztr/ZNoFNE9gK3Aq4U/RZg\nPfCpQIn4ct+r+gRwKrDdX36zv81HgfeKyBN44b93q6oCb8Cr3HsczyP7oKoeqtZ5G4ZhGJVBvHu4\nEWTLli362GOPLfRhGIZhLEpEZJuqbplrPVOSMAzDMGoSM1CGYRhGTWIhvhBEpBd4sYxdLMNTw1iK\nLNVzX6rnDXbuS/Hcyz3vNao6Zz+PGagqICKPFRJfXYws1XNfqucNdu5L8dzn67wtxGcYhmHUJGag\nDMMwjJrEDFR1uHOhD2ABWarnvlTPG+zclyLzct6WgzIMwzBqEvOgDMMwjJrEDJRhGIZRk5iBqiBz\njbhfTIjIKhF5UER2i8guEflLf3mHiPxKRJ71/29f6GOtFiISFZEdIvJz//2JIvKIf+4/9kWSFxUi\n0iYi94jIM/61f91SueYi8lf+3/pTInKXiNQv1msuIt8SkYMi8lRgWeh1Fo8v+fe9nSKyuVLHYQaq\nQgRG3F+BJ2Z7vT96frEyCXxUVTcC5wP/3j/fjwO/VtWT8IZJLmZD/Zd4QsiOzwJf8M+9H28EzGLj\nn4D/qaobgLPwzn/RX3MRWQl8GNiiqqcDUbwJDYv1mn8HuDxnWb7rfAVwkv/vfcDXKnUQZqAqR3rE\nvaqmADfiflGiqgdUdbv/ehDvRrUS75y/66/2XeAtC3OE1cVX1v9z4Bv+ewEuAe7xV1l05y4iLcCf\n4E0hQFVTqjrAErnmQB3Q4I/vaQQOsEivuar+Dn82X4B81/ka4Hvq8f+ANhFZUYnjMANVOQoZcb8o\nEZG1wCbgEeA4VT0AnhEDli/ckVWVLwJ/A0z77zuBAX/MDCzO678O6AW+7Yc2vyEiSZbANVfVl4DP\n4c2dOwAcAbax+K95kHzXuWr3PjNQlaOQEfeLDhFpAu4FPqKqRxf6eOYDEXkzcFBVtwUXh6y62K5/\nHbAZ+JqqbsKbTr3ownlh+PmWa4ATgROAJF5oK5fFds0LoWp/+2agKkchI+4XFSISwzNOP1DVn/iL\nX3Xuvf//wYU6vipyAXC1iLyAF8q9BM+janPTm1mc178H6FHVR/z39+AZrKVwzd8E/FFVe1V1AvgJ\n8HoW/zUPku86V+3eZwaqchQy4n7R4OdcvgnsVtXPB360FbjRf30j8C/zfWzVRlVvU9VuVV2Ld51/\no6p/ATwIXOuvtujOXVVfAfaLyCn+okuBp1kC1xwvtHe+iDT6f/vu3Bf1Nc8h33XeCrzLr+Y7Hzji\nQoHlYkoSFURErsR7ko4C31LV/7TAh1Q1ROQNwP8GniSTh/lbvDzU3cBqvC/121U1N9m6aBCRi4CP\nqeqbRWQdnkfVAewAblDV8YU8vkojImfjFYbEgeeB9+A96C76ay4i/wBch1fBugO4GS/XsuiuuYjc\nBVyEN1bjVeDvgZ8Rcp19g/1lvKq/EeA9qlqRkeRmoAzDMIyaxEJ8hmEYRk1iBsowDMOoScxAGYZh\nGDWJGSjDMAyjJjEDZRiGYdQkZqAMY54QkSkReVxEnhCR7SLy+gK2udBX0H5cRBpE5B/99/9Y4WMT\nEfmNiLSISFxEfhdoQDWMBcHKzA1jnhCRIVVt8l//GfC3qvrGObb5Z+ARVf22//4o0FVor42I1AW0\n4mZb78+BN6nqX/nv/x5P/PgHhfwew6gG5kEZxsLQgjeeARG5yM2U8t9/WUTeLSI3A+8A/k5EfiAi\nW/E04B4RketEpEtE7hWRR/1/F/jb3y4id4rIL4HvichpIvIH3wvbKSInhRzPX5CtgvAzf5lhLBjm\nwhvG/NEgIo8D9cAKPA2/vKjqN3zFjp+r6j2Q9sLO9l//EG8W0f8RkdXAA8BGf/NzgDeo6qiI/Dfg\nn1T1B74MVzTk110AvD/w/ing3JLP1DAqgBkow5g/RgPG5XV43s3pZezvTcCpntIMAC0i0uy/3qqq\no/7rh4FP+DOsfqKqz4bsq8Of6wWAqk6JSEpEmoPLDWM+sRCfYSwAqvowns5ZF562W/C7WF/gbiLA\n61T1bP/fyoAxGQ78rh8CVwOjwAMiEua5TYpI7v0gAYwVeCyGUXHMQBnGAiAiG/BCbYeBF/E8oYSI\ntOIpZRfCL4FbAvs8O8/vWgc8r6pfwlOePjNktT14AwndNp2AGy1hGAuChfgMY/5wOSjwhrzdqKpT\neCMs7gZ2As/iqWIXwoeBr4jITrzv8u+AD4Ssdx1wg4hMAK8Anw5Z5z489eq9/vuLgfsLPA7DqApW\nZm4YhhtA9z1Vvcx//xPgNlXds7BHZixlLMRnGAb+gLn/7hp1gZ+ZcTIWGvOgDMMwjJrEPCjDMAyj\nJjEDZRiGYdQkZqAMwzCMmsQMlGEYhlGTmIEyDMMwapL/D9GCZ2QoBqNLAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan3d.num_averages(100)\n", + "chan3d.buffers_per_acquisition(100)\n", + "chan3d.alazar_channel('A')\n", + "chan3d.demod_freq(2e6)\n", + "chan3d.demod_type('magnitude')\n", + "alazar.buffer_timeout._set(10000)\n", + "alazar.buffer_timeout._set_updated()\n", + "chan3d.prepare_channel()\n", + "\n", + "# Measure this \n", + "data3 = qc.Measure(chan3d.data).run()\n", + "qc.MatPlot(data3.my_controller_myrecchan_d_data)\n", + "print(alazar.buffer_timeout())" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\jens\\qcodes\\qcodes\\instrument\\parameter.py:1092: UserWarning: MultiParameters do not support set at this time.\n", + " warnings.warn('MultiParameters do not support set at this time.')\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 100, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (382.984929 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 10000 records (38298.492913 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+08 bytes (6.27483e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0012952809486961314\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.22227982936425406\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03436174789322877\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 8.797470769650317e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0028477412933654023\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#057_{name}_10-56-58'\n", + " | | | \n", + " Setpoint | buffers_set | buffers | (100,)\n", + " Measured | my_controller_myrecchan_data | my_controller_myrecchan_data | (100,)\n", + " Measured | my_controller_myrecchan_d_data | my_controller_myrecchan_d_data | (100,)\n", + "acquired at 2017-10-25 10:56:59\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcUAAAErCAYAAACvj5h2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nmqy3QwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = qc.Measure(myctrl.channels[-2:].data).run()\n", + "plot = qc.MatPlot()\n", + "plot.add(data.my_controller_myrecchan_data)\n", + "plot.add(data.my_controller_myrecchan_d_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2D Samples vs records" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan4 = AlazarChannel(myctrl, 'myrecvssamples', demod=False, average_records=False, integrate_samples=False)\n", + "myctrl.channels.append(chan4)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 100, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (22.001452 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 records (2200.145168 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+06 bytes (3.60472e+07 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0018140384760272354\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 5.219832667080482e-05\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03659865146502739\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.004599610975830615\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0021222432025638227\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#058_{name}_10-57-00'\n", + " | | | \n", + " Measured | my_controller_myrecvssamples_data | data | (100, 4096)\n", + "acquired at 2017-10-25 10:57:06\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaUAAAEdCAYAAACsS3i2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsvXu8bUtVHvh9VXOuvbkHgQuoQRAv\nCvjAFjX8ULvjC5QGjWIiGrA7oMFGO7F9JfERO4A2scWOARP9qaQxEh/4ICpEUZJWUdN0oyC+rorQ\nROEK8pCX3Hv3XnNWjf5jjFFVc+51zt7n3H3uPvuc+u5v3bXWfNSsOdc8e9ZX4xvfoIigo6Ojo6Pj\nWkA46w50dHR0dHQ4+kOpo6Ojo+OaQX8odXR0dHRcM+gPpY6Ojo6Oawb9odTR0dHRcc2gP5Q6Ojo6\nOq4Z9IdSR0dHR8c1g/5QuhtB8kdIPues+9FxfkDyfyf5DpL/8az7sgsk30Pyz0k++az70nF9oD+U\nrkGQfCXJr7yC/f4TyceRfBrJ15J8P8nbSH43yaHZ7r4kf47k7fYH5cuadQ8g+TKSbyUpJG9ZHeNW\nkh9oXvOl/mCS/FKSryJ5B8lX7lj/idbXO+z9Ey/R1qeS/M8k303ynSR/huQDmvXPJjmt+veRqza+\njORPrJbdk+Rb7PM/IPmvTtrH445J8jEkf8d+izeRfMbFzm/H+X4QgG8B8DgR+YKT7nd3QkRuBvB/\nQPt5IpD8bJK/RvJ9JP9sx/pbbP0dJP+E5Occ057YvezX//9s1v3S6rfZkvyDS7RFks8l+Vf2+m6S\nbNaf+H7tuDL0h9J1ApIXAPxNAL8O4CYAXw/g/gA+BcBjAfyTZvPvB7AF8KEA/gcAP0DyEbYuA/hl\nAF+86zgi8ggRuaeI3BPABwF4M4CfuUTX3g3g+QC+a0efNwBeCuDHANwM4EUAXmrLd+FmAC8AcAuA\njwDw1wD+3Wqbn/L+2etNq/WfB+Dlq2WfBOB19vlvAvidy+zjzmOSHAH8HIAfAnBvAH8PwL8i+ciL\nnN8a97X3Pzzh9meFPwRwv8vY/nYAPwzgn15k/Yuhv8f9AHwbgJeQ/OBj2nxkc/3LgE5EntD+NgBe\nhUvfr88A8EUAHgngEwD8bQBfBVzR/dpxJRCR/rpKL+gfu9+B/vH8KQA/CeA50Bv6FwC8E8B77POD\nbJ9/ASABOADwAQDfZ8u/F8BbALwfwGsBfPrqWF8I4GUX6cc3AviP9vkC9IH08Gb9jwL4rtU+AwAB\ncMslzu8zrY8XTnAtvhLAK1fLHgfgLwCwWfZmAI8/4fX9ZAB/3Xx/NoAfu8T2AcDbAdx/tfwbADzL\nPr8awMedtI+XOib0oS8AbmqW/TaAp5zw/D7K9g+r5T8CHVj8ot1brwbwUc36i94r1t+fgf5h/WsA\nfwDg4QC+FcA7bL/HNdvfG8ALAbzNrsNzAMRVfz4DwNuu4N/H5wD4s9WyhwM4BPBBzbLfBPDVl2hH\nADz0BMe7Bfpv6yGX2OZVAJ7RfH86gP/3NO7X/jrZqzOlqwQbPf089A/+faF/CJx9BOgI/yMAPBjA\nnQC+DwBE5Nug/wi/RnR09zW2z28D+ERr6ycA/AzJ/eaQnwf9I7ULnwHgVvv8cABJRP60Wf97AB5x\nZK/j8TQALxGR269gX9gxf1/sX7fh9y+jL+15Ob7ApvduJfk/r9Y9GsCbRORdAEDyhSTfC+C5AP6p\nfX4UgFeR9HZP0sedxxSRt0NH/V9BMpL8NOhv/l+OOzGbMvpcAH8hInnHJk8B8O3QAc4boYMZx3H3\nyhdA78uboYzkFdB78oEAvgPK7BwvAjADeCh0kPU46ACjxW0APviUprIeAf2N/rpZdpL78zdI/iXJ\nn11POTd4KoDfFJH/eszxf+8ix76r92vHCdAfSlcPnwpgBPB8EZlE5CXQPxYQkb8Skf8gInfYP75/\nAWUdF4WI/JjtN4vI9wDYA/DRzSZPwNFpKZD8Cugf2n9pi+4J4H2rzd4HnYo7MUjeBOBJ0FH7leKK\n+0LyEwA8E8spoJ8G8LEAPhjA/wTgmSSf0qz/fDTXSESeDuAhAP4MOtX5DwH8oIjcR0T8D81xfTzu\nmC+2fh5CBxvfJiJvOe78oCz63wD42ous/1kR+S0RmQH8OPQh5Od13L3ymyLyCtv3Z6zv3yUiE5TN\n30LyPiQ/FHpffb2I3C4i7wDwPAALUYPodOXzAbyO5M+f4NwuhSu5Jz4TyoI+BsBbAfwCmxhqg6fi\n+Pt1ffz3AbinDRJO5d9Ox6XRH0pXDx8GHeW2o6o/B/QPOskfoooM3g/gNwDch2S8WGMk/zHJP7bg\n8Huh0yr3t3X/DYD3r//YkfwiaCznCc4OoNNt91o1fy/oVM7l4O9C40W/3hzvB5uA8j87QRsX7QvJ\nB7cB6nYDkg8F8EsAvk5EftOXi8gfichbRSSJyKug01hPanYt8SSSX2jX8TYoe/lLKCt4Ksn3knzU\ncX087pgkPwY6bftUABvoiPqbSH7+Ca7Nh0DjKd9xkfV/2Xy+A/oHE3bci94rhrc3n+8E8C4RSc13\nWHsfAR1Yvc2uyXuhLOpD2o6Q/BDow/MzROSLTnBul8Ilr/dKtPBgABCR3xCRrYi8F8DXQQcaH7vq\n498C8DcAvKRZ9s+atn7wIse/F4AP2L/j0/q303EJ9IfS1cPbADywVe5Ap+oA4B9DR66fIiL3gk5D\nAYBvu6gnQvLTAXwzgC8FcLOI3Ac6QvPtj0zdkXw8gH8L4AtEpFUb/SmAgeTDmmWPxNFpsOPwNAD/\nvn3oishXSw0qf+cJ2rgVwCesrtEnALhVRN4sywC1n9dHAPi/APxvIvKjx7QvsGtE8m8AeABMxCAi\nL7Pr+KMAvtw+vxvABxtTes1xfTzumAA+HsDrjZVkEXk99Hd6wjH9hk3ZvRTAx66OfUmc4F65HLwF\nyvDub9fkPiJyr4ZFOh4G4H3tAOEu4FYAH0lVHjrK/SlLQcmbL9JG+xs4ngZll2WAIyLf2bT11c3x\nWyFK+2/jcu+FjitAfyhdPfw/0Ln4ryU5kPy70JgGoHT/TgDvJXlfAM9a7ft2AK2U+YOsrXdCHyjP\nxHLEtpiWIvkY6JTOF4vIb7UNW/znZwF8B8kLJP87AE+E/nH2/fehUz4AsLeKR4DkgwB8NpRZXBIW\nS9mHCicCyX1TpQHAK6GB568luUfS42e/epG2Hmjrvl9EfnDH+ieSvJmKR0NH7y+11Z8H4JdXzBUw\ntR3Jh0CD9Qer9Zfs4zHHfB2Ah1Fl4ST5UVA11+/hZDiE/hu9KIPegePulRNDRN4G4D8B+B6S9yIZ\nSH4UyfVU82h9PRGsnX3bj3ZPbOyYfwrgdwE8y5b/Hegf/v9wkbYeQZVpR5L3BPA9UDHCHzfb3APA\nl+BkU83/HsA3knwgyQ+DDiB9v1fiMu7XjivEaSsn+qu+oLGc16Gq734Kql76MOgN/gEoc/kq6Ohu\nsP0+zZa/B8C/hv5ReiFUTfU2AN8EjYN8DnRq5p2+r+3/a9A/TB9oXr/UrL8vVIRxO1Q99GWrfsv6\ntVr/rdC4xEmuwZfvaO9HmvWfBFWI3QllMZ90ibaeZfu35/WBZv2LAfyVLf8TAF/brHsJgCet2hvt\n2hEqQnnhRY570T5e6pi2/kuhkum/hk4VPhcrNd0lzvfBdr6b1fIfAfCc5vtnAbjNPl/0XrH1z0aj\nFsRKAYequnQ16L0B/ID1/X3Q+/nJq/48FsCbL+PfxWftuCde2ay/Bfrv404Ar/e+X6Stx9g2t0PV\ngz8P4GGrbZ4CnTrnCfpGAN8NZc3vts+t2u7E92t/XdmLdqE7zilIfin0j+2XnnVfrlVY0PsvobLp\ndaD6mgVVTPJ+AJ8lIscq9s4KJL8Jeg8++tiNOzqOwS6FSsf5wnuhiqiOi+O+AP75eXogAYCI3GGC\nkR8j+bty10UEpw6S74QylG866750XB/oTKmj4wxgaq//cceqH5MadD+3oOZ5fcSOVV8lIj9+d/en\n4/ygP5Q6Ojo6Oq4ZdPVdR0dHR8c1g/5Q6ujo6Oi4ZtAfSh0dHR0d1wz6Q6mjo6Oj45pBfyh1dHR0\ndFwzuGoPJZI/TC3j/IfNsvtSK4e+wd5vtuUk+a9JvpHk75P85KvVr46Ojo6OaxdXkyn9CIDHr5Z9\nC4BfEZGHAfgV1BLKT4CaOj4MWvnxB65ivzo6Ojo6rlFc1TwlarGtXxCRj7fvr4dapryN5AOgflcf\nTfKH7POL19tdqv144YIM97OK0QTA1bm4l68tJ22ZAGyWEf652Q5AoIAQsGkKFAQIAkVLgjaG3t5W\ngNS2zLDYjxGQF8csXYceS4/ZQr/7cZpTqG1yvYeA1oqvCfZJFsdl83lpTc5Fr5f7rY91dJnun3dt\nI252Vo+doaMjAZDLFQeysFxHEdr6YPsszzkLy760794XAEgS7LtuE5B1eyGy1F8x21kLCBHb3o7t\nG/m6tl+Lk7djH7k07XJbt7hlZfnOXctlZX+9bmfVHi/WbjmBuvmyDTnSlu5rH/KO+6HsJ6tl/oGr\ndXL0xlv/Pdq1jTXDtjn/sPq3sNhV/N/3DsP0kyxj+R/eP7/zXSJyXIn2Y/Hff/YF+at3p+M3BPDa\n3z98hYisB/rXHe5um6EP9QeNPZi8LssDoTb5jtts2ZGHEslnQNkU4s0348O+6esBADIIEAUSpd5L\nMQMEQsxgAOKQwCAQIWLIGGJGjBkxZAQI9sa5rAsQ3GOcMDBjE1N5KAwhYRMSLgyHyELshbn0bQwZ\nAxNuCluMtnyfMxKIfU4AoOs4IzZ/jUbOiMjYDxMucIuAWmg0MiNCcFPQ/SMEIwWTEPvMdgwuKO8E\nQYQuGxlsGzWaTtIet5pPBxDZzjEjY0DEyAHZ+nIo0+J3CHbESVLZz5Hs+AeSkO17WSf6EJqESPYP\n/EAi9pmQQBzIgIM82PKxnP+BDEgIuD3vIUvAVmJ5QAVk3JH3cEfewyQRgRl3pD07Fz3G++Z76INL\nAu7MIy7EQxzmAXemDe6YN5jtobVNEYGCWQLmHHCYBkwpIuWAZA+VOQXMKSJn6vK5ufpCpCkAmUDW\nhxeT3ZCTvocpABlgtnWiDwQmW2Y/PxN0XbL1s332dajbh639Lkl0Hb090fUzABFtJ+tyCMBZEJL9\nsZ4FFFueBZyz9SOXEQZz1na2s+2T69MhC5CSvsoPbjumpNulpNuKQFICGVAK66YMmSYwRl2fs+4f\nqG37djFCphkcB8hk//58HZeTPwyE+APUtuEw1u+2PcdBjwfo8QEghHaECjIAQwRyxi+/4wf/HKeA\nv3p3wm+94sHHbwggPuAN9z9+q/OPa8X7bletl51DcxF5AYAXAMDeh394t6Po6Og4txAIJpmP3/AG\nwt2tvnu7TdvB3t9hy28D8OHNdg+CljU+HgJIECCsp+58ukCnWID6HkNeTA0BwBBzWe9TP3P2kbiO\nnDOIOUdkIbZ5QKAgS0CwdnwknaEj8mjP1ZEJk+j2kbmM8CNyYUmRghHKFiYrn5Obn2ey9hKILChs\naZIlS4okRqyWgZgkI4lgQkYkMSEXFqTHEkySMEkqLCgjI0kuLCkUZhIW++oyIkEQQGNpxAQprMn7\n4VN1+l0wScA+EyYJdo7ZziMjGmXYSkRCQLL1CWHBNA9lLAwpMCNLwBhmRGYkCTjIo/2ueuSBCZPE\n8lsPIdlvyfK++P3pU6+C1CzzeygEAYSQRB18N30jbdZOmhOnlM8SlN3rcl+GMlUnvt1iDrkud1Yl\nQdlN2U6W2ztLskIkxsBsajRQ9yv9w5HpPYooS3LmQOr+pLIZZ0uksg9jQwjNcjTtZp+WzcpM7DtD\nKCzKLnRlLrpBYWLOklo2xBjBQGVBsrxHGaOypNVyAOV4DH7BpTK+I1OOV1IvcTd0SlpO9LpRcHc/\nlF4GrQAJe39ps/yppsL7VGgVy0vGkzo6OjquB+QT/nej4GpKwl8Mrb760SRvI/l0AN8F4HNJvgHA\n59p3QKumvgnAG6ElvP/hZR1MdDgq7QDGR5tcjlxFNA5Q6o7bqpRDYVADM0jBJuhIyeMSAYJNnJFB\nBPjIOpeRdTt691F7AnGYx7LdJLGM+B2RgiQszCBCGjYlJfaisalcWFKgMaZmFBWMjUTSWFMoIoeR\nESMC7pAZEcRgjCwYs4kkRsYSX0o2olwyJynLMjImZCQYA/P9bGQ3NkP1CGIkMVLDE1sEHIjGbyZj\nm3quAfthRpKAEamwzX1O2HBWloRcrqPH30YmZAmFDSmD1TidX+MhKBN1luMsN0tAgGCw31+Zbrsd\nkWx5DJVRE4DkRiwSKhsvoogmRgQCzLtH2eKMCnVboIoPmFG1As3yHOux2rbaPrSg1EmE0r4IwiTK\nfHwfsn7OgETqsuzxH9FlAGSIypZaJhWM/XhMKTTsKdXYDS0+5MxEvI2GkXmsRy+wxoEY7DcIysyc\nTUlKypqaZWW5Mx9rp3yXhul5X1tmF9uYYXNOpwCBIMnJXjcKrlpMSUSecpFVj92xrQD4R1erLx0d\nHR3XKm6kqbmT4Hw7OrSSb8pOeW1hSUXuLSVGMM0RpKrmAjVeIC4ttpEyoHEHZ00AMNjQdy/MZbQd\nKBiYLE6ULF4SNb5hUqlAwciEkTMC62hLWZJuHyEIFmsai3LPGYLgjhyRQIwUHYhaDMdbm0Q5lo+u\n2vnoSRImZOwhIjQsxrdx9qNHY1m3x7GwJUdhXwgYEUrcKIDYZzT2VONJWxEcNHP5G+g13yAvmOAG\nGl/K0FeCMsjb8x62MpSYUkC2uJMgSUCy/vm1TsaaJokYmZBE44ERNWaUwcXvsE2xsOA1AqSyoOUt\npqBouMHUnbviPwAg0eI+GcqcxNgTceT+lTbGs4bHh7Dcrqj3mhgUs8aNgMrINIZE73qNcQ0WK3Ip\nNmydMQeJUfs+KJuQIahiLxAw1RwAYJ6VYcQmRkMqC4mrPzuhZZvKqBaxHUD3sftHGnWfZIHMU2FO\ntZ2l6s4ZVavg4zBqWxYDY4ym+Dsq0aar+k4xngToT5hsduG4142Ca0V919HR0XHDQaADyY6K882U\nWggXo0fY6LPM+bsCL7OoppxFbVMso2dfFkNWxV2jyPNYgyu2PG7hy2aJJdahbCaVkbu3kZwFNLEP\nh4/QsynNJhlUPWYMAQD2mRZ5i6ONokZ6XEtZU4bmKLkqbmQoMaXSH0gJoI6MC+Wd5igpS/JtWrY0\nF76i8SRV2+l2k2h8aWxYUiSwz4BkwjNleILbZcDIXNSFW8SS6ArUpNcNZ2NOYZHndZA1l2lDVWI5\n6xqb/LFJIiIFe3E29aKy2yTE2DAlz0cbjDn7e6DmvuWGKS0VdvVeWtyDvt5jOLaOmSXmKc3yloip\nmq62VS6JLNsteUcCCAmJK2bWsKHSPqltuwKOQI6EkOAsqsYLyoIA6M3kiacpARZLQhJ9lYM1n4cB\nmNMyybZmHGtuUpYF60GMyxgSrI8ex2GAZFmwImc6HkdasCnJyqTsVdbNk8WxTPlneVCS84KhLfoR\nWPOpwumypXzC142CzpQ6Ojo6zghyg03NnQT9odTR0dFxVliRzY7zPn3nP6bPS1gsE20yra8KufG2\n8yk6e7cpnJTDQgYMVDn4bLJhR14FvcdgU1wUTdyElKm5wIxogf1cgvqhCB40MVQD+luJJjfQ9S3i\n4vg262DfVdQATCLYo060TZJNml1/5pGxyMWBOiWXJNvUnyXZWpZ5RjYrIX33bRwBKjvPnjhLFhFE\nLFOKtY/aJhqpd0IWFpuhaAKGYAKIDJ3yHJmK/FunNZfXfyuDXWcp8vBQJPYZSYjDNCyu4V6YcZiH\nxRRt+/vPOSx+Z5eDk1KFMARSCsjJvPVWIgfAZpb9fhRTNJiQQUUGdl82f5zCjEbI06xrmi9TfwCO\nDLabab2yLWD2Qi59tjSKImJgEUio7ZGLDFT8ICZU4JSAOR/969GKACRXQUMMi6k7AEWuzWEAGcBh\nqHLzmqdR2whUW6JxqAIGNMmyZUGo03IMkJQQxqEIHSQLOIxlPYBqVeRSb/qxxrJcUqpTiacIQZ++\nW6MzpY6Ojo4zQ/WA7FCcb6YENMNGG5EKVOTQBpyJhZzXR7vJRBBJNHHWGVRohqwDLejNyoQyNEC+\nlnUDOiqf8lBsbzywnhZsJVkCqAoY3GYoScCGCdkkBElCMSQdmXEgEVuEEmfNUn9A74kzJBc8eCKr\nMqmMQ2NAa6ugyNCIHCIiK4PS5NpQ2gkIpb02x8LtjFz80Cb8RbMdqtfAk2X1ZA6kJjq25x2g11vF\nCrmxIRJjUHO57o7JBCeTGbv676l2QsvfbRecMbUpAUC9bxxi4poQpOR71hQEeyt2QHZPBmlYizGY\nzIWoocjB2+8tCfH2V/961QoIC+uhsi5bygS5kIcDQCjGq5oQWxjSygmcbqQ6BKW/WZeJn/zChijU\n/bMsE2KbtmU71cTWEJSJedJry7BgibJ5+b2VfktKC4ZUrpfLvsuCxoLI5eKBhZXJPCtzc0TtE8fh\nqDjjLkLVdzzR60ZBZ0odHR0dZwTNU7pxHjgnwflmSu2cus/LuwI8LyXekjUhlo1xqzuLFHsfs5lJ\njRFraNhTy6AmS86sVjV6vEPReWhP3hzN/LPElyyp9kBG7IcJkwy2PRs7o2raCtSbNlCwz1ySZlOT\nNKv7VXuhZLGl1mZoMtajMaOEoUmiTXLUX2tdzmJkKDEltSNa3j6timivWBgptiIlyTeBpXSFX7d9\npkW8xxEXbLRKwjUpdjZW6YwmlOsSIMWQtY0Z+W9RbYayyvtXfxi8zZZhR3pMqdZ60mRZ2LZNAz4Q\nT027zf1aTFgBZU/tpWTzQt2Hq/a9pEXZ1hmVx4SyMiRpk19pcSXWmFGOtPiTnXNkSa71UhVClYwD\nTaxp/dcjtDGk5l5yeyHUfrTMpJ43F5LwIs92dhRjYTYuAW8TZMM4FCl4iVmtkmbLd6766F31Ehsi\nyvxyla4rm+OSRZ0CPIZ53OtGQWdKHR0dHWeEzpSO4nwzJWAhRWI7IAtSYkkMOqLNmcqgBIUN+VS3\nCDGnpuidxY68fIHDRywjqz2OLxssUXYMM8YwH7EZ8lIV+5ywzwlbi6Po6F8TNw+MOY2csTH2sM9Z\nrY6Qy6BxpBb703Y1QdYZ0mQXYUQoZSpcFTeVmAwxIxVLIY8hebLsJEfnzT2e1Bq0jqzKO6Cau+p6\nHLEaGlmVdyMF+01ysV/PjVsFFSNZu34WU3IrJ08yrr9ZXrCtwNzs69dKSkzJS4y4IWvLhGc5+k/D\nY13qqqMKPGdO0sQwCxvfZX9VlG3LpFZ6HMlhTKewoGDrd/39amOnazuhoIo6V+qxMAssk0CpybdM\nUmNAgMWg1EqIZhUkwyrWY2yq9keWMZwacCtxI7FifxyHZT9aRtWwqqKQ8yZNjVd2y4LspSxiRJ7m\nYs5a2JFtt4gpOWtyZZ0zypy1r9Y/usErCZlPr/6RgKq+PcHrRkFnSh0dHR1nBBU63DgPnJPgfF+N\nVmGHVd5GWc8yr+8xAIY6KtbcE5T1wSxjsrCMnmvMgiU25LY4ayXXwIQpD8gSsBempULPTEa9aN0i\nl4YZGybsN7lJup2OpAJlQfMPJBTWFIBaSK9ROB0iIYmoQaqZs3p5CQAWU/Lz0VHnoUzGhYiRdczS\nxo9aNrTGhKq+q+etx9snMbWKQUEpX9FiK7GJtYVy7drPDi2aWPvi9k7Riv2p6aoUdaSXrnB7odEU\nedqfGrtztWVr4EsKtikWlV0I2WKVQBxyKV1R4khSWUtrf7UOD3g5izWjqrZAAKeqqnMoE2pykQJL\nafPlhtZecObUyDeb4xYlXWBhVGo9VONKADRPqS0LMYSaOOdl0SXrd3+t8nvU3kf3I8PSlNXWFTWd\nLStsydmNHz+losRzBkUrDtiWr/BlxZIIaPpXlYMMQeNZVo59UWTQjFtPD5qHd5LXjYIb50w7Ojo6\nrjEI1OvyJK/jQPLxJF9P8o0kv2XH+j2SP2XrX03yltX6B5P8AMl/clrndyXoD6WOjo6OM4QrRo97\nXQokI4DvB/AEAB8H4CkkP2612dMBvEdEHgrgeQCeu1r/PAC/dCondRdwvh9KHov16Ydcl5X1rHVw\nQhCNGdsUnSpVqxRbimBBE2Y92J1BdQwHm6mesLhRJom4M42YTbzQbge4cGEuLuGe7Nm6hB/IgAMZ\nMJlTdiuHnkQrtfoxLzCVGY8JUn5IFSPoNJ4LHpKIVZV1WTpxIKmRe5vsvUmKdWRkRAZMkrDXTOdF\nBgyImKRWngVQail5pVnHxpJ591mn0Vr4NGWtizRjRCrXVvtyNODrFkR+LUvirItIbFmLObtcvUrJ\n9b32yR3hRWoVWhEimgQ85YCcA0LMljfKciMuhQ6NiMHuRwB1Sm29rHYAsqoq6wm11M7XTeNyirAe\nq04BMkmRiK8hNl3nlWQXyboEEE3sYFJt8amtdjqx2AE1U3FkrUDrybWNzLrYCpmQACnpSwQyTShO\n3TYd6FNvLnBop+wW8nCb3qNNy+XttggbFomvPoVnybX0xF0TNPg6mWZ1CNdcgCPX765A5NSm7x4N\n4I0i8iYR2QL4SQBPXG3zRAAvss8vAfBYUk+U5BdBq3/femond4U43w+ljo6OjnOObB6Px70A3J/k\na5rXM5pmHgjgLc3322wZdm0jIjOA9wG4H8kLAL4ZwLdfrXO8HFwX6jsJoqM7H1m6jBY1QO3ImYhR\nkHPAOFhFWAimHLCJSxn0JqRqUWN1k3z7FoGCPavxc4+wLRY5AIrdUEDAVgZcCIerfXORQHvFWjce\n9dFRhNYj8uB8AtXAFToCHcuxlCVlACOIkShy7ZYteb2jjAw1OnKm5IaqVfIdEHAoEyKJQ5kxMtqx\nUtnH95skF2HFgajIopWDb+jSdSC6bJ1ushpKVdlItWByyXyAICAVFpyEOLBE2AAp16k1sJ3g0nrt\n552W1Ayo3VAy1nuYNhhCwkEaMYSMOQdsnUlRNKHaUgVcVCFmS5UzkVNQlgRUYYPQikZVoQMFhVmU\nhFe/3RpD4XpjoFSn9XuaM4q4R1yv0JiuevKrWxYJUYQPKhUXW2d0K2j9JGapcvAGdINSk4M7W6KI\nWltHQhLAbVpWmG2NSyXV5FnKYslJAAAgAElEQVSXhJt+3oUMMs212muMkO22JKiKVbCVbVJTZZe8\nz1NlQ/Yucy5siYHI04wwDlUOnhI4jFUSHo3FmXChJM6mpEIHUutCpQSEQQ1bT7mWkoDYyon/DL9L\nRB51kXWXShY4bptvB/A8EfkAT7my7pXgungodXR0dJxHuNDhFHAbgA9vvj8IwFsvss1tJAcA9wbw\nbgCfAuBJJL8bwH0AZJIHIvJ9p9Gxy8X5nr7zcYAQiD5CateZgaYPZK2sQMqhsKeUrTRCyIihTao8\n+loYtYZUJOK+fsrL+IXLwrOxADVh1dIULgt36bNXmfVYi8eTLoRtYVBATTwtNkPWJTc7dUm4M6Sa\nyCqWWOtsaxlPGhkxIxlz0jhSkow9jtjj2JSdqCas/vkOmXEg6UjlWWB5g41kqR3j51lsgcygtbLR\nKpX3l7Mnv2Z7nBCZrRJtLvGmgx0jz5ICAGl+01bmLguWVH5zSwuYGuupIdZgCoPUyrNtaZRcCMGi\n7ITHediwJjGboSNOMn7fWoyoTZ5dy8NL5Vku9y1VZktbRDFlbeMjOwbIeRNtO5OGNzZEGIJKxQHI\nYPf8bKwoWCwpxGXiLKBxJGd0TdIqNxuTiGdwGKqtjzOfzagsyqvIcvmnS7JJtRsbIo9BldIWrYw8\nC2S7rafvcSQRMDSGriKaQFsuyunGlABl/id5HYPfBvAwkg8huQHwZAAvW23zMgBPs89PAvCrovh0\nEblFRG4B8HwA33lWDySgM6WOjo6OM4M7OtzldkRmkl8D4BUAIoAfFpFbSX4HgNeIyMsAvBDAj5J8\nI5QhPfkuH/gq4Lp4KBV7ITZOIaWOhUEINoX4PEE2Eg1r8hiOYpaA/TCXfZQtVSaly3Ozro70tWCd\ns5CESQZjAx6p0RF+NWrNhR1NiIAoS7g9b7Bhwhim0m6131F2MTbD3AAiIWudQ3LBmCKJLIKRAUnS\nIiHWDVqdBSVjVJpMuywKWGNRin1GjAw4sCKANWYF67O2eSC5FPzbZb7q13mbIybEcj0OLB40ci5x\nJkeSUNZHZEyIRYW3H6aivnOboSwax/Is+sCM3LAjT5qdYQzYfusxZKSs3+cUyr0CVNVmMQG28hSM\nAplZY0rt7RiNnJipaluQrySFe6zIY08tC7J4kgSNNZVjoLZR4keyWgdT4QVCRFV3IUmltd6fOdt2\nKEX+2PybkqZ8hTIkU95Ns8VtPK7k9NhOJAQgN/HbaMxkbVdUL7Du6wX9PNnWbIS8kF+eZGk/ZKar\neaoJr4tYVNzodlmLkheLoZSq6aqV41iU0zhl5OOVdSeCiLwcwMtXy57ZfD4A8CXHtPHsU+nMXcB1\n8VDq6OjoOI8Q4FSY0vWE8301WtGTGbIuSlm0w0MKcqpF2sro1kejprQCNG7g5a69JPZcSlT4CFut\natpRzkhV67kRa2jUcsDREurtvm1+TYQszEbbeIi/X7A4U2m7tJNNGNWWnaiF/gKUyeybis4NWAPU\noNV5nO/nBf/8P2dUM5ZKxRKrEi2/PiGXPKUIZaQeZ9rlhOOIyMWI1s91n1Mt7ldiTVICxB5PSgil\nHHpkxkGuirvU2P/facvD6vdrma7HktYM2KGM3PLegkndnBh4zlJmyVOCQOOeubbTNukGqi1CWq5f\nFAIEats4yoQALEpWlDhOy8bgLE084l7XGcOSJh5UGJGjKXeh9VSSKtTWcRdvI8aap+T2Pr7vClrm\nvMl5irEwIwALg9ZiHQSUfKVivFouhtlGDWPZrrTjOUhmIbQoTdH0QSTXkumnBAEX//Yv9bpR0JlS\nR0dHxxlB1fXnmxucNs731WhHiSWL3lalkqykg6BMhFDdHRxkZUaasa+5KG1p9CFkBPiouX4GUArV\nBRu5+0jeyyh46YrAjH2LC+lIXjBy1pLpQuyHCcFG+WoqqgXsvFxDlhpLipBSJG/EcpQ5Mpjxqant\nrLyEGqzGI2UmJplXuUq1TPq6AKCq8mjlLvS/1LQ3IixYmbZRC/wFlPSWcu02qPGdLXREuDWF4oiE\nA1MlBghGpIYR1RGrl5fXPKda5C+Dps7T6+2saBPmkh8Vynv9vVtW5I4OLUEgVYEnDfsCxYwExGJL\nSmPY5BmtqdCukhb+ubgqrEkHsIg3FWcIG0i3qr5SFj2ixktqdxf9qIxH85OkZTLSuD04PF/J1wU2\nOUjtdlINWdtcJaA6M8S4WO9F/sr+/tqhuANQnBvCOMCdH9r8JAbW/CTfHlD1necrQa+Rl9Twd5gC\nUOa55imdKls6WeLsugjl9YzOlDo6OjrOCILOlNboD6WOjo6OM0QXOixx7q9GGWR4nRpBnTaBTr94\nvDOlUKZnjk7jVQGET8etq5E6nEq77NsTaNcJbgclMTYiImMrg9ni+P5aUylSmiRaFTrolFUu7QQK\nNshWw0nl4FmAyaTXbsKq/VNEEqOZrOpyNU/16bUMMXGDTsENOBpMTU2wODT/La+HLExZAeAmDnYM\nNWPdimCCYL9JoI0QbE2csAsTIkamYsM0Qa+jWzX5CNODwC4Nz2Zme1PYqgGuG+2avVA7Fbq12lf+\nm88SMNgUrqcOeBVioKYNzMkSsE3w4JpsyQSjCQdW035YfV7cLutL0CbLiifH2j6+rp3Cy3U/QE1a\nS1OukJYqbFgIK1zQEGAVbrm0LiKb9lneZVArnlKtdo1kEm+f7lqLLmJU8QBgIoZclhcz1sDGwshM\nWa1eUrl0dmyvPAvJy6RZQE1ZYZJwb2sY9VitLVI7fejiDOsDN2OdjjwldKHDUXSm1NHR0XFGEJxe\nntL1gvN9NVYy2WJ0uc4kpAagQ1CW5FVDHRlEyqFIwgEUGXhbjVSXr0ongBhCNVSdREf3WSoDyJbg\n6cmYsenbyHkhXR5ZdcAuC2+thdrjBlaZeC77VIGBI5KYkItcO6BNqq3yb5eABwRE6qvFoczIyBgZ\niyHr2BzJ2xypknA1d9W+7JMYjdW1Qgd/z0Lscy6CkWwMyq2XpobF3Z73kBCKvVA5zyZZ2ZNm28qz\na1n3bIau2neW5FnfblG6wq+rlbAggTlFMEgpWyGJJYHWQdfbFBGDaKVZFyLsqESr2zX3drO/337l\nXkfzHVUc0doQ+SDb2VEeTACUXFxgx0uyLEfRsJ9SlVYvlp6YJdR6tdpFYqkzrNZiKNUEVRcvkKEY\noToLAgDJWSXhAJByXd5Uoy3GqoYibrCk2XXl2kUlWk/A9feGLXEcy7HQsjegbntqOFktpePqKV1P\n6Eypo6Oj44zQmdJRnO+r4aPDoRnREXUCfoVW5t3GlFQSrp9b49XKjpZsabCkyywszGYMuSRzplXi\n7MiEfU4YmWwUr+15HMlLLrSj/lwYTNgZ15pEzViTSa3ruWhxvWoLpMmyzmiirWsL/ik70u0PZcIk\nCUkyJkmIDJihZSjUnkgWBf88nhRB7CEWmyFnZBM0rnTQBFcOzK5ptDjZunzFGgcy6vUzSXg1t63l\nKSIzAtXwNjUS2gApNkPtP35nP/eIU9kusHnZ9xhyuf6TBWo80bokW1vyrEvCW8l2OW2/34RaasXj\nTmH3qFssblTZP6xI34pBlR3sLbAs99smzNqWx4oWJSpYY7F5CCWGJIGQgYUdqezb2/Wg4NJ2aCGV\nDjUWUy7CMFTpN6DrPD4zDrWURcOKLhnDaVgRUGNL7fo2kbY1c5VSUNCYkJmuMgQtMNg2Y8axxb7o\nlMtXdKa0xJk8lEh+A8lbSf4hyReT3Dd321eTfIPVkd+cRd86Ojo67i5IqTRw/OtGwd1+piQfCOBr\nATxKRD4e6n/6ZGi9+OeJyMMAvAdaT/5ksDl6sVLVJabUJhkCZcRZ4koNA4lBFnGltToPgFkN5QVz\ncjXflAOSMafYsKTWCqh01y77PreYZEDksrBfsKjKPifss47a2jhShGDPDFkPxNRvUpV1rrjTuI7G\nkCK1DLoX4GvNV3NzobyQH1CNWgFV3/k6TaCtpTH0vKqVUYbgsCmT4XEkTaQ15aB4+Q3acbO9z+V8\nAbUWOpAREyI2VLZUCwBma1dTgJ2N1v7HRUKzx/u0v4SXuPfYk9tKtUwrWwypjTkC9R4RU9l5eKMU\n+XNFJ6GMaM2M1omsq/dC+J0V2WdlPagF/prk2ZCkqPZcgScBy1LoNDYVajxLAhDmjDwEi2eJlVA3\nJuHxptTElqAMiq1arZiw5qWqTS9MTZ7dkYTKcYRb/ZT3qCzFlXRuuLpW4HnZivJqEmc91lRKp5uK\nb/Fbeqn3nI/EnyQliGRlTKdcEl2Arr5b4awevwOAe1ihqZsAvA3AY6B14wGtI/9FZ9S3jo6OjrsJ\nWs/tJK8bBXf7mYrIXwD4lwDeDH0YvQ/AawG81+rGA7vrywMASD7Da9Sn229vVgDMrDElW1YPrMoo\nhmop5PYxra2Qj37jwlpIFgosoLUR0u33gpZDT42R6row3yRxkX+k5SxyE2Oq5RoywmIuOUsthXF7\niZvUH9DLV0yWGwSgFPVrLYR027AoBuhGrL6NKuwG7HGsFkKmuHPVnbMnz4Vq4XGmADNjtZdur9ts\n4QX5orXvVkrL6xeZsc+5sJ2tMZ/9MNVSHxKx4VwMWadGVReZMYa0uMZ+vBbr33rOYZGf5CyJrPcP\nAFPiyUJlV+NKej+u7YN0R7ZvlQnZ5yNxo4b5AI26bs2yUPd1Q9eFYs+/a4S9sKdgDChMynDE2JKY\ndVDLjhBQWA+TVEVdWW/fjeUs1HciZspagriVtXiukpUiLwq8QI1HNWrQ1oS1NWNt40xeEn0Ra7I4\nk+8nbiTr8EKGaWk4XM7LixieEvRn2F1UdP26UXAW03c3A3gigIcA+DAAFwA8YcemOzmyiLxARB4l\nIo+K97xw9Tra0dHRcTfA/RyPe90oOIsz/RwA/1VE3ikiE4CfBfDfAriPTecBu+vL70RRKLWCO3EF\nkg8N26nuOsJtsU2xsCWgZu4PIR8ZpcxtgbiVqwCgo/Ns+TWhqMKGEuuIVuwPaEsx5Jpfg1hiSc6O\ntoglFrPPjJE1VrWhqty2IqVcRMsDSu6QpMJYJsmNMWsoZdAdGRmTzCVfabICfloSI5e8pkkyJmhb\nqRlHtGysXhd1c5iEuODXYpWDFZEXKkRX0wXLWYqo1zPA310luSwn70au7dSHOmJkHOa6XznnRnk5\nhIxtqr9pe794OfQQssYosxaQjIMHlWDMR2OcrXNCC793hUATBtPPKwZUUu/8VKifJTasiUCOXLo+\n2PLi4CBi7Mb7sHRvkEHzisIsquQDzKTVOqhVMdVZN+clg2pzk4BaHh1QdlQK58mydIVjMxb1G0NQ\nNjTNyqSa+JOXO/fPbWzJGdIiZmRxJlfh0Y5dtvP4k5etaIsTxgiOg8aTgOX5nQIEJ2NJnSldXbwZ\nwKeSvIkkATwWwB8B+DVo3XhA68i/9Az61tHR0XG3wpPFj3vdKLjbk2dF5NUkXwLgdwDMAF4H4AUA\nfhHAT5J8ji174d3dt46Ojo67EyLAlG+cB85JcCaODiLyLADPWi1+E4BHX15DOnXhElhKnUHQKRRb\nSA0+k6Lv0KkXTYBUqj6GvFMGvitxtV2m03MuJFgGz92s1bdzC6KDPOJCOCwJtoCKHtbyb5WL67IL\nnMrUVDvtVMxXodVdVZJ9cbQSbt1fK816gmygTucVmbi4TDtaP1NJtq1WRWpjlFfzU8mk6qMl0UJ0\nqhEQTCaXB2s9JcfIjAOp55qk1pXyaVIXjYycMVnNpeWxA8Yw49AsnEYmHMpgU6oCQKfw3PIpgxhC\nxsFsScE2lTdlfw9IJn5IWcUNKavNEDIh2X6VlbjGZeAqsgFKwV7TcpfsBZN4+7Qc/bNPrSVbtrAB\n0vU5AtGm/EKSpcTcKsiGJNamihMWt7XotF8AytSeRNoxMxAJcZsnEpizzrGY0kbyKonW4fZDZK04\nG2P93m5qU3UFXqUWWCaturnsZoRspypaSEll320VWtj03maDfHAIxiqKIFKpZovFVJ8JOLzG0zxD\nRHRaL1uc4JQNWW+kHKSToNsMdXR0dJwhbiS3hpPgfD+iV8mH0owsyyi1+Z5zlYLnHDCnUKTebSAx\nMpfk2m2KR6yHnKlMEovdEFCTYlubId+uTeqsUuZhoao5kLEm3pp0fCtxUWoBWBbjTI3AYI/BEmRd\nDl3thGr5CmOGxWYo2L5jESYUs1WrVBsZ0FaeddbkrGtCtsqyTR/NXigaS0qyvNnW+YeeZJwQcJAH\njKiR/8jKkBICNnYtI7PNt7tsfcYavl0rRGmTdaccy0h1zs5qq92QQ5XA9T4hlXGLsSTAcjatfEVh\nOAFgIpj8fnR5NBemqaWsRBFJ1KTXImrw5cRCSl4rZxhr8P20o/W8By7a8OOWn624+jaBfgBea4Qu\n5x5C2ZZzrvv4sQ61TERhFG3pCmdMznAka/mKRppNZzA75NfFJmg7HVnmF7wIHyyJVqxsxRGsq9my\nJua2og0Og/ZznivzOyV0SfhRdKbU0dHRcWbo03drnO+r4QM6S1Y8Ev5ZLSBt/nu1XJlNHQV7bGmb\nIwZLmpwllPIGeXUjjbbNwKRJrqy2NkAtadEez0svOFsaORd2sKvoXcuWLjalPVn8Z5+eWMsFQ3Im\npNJsMTazlIZ7aYpIjSutY1ADatkKZ10lMRZLI1i/Qh7vqsUHa3sRgn2mwpIAYD/M2DCV5Fltr8ro\n22KKzkL1cx1jjWHGlDXWNOW6TTSj1dGshfR65mLA6r+xX3O/L3TQLCWJNuegknACIarfDy22CeBo\nlp3bC60Su7WMhbEvJ4e+SQbygML42b43bazvfebKqpjF4q5UObigSr3L9rpNiQv5emcEoVm3jgdx\nRzxpaMa6XugPQDFjdUk4qVLrlCubMasiyU3pCWduZi20TmwtFkOoxfx0RShthHEo2xRYeQuZZo0d\nzXM5PgBgHIAQyvFKXGlX/OwKIaJGxCd53SjoTKmjo6PjDNGZ0hLXz9Vo59nbhRZnYsiqvLMRawjZ\nxEGqyvNRMa0kdpKAgRmDlS7wAnCAlzmobGgyE8/ZRu1r88RgyrG2MF0yd+AL4RD7nHCQx4YV5BIv\niabuc3PXFiMrU/FyFV6CfK+ZK58aNnQgqTAqPZbHnHJhQMqwVE03ckCSXBjXocxFebcLk9SS69qW\nvtpqCZMNlLdmpbSFXr8LnLBBwiTVcLU9560M2DCpKhGVhbryzq2fpjxgygPGMDfHPBpTWqoYdZn/\n5mss40tEOlLMzxJlPZ4UKn0RopgGl8TuEjfS7YTGimDrPAyzijGV47kNkZOQCC24F1qWZOsaW6D1\nvxGhKu8ALV1hF6iptFF3kOiMTgp7WhT5WzOtLGo11JRQL4o8Zxxe3qIU7jP1W2j2A46yHKCYq7bf\nS2KtJcy2pTBao1WPQ5XkW2NBJYEWAEp5dStGOM/1vE4JPXn2KDpT6ujo6DhDZNw4D5yT4HwzpV2/\n5WKZ1JGkq/FsEy83kDJrPMGMNtv4khtztiNlL3MAVOo9BtWBHcpYlpcSCU3MKqMasgIaH/EidFpm\nQRqLnGxlKmohPC314HlMXhqjlquIpJWxyMWM1S1/kghu4lBYk9sKuWXQHgcMiJiRSmmKjIwZqcSK\n2rIWayRoIcDWoDVafMvXqxWSft+g5igFijIks1OaEIv6cESyMhOhxJO2lqfkv0drzqrHzSVHSb+7\nYjKUYwUzawUqa/LyFa7E8/tgyqEYsboBq+ct+feaH4fCiMQJU2jkh9K8G8Nf+MO2alL/bsyIwMJW\nqNyWXpqiGcSXwn6pCWVZSYoWzsYoomzI2UzZwE4ko8aFAMgYazxpR4G9BSMiq6KuZU7tfs6OLKYE\nWP6ReH5TQGsJtGA7w6jxo2EsDKlV1pU4lGTIPFUGRWNpIqWce2FEK3AznnqBv66+O4rOlDo6OjrO\nED2mtER/KHV0dHScEURYDJ47FOf7apQpCe6WhBe3cCxUEE6ZtZpodZEeYyqSX5/W8UqkrRO1Lo/F\ncdol4RkBA5dy1b0wFYshrxV0KCM2TMXtuk2g9QB/a8CYTAiQQOwzl+qzLnTw2Rif1dm3JFpPkPWK\nsBmiia6kiR9CsQkKoNVVEgyIpV5Skow9jva5VpUFsBBG+JRgauSyGVrfySvPViskO1eEUkdJz5PY\nNEmzE7S+1IFNidYqs3WKrnUCzzYl58myAdJcd51y3QvzYirEpwNbKTig03it4CE08nSvQkugJmSn\nUOL89KrHXt8LTWI3pUi7iwgnsQgTXKRQpuYaoYO30/4Nc4st/UyTdmMBib7OxA6uyW+3a6YBIaJJ\nsSI6PWc1k5gzkHXartgNtfJon+bzKbeUa7KpOW7bnLkmzNp6rqfZ7KK5UzhcFm6iBpeFe5KsZFFp\ndxbIrNZD2UQKRVbOsBA8LKrPXsrpHCoFl5Rqxvopo0/fLdGZUkdHR8cZwQfIHRXnmykZhFDTy2Y0\nCmARcK5eREf3j+1oPYfKisyksw1610TLpVihjLiFZX0CcZhHZKsD5LWC9sxkNVsSbTSzHO+LG40u\n2ZKKGg6KMEDrEuk+xRvTqs1WZgRUO6AArQA7SS5iBBc5ONpk2VgsipRVtfWRDmXGHuuYxq2GnIWp\n6MHZk7082baJb4+NiCRCsDWGtrYZ2spQrkekIFKKdN4TaPfCVNjSXphKdVp9N6GJVOHKYR7Kd4cL\nWwa7J0p9pai/i0u/vd6WG/06vLJxCyGqzRCsgqzfq0CTWLtkR9IKIwobQtl2IZgArFIsamVZX56w\nqKfkSbSIrMm0LkMPAAJtmcu9TRpun1uxgoSgbCoGk3h75VeplWddHEGTXg9RJdZmLyRSGRfHKk6R\n3CTVxlYP31gJ6Ya62BhRm0wbxqGasBZmFJb7zrPKwUNQgcWq+qzMc93XJeyniM6UluhMqaOjo+OM\nILixHjgnwflmSu1vmXXUR7PSB7BkTcBiBOufsrDElFLWkXCxn7Gh5iZa7KQxZfUqp1X2TUw5YGQq\n+6+rqgYKDvKISYYmObRhSAiLZFE3GHVJuLMlZxk+WBzN0mcssaRqM9Qim2QbgJWaqEm1zooOZS7M\nKUkulWfbNgBgj0OxLjo0VnMgWv4iWtzJS1dsSGzoLK32J0Iw7RgFbiUuzG2TBOxzKmxS7Zliw5zU\nMuiOvCnXuq1Cq79lK6lvY0e5sNtNSCoJb4I2nibg94YIlyGI7Ea/9t3bDigMaGEL5GapnvwKHE36\nNtZS4kP+XRom5cew7dskWyfxbtQqzswaKbYn2Tp7Eu9bKxfPUiTfVfqNEndaQBpGZMcodkKAMqh5\n1nhTPhpLKs1MkzI5jz8Ng/Z3O5UEWzdNLSUq9B9900hG2GzsY/PvP8si/lT2iRGIy5iTpKSsLeci\nkRfJNT52itB0h+Nfx4Hk40m+nuQbSX7LjvV7JH/K1r+a5C22/HNJvpbkH9j7Y071BC8TnSl1dHR0\nnBFEqjv9XQHJCOD7AXwugNsA/DbJl4nIHzWbPR3Ae0TkoSSfDOC5AP4egHcB+AIReSvJjwfwCgAP\nvMudukKcb6YELNiSEPDBzGITJ06Chc1QXV9HPim3rKDO5y7iDs1I2kfaY9PeyFRiGwAsFjQiQuMb\n+0G1byM1RVUTZwezItLOeuG61qjU2woEDiSYAk+XT5Yw6yasewyF1Ryaqm5kQJJlgqsX6psklbiR\ncqjKlnS7+t5+BoA9RIwI2LfEWm9f3zWZ1+NJreWQs8I2MTjCyw7W6xmZMSFiY9crSyj2QoXlGpsa\nzchV7Z90zHVH2ixshjRBNmJkxjYPmHM8wpCAGoD2OFJZnqslFQgEs69a3HemvhNnNkFq3MYvRKjs\n5whbapkMUGNMXsoCqGyr2d8VfLWcRdMfj+s4+yklKbQIIDJUmZdrEUChBiyL3VBkddR1qyH/XlR2\nFlfymFIMywJ/9YfwC63WPqaUa+M6rtZjIGSaS+Ir9/aqRZBfomIkGwojAiqz8vWLeBRDDXB6cT9/\nb4oLSmM5dNo4pZjSowG8UUTeJCJbAD8J4ImrbZ4I4EX2+SUAHkuSIvI6EXmrLb8VwD7JvVM6vcvG\n+X8odXR0dJxTXKb33f1JvqZ5PaNp6oEA3tJ8vw1H2U7ZRkRmAO8DcL/VNl8M4HUicnia53k5OP/T\ndzYALQOYMrKUqliyAWKwstRYDNYa5ZSpurT8hJpzHrEYkoBhRzG51LClgzzig+IBABQ2NJohq9sH\neSmFkTOSsNjgJGMBQC0GCKg9zsiMLQIuIGFTyjjowPUmxmIrpNP+tVT5HipLyI31kucp+baeo+QW\nQ769760MbLB8Jrf1yYUFaZvEgaQSUwI0P6llSxsSh9IqCpWpuPrOY2kaF2pjc40aUVhKf/i1uiPv\nlVjSYR6NsS5Ncp31ehn7jcyY85JFDcjY5lhGpyJEDMokEogQBCm1LIrlvcAvSRvfbFR0i+p6bQ6d\nx4TaAbmxo9aKSEwMtygEaMsXfrJS2ZCzqGDxKgSCs8WTSCvtjiWbaplBKT3RbCOiJTdy+UcGzJan\n5Iarvq7Ek0Itf2ElziUlYDMC29YCqInP5QBGPUFJNVqYp1mZj+UhSZZlHpIoy3JbomLYClQ211wn\nhACkVGyOGE0piKQxsKuQp7RWa14C7xKRR11k3a5G1p295DYkHwGd0nvcSTt0NdCZUkdHR8cZ4pSE\nDrcB+PDm+4MAvPVi25AcANwbwLvt+4MA/ByAp4rI/3cKp3XFON8PJZ92NrNLZoDzavRZposFObPk\nlbghqyOUZfXH99HyXEpTBAzm9DCEWt4cqPGHZOUmdFnAJEM1CS2xmGBGrEPZB1i6BrQxFYeaswpu\nt/YORLdKENwhCZMxnpG1uN9k8SE3ZK2l04cSO2rf9dhtXK2WtACA2ZR2reuD9o2l2B+AElNqz8LX\nqymrlBLoLRN1eKxIHR2Gkuel+1fXi1zaHIz9VBYaSqyqmr66Me7I5fXd5lh+Z6CyZEDdG9o5/bwq\nW+GODsAyPqkLpOYWZd/dnRAAACAASURBVMtXApZBJHN5KDGgJj6kH3BkzOtsqo0ZCVnYUI7eVjNd\n4N2IhJPDxSDd8pTYlJWQSwRomZwBmXODl6/wd3dAcIYVozKRxjVBUqrbT7OyJYsjlT637CTGRaG/\nYsxqpc8XMaZY709Hm7MkKS2PAyibs/0Ymj+PbtIaG3Z1CvCct5O8jsFvA3gYyYeQ3AB4MoCXrbZ5\nGYCn2ecnAfhVERGS9wHwiwC+VUT+71M7uSvE+X4odXR0dJxrnE49JYsRfQ1UOffHAH5aRG4l+R0k\nv9A2eyGA+5F8I4BvBOCy8a8B8FAA/5zk79rrQ67G2Z4E5z+m1NHR0XGOcRkxpWPakZcDePlq2TOb\nzwcAvmTHfs8B8JxT6cQp4HwzJZfJAmWaRAab02isWyCA5GCxWZbXEDNS1sTIdjRSKsx6xVmLHLv1\nzCwBc46awLmyqfFkXJVyswnmj2VqLyAXQ1a3IGonutaJo6Wmj4RqwgpitIq0YzN15gKDSOJQ1PrH\nZeKRLLWVtIKsTxsGjIyLabtokvIBsYgeRkYkqWIIl437sZNNE+5T9zkUPROt96TtbkhMIA4kWIyb\n9bqZJDxJnQJ1w9XtyrjWscdJE1+5rDK7FyarQBst+TjhMDe2SM11HUIqv/lgU3VeM2tdR4sUhCCL\nkWuZjQq5iB5aqJWPbdsKHdyAVbiUbzebXEQPsQhZt/sdMWuFCyHqDiEJeHR2uIgaNOE21OTZSJV+\n29TbEfGDT5nNNh2WBQhxOc3V1kqa5yqkYFABgfdvO0FyBjdjTaCVvJCPu2AB0Gm4sNnUqbu23tI8\nVXm4TwG2lWotabaVhLvAguOofYpRk2aHoZrIph0X7woh6DZDa3Sm1NHR0XFWkKuS+nSucb6ZkqyC\nwWU5d4ghxUa0dfQ7p4AhZuwPM6KNcgFNjhW3nolpkTy7ZkaePAtUcYJaDg1FmOCGoQuhA2qphTUD\nSKiVVP19tMD7gQRskIvdUBZNnG2RAasy64IAKRVjC7uh99mZlKfFquDhUCY1cGUo4oaMbMm10rCs\nWrYiGiNLIlYao/ZtYxVxbxdg3xien4ufn1+rDVMpV+HlK1p5fKSgNaudJGIrQyOz1+TlMcy4KW4x\nhlR+gyqCkIVFVAaxiakYspZraRZDrY2Q5ofmYkEUgt5bOYWSUKvbQtn8SsCgKzU1QVmUN75kQ24F\n5HLyZSIsdu7jOCIrB3YyriKGYE2ULZ1vhA5F8OClL8ysVUJQBuUYVuICNzAVKZY9tFIUMs8QsTIW\npUNUY1RLeC0wNiOzmhk781ls15bAsKq0izZsm9awFesqsyTk8LDYHblggzHqfi7oOEWcls3Q9YLO\nlDo6OjrOCAKeRFl3Q+H6uBrGjBZz8g1bEvNrCaFuQIoW+MsB2xTLMt/ei/1tUyyxJS9dsQnzonQF\nYCNvBOyFGWNIi5G9j84niTjIygAiVL58kMeGQTnjqP1MzWi+XecDNo/JVBsflh91WsSpcpWJixv5\n5EVsyJcBKvl2I9Za8E+ahNu27So/j2sJMZRBbc2o9YKtdra3RY3taBFDHbmOSBYvq4mvyST2+9xi\n38t/WJwuiybM+nX2on+TRNyRNogUjCGjLdLov2FeXWP/3ErC9fo0v0sO5nFamZGXrfAE7VIrjrKM\nJQHKcCwZtL1vuWJBR9TyVtSvjR157IlWkqJUbvF3M1DVxFw5GqcSseUWL7KyFUx5YcjKNnl2jSxV\n7h2IUuQvyzIG05S9KPEkX+6bTLMW+DMzVjCUNrnZFHuhNrYEyVrgz5lRGztqtqH3DTAWF2shQusH\nh6EWF2z75tZFp5xA23rZXup1o6AzpY6Ojo4zxGmp764XnHumVEaSuYkjlaGjfTWG5EmPgnoj6JSx\nxQbMZHMMaRFnAGripZt5zhKPjKwB4DAPxSrIC/25qgwAbgqHps7TkfyGaZFgCyhjSBIKC9iVXOoF\n/vaZi/quTV71uBIAM1zNq/3TIi7UbqdKvYBDmTBJKowpUo1b85Fghe9b40nehxYJgq2oEm9cnVNV\nKS7HSRks5qsbzsVaKMGuMbTool/vZekP3S9QMOWAKddyFp4EXY4jXLz751q2oqrvAJR7RbIyIzb3\n2hH1XaYmzQ71ngSgxfea8hZFLWdMpizzQXxTvG9tLQQBJLDGoHx58+7wsumL849NomwWKxhoy1bD\ndDZD98KggOWQ3tmNK/DWSbxO9d2GCFCmBYCbUc1XU1qwFFzE5qeo7tpSGI0KT4+bl+u9zdz0PTUl\n0ttzJkvsa1dC7l2BXjKe6HWjoDOljo6OjjPEjST3PgnON1NiMwoMsphnb22GPIdEa3XZSNfiBDFU\n6xlAYwUZdWTi1jOusis5LJCdDCZQsB+mMiKPNor3kf2hjFbynCWmEZhxIRyWmMU+VbsWLGcHqLGj\nI8dDVbjtMRRG5EX/luXNufg+Uq2CnPnMSKVQYJKMezTu9c6qXMU3IC7shzJU7acGrjSbocreNlwy\nOWdGfs02UFZ5U3Pt9LhS8pYOZFPyu9SmyTO8VK0YkUvu2BjmRUE/N8tV1aKey51JC8Etyp43bqbO\nhlyx6b+PxopkwbbhrCnV+w6w8IVA8+YSgUzQGXtUFrWqmFEYUR6wVNr5etZtFqo+V/s5uyLKiF9K\nWQcu2Ecbg5Josw2BC6YgIVTG1DIe73dpL9c4TE6aq+Q2Pm7A6u3k2ofSbqOU4zgs2UrD9Nu8I8mC\nbKyqlKeQvHytVHltWYsST7KChIWdFdao/S/xr7Zw4Smhx5SW6Eypo6Oj44wgIHJX3y1w7q9GG1Oi\nD3BKYoiPpnzeVkfFRQhlDMlHwiVeACnr2jgSoEqt3LCcXagKO8HIuYzM2zjIxvKW9sOEiIzbs7KS\n1AybN43ha1wNl0sxQBDJBq1VBWfvzehyj0OJMcG2dabjZSuqus4LAObCjHxbf/djjebecCDLGI3H\nlYqjQ2GBWhZkkup2kYXYIixiShm1NHxrUtsa2foyZ1MJtbCiF/hb5pRpyYpsx90LM0bm4ugQKNja\n7zwwY5viYi4/Wf6alj9nDWHuGjiXGJN9dkYTpcaRssaU3ES1wMMyabWvx5Ngt3eTxyRWcC/MzbHN\nyYFuQir1n4YE1BG/xagoAhmMLblCTgTMGcy55CNJNNWaF/9rcpjg6jRS2VK5+G28p8auFsq3hsWJ\nlyEHqkrO7ue2WJ+XpVgX/FvEj1ZmrRyHGhtydWAMRS65KDLoTczz0ZynU4Kc8HWj4EweSiTvQ/Il\nJP+E5B+T/DSS9yX5n0m+wd5vPou+dXR0dNxtuM6EDva3/PtJ/j7Jd5J8M8mXk/xHJO99kjZO9FAi\nGUh+EsnPJ/kYkh9617qO7wXwyyLyMQAeCXW1/RYAvyIiDwPwK6gOth0dHR3XL64TqkTylwB8JdSp\n/PEAHgDg4wD8rwD2Aby0cSy/KC4ZUyL5UQC+GcDnAHgDgHda4w8neQeAHwLwIhG5+FzW0TbvBeAz\nAHw5AFg9+S3JJwL4LNvsRQBeace+JMTnMmjy2kQwSp0PaadvwrJKqNg0nAewfTTi0zvVWqhO44WV\nRDtbjSU1YiUGAvth0gqoJOCVUZGLaWikWDVaneobOas1jsmfJxkQkLE1y50stLYAUOXU+6jy530S\nGUAWKaOM0QxVy5SeT7+hmrRmK6ATFsICNWvdo9V6kozIUKbxEpopRZOIRxL7iGrIam379F0kkUVr\nKCUINqwCkC0aEYegSOcnhJI42ybjugBkxAxgKNM5GSwSez33anbricu5mfazOqJlX5+SzcJiuuuG\nrDFkIGv9K78PqvihSswhJgsPywq0km02zZelZh2BkH2aDGUaT7dHRbCfvp09sj9UEoBW3S5BtytT\ndVmQR6r83NqWQK2F1OwDAJxQknN1gRvFqhkr22mtnMuQVkBQqDvnxt+I1LLIgWrW6lN428nOq06n\nyXaqbYsUM1bJloTbJrwi6lS7ixjEjFdTQthsTKzg60zGzQCZtaotUqrTe2LijJUEvJ5jI2m/ChZD\nerrngwWdAH9fRN61WvYBAL9jr+8hef/jGjlO6PAcAD8A4KtElpOsVm/jywD8fehD5KT4SOjD7d+R\nfCSA1wL4OgAfKiJvAwARedtZ1vPo6OjouDsgOFo08hzj2SR/QkRedbENdjy0juCS03ci8hQR+Y31\nA8nWvUNEni8il/NAAvRB+MkAfkBEPgnA7biMqTqSzyD5GpKvSR+43TpDreqZ2ZSscPmusqhSeZZS\nBqEpV4k3UJMl1/ARcptPcGiGq7sED8mMVn3k7tsc5BFJQhFCTFYtFYBJwGUhdFiYkBpz2yCrCav1\nZRJlSc5Eokmv2wRXZz2+bmyCwGvJuMrC1WKoFTdo0mwubem+2s4dMpcKtwmaPDsiYBLBgWTrlw6a\ntT19dzPWlpX6dXFWlMwqSL8TB3lUFlpYrV43t21aC0IO8zIx2U1wXbjSWge1jFh/N1n4knlSNQBk\nrwbKmpxdDFiTqQmCNEIF0WzixmaonPKO1AKJzeLcfA6VRLmcu9yWZQUWibjOsJyNNSdsMw0sNkVo\njVybf/Z04QGNZYVglXQFnBtRQqv68AqybkGUc5F9i+SSvCqTziC04gZxo9T1n55SzVZPpLUVKiwJ\nKMKGVjLujMm3LwIKoAof1ufRnE+xRDpNmyGB/oAneV37eAOUDf0ZyeeS/MQraeSSDyWSf+uY9fci\n+fGXeczbANwmIq+27y+BPqTeTvIB1u4DALxj184i8gIReZSIPCre88JlHrqjo6Pj2sL1kqckIt8r\nIp8G4DMBvBs6G/bHJJ9J8uEnbec4ocMXk3yVNfr5JB9N8jNI/gOSPwrgFwDc4zI7/pcA3kLyo23R\nYwH8EZb1458G4KWX0y52jBaBJsExhxJT8rhSm0zL5n1KSyuRUuQvaEmETZixV5IzQxlhe3mKSeKC\nRflI3Y/lMnCgmoGqFaomgY6cC0toE0m9EJ5Paztbcrn1aPGcZPJul4C35qlAtR/a41jKUjjclFVt\niJaMC4AVB6wxqQzBHiL2rBjgWOJEypr2GUrSbLS+6bVAkYG3Sa4JATeFbYn/eKLyJBEHssFocbkN\n06J8hV/L9npNEjGGZHE6j4mxyMADcyn85wyptRvymNLFiqzFkIvVEENWQ9ZsMU1A0xQISJSa0Fpi\nndCYUFxeX2czakFkg+SImuXQsKZa4NK+Ry4G1c6iWta1CLUG7iJpKEnpzvw8rmIxJYkEcq52Qy7l\nLq8dIeY2IRUNM/E4jZWsaNc7g2oZjSfElgTY9lirz55M66Uqjki6nXXtknp7X5rEX5FcY0unietE\n6OAQkT8XkefaTNiXAfg7UDHbiXDJmJKIfINJs58ELaP7AAB32gF+SET+yxX2+38B8OMkNwDeBOAr\noA/Inyb5dABvxo6yvR0dHR3XF86P3PukIDlC1XdPhpKOXwfw7Sfd/1hHBxF5D4B/a69TgYj8LoBH\n7Vj12Ctq0OfvFwcBmkFzLVUNKTGAGLQcegw1fkAKxpiqEs/thiRgPyTMmaXQXxZiDFXdlRmQIBg5\n4SCPyohsQl/Vdqo6SkIkxGqZY4zBDUQnDKVgYJIAmLErAIx2PvteLtySZ13V5jY/qqtTHEjCPj2G\nwqLAS6WEhVhsSVmSl0cHgAiNKY2MqEUApbAvj0n5cXUfZUQjiAPx89DfaRKzRrKfq7UbUtakpcpr\nT3TdVgYkIaK1sW3jRG1cDIKpGMwKDvNgpUSWMcH/n723DZZtu6rDxlxr7z7nvSdh9MGH0INIlGU7\ncmIHo4Bd+AeFLAmMQQoJlBWcvLIhSiV2CmxDjGIHVQFOoApiiiR2rBKyX4gD5kOOlASHEgI5lcQG\nZKBwFGI/BYh5QZHQB6C8q3N677VmfsyPNdc+fd/te8+5975z7xq3urp79967d+/e9/Qaa445hsTa\nC5O6se5cbdd951Y30mvFYkxKYE5ctSm7pGY/VPsaAKm9kIvSwrVJVn9CWyaNsHoJV72Z0i6SEG5K\nO3vu++emxLsAi7Eo3PWZCwMCmOT/CU9SP4r1JNQqNSVjTNAa07bOEq2EjCWZei8nqTVNWVR5/uVl\nCdcDhDVtIiVg4YBWH2KLL9em3hj2F2tHUObVbVubGew0teUAvAnYjlnjLTy2/Qrj0OUYr3Z39wtE\n9BoAbwTw5QB+FsAPAXgTMz9zO/sZNkMDAwMD9wssA5sHBP8RgB8E8E3M/LE73cn1thnyEWKcSA/L\nwgja7GFAbelaWrjbUjKm3FgPhZH1WmXEvi8TplSwhjrSFh7GR1WNWBsTKBZIp+Y4BrMVlbgKchZg\nMeBzuNn+FpY4caBFjVtchbA1YUszJZxSDvUl9rrPioIY2GfcpDpLa2xI6kzVlXsTcrAjkve0GpTH\noxNhDoashaWnSo63N2SNKKHOZudgp71cz9QTUdkRe9CfnatErZ5nNkNzKlhqXyMsyopE7dge+3do\nTCuYsbKytENIqbHvDsSqxEPH5KW+xLDeOjdY9RXQsfyD8DrSxWW+G/svUdvzQx/BbYi0d8mCAGMv\nU2NGYbvCzWrIF4bHFl1hjMNeNyuhZenXrWYjlMC1Ssif1anMviiG+lmchRmvbhF6lTomtF03RqKT\nsC+OPUoQ5R1z7ZndlYGOvD3n8ZUqRLvpDxIRPe9WO7neP0oDAwMD1x0PjtDhvyOi71ExnEujiehz\niejriMicHp4Vx9oMfTURPV8f/xUiegcR/aE7PvSrRuj96Jo4DPowaQAbA+7MSySjaaspxT6VyaMl\nVJmlajsgqOao77GxUXc3atc4BXEVyEgQFmVKsjPeeQRDQmMA2yh0QGpJS3ieIcF5orwTZtRFRKjJ\nKiAGrUVrQhJrIfWkGF9hLKew9h3pPdBMXS1GHYA7LmStVfn+kXDG1XujrFdpz4wzZmRw11Nk53CH\nFiVvbNLOQ9aIj8oJGRWfqKduyGq9SjMViZinijlptHoq3tdk77lV01VVAK6c3JzVrgFT39k+LBCS\n1SLBmx+DU4iDWOtJypisWBScHWIvkSxAryINajgOj+VgGssyZnOQeQEei96p4DTM7+BAnBuL0pOk\n+5daDxO5YavHXVjtx2ovFl3h4X8kDMRqNACwrF6nMQUepdSr5XKW5zHeIqjgeFPTcheHsD6vi/cu\nyefR+6lVMUSxl1T9t3g9qYu6GOq7g2DmV0Ms4v5dAO8not8moo8C+G8AfCaAJ5j5R2+1n2NrSv8x\nM/+I9i29DsB3Q5wevvCOjn5gYGBgAN48+4CAmX8cwI9fZh/HTt/ZcOPLIU4M7wSwu8wbDwwMDAyE\n9q5b3B4WHPuj9P8Q0d8E8DUAfpyITm5j27sPq+Bu64EMmTpRqS6ZIau+NGWdMiCR/FqjpBW9V5V+\nb5HAmFLxLKAtbNooJssmFT7EgvoZy++6GLL2TaHRYsjk5xmMGzV3swdnnKBKXgAt56gw44RaLhIg\n029mM7QEEUP7XEnFD6kzYbV1Wv5SwgmZVVJtwgZtnrUpvEdVYFHCZ87ULhw3ReUmLNijiTwMNq2Z\nUd2iybKpbN2FM4oauT6az0VaX6cw9deOYa06ndp9drVxSn0hOxqzcpCCu12Vz0rJ3Bq5lhs+ZceZ\ng8a727nekwgWNpdabHj1DCS9zLvpPdapOftvwEBa4XlK1nwrwgraaoBkis4k4YBLxnkiFzFwSiCb\nwrL1tn8Bpo2x6ZTbVJdP2yURC1hyrIkOihq2ap6RG7GGBlfSKTyXd5vdEKVmIaTChnp+BjNjtek6\ne+zrWkptqf6+fqzMoHlu0vaQ1nvlqHTc7SHBsT8sXwO1I2fm3wLwQgDffNeOamBgYOAhgQ0kbnV7\nWHCr6IoXhqfvDcvOAbzv7h3WbcBGkZXAs410uI0EyUZkOvpJwjqmXLQxsqIkAkqWmAL00RWRCRlD\nAuBGrrNuMSdJRU0qhiickBNjTgvAEquwIDsDaAai7XmUkM9Ue6EDNYscwB4z5tC0WiHNrjbSOFcJ\nd7QbKmCkTQKtSb5NEBHZUwXjhGac1xUzZbcfOmcVYwQJeNzG3j+hb6attg1JQ20Ga0NsaiwJjDOe\nUWDCEMYCs2pq5rYJ1e2IMlVA97cESX0FiV2TihNMJGJxI0vd6X4Za01YgwGrCRwqE0pVOT9nNfeV\nT23s28QOJn6IQgSyugGhCRyU9UAZDhDu7bEJdFSx3DXJWmOskbBNo6z2XMs1X1XmXRtjsn1zli/C\n2BfpteF2RyaMSCrYKKxGs/p5CZB028Y4XNwQm2djA601rSYC1QR2qXa7LklZVRMqSOQETbPbCwnz\naYmyLmCgBJqC6fA8qcxbmVVouqV58veW/dVeDFIrME8g2rC+q8I1ETHcCTTp4dSeM/M/P2a7Wwkd\n/jHapMPnAPi4Pv5UiBXQy+/kYAcGBgYGgCatfHCgQX7fA+CzIMba/wLEmu73H7P9raIrXs7MnwuZ\nuvsKZn4xM78IwJ8A8I7LHPiVgSHhfnEUyeQjEIqvKZKzJ6kFJIi10KH6EQDsdFSdSBpoDbPWigC4\nBY4FAZ6m5WB8xRyGs2IgKrWRM94JuwIjoeKsTm7KasclDKo9BhAsdRpMpj0TeaTETK3Z1V6PDGeC\nsKDCrKarFpiXsWjoXzR2Tfovb1hSJsIJ8oXlQKx7NRQQzjijgLBD8WUzrXou7PNWjbGYsPCER9M5\nKpKa1xL2PHksRVKGFCMrzGZopuJs174Xe+6GudPqz2N0hS0zOyGLQ3F014+N2vVvjl2HxN1qVIXq\nUw3S7hgfAV0ellltyYaLLv/m9vfNrYzCqL7bP7VtunWIwDmJTDwyF4unyNQYjzfbmlbcqvLhG06h\nlmTrTZOzJeba2Irug1RSzrU2tmU1JMBNVmNNyZto9XVvqA2Ns5QIZj9EOffvC7Q6FgUJ+DxJ4+y6\ntvN01aoDPvJ2ffDtAP4wgH/GzC+H2Mf9r8dufGxN6V9VqR8AgJn/PsSefGBgYGDgMqhH3q4PFmb+\nKIBERImZfxrA0dlKx/YpfYSI/gqkCYoB/CkAH73tQ71q+GhP5rypkI4GW03JYiriJqKwa69XiM1Q\nTjWwqKbC29fsTbGnWWopEncu8eOujtNtz+uMmQpOVBV2olEVFqEwE9QKyJpnZ2kK9dpQUqZQXeEn\ncegJGaXr3zMTU2jzrNR7KmYSJVxUzmUiPEqzGqymLpbC2JRh4dXrSQXWSMu+bnKGFmtupM217NEV\npvRbGJip/781E2OpCadUsJhKDhWgZsq6I+CM22V6SnsUJK8pWYNtjAKxOlSm6o20/jlDna5ywlqz\n3FjqSVOquLFKpXCtjaUWwO2KaqVOiQegXWM+shWj1m6ES5BrlAAyWkPtuk3qumP1Ia8L2bZGvozp\nKAtL+pwTIanJqtec2gGCwUiFtQYEeGEP6JpkqTLI6kMI9SBlQhbyR6V4I+22KRfTJIq6tcBtgix2\nfL+IMq8WZUAXbX48xsLqT7ldaVzZ60iUM+p+31kIcQnr6XKuDJqnFqM+TWIvpCavchERkFN7f4us\nIBbLo1J7k9irgM3sPFj4LbUT+p8haRAfBrDeYhvHsUzpjQA+DcDf09un6bKBgYGBgUvgqtR3RPSl\nRPRPiegDRHQhzZuITojo7+rrP0NELwuvvVmX/1Miet0lP9LrAdwA8OcB/E8A/i9Iyeco3PJHiYgy\ngDcz8zcw8+cx8x9i5m+8jAvslcHnzdlHjpS5jVBt7t/shUwlxXArGKspGUvKqXbPAQn5m6g6czJG\ns43eNswaSWGPrXZkI3gAGn/QTn/h5Oq7uMz2Mav1jQ0cK/fvnwAsYJx7VATjTNlRDiO7vi7UzFgT\nyCPPEwgzTV5PMti+ZspYUbCiSGSF7t/qVzamnUFYlF3NYTA4kwQULixqQqsp2fletHZUkbAP5yxr\nzMfCMZK9+mvx/AOtjrdUsXay/e/rhFnrTn19SZWZup2FO7rJrl4TU65eY7RrCwBY49HtmiSLQzfE\nmrY9qIQ6cbuW4+obllUzvP3JrIRSUcK18Qn1GpWZn1p9ibRPSS8i0h6cqmo10mVWU+KuJqV9RFOC\nGbR60F8NTCnnZnKatZ5kLMlC8sx8NajfooXQhUA+rVV18RS6XseGQuS5RVRYjYmXtdW71lVqUqU0\n6yBmsRiKAX/GAs1qKPYsXRWuoKakf6f/SwBfBuCVAN5IRK/crPZ1AD7OzL8bwF8D8F267Ssh2Ue/\nH+JN99d1f3eKb2XmyswrMz/JzN8H4C8du/Etf5SYuQD4/Esc4MDAwMDA3cUXAPgAM/8KM+8hWUav\n36zzegBP6uMfBfBqIiJd/kPMfM7MvwrgA7q/O8VrDiz7smM3Pram9AtE9C4APwLAA5uY+bmhwBsY\nGBi4priNxtgXE1HsD30rM79VH78UwK+H157GRW9SX4eZVyL6bQAv0uX/aLPtS48+KgUR/XsA/n0A\nn0tEvxReej5uQ3137I/SCyHChi8JyxjPBVm4TXtY3Xj7MhPqmpCm6lN55vCcEiNrzs1aEnZTccED\nMXeZSWZ1s9aMXVoxJZlqS+gtbKwpdosoBTeH8IUngOHyZhFB6BQeT9pIq0mwKnqQ7Vue0kyM51Oc\nJjNhg4gwzAYoE2FCxid56RzCzVLI0mXlszI+yeeYkJF1KmTlln0T7YagOUs+ZUdJpg1BOIcIOqx5\nNp4VczvfI3mj8qLTnCLeqN4wKzZC2qasDuELmtAhacOsObPbNnZfOeO8tkt90nM8UQEg2/W22mjT\ncyTNvfsi04iUGOerJdAmcJUp4VrMdZ7BoOYMrjJwlHRQQcWZD/9RMqGOiR5U0MDUpuxsOtC3N3m4\naRNK2EdFlzQrU2+6XmV9jYAJoH0QPdj0X9aE2dIfrKTUQuZcYvMsoFNyUR6ePBeJtfnVM5IKyxSf\nT8+R5yr53BUlAKVJvqFCh2V1ybcn0QaJuC/j2jXb0jw1kUOcpqx6bGkzkWTTfFdpNcS4HQuhjzDz\nocRu4OKfPtv7zcfq7gAAIABJREFUMescs+0x+G8B/H0A/ymAWNP6xO2Ue476UWLmP317xzYwMDAw\ncBSu5jfuaQCfHZ4/DuA3brLO00Q0AfhdAD525La3BDP/NoDfhorggqPD84joecc6Ohybp/Q4Ef09\nIvowEX2IiH6MiB6/3YO+clhRuR6iSEafgJRV9mryXm2IzKmiVJGE20Ap5iOtnLzYbcV2Y0Fi6ikb\nlXBfvOm0NYICIhM32fLCGQtPzqpu1BPPBZL9CI+ZIQKHtl3qBmmnVDGDsajp6aPKdIwlRRRmT5pd\nuLqgQV6rndChouIROvHX5MZq8iqMZVIWI6yLXAa+cHVmtD0GGeeyD7bt3ETDWQDYs9gxiRidNHup\nqqx+9Ybjii27kec3yok3Ivt7E3cZWLa+ybwTmqVUZMisFkNiI5X8u65MSKmqmEbfI9cLLQjtAEyM\nE14zNkRB+r1BlH/7jIDJvcM2MYHWmm87CTnCMg7sTJthZZ+szbMkAghqhqyowpYwBRFARfsLsk2c\nddFDaq+bcCAnz1LiUuRxra251g7Xngd2sm2ABcRGyAUMFK4JY0xq2BoFER2iHRLgFkcoBbzfN5k4\npT799opwReq7nwPwCiJ6ORHtIMKFd23WeReAJ/TxvwHgp5iZdfmfVHXeywG8AsDP3vHnIfoKInoK\nwK8C+AcAfg3CoI7CsZLwvwU58M+CzDX+97psYGBgYOAyuAL1HTOvAP4cxH3nlwH8MDO/n4i+TW1/\nAOD7AbyIiD4A4C9Ap9iY+f0AfhjA/wGRcP9ZFbjdKb4Dl3B0OLam9GnMHH+E/jYRfePxx3iXYF9W\nZh8FciGQGbOCQKmCK5AmTQrVkWdKFaUmnO6kVtJGzwRiQiZJHd2XjClV7FLp60sq0RZrG4tQkNH2\neZ3FjDWwpVNatF5SMZsMO0RbxFH/Y0miFyoSzuqEx9IeCyeVhcv+pO4k9aWZqLtopc4ljayzjhyN\n6SwQJrNwRQrxFIWrG67OlFFRkSnp8kk/N+OcF69HAVKzmikJI4XIxc9VRp6JJHXA2BExFjbG1LOS\nxpYqdlRwpjWkKJOXaAo5h/tADSrIYysqJ5ymBWd17uT1dp5jbSlRxSN5j319pO0rNDLaY2FLJJJ0\nbix71ToSM8Tot6RWU7KWg2p1JTQ9dwCZkWsGyNT3DGdBzpSU/XAG0t721UphacWFP15SY5UVqbBv\nIwxI2VKRwpKxKSqs+6W+oZZZOoiNvShLMnZFa4HbD1UWhrIuwpSMIdnrLgtXE1SuoN1OrHysnsPc\nbH+yFMp4XVzmDcCNWY0JSRMterZk66611ZmMQVXuJOWyeu0aZ2meJRk3JWGJV11TAq5q+u5gwB4z\nf2t4fAbgq2+y7V8F8Fev5kjE0YGI3NGBiL7r2I1vx9HhTwH4QX3+RjwXHB0GBgYGrjHEjf1qpwOf\nA7gnjg5/BpKp9P8C+CBkPvLP3OaB3j2EL5Uyh1As9igBrumi+i7aDxEfrAXsculYEgBvrtwG/CW1\nEjpRv5gznjSeom0rVkPKPHSYuwthdbKdWOMkZQ1WpxJrHBmozdpIC8CVd2YFVAGchdiKhWtrfA3x\nFGILJDUj2b7i0bTzhtq43LYpzL6tMCNR21WwMqlVluv7WMBfJg0BJIvY4C4eJJ4jUTW2+pvU2NhZ\nSlQ32no7WlXVWLo6XlFFXzv/veWQ2w6F5t3ImnNS1SZJrc++o7Uk1CoMkZQBUWKwMSNVdWLiZqBa\nEAo97Z6TMpVgKWTwbe0ltR/iJOtRFTWev14RzFgbMfMAP1/x4nuZ0q6rOR2CUPF+u6zsIimbiAam\nxpLssSnyEul27CzJP7dFSNi+TK23gQX/WeOsM6lQY/JAQLQ6FJdysUHX4jjMXsjqXPMEmqYWSHjV\nuILpu+cYXg/gk+gdHb7i2I2PVd/9cwBfecsVBwYGBgZuC7fRp3QtwMzPhKdP3nTFm+BY9d2TRPSp\n4fkLiOjtt/tmdwNde4nWlBrIl0PZUURlMdaMNwv6A5qdUAVpNLqOkjlh5RY6Z7Wj6owmaR1JGKup\n7ezxTGtQcTVF1xnPN7UuMlg9KU5rn6naLtaQsiriosXQFmYTFCPUrQcp1pIKV7cVks/ZM7No/FrA\nbjdkBq7t2NnZkrGZXbT/EbtZCepDdoshC+vLqkSsnLw3zPqUjEXdqDv/Pk7SgpkKMipWM9X1Op7V\nxPr/Attgx0Nx9wAw5cOjZsqR1ojllf/RiW9VhTKK8o68XgTAa1CcjvuDxYER2SUvwX5QyyD4SFt6\nlvSJ1o86JKgaj1yNJsfZVHhS3+K+78rX1YU51F+srmT1JGVHxpDcaijpeltGFFR0bPUqoDNhtVpR\nVNZF01YKijlK1L3WHT9UfWdx6MnqhlZLuwu/IA8IUyKiTxDR79zsdux+jq0p/QGNQQcAMPPHiejz\nbvuoBwYGBgYa+MFhSsz8fAAgom+DlHp+ADJM+lqIq8NROLamlIjoBfZEI9GP/UG7q/A5dOgoMLP2\nhNhCXe8m9aPK5L1IAC6EugHSwzJRG23v0uo9RQBwXidkYhQmZUXZIxQseO4kLdhRNDeNNZTWlwQA\nM4qP/M3VoWA7ooe/bmanmUgjKNqo8Ezjy+VzJDVUFfXchOzqu0zymsSdJ8wa6ldh/U1Jl2ec0IwK\n9jgMe1+JPG/HaSwtgzT6nJwt2bHbdwDAmaUtjyargNV0hO1YdEXS3iXZT8JJWrBw7rYtSBq4KOq8\n2R6jxVdM1DPkBMYUTHk9woITiKSmxEAzZCUGmKSmBOjoNhZs0Ea7kdUQJKQSaAo4HRlTERNWAM2d\nIYfelbrZxhD+P/jb2z6dnYXjsM3UtcHNWM1wNV56VksKbgdMG0VaNC01V4dobmrqO9t+CTXwnMH7\nvbCV1jzot+jmIA4NfJExAQAl1Ljf0BcVa0zdMZfqAYOyrF0TRNpbZQzwKvGAMKWA1zHzX2fmTzDz\n7zDz3wDwrx+78bE/LN8D4H8joh+FnJ6vwdXJBwcGBgYeWtyscfoaoxDR10JMYRmi1j667+kopsTM\n/zXkl+5DAH4TwFcx8w/c/rEODAwMDDzg+DchxOVDevtqXXYUjp2+A8SU9Rlm/s8B/KbaUdxfHGDR\nXNFLxNXepXqjo6aG1tb4uNaEotskYp/KEQPWhL0mk1oRfK8NmDINlNSck3CSVlQkz0aS/cm+zuus\nU07sgghpwK14LJ0DsLwg8sZRQ0HCKa3yPiDMxD5bIjZDUnM2YUFR4UOUZie1LzWJuE3hWbPswkUN\nWCVjaeEV57z4dB0AXW5mrIQTmjy3SY5F9plBWFCxcDNjzQTsWY71jLlZCmnTq0GshKpLxq1htSB5\nkuzCE07T0qT14TKuG3sh+Z56Sf8SpOD2/dSQJJvAWDn5MkuZdcspEiNfCtcTV2nUdiQAKiU3xyv/\nmGEaL0q4O81FECzYc85wc1ZABQ7ZZw67bdt7kk/ZcW7TZ/36TcTApFN2vp3IuT03yR7XCiSEKT6S\nNFmbmrMpvThlV7TBdhU5tokHxBi1tps2zlJKbWou5ijF/CSzHQoiCJOJx0Zby1Wiae6l4/qafrEi\nTXcjWEWc6vNE3ivEgzd99zvM/HpmfjEzfxozv4GZf+3YjY9V370FEtL0Zl00Q6LRBwYGBgbuFFYf\nPOJ2jfAzRPQjRPRlmtd0WziWKf1rkD6lZwCAmX8Dt6GmuGuwWmrmg6zJLIXAypjQBA/tXh7nJGmz\nVgA3JGJPno3yYBthF5DbC32yzJioOOMx25sMxklahGm5CSp58+bCk7AAlmbPHRVvqLVmzzNlBTtI\n5ENqg1s8aoICIl+2naa2Btgo/zYBhLGf+Bog7Mqaay0kIhPhk3zeyclPQ+SFnBNrsBWYsGFHssyS\nZzNa4+yizAQAzuqEBD2HnLAguyntTGtnzirHKyxqphWJ2naVE87r5EIU+axJBRFNHCHH3jfPTp70\ny94mUNRstep9vJakcTY1QY0KHZg3ogLLV4ky7g2sMba7plmshDjjwrUe92OPiYP824URjSVxVuGA\nsiwWau0NtCYbpyCVNtbDk4oQKtSWSNep4Z5U3m0MKkq9sxqkqniAS2nJtEBnM+QNrtMUYi5ErBDt\nhnhdnA1t02gtuiJuA66gaZbnOTfbo2nqrI66ZFo99i6O4yrw4DGl3wPgrQD+bQAfIKL/hIh+z7Eb\nH/ujtFc3WQYAInrstg9zYGBgYOAiHrAfJRa8m5nfCODrIc7kP0tE/4CI/sittj/2R+mHiehvAvhU\nIvp3APwkgLfd8VEDIKJMRL9ARP+DPn85Ef0MET1FRH9X7ddvCbHcJ5m/j/P2gMx5F2rz8xZHAKsF\nyKh4LTJKNzl4Anc1CGBrbcPeIGv1i0SMR/KiI/jS1SxMjmxWOGYfZK+JlFyiLMxeyOosZ1WWnwY5\nudWUxOyUUIFOBl5UFn7OjR019kPeYNs+D3ldydhQ1kgKkYonyFFUTMguD7f4i6LRGWY9ZO9pzC3G\nVezIand2XrljKFY7ylpX2lHBKYltk9WQDNVF4YQ9T954a7UoCf5jr/klYmdIFvIXv1djatIcnbDW\n1NWaAJWCM1pEBQPFjFir1C55G6VirKhCrlM3P5V7Yyq00SdZkJ/Vk2pGF0MBa4olm+JpLM2C/TjR\nBVZGDKR9BTT0L62sjEkbSnU5WIP/uEVagBm01l4SHuXbxo5qaawi1mTsGA/N6kyTMyQL+fPaVGRj\ndv0q+0nzJLWkafb6krxX7ZpmZVHPsDrzVq0pidGrvl+wJbobICA0Oj/77bqAiF5ERN+gKbnfBOA/\nAPBiAH8REgT4rDhWfffdkEz3HwPwewF8KzN/3x0fteAbIBbrhu8C8NeY+RUAPg7g6y65/4GBgYHn\nNh7MmtI/BPApAN7AzF/OzO9g5pWZ3wfgv7rVxker75SOfTMzfxOAn1Id+h1BAwK/HMq2tBj2JZAf\nPkD8kt5w6x0F5VElb0Jknc/HZlBmKql2HJBIgsReL8ipYg0yqFXZkzXO1vCaGIpWtwlaOXdNrsai\nzquo10Q5JgHnFsFgKExdZHoJ7/NM3fn+WjCeMCZ7D4+mYMas65xQM181iOKuetOsBfSZ0s5qRyWY\nTy5cvIG2otWi7LnFYViNyWyHzCg2Q6JAku9PPyNaXclqZ3ZOYvOwG7GaMSxJM7GFIbbzLQxzCbEW\nmSpOU4tyB4ApFW+krZwwpdKx4+4xtWuKmTp7oVITKDFy1pjtzEg5UBliV4KSMnaq1PInM8LrQEcE\nWYxWqaD7wwW7rKOizwgS0YXZArMZsmZbu6x40vfltqyLPq+hedaY3SoMhjO5+s63iwyoFCDl9jyy\nFTNkLbW37jHj1ZxBu50o6Cy6IqxjjIUSuT2RsSXKWWpLstBZEyVytZ0xJ2+ejSarpjQ09Z2rEu0a\nCCaxV4kHbPoOwO9l5m9n5qe3LzDzLSMsnvVHiYg+hYjeTET/BRG9lgR/DsCvQHTod4rvBfAfotXj\nXwTgtzSoCpB43pdeYv8DAwMD1wMP3o/S52tS+c8T0S8R0T8hol86duNbOTr8AGQq7R9CClbfDGAH\n4PXM/It3crRE9CcAfJiZ/zERfbEtPrDqwa+BiN4E4E0AkF/wAp1bZyCxjEJj7HRUJVUChVEuqVlm\nVnY1a+hfTvVCnWNfMna5yOi1swcSNVllwpwis8h4NO1RIIF/s8ZPPD+dXbC/MWRiLJxxStLrJKGA\n8gHMFsdNSO0QqNW0KmSEcUIJ51yRAWcuVjOKERQ3eMGjNHcsSl4zNRpjphyi0mWoLZHokzMsqyOZ\nzdCpR7K3fZ4x41EiLFpbOiXCJ6owvzNlNdKfZQawSYP+UouL0Hvr4coQBlRY6kk1RNGfpAU3yon2\nhBHOlKl6zahmryXNqeDGuutej7A+pZzYW2Wsb4n09dr1xUGuu6qFnMTA2l5nalMxxABP7Oq8bd2g\nZmFLTJAAQP3jRND7jcVQp5QzVpXEOggA6tQeO8uyXqJoZFpkGa3KDDKJeav1HG0MWZlIjyl8gHUN\nXljKOqwPKQT8eb1ovzrL8qC9CK4Aaey5fU8W8geALRbEgvzi8ZjCz3fFHWMiYrUwSu0zAl3dDIBH\nuF81rtnU3DH4O5Dfin+Ci0LgW+JWP0qfy8z/MgAQ0dsAfATA5zDzJ273jQK+CMBXEtEfB3AKmXv8\nXoiIYlK29DiA3zi0MTO/FSI3xMnnfPaD93UODAw8PGDcwZ/t5zx+k5nfdacb3+qn3yfjNbP9Vy/5\ngwRmfjMzP87MLwPwJwH8FDN/LYCfhoQHAiIhfOex+/RI6SQFJhf2mGCnaACb9ojYy8aS4M+FLVUm\nUV5p74r3KYUoi06NR4ylSn1DKkasERXF+2ZmjfiOtSJTk2ViibMI7gZWS5mpYlHXiMUVfc20FBAm\nYuo7YS8S/JfUTSGyJFtnVvVcYzstfqKp6i72NsV9xN4nj66wUEF97wJhSeI4AXd2iOo7N2DV87ej\ngj1nX75wxgLthdI60J6z1/JOafGAP1vHvxu0WHozyJ1SrN2RP7+ouGS/LqLbg9UeGRDGosycK8m1\nFmpJAHqnBoSRsdV5NterbWM1IGJ0/1OpyrpmrGrRFZyo61Pymqrtp7D2LUk8OmfqmIGp7ziapU4Z\nJp30+IqEniUxA2txNwZMk0aYo7EOQAMAlY3kZpAKItkmqviAxrasl2hdRWGXc2M/QYknd1o/CnEX\nZtTqjg+JfB80T8KStIbFytRkZ9QHD5bSmOUV4gEUOryFiN5GRG8koq+y27Eb34op/cGQg0EAHtHn\nIhhl/pQ7POhD+EsAfoiIvgPALwD4/ivc98DAwMBzE9frB+cY/GkAvw/i/BObGN5xzMbP+qPEHGRM\ndwHM/F4A79XHvwLgC+7m+w0MDAw813DNWNAx+INW9rkT3J3K3T0GJ5kuoUoueoiZNWYJI76Q7AMT\nM2H1plptsOQwVQM0s86EPrk0axNt1e0qNENJp+u8kVOn82Ih3WxyLHn2rM6ep5RQ3V5n2UzhyXuK\nSGDW4zslESJkkkZWa6a1abqFi0+rFfSS7ihYsGTZCf1YxNa33KQahnZx6m4Lq6lXSAOtf/ZQV9+h\nuizct9vsz6bfSkj/zXq+7ZznkJck1k8Vc+rzq9r0XpuGlecm+2/fpcGaZG2qcKm5m72RaWHItLFm\nK3ElQBNoyYQNJryxfScG5yZ8cKsf37EdADyh1o9JLYGQ0BpsXZ59cV82dSePdYouN4shF0qU2Cxr\n782d/ZBj0ukybzJVo9S0seGJTbVxWswshXT6zE1bu/eYRMxgFkNmU6QNsLTbNek3HyjMhERaUJIm\nW5vGi5ZIvj67wIJyVml78uk9T8jdnovL4mZqu+3t+uAfEdEr73Tj50RQ38DAwMBDiev3g3MM/iiA\nJ4joVwGco5V7/sAxGz8YP0o6rLPmWejItQ0BZcSbc/WRb2XCLoudTUVvsBnZkj03SFRFcYl2jD7I\nKiUXCTgBOvt5os2bs5q1io2QyJ1PaS/bQY5j5xY5E05pcRZxaqagkOiKM5bR4Yk3fEYjVXmcg/hh\npoQMQmJpdjWhA9wuKKuVELuI4RE6wcKrWwZJ8mw77ROyj+gtviITobK832MpabSFRFfsiDrLIWue\nbamu0kT7TE0ubDC7oBkFi16up2nBM/XEjyM+TyRBFjeqxVoYw9km9zISN5HFygm7XLAv2Znxqi0C\nS8nIxGAwiAjLmu2yEmU16d8VVxlAR/7aihDe15pnqdAFW6EoCacS36A9d7/XsIx1W6rcLvvNHzpO\nIkgw6yEKDMFk46Rps2CVg6dGaTkynnDfrIlqY0M5AWttTbFeVTj815dIxPvGTAhoEm5jR4nAy9pi\nKdSY1ViSNMMWALlZCwWRgwgZ2B+7eAIQGbociOx7Cn8Wld1x5cbqrhCRPD9A+NLLbPxg/CgNDAwM\nXFM8aD9KzPx/X2b7B6KmBEDm8IO1kNSWWr3IIgOIuBu5LlVGS2sIAQRkvQrqDDm3UnCLpgCaLDxa\nB8lyCQKcqYi0WdmT1ZSEMZHGXSSc8YSFJ68rFZWlW8RDV1Mi9nerEJYyU2pGqDoyNQNWqTexB/+J\nuarVi1In8z6hGee8IFPCCc26be0iLz7JwgDPuHg8hZwXxg1esWh965Soe92/Mm2etQZgi7DYaT2u\naPOsvMeMmVac0oKzOovBqlaVFs5qMZS8fpfV7NbO+xyYZgwCNLY7BcZr3+eUqtcVAWBfsl8bkUn7\nNaZ1IyIGSurbE7T2w7ENITCfQKwdUSrOqUm/4/58V/Gyo7Zvk4137Cm8JtsG1lPhzbOddVACSOXb\n3oBrtaYcDsQiHyhJLcg/jLIok44bPFqCpH5jsvLuRIT6ky2q3DXBRishi6vYSsY9MDBnubnEOx02\njY0Sdj1WsyK6Ujx4NaVLYTClgYGBgfuJh+gH5xhcb6YUBqiICidjTKzMhyFGmaHklIhRKqmLCnsj\nrY16bZS8csIUTForp06VFzEnGbVbwFwcqZuqy+LQ99rICTS7oVNaupG5BNdpQy71ZqzCMsQUyJpU\njRmZEi+TxZKbYq3VmKKSro+iSLqP4oxo4VUth9qxWRz6GRdnXoCwsRkpxLBD7IW0qRcAFt3vHqIs\nvFBbgrCgTBrxAcZOozskjqK6+m7hyVV1ZshalWF5gF9gP2ai2463fYdrTW4xVZmwlNyZ88Zma9rM\nuVgUuhv+qvqOi1hfeXSFn8DA4KFsJtaYIsMB3FBVtrn42FiWxxwEZR0niKIuNeZUc1PktWPSXRrz\nCYzA4yoii6mq4lvCgVstyOIrAGE/RMJOphAFYfUoC9mz5UCzGTKlXDBQpUSNGUVYvLqp5cyEVY1a\nLfyP9/ueGfmxa73JmVH4wramslcFxoPYPHspDKY0MDAwcD/xEP3gHIPrzZQMpraLNSWgqZcA1Eoa\n7EctoA0y6LHYilKT35Zi0Q7csRygKbpmrVsAbTQ+U8F5ncLydKE/xpBUZbej0tVPjCUUTlg4IYbX\nxWDB2WxwQBod0WBRFrK/oCREC/mLyxdeu/W38RRAz7QkDt1UfJHdaT1LmVE8Jnts/VX5wP9GUyVW\nvTT3B/q3F568pmTqPH8PPd9zWlE44azOOEkrlpq6878EBhRtieQ5dTHohsiOrKZk1lXVapJ6nTnM\n+mrbRlNMNhdrGWj9RaGOBGNZ4Xp2tnRAbefbyAHKnUafd2awoVepOwUs66NyF0thNadoN0SFJeTP\n3itpfcYYk9VhPFpcajTOSBJJJESpHkPexaDn1KyGYo1IVXhdrcgO36Lc3T6IEXuZutqSRZ0nArJG\nVthn3hiyWtQGL30UymXxoIX8XRaDKQ0MDAzcRzxMU3PHYPwoDQwMDNwvPGTKumPwQEzfcd7MXfic\nBMI0BjWlp0p6cwrF9ZClFKdpYhqpPO9lwlJ4Z8xJ5MnnLNNFJk1egtv1vOmWXFjaVctmWq/qFJZN\n6y0qDV/YJM/kfY3nTG7hM4epMxM6WCKsTc2ZsGHh6rZCBhE/mChCLo1zlX2bVZFB5OSbaS99n3P0\nEvFDcnCbhrTmYDtHVeXxMVHWxA5yXCxu4ip0iOuZy7rv2zKTqBx0ADfBBCDNs7aOtQIACFO+bdtu\neo5lys4SZ9NUQYn7aTa7Dg/YCHG454xeth2tLO3ellOY3kM/2o7TeWYrRAcK+yZ0IAbSwiIH16kr\nMqsgs/8xN/Ao/zahQ5SOmzggbm+vqQyb11Uu3rV0OUcmpKCcQdOkQgV7/+D4DQDaQMvrgro0OymE\nzKO6rG3/1jQbXuf9vsnCK8sxM/dO4X7PnqfUNddeBfjI20OCwZQGBgYG7hMeUEeHS+F6MyVSlqTs\nSHJnQiUXaCNGBpKOYCuTPEZvD1RqCgIIdjlwHGVPoeK4BBFDYcJ5nTCplZBlKJkxq6G63JnVVmf1\nUT+AjiXstQk0soloVjqTNNAWhmcoLRtjSjNgNQGCpMgWzGRCcPJcJdt2RfEsJRM9OPMicvPWiopF\ns5ds3QrGiTbl9sKLxuQyQa2ScseQohlqRWtw3Wuekgkc7HybiN3OW0bFKTWWamITy7YymT4AN9ON\nLDVmJtlzs5+SWn0TMfi6eh1xFdrikvDAeEQO3sQBgF63QZBwUPqNtg+ktm6VWGF5KeYpEbWZAXu7\nYsm2F9kq55a/xFkaZP3/S076/yvJl8fc5yl5Q20TQniGUiJpnLXcpI1FkTMNY3GUZD2Vjlvja2M5\n3MQIypiEzfBBoQOAZkUENHYVHxtzCseBICWXVNzavc6lCJsq2y/ocqDKR90u9R5ELySidxPRU3r/\ngpus94Su8xQRPaHLHiWi/5GI/k8iej8RfeelDuYWuN4/SgMDAwPXGcdO3V2eTX0LgPcw8ysAvEef\ndyCiFwJ4C4AvhMQIvSX8eH03M/8+AJ8H4IuI6MsufUQ3wfX+UWIgrSJrRQmjvkrdKJRrb/diMRat\nbiAxFjZKn6h6EyXQS7lNDp6IcRKiESoTTtIqZqxBXxvZTUFrvAWAx9K5N84aOzokk7b3M0l4ImBh\nwrKpRUnKrDW/MhZmnFL2SAuzGWoNs7L9Cc1IIDxCszfS5jD3PlOb5bV9yDEnnFLuJOGz2xVJGq41\n9u6IcGaJtGxenfZ5GLMzGGNoVRqMzQZJbZkWnnR58uReOa7U1ZQMHmmBpBL8fEECbufXG2dBzogj\nO4q1xq1cPOXavEpD6mxjHtz9YaFK4Q8OtdoToFETtmLbB5X2uGNE8e2o3WRf5M2z+oE0fbbVlExC\nLvLuVoPiTFJbygRO6WJ8hSfV6vkstZdRbxnF1tQVwpKYQ/1Ja0p9ky5LLcpqRBpH0TEhuvidcuUu\nhdasibq02mgxRCS1JGeEqUncN9Lxq8Q9ap59PYAn9fGTAN5wYJ3XAXg3M3+MmT8O4N0AvpSZbzDz\nTwMAM+8B/DyAxy99RDfB9f5RGhgYGLjuOJ4pvZiI3hdub7qNd/kMZv4gAOj9px9Y56UAfj08f1qX\nOYjoUwEayMUmAAAgAElEQVR8BYRt3RVce6EDJ7jJJen0NoW58W4kaSypEpgIUy4+Ms5hKFI1HiLC\nrGeqNkvu64Q5W51Cm2PDb3w0GTU2AMBrSADwTD3xx6caoSF1JNKohowdilrnyIfYoeJMVXg2UNyR\n1G9mrelkEBKEtbgJq40OWVRy57ziEZqF5XB1M9atoi5TwsIxLI+8XlTVwiiBIJyPsHD1aIzFDGFB\nWPS4RBkox2Hqu7PAiEp4/x0Vb54tyowSVTymjOkMc3esxoBmKjjnhEXjKxIxlqIhicyoGpoIAGtt\nTdL7mj3MEQB2uWionzQCewhgYlRlQ3aV1MiONugupUKdOo5sPxOD9m0fJiKN9SXOwpYOqvL8zcJ2\nBFGNaVyFKMgsOqP9n7F9sCnsEoErIxUIeyBCctVbeDOZYgBlrQktq7CMdQVSlmUWacEsFkPn+8Px\nDxri542pRKCUwMuq6+cWxhnrRXYo6wKaZlHkqZ2QrQsANM3+2Lb3/eSswYHcwgSt2dfqS4AwOqKr\nrykdz4I+wsyvuul+iH4SwGceeOkvH3soB5b50RHRBOAHAXyfJoXfFVz7H6WBgYGBa43LT83Jbpj/\n2M1eI6IPEdFLmPmDRPQSAB8+sNrTAL44PH8cwHvD87cCeIqZv/cKDvemeDCm73ijHGJ0DCllBqWK\nWppiykZdFolu6jugWQvZ8olqZ8yZwJhUzRVZjCm5rD/GRu6mnsvKRSxqYUdFmJPGLyTtrXEbIe0j\nmsNwOZGwqog9N0ufJczFt/oRdbZDss/kr2VKqrKz4D/pS5K+o+o1I9tH7G8yBtYMWAknyF38+YIQ\n7Mftc0TMVLFH9ogOAB5rbsq6hKrnakJB8vpd7CEzWF1vqdl7yUTdV7Eq+6qIaj8SE96b9CqVKkq8\npPXIrSGr1S0tEr1RHVyoA3VtTkkKBlSot/pJYd1D/U3h9abc44NFcU6tT4mMEeiXwDcZG5P27jBJ\n4J+btLoNEguLmjJ4CkataxGWZNZBXvdhYVJTULzZMXnMeQUlUdN5LPlu7sxTO3YDtOgKYzNWR1Lj\nVq8nrUszclV1IFmEhQX4mVow1sVqBe/3YK7ep3SlQX/Kau+BzdC7ADyhj58A8M4D6/wEgNcS0QtU\n4PBaXQYi+g4AvwvAN176SG6BB+NHaWBgYOAagnDPhA7fCeA1RPQUgNfocxDRq4jobQDAzB8D8O0A\nfk5v38bMHyOixyFTgK8E8PNE9ItE9PWXPqKb4HpP38UBC8N7OWgzOmXt08hT9U2kJwmYpyJuDqFX\nKWUGhX6UlRN2qXc/MOWYuQVUJu9ZMoPQRLWrepjZ6Eyr1o64qe7IQgUzZtqH+lTx9wOAM044peo1\nr4UJJyRhejNRx5QKM068N4g6w9XCUpM65xWP0s5ZE9AiLMS8dcI5LxfcHKSvST8vaufaYM9PKOGc\n5ZPYQPuUCDe4BRXukfxcZoiKKpqlijkrea3J7wMrjWpHqVFNmNOq9T5GQsG5XuoLZ0zBWcPY1UQV\nK1p0xVmZvG9K+pQoMHF1eQjfLVl/XNVeJXN1iH1LDLi9gyvehOowAfES09Jlv609JoBWdGaqtm1U\n8KUVUpsxU1RoZAULQ6Pl4l86JgJZv9CkirwpSXQF0P/nivS3cmMYVnMxNmRqtQMBfswVVJVpWfAe\nh/qS9SiZ+arWu1DXpsIz01UAEvKXWjy6b5M6FoVV66RVDF9b7QpeS0JtakJSRsXrerAv6lK4SUz8\n1b4FfxTAqw8sfx+Arw/P3w7g7Zt1nsbhetNdwfX+URoYGBi45hiODj3Gj9LAwMDA/cKBGuDDjutd\nU+JN0fgQwaT2Ilfq7GyMNe9UGm7F66rTM2lztci2fZpphBmwAvDU2S0yyeRYJsasaapRBj1TQYVM\n8VkDqb2fSahFOAF9H5GEF0izrO1pWxc1C6GYjSTTcxmFK2bKbh00IWOm7HLwE5o7myGgZTGJfN0E\nHU2SvqCGqTtZd8+MM5tCJBEy7FCb1B6tedbEIjsqah0UnqcFmVgk4pv100ZkIvZCzUpK1rFpTH7W\n79OWW7ZSCZlM7RpqjbWepRR35bZX6JcT+3Seixasp7O2WT6Dz1DaMjVjjSmzsiJcXBGFE7KuCS/U\nesimq8yeyNb3BlpoIb72pqu+nogrTEbe3qw2ebXd+/uE94z2PTm1DCZAzFKDGSw0PRZAm4Lzt1MT\n1XXx6bo0TzAD17qsF9bvjtXeV9+LS+lTZ7M00DLXqzdjxT0TOlwbDKY0MDAwcB/xMP3gHIPrzZQQ\nvtAwAGsvyl1nExPkvDmx9/XJcxtt96zJG2dBnex47grmrOarG/sZXV/SY6sKHSyJNikTWCBZq9wX\n7aPEOUQ9xC9tVhsfAB0rmQOrydTSZoEWXxHtgc55Ubuh5FJwQ59Km3wfmaRZtuoxmM1RTLStAM64\nYs+MUz2eU6JO6DCrgW07T6yxHiKAMLa4U4HIXiX1xjRNvlI5ufmqnXuTfbswAo0tJaqYU3ExS2Vq\nDbKBVVUmjzbJqbo03K+RKoV0k4NTMkZiF2U4GYZN/EUcDXParEtN1KCrN0a0FfsEHUJssnXZeDH2\nEdkVg1b2hlrfnTIha6DlTBeFCvqax1ZYRAUgDGPKTeDgUvQmIadoD2RCCUulBaQ516x+giTb7YNU\n+p3mCTSJrMjMWu3eEmj9dEZWZ1ZDYRntdmpnxHLsxqy2zO8qwGjn5la3hwSDKQ0MDAzcRwyhQ49r\nz5Qi6CYDCiL2ELatsJGojbSteTY2zsYRc0I0aU1u7mk1EZNx20jd4xEOWOjIeisKE864Ccd3VJwV\nLTy5oaixhgLCoqasBpNjzwdMKYHW9NqMVAk3eFHpt9SBJmSXeJsUXPYp95kIJzR7c+0WszIsY07J\nrY6iVJz1PLDXlLxRODQN7zkjHXifvRqwVk4uqTebpr1aENn3YuvNGiUiz4PMv8p3Z9/pRBXrge/f\na12pD3cElIEb8w7MiYuN6Lkx91AjcpshZVNUtXE2kqet6phV4h3ZFMLj8LyrRzFvalnUrSfy8LBC\naEKnVeMqjEHZV1LRpNLMIiGPZqwmQV+VbaTUakM66nfLH9YG21Lb6xoRQTmD5knWVbbDlcWYVRmQ\nxVh0gX6As6O4DiXrD0EzZzWTVWVBlJIGCNp3mPx4aZ6aOetVgo+8PSQYTGlgYGDgPoEwmNIW158p\nEUThFL7ZyJZsfr/WEEGgr6XUGlcpMCLZR6szRHXYWnMXaZGodttJ/SL5iD2qwawuZTZDZ7xDgdSV\njGUZe9hrAF40dLXnlaVp9kZtFaxZzVCLKvDkXlRwADqWBACnlL0J1thS1X+fVBZVuLoZa2H2aPRt\njLrt3wIB5XjSBdujDMLOmjgZgUE2xiRR5z1LsudmN2QoTLhRd10tz2t4nPw+1vG8WVa7Tc9ra5Kd\nNnEUsbZk186WTZOxIQ7KO61dcpEYda/d2HpWC1L1ndsR3azgbQq7wKa8/mQKPDVdtWbatj75em19\nbiNvjbLgSVlfDO3z8DtV4KkijZiBJSjlktZkrPYRVX2d0o2dDVmNx2tKpr7T4zWGxDGunKuwFdtd\nsClyViRfir/mNaVpdnZkrImsWVeZmKwfvgQibaTVBt1Smk3SVYGPC/i7bMjfdcJgSgMDAwP3Ew/P\n781RuN5MyUabVaVEOvdqI1cAfcCfggGNHxBbGaslWA1hIlFZVe5NOqdULoy0+6h064lpo/aqMRMz\nrV6XslH8TKtHchfdbnGlWenqLQu3HpkTkhj0R1PROhNrlITUfux+4YpHaRPvoCatC1esKJg1pM+s\nhcSaaOrUd0CzKZKoiqawK5v/UZF5xdcztcc31Hpnhxb1vmjtLW/Oz4zSsah2PKxHzH7OZB17v+rq\nu8oSVb/tU7Lv6DQvF/qU6gFmtFSLMCC3pJLeJDR5XGTpBLk2E7uirouKiKaqta8jWY9QO1B0NakD\nOYWqlNssNJNWex+tIfnhZmrHRKKm65RozMrCWl2IiYA5+2OKwXiHirqHllndyd6r9rUmANIT5Cap\nbT1jReTsRljUoaA/e93CATvWZJHq3X41LsPqWxZrAWF1vCy48AflkrhH3nfXBoMpDQwMDNwvMK5W\nYv4A4J4zJSL6bCL6aSL6ZSJ6PxF9gy5/IRG9m4ie0vsX3Gpfsf8iqpsurMbQOX9oFHp7bOi69UEX\nageA1JMmVcNZOJzdA8DKWSLPdZRuiCP5hTMyNacGW29WZmQKL1OgGXvLYJxSkSh0V+eR9ClZCeDA\nZxeVHauiLoWeJtLjEbZk/UfCtGoXgS7RFgknNLnCb0XBhOzBfUWdHOT8GcMjX5YDszrR+liExb3v\nYbESCWc84wbvtL6WsNfICtlfqzNFVZxEicg653X21x7JS/ddxdj5fTVVH7m7hx9Tqn69xD4lIsaU\nCygxUmqFI44GrMSiwCskxqsMD6RE4k2AHx8cDTsjMuak9Shrkds6P6QVPbQnKRq12r3Uj9C1TJlz\ng4UC6klWVV6oN9UKFG5OD9v48px7hmMqPKAzbuVSpK6UhIXRPCuDuWje2jGhUDcC0Fwe4i0ut8dA\nC/6L/Usa+selSFyGnbvw2biUxt6uEnzk7SHB/Zi+WwH8RWb+FwH8YQB/loheCeBbALyHmV8Bidr9\nlvtwbAMDAwP3FGP6rsc9/1Fi5g8y88/r408A+GVIDvzrATypqz0J4A33+tgGBgYG7jWG+q7HfRU6\nENHLAHwegJ8B8BnM/EFAfrgAfPqtd9CKt8jcG7L6fAV8KiWlZqAp7yOJopXJp2YA+JTPtGm6BFqj\nrYgeuJumA2QabqmtybOoNVFBb4Gzo6JWOu21AvLmWZOImyzZrHgWFoueM06YSQQOuzCdYKasKUyb\nSbqsCBVsug1osvHC1kTbWwtFGyJLorVpvhOaVSiRutRZu7fMphOdctlznN5r02eSSVWxQ1WD1qJT\ncu27yFQ9hXdHTWySUDcihzYV6smznDGnokKH6hJwy2zKYQg6pdZAC8Ath+J1wUxaAyfUmlqbgcnJ\nN/JvVJOAc/+/LRi3kot10MOu7dhYa5d1Do/Dde+mrj6trSILs/UpfFAkwQTUKYmIgeNy0ryktj8/\nvGezvjHBQky6jfdJBAykja3NykdNT5nBmkTbWfvEabaYJAuIzVCc1rNpPLUjYrUq8mm7jb2Q7MOa\ndZPczCwWNhXIvVnrZXHs1N3D85t0/4QORPQ8AD8G4BuZ+XfoyHlaInoTgDcBQH7BrctOAwMDA89V\nyHjlIfrFOQL3hSkR0Qz5Qfo7zPwOXfwhInqJvv4SAB8+tC0zv5WZX8XMr8rPe6yNIKtKW506bTds\nzbNWyC5alM6pYlVrmDkXVBCIGCungw2VFSJ0yAeGLxZfcV5nZ0WnJE2nsTFUUmjJ2VLeHPNMqwsi\nKhOe4VlZBfvgzhpr/dgg4gJpWo3y6ZY6a6mwYhs0dY2wE7LKvRvzkfgKS9RtNkQLFyQknLFZKkmj\n7kkQSCxgfKIWfb8u8WBzzhL2unSPHCTgksZbOGGBnNc9Z5zVJnOXqI9+QFOcsV38fsw6ymT252Vq\n8n5df9XE2vjd59Sb5VYmJGsXUOYENWN1AY3ZD8XDMFoTIyduEpvRHb49juwqNNKKxFtZGV/c3qTf\nnOiC8aqBSmNzHnNB8GWcksra2ffpywGVeNvjjdFqHHRaMi2HJNcoouAgzy6lEyPA7IXiqVHm5LJv\na8ydZmFPYRkQJOSsZqsWR2Ey8AgTR6yrizGuHPXI20OC+6G+IwDfD+CXmfk/Cy+9C8AT+vgJAO+8\n18c2MDAwcK9hmVS3uj0suB9M6YsA/FsAvoSIflFvfxzAdwJ4DRE9BeA1+vzWYGsCbFLb3uO/DdpM\nygvAawOSWcaY1LB1KSbVlhH1vjRbIcOkku/IUtaaPR5hpoJH074zVq06+o6WN6dp8XpTCaPlU1qw\n8ITCCZlarWXb4Lm4UWs7PrMZskC+pPZDFmPxqMq6jUlZVIUxJrMaavurXpOSRtv2WkXFjIQlGLue\nay2qgnFKqat3te30q9q8tGWeBS1oUaIq2nnbc/a6m6ybUCD2Tqe0Yk5yy1Sx1BxCBDWKItQGrW63\nV8m4yf7tcakJpVK4dlrMSWVCLVrcZGqScMCXuZRba5sA+vYFY1NxGcPtgmCNtZEF2Tp2qcdaEh2q\nLV2cROBMG7altSMzTc19fYlqBbI2z0KPy5pnY+0IANZVDFmjJNzuJ21ITQnISUxZc7rAVMzyhxfV\nuRvDAdxoVZ90TMiYkQX/ufkq4LUoNtl6PLZSm81QDP6zRl87vnSFfzZHTekC7nlNiZn/F9y0owiv\nvpfHMjAwMHB/8XAp647B9bYZstElSYMiEKZ8Q8Aa+xQ2+WZAH01hr9s6lamLqkDYxhDj0U/yqk2u\n1U1XZf16sJm26LpAi/heOOOMpy7KQppmVz/WRY/v1GtTrSk1MqTumFUJJ+F9cpspBUsgMexZUbqY\ni0xJI9LlM9t6FYyZrMmVL6jvFlRnb4eiK05JojeWDfOzxtk9ZyxaW1qQW/TEgcu1aPyEYabikSI3\n+9783BJ7Q21koXauLfxPGmWlSVfYtjRbC9vW5lliUeAxhC1t3+6Ass5v25qSKu68P0UfR0NWv7wD\nE/JajxI0U6cCaH/4zBQVUkPy+pKq7+RxqJ34+xib4P6vRjB99f0DUqcxlmHvaQzD1HfM0jhbudWZ\nDtVsQjOshfJZ/cjUdK64s9A+tObYQ7ZElLMwMI069zpUSqL4i42zFm9h8RpXqb6z9xghf45hMzQw\nMDBwv8AYcegbXG+mtFUaxQGFxQHYerDYamqCvRBJESPTn40htSiL1PUpLTVhTrUL8qsaYSGmrNVZ\nVFK13cITFg2uKyw1EbMbmmnFgqyGq6lTpAFab6HeNstqSMZ2ouJO2E2owbBFVcg6sfZ0QlPoOWrm\nqxLgJ/9MfddHn7c49HqBGohCrzBwxuxx6O01xk7rWo+lPWapEGFGcTbk8eeckIn1PFaPArHzslxI\nyBMGtWW5Caw1pWbI270e6o+lJrefetZBq52OBLESyhevQ3nM7Q8ScYuc0PXMRsickdiWcVPbdf97\nCR5dYf1Nsm9Ss1ejPMJQzIzVlyOwIX2dik4tWS2FVELpRUE0ppU3f0qq9vfEWlIprY4DNHYUYWzP\nbIZivLq80NeMTHWnr21VdhbOZyGA3qNk6xapZ3GVWAyutb1fKR0rYq6iwrtqDKbUYTClgYGBgfuJ\nh+f35ihcb6YEyKhQ4wH6kSh6FgUg5yqhf0BnxuqbqAEn0CILtkgkvTOxRlRZWNJErd9lW0eSelDW\nvhoL9EtdHIO5FiRUnPGMx2ivMeE11I6s5iXs4oTEKSF3bKavLc0bRgMAs4b8yfuljkl57AT3SrxH\naPboCmNM51pzstpSYbm3OlPZjPCsX8mm6SPzkx4lYT7i6ZC6HqSijDOyUWNL/Wcrrabn9TBjQ9VZ\nrn138l2xsyOLL7HaUnT7sPsph5A7Vd1ZjcmvPYYE/VntyBBqPa0ABNB6UU2XClqQn+63bavPc3sM\nwGMvzMmhK68p+0hlU1OSk9RqRLGupNvwgXoP2/KbjeQjWwK6ID9T5rU+pE0/k6v8uO97sprR1Gqv\nHq++LgDXrmeJ93uk3U5ejzEXFsXO7Mo7i0P3Y7ZQwVJBlMRt4ophAYq3uj0sGExpYGBg4H6B8VA1\nxh6D8aM0MDAwcJ9AeLgaY4/B9Z6+i01lJsO1mmDtOwXNMLNrbkQrbhNJkuh+ndxmqPpUWRNE7MuE\nXVo9UVb20Ru3zmnFUqdOlhwL52YkOtOK07SgsBiwLmhF2hnFM5cWzp1k2cQNWzn4wm0KbuE+AXaL\naBk0U3aJt03NAZYia/sTUYSJIGz5jKTvT76NvefC9nnhmU92XxlqLJs9S8mm5sROSQrKp2q3ZCg+\nLajnjCc3bZX92vby+c6rZDAlVDVizW4rtJ2Gtak7s5LyfC2mbjrXzFjtMSWxF+qylBgyz5a4l23r\ndWoSb1Y5ucvD4/aKLoV2OxUIFUBsZ9Z8GpBcNGHPoYeGRP4cUDGENs9SqTr1t30zatlKFf3Uknej\n670JGUJqrZ40vwCYqzTP2ms5X5SY61wvl+LTbjFLCZSQbJrNpvbUcNVsiiQLSab7YiOtw85LXGap\ns5UvCjmuEkPo0GEwpYGBgYH7iYfoB+cYXG+mpPBGQW0upMTNbqia1Ftl3wSUkjxN1EbFpSbkVDHn\n0jVjWpyBjKpFQmwNl0tgQktNXkxf6oTTJCasHrOgo3Az9ZxJpMh7zm7G+hjtu8+V1TR02+SbKAge\nIFJrq1HH1FegNbTK8TYJeCbqGmML9xPbUSqeKQUmFGXksvyUMhZlV0uYILdjWMAucNh6S57qMP6M\n+yZWkYFXbyauIOxoRUbFKe0vSMLtvJ6kRYQnen7nVDpxCYDOTDe74IH8e4qih1IPnP/U/xHZsm+5\nCCENtd5/QHqNshsHe3MsUxMyxP1GwmBihi2bMgm4kRUTQughpiLvl1YRK3T6Hm+c1f8j5rFGBFbb\nHyrVvzDStNm4DUfLHZNwR8uhGtbnfltvXA0iBt7vhanF/ZYCBMbj60Yxw4Y5cbAkkpUreF28kRZQ\nNhWZkTI7T761z6TRGmwCiKs0ZbWa0jBkdQymNDAwMHAf8TAp647B9WZKNr9ujYg+d09eU6KpgpI0\nzsprIg1PqZmwGjNyi6EQfbDaSBlWbwhy5GfJKJam17a+y41B3jC7xZkuF2aQNNai1Tmk7mJMKIzc\nAbf12TazxpqShe+Z3VCrF1l9KV1YN5Mxu4yFSyfxbpEW1cMDT5DdZijWuADgBlsAIboIjsqk0vcW\nK1GRcMYS/2HRH2e8c+PVrKZHMwkTslqTnW+ThBdOXT3Ozt+iDbkl1PrsWOItp3qgniQ1RzazVUhN\nkixE0gMmqW/mVlbkoX9A97gDNdbDKayi9SVjRi4hj0pqZ2BSQ6oTPLLC1wu1KaqsUnPy16izB0L/\nWJtyxf6IwSk1xuQ1oNwiISwYL5qa6nLKWRpS11UC/ub5IhOh/s+UNcEC0O2Xm77WsahYj0okxxfZ\nkrHDaZLjALx5l+ZJmFW0RLoSHFlPeoim+AZTGhgYGLhfYDxUPzjH4HozJaBTJXW+lha+Vkh65TS2\nghKDAaxaVzL2klPtmmdZa01AbJjlUCOq3QgcQBc/AWyaOImxU0VZ1oZYoEV4S0VKGmwtDjyhugLP\nsEfySHQAGp0OzEH9FuPO5f0uKuPMkkiWR7NYDe3rLIm29abqqj2JtEgdI5qRcEpWd9NmZBYj1p2G\nEAqLbHHoFlhYmXCmcfKZqtgvKfs5pb02107OjOx8ZdRgF1S7QL6k9Sc7X/13mLqmWWNNU6rOlkSZ\nSW7IarBm7NrFVWhNMzD4Lsivy45AX0cyhrNR2FFtdVP7H1untquorgNM1RcWUFtO+keQVvbXOFFb\nZ8NSWNkNJ4lK5xj3oPZFxCxTUMaC7OI0S54cWFS07YkMxYL+rAnWwv0Cy+lsgrbNtGbOqszILYi0\ntmTWQtCaEi/r4R8DN55ViyGrZZl5K3Axc+WyuAc1JSJ6IRG9m4ie0vuDsd1E9ISu8xQRPXHg9XcR\n0f9+uaN5dlz/H6WBgYGBa4x7FPL3LQDew8yvAPAefd4fB9ELAbwFwBcC+AIAb4k/XkT0VQD+v8se\nyK3wQPwoUehJ6gZ62kMCAFyTjwajmiqynbVkrx/kVN2Y1cw7Y13I9mNIxK7kmpMyIjBONMjvvM7Y\n89TVQBJVry+Zpc5Mxe2GAIm1AIBZw/6MUdjjbRSLm7AyO0Mq+ljYTXImFVV0maQ/aabs9SapPVVn\nTbY/qz0Zw1q44owLZrQ4jBu8IoVtAKl7xUBC2dYsl9o5NaZon39rIyTntq1jYYix58i2ERXexZpS\nIsYa+r8sAt1es3u7Tbn69271pFISuBJSYnBNzWJITo4glJhaDRRCfQIj2loRxfgJoNWIIjgri/KY\nC26WRM6iGErQLwb8AW36iIG06kEH9RxpPcP/OC5FvKLs9cKNHW1rHzk1dmHRFVZnSiSqO3MVtpA/\nY0zQ4wrspDNbDbUjrxOZWevWviiEAVpgYBepPk2dCs8ZXEqARrJbdAVbhPpV4t7UlF4P4El9/CSA\nNxxY53UA3s3MH2PmjwN4N4AvBQAieh6AvwDgOy57ILfCqCkNDAwM3C/wbQknXkxE7wvP38rMbz1y\n289g5g/KW/IHiejTD6zzUgC/Hp4/rcsA4NsBfA+AG8ce7J1i/CgNDAwM3E8cz4I+wsyvutmLRPST\nAD7zwEt/+cj9HyqWMRH9KwB+NzP/eSJ62ZH7umNc7x8lLQq3QjJvettUolvRbGCSbJa0kJ1YRA1r\nSdhNRaXXbVpvrUmK3iCViDebGqC5TFcmZJ3qO68iZV6QYT7GJ2kRGx1tCrU8JUCSVnckTbt5O0cD\nmUay6ToA2HUNqq1a7oIGhsqzVQygFjuWmXRKGQtXzNRshUyksXDBCclxxUylikXfLyOBcM5rmM5r\nQgq7n5EAqjhTuTiIMYNcFm5n0KYllyCdN9hUpcHEDTOtOKtyZgv3M9BnPHnz7MLZhSbRJTwFC6Gk\nYoQE7qyFkk9tMva1l5UD0MTZispZr0NGXdV6qOjUXHct6tdUVEYeJN42k2f3QJB1I6wbHrsTuE3h\nhW1jphJnCpJvfR8VJ3CmJniw91W5NBOBumZRnULKJFN4cnLaF5kIWGtYtzYWYAKIKA3X7W06Tabw\nmjybdjvw2blM3wULINqIDDxFtq4+TcelIM2TvKb2RFxwwXoIgGc8kbmIlwJKmq+UsxzvPPlUI9F0\nxZJwXJn6jpn/2M1eI6IPEdFLlCW9BMCHD6z2NIAvDs8fB/BeAH8EwOcT0a9BfjM+nYjey8xfjLuA\nB6KmNDAwMHAtwWj+ere6XQ7vAmBquicAvPPAOj8B4LVE9AIVOLwWwE8w899g5s9i5pcB+KMA/tnd\n+tFN7VsAABXaSURBVEECHoQfJR2lwu423x2RpH+aISsgo3GTg2cVQlgj7dZmCJDR9ET99k1K3PJ5\nEqo32iZlAK2JljQn6GLzrLCksH8k7Ki4yGErBrDHdksQK58zripSEIm4Ww5BJNsmdpBMJDFVtQRZ\na6idKWNFwcIrKhiZEhaW0azlL0n2kjWnGqNorMkEDQsLOypgT5ydw0BX5O3JG4NnPcfWPGyfd3Fj\nWpGCV044TYs2z/ZJoDMVnKTFmVTWXKT23RljksbZQw3RlQn7mrGq6IVU7CCpsy03qcbMLaa+x1Op\nD9s1aceQ+ntnRBtpuO5SaX3YZ9w/4eL1vt0XcDFPydYNWUqcRP7Nk7Gk6lJwT4PVBllWAUDbkYoV\nvIG2tvfZ5ilZoqwJJXJuEutN7hLNE6zBFsqI3EIofiR9zWXfgFsQyZsk385ZkgkWSKyOuEqeklsu\nzTN4WeQzmcBhe4xXgibQuOXtcvhOAK8hoqcAvEafg4heRURvAwBm/hikdvRzevs2XXZPcb2n7wYG\nBgauMxhXPx146G2YPwrg1QeWvw/A14fnbwfw9mfZz68B+JfuwiE6rjdTOjC6pG5UaaNalYQDniRK\nIabAJL4WUeCRFSDsctlIhNvIew5NmLK+2d/YyL90ERdWEzG5coamymoMAyA1kZlWnPHcSb8BqSXF\npFZLnz1TRpL9uKW+tIRRnSXGmgUQ0MdWiKWQMCmRkCdlVc20dUVRmyJr+BX2Zemztl87jlkbZQFg\nR4THwujajv2UitfMzHz2lBapu2mNzZjrrIassr1Vw+T7Ejuh5OfdvhdrSF7ULqqA3JD1JK2YUhG2\na+eOrUmavZZoy3MSA9iUGGvJ3pBdt4aspBekGbJ6sadfzWXffGD7WFOy+lGUkB9qjiWpV1GB2xBJ\nDIU226o9kDMkk06zGLfaXwMqVRpqw/UTm2opNMG6tByQZcas0iaCYhtHEU1ZSwXWtTETBFl25da4\nmgjWCOv2QVs2EaIrjBkZyyC1CwLg2/r7rGtvAmuWR9bsWxm8X5QRXnHz7LAZ6jCY0sDAwMD9xEP0\ng3MMrjdTAppsqd3J0M8iKxKDK5DMEiYE9vm0t454k418NwosQEbKscESMLayXZa0OdbYQv84oVne\nGDIxZlpFrUfFa05FR/62/R5JQ/FCEyiEhcyhwTUBWh/qR3QLF2RI1EQm8kZX2S6hMGNF0Qba6mwp\ngbp6UgwCLCwmrDOlzvw1Pjbm9EytnnwwU1MaLpxwSkXthqozUD/HqnycIecmUbNfMlaUqWKmFQWE\nG3WHrA3LxnTm1Jppp1T8u7Pvb1IFZfwu1wOqu6W2Bk57LeeWG0FJrYicBgGcuasBxegKABL0F5kR\nNkxInxOjNeVqrarrKya4xVA0ZOUMpIWbUlUZle+bZD23s0nU6rOR7FhtKWuTK6DqQVIT1iTMYpou\nqu98J+SmplwK+Hwv7O3kxKMkTPnmTatWl1KlnMVQOAPa7WRb20b/L3jwn39QqSNZhAUCc0JozHW1\nYCkeUCjrp6tnScOQ9QIGUxoYGBi4X2B0foADDwJTAjr1HVfI0I/Y5+IBuArKGFGtCTmxq7AMHB6b\nEstUWAmMfZHf8Sk1+5oLo2nOWOrUguTAqhojDaXrxwJFw//MXsjMWFvtqY2SZqquDp2Jsai6TfqO\nWk1J9tu2S87Wkr8mhqrJTViltmSMq10amRJWWIS47H3S6pmZvJrxqoX8zeHSSr4fYXUA8Axn7GHR\n5dUVitvzWTRi4oxnLMjNRBUS7WHfXeEW9dHiPZRFHXCzXGvWGlb10EZZLt/TRBVTqpg26r2cKkpJ\nmHLUQqLRHO6vIf8KNAbd2Yqua5um0pGrC0pSMlYUepCQcLH+hJ49mRqPQ/1IbIPCfv2xMiEij0vv\ne6R6dRwqumBAAKpWK65q6yLQYx0pJ+n9UfbhtR0KdkI1/Oc1pZyarLrajhJ4vxfWtaxdLDrbNoDX\nj3hdJBbd7I2MjYXj5FJarAXQam/2ma6nzdC1wWBKAwMDA/cNfE/Ud9cJ158p6fw8oHPzcfga20g0\nnM36TAB4DEFS54cSFHrGkrYmrLu8YqKKfe1/z+fQazSriWiMScioOE2LMCLtrSnaZ7ON6zaUTb0q\ng7Fw698B2qBt0b4gX5fIHRcW1PZYe5lk/1X7lIxhVcSQwBgCOEGMWq22JEq8/phnJMxQ1V7Xd9Wj\nQpSE5kxhfUqijksX4joyVY/92FHBnrOzoIqEvTLP2BvmkSG4yIYrE6YkNSyrX8kyZYGpYjWHiY3L\ng/UorSUjpaqsm1odidAbswLCkqw/6UKdpjGkzsUB4bGyoZrb484Vwrb3mIfIxpohqz3nRLIvDf1j\nZUSmsJMoCh2daw3K01E9CJDEkYFIVX/c133kC2n3RM30NPi9EaVmzBqVd0SgnQb+Wc3Koieigg5o\nfUgWVQF0NSdjTB55wbUdizMpbu9rbC8q76xPKNHV1pUY4P+/vbOPteyqCvhvnXvfm5FaC6kT0w4f\nUhSSFgGlTDFFYlHbYrAlArEJqeEPJciXMSERrTHF+IcaI8GIgqlGY0Kg2mCa2pRqJPKhKTNIW+zH\n4LxhlIGiU7Ha0Xnz7rtn+cdae599zjvvzRv77j23veuXnLxzz917n/X2Pefss/Zaey2td7UtC6Ep\nBUEQDMleTwc+zYlBKQiCYEiWyF60G57203da4ZZitbxK5ZRHCsiKOzik3Er+eXNqRu0yT07KnZQW\n0VbFFF8KIbRRGMbT9NzZlC2VOk8dpc/QXjhrwVib0DkTHbXC5dRYfqCaquWmXGZpXZF2sNJRsd/N\nWZSywKYpvDITba7j0wNpgexUa87oWf/fhU2mW9zIJzptZZzt5mkqj28UIYcqts6ClEFZ0/++4Vll\nJzrK/TdVYb8Ht019tl8mTH3hsvWFunyjvKVcVxMd2QLqwh0997v39Ubd5FlKoYXSb5CnfD3s0LSu\n3IO4CCmE//Vgr1vouGP3hQbqLpZF3IHBnR20ojWF13INL+6B1Lbk9ixAq9Sg49IJwT9XNA4KyXVc\nFR1Xjat0TZ5qy8nnyjq1WtbZatQsjhUx54FUJonaMzUlvgBXU0DYVD9da0XuI0nTep5HKQds9Sk9\noJWHCYppP22mJHOZ5OzhmWtzWKS6md7bU9JC5N1sS0JoSkEQBEMSmlKLp72mlN8Qu6Fean/NzF6l\nTSDNXFeaLKMpjAyYcTvttxZTapUX0Fom2ioH81ypag8iaotnkwY1LQKLrtcr7ro8ovLwQpVrTuu+\n0HPqjgzp70bWqJqFtJXAJKdegKnSWii7UgRHBXP/Lt3D14vQQbm7/PMYC8i6yTQ7NaSFtSbHNDs5\n7JNxq92JmkPFSg5RZN+1wh/lsD2wXoRgSprJauEWv+rpJ9Ii5hF1ozG547xl8t10DXXsziBWJzlD\nWB9Idqgo3cGTBpUdGwp38LrQsmt32wdYGRdv6qKuIbmzTcun247na7S4RJNTjqTrVmmcEyjKd1zD\nUxtSakxF2dI5IjsxpENqzhBaSaNFpe9qpZoUxnzrDHNwKEITpaCsrRQU6XNyaEgLXuspbBbaRTd1\nxaijySStBCw4aulGPrX2dbKZtaBSA5LxSt7PGlARRiilsEBrxNNalGVzRtpCY2q1vzL2QK57PYBo\n1srOtS0LoSkFQRAMhRKODh0WSlMSketF5KiIHBOR9++6orviqk87q9K44LrC1NKQaN5wU3K+5AY+\nqurGNRxlYzpqaVNlaop91WajEankt/GJjrIWdbZu3uAqUQ+HM22lpkguzo1GoJ4gcMr+ajO/4afg\nrOkaTgtFVz34agovVEPWUiyAanIBN3vQCMmJ/Jrgqo2dqaJqhRWa6LRlj6rc7TstqJ26nWlFKiZa\ns54X40rLvrWuZltK7M9u85ptZfn/kroVjmmq5vo96hxbr1dai5HNZlTn71dkajYoad/4K1KzqaPs\nKp7CDK2ObFH0xrRjh1BPg4GyMRnn6ygF/E0hhgBLJpnUnnQdFotnoVCkius0L2JNL/ppcWw3dUVR\nLif7K+xPyd6UFspC43aeXc97TBQq0g7+SqEZJRHSG3tVmYqeFs+OLb1E1iSSlpPtUK4hVZVpT+WC\n1NYJ/HhVaEIjd+OutXEHdzm01iYwazouldmXRqO8mDanrPAFuJnx2OxfI7OZlYt4M6MKnWya7Wuv\nbUr2T+xuWxIWRlMSkRHwYSzXx0ngsIjcqaoPDytZEATBbFAKx4sAWCxN6RBwTFWPq+oG8HHgxh1r\n5PlzzW+G5TR0euVLqSuyo1AK1uo2pRRaJnlTJW2pRlq2BSs78oW1VQ7qCY3GBbRsGUArnUKZojuF\nzFnNC0FLu5AtqF2vx1mLS20lJtok+bP6XleEFbFkfq3AqOWCWk22myqHCtonK96Oe7G5bahuaSfa\nCjV01rWliYccqpC8iHaqysjlG0lzsa2KtDzvTLtsUneYfGMLK4QtXF6VzS0hmroJ/lKfjlr/c82k\nHrn9zjTclM5+3PmdVj101KZWjH1hbNKwTYkwu1IKwJq8OFVdOwILyDpyr7ukRW1HErOWLfYkrRot\nKHW/TNNJyfak7OhZ1O8uws0BWmlsTNopr5W0nwaS7E52U2n3H5lObfFsVW39rnzIugZiHeh2oo5W\nZV5u2k4cmGQAsyeV6cuhCdgKWz3utG40qOL7vLDW06TbB7W2Nzs2pYRrWrK60siyl4OIamhKHRZG\nUwIOAl8rPp8EruoWEpG3A28HGD3nOfORLAiCYEYskxPDbhBdEHdEEXkLcJ2q/ox/vhk4pKrv2aHO\nk8DROYl4Lr4TeHxoIZyQpZ+QpZ+QpZ+dZHmBqh54qicQkXv8PLvhcVW9/qmec9FZJE3pJPC84vNz\ngW+co85RVb1ydiLtHhE5ErJsJWTpJ2TpZ9lkWYZB5nxZJJvSYeB7ReSFIrIK3ATcObBMQRAEwRxZ\nGE1JVTdF5N3Ap4AR8Meq+tDAYgVBEARzZGEGJQBVvRu4+zyq/OGsZPl/ELL0E7L0E7L0E7IsOQvj\n6BAEQRAEi2RTCoIgCJacGJSCIAiCxUFVZ7IB12NriI4B7+/5fh/wCf/+PuC7i+9+yY8fxdYu7dgm\n8EJv45+9zdXOOb4BnAFOpHqdc7yhkOVRYC2dY2BZzro89wNHZi0LcDHwaeA08Hud3+jLLssx4HcH\nluW//Te637dfn7EsPwZ80fvgi8B1A/bLTrLMu18OFed6AHgLA91H55Bl1vfRlmeYf/987Pp9326f\ni7HpbAYlzHtuDbgMWPWL5PJOmXcCH/H9m4BP+P7lXn6fXwxr3t62bQK3Azf5/keAnyvO8VGv917g\nz73eT3TOccrLjYB/A+7yczzq29xl8TqngE/OsV9eCbwGeAc2EJS/0THgb7CANp8Bjg8oy8PAvXPs\nl58ELvUyLwWeGLBfdpJl3v3yA8DYy1wCPMlw91GvLHO4j7Y8w4pn3B0u3/t2+1yMTWc2fbebOHY3\nAn/q+38B/IiIiB//uKqeVdWvYjf9oe3a9Dqv8zbwNt9YnOOIt/H7wDVe712dc4iXO4RdKK8GJthb\n2ImBZAH4H+C1c+yXa1X1c8B6+RuJyCXAJvAKP/514NQQsvj+KeDQHPvlJaqaFnI/BDwL+NhA/dIr\ny0D9cp2qpgCE+7EH7Z8xzH20nSww2/uo7xmGiLwRe0Epl7Wcf3zPJWRWg1JfHLuD25Xxi+m/sCmb\n7epud/xi4InigizPdRB7yH+tOMcTwKWdtlKSgIPAvxayjGj30TxlAQu/+e3Al4Br59Av2/1GB71+\n6pdV34aQJfXLtwEPYjf1PPvlTcAG9sAZul9KWQbpFxG5SkQewqYTv4kNQEPcR9vJkvplVvfRlmeY\niFwA/CLwAdrs5rm49MxqUOqLjdz1Pd+uzF4dT+fYTQIU6WlrO1/5eckCcDV24f4U8H3AS2Ysy3a/\nUbdfpKfsvGQBeCvWL2/ABvXXzEMWEbkC+E2a8FeD9UuPLDBAv6jqfap6BfAq4AA2LTbEfbSdLDDb\n+6jvuw8AH1TV053vdnOdLz2zWjy7mzh2qcxJERkDFwHfOkfdvuOPA88WkbG/rZTlT2KB/59XnOPZ\n/n3Z1rQo//xClm743nnKAvDvXu4rmJH2lXOQpST9Fie8fuqXs9i0zBCynMTsFRdhb+P3AS+ftSwi\n8lzgk8BPA786ZL9sI8sg/ZIaUdVHROQM8FrMfjTEfdQnyxqzvY/6nmFXAW8Wkd9y2WoRWcccU843\nvufyMQtDFTbYHccMicmgd0WnzLtoGwlv9/0raBsij2Pq/7ZtYsbE0hD5zuIcH/V678HmfR8Abuic\n43EvN8Zu7L+i30A7T1kuAN6GGVkvwKYeSiP6LGRJ9d6GOReUv9EajUH/s0PJ4uf4We+XFeBe7OEw\nS1le7X/f1HPtzrtfemUZqF+upXEueAE2jfYnDHMfbSfLrO+jLc+wznPuVhpHh3M+F2PTmbqE/zj2\nZrIG3OLHfg24wff3+499DPgCcFlR9xavdxR4/U5t+vHLvI1j3ua+zjmS++i/FLL8LfCYn+OGQpaj\nwFfTOQaU5QTwv8AjmLF0XrI8gXkuncYeavd4/X/y865hg8RQsqxhhutHvV8+BPzKLGXx9pPtJrkc\n3zlEv+wgyxD9cjOmhRwH/hFzwx7kPtpBlhPM/j7a8gwr6t5K2yW89xyxNVuEGQqCIAgWhojoEARB\nECwMMSgFQRAEC0MMSkEQBMHCEINSEARBsDDEoBQEQRAsDDEoBQuPiFwsIvf79k0R+Xrx+e9ndM7v\nF5HbfP+7ROQuEXlARB4Wkbv9+AERuWcW5w+CZWWh0qEHQR+q+h940FMRuRU4raq/PePT/jKW+gFs\nfd1fq+qHXIaXuVynROQxEblaVT8/Y3mCYCkITSl4WiMip/3vD4vI34nI7SLyFRH5DRF5q4h8QUS+\nLCIv8nIHROQOETns29U9bV4IvExVH/BDl2CLdwFQ1QeL4n+JxZwLgmAPiEEpeCbxcuDnsaCbNwMv\nVtVDwG1YSBqwSAcfVNVXYVG2b+tp50osUkPiw8AficinReQWEbm0+O4I8EN7+28EwfIS03fBM4nD\nqvoYgIisYfHfwFIZXOP7Pwpc7mlvAL5DRC5U1SeLdi7BchMBoKqfEpHLsKyhrwe+JCIvVdVTWGib\ncpAKguApEINS8EzibLFfF59rmmu9An5QVc/s0M4ZLK5ZRlW/hSXT+5iI3IVFoL7Dy+3UVhAE50FM\n3wXLxr3Au9MHEXlFT5lHgO8pyrxORJ7l+xcCL8LSQwC8mPZUXxAET4EYlIJl473AlSLyoIg8DLyj\nW0BVHwUu8gEILP/OERF5EPgH4DZVPezfXYOlaAiCYA+IKOFB0IOI/ALwpKr2OUKU5T4D3Kiq/zkf\nyYLgmU1oSkHQzx/QtlFtQUQOAL8TA1IQ7B2hKQVBEAQLQ2hKQRAEwcIQg1IQBEGwMMSgFARBECwM\nMSgFQRAEC0MMSkEQBMHC8H9pY11ntJwUCgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan4.num_averages(1)\n", + "chan4.records_per_buffer(100)\n", + "chan4.alazar_channel('A')\n", + "chan4.prepare_channel()\n", + "# Measure this \n", + "data4 = qc.Measure(chan4.data).run()\n", + "qc.MatPlot(data4.my_controller_myrecvssamples_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2D Buffers vs Records" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 72, 'buffers_per_acquisition': 10, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 10 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 10 buffers (132.088308 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 720 records (9510.358142 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.17965e+07 bytes (1.55818e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0020940912960440983\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.03831063927994194\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.032004905469705136\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 1.1729961073569939e-06\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.002951551448646228\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#059_{name}_10-57-17'\n", + " | | | \n", + " Measured | my_controller_mybuffersvsrecs_data | data | (10, 72)\n", + "acquired at 2017-10-25 10:57:17\n", + "10000\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaYAAAEdCAYAAABHfMO1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan5 = AlazarChannel(myctrl, 'mybuffersvsrecs', demod=False, average_records=False, average_buffers=False)\n", + "alazar.buffer_timeout._set(10000)\n", + "chan5.records_per_buffer(72)\n", + "chan5.buffers_per_acquisition(10)\n", + "chan5.num_averages(1)\n", + "chan5.alazar_channel('A')\n", + "chan5.prepare_channel()\n", + "# Measure this\n", + "data5 = qc.Measure(chan5.data).run()\n", + "qc.MatPlot(data5.my_controller_mybuffersvsrecs_data)\n", + "print(alazar.buffer_timeout())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2D Buffers vs Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 100, 'buffers_per_acquisition': 100, 'allocated_buffers': 4}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 4\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 100 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 buffers (317.212661 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 10000 records (31721.266108 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+08 bytes (5.19721e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0026767771110911553\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.27665113131075714\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.033519536689993856\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 2.9324903039196215e-07\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0022404225601206917\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#060_{name}_10-57-23'\n", + " | | | \n", + " Measured | my_controller_mybufvssamples_data | data | (100, 4096)\n", + "acquired at 2017-10-25 10:57:30\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaUAAAEdCAYAAACsS3i2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBEHQGKJRCoIgCBpDNEpBEARBY/gv2v2Mr22VyrUAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chan6 = AlazarChannel(myctrl, 'mybufvssamples', demod=False, average_buffers=False, integrate_samples=False)\n", + "chan6.buffers_per_acquisition(100)\n", + "chan6.num_averages(100)\n", + "chan6.alazar_channel('A')\n", + "chan6.prepare_channel()\n", + "# Measure this \n", + "data6 = qc.Measure(chan6.data).run()\n", + "plot = qc.MatPlot(data6.my_controller_mybufvssamples_data)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Single point" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (24.299851 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 100 records (2429.985107 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+06 bytes (3.98129e+07 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.0012281269216600776\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 4.310760687076254e-05\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.035720370631565856\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.00266709989324454\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.0013345763181860093\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 100, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#061_{name}_11-01-05'\n", + " | | | \n", + " Setpoint | single_set | single | (1,)\n", + " Measured | my_controller_mybufvssamples_data | data | (1,)\n", + "acquired at 2017-10-25 11:01:05\n" + ] + } + ], + "source": [ + "chan7 = AlazarChannel(myctrl, 'mybufvssamples', demod=False)\n", + "\n", + "\n", + "chan7.num_averages(100)\n", + "chan7.alazar_channel('A')\n", + "chan7.prepare_channel()\n", + "# Measure this\n", + "\n", + "data7 = qc.Measure(chan7.data).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we are not integrating over samples the setpoints (label, unit and ticks on number) are automatically set from the integration time and integration delay. **Note at the moment this does not cut of the int_delay from the plot. It probably should**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiple channels" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "chan1 = AlazarChannel(myctrl, 'mychan1', demod=False, integrate_samples=False)\n", + "chan1.num_averages(1000)\n", + "chan1.alazar_channel('A')\n", + "chan1.prepare_channel()\n", + "chan2 = AlazarChannel(myctrl, 'mychan2', demod=False, integrate_samples=False)\n", + "chan2.num_averages(1000)\n", + "chan2.alazar_channel('B')\n", + "chan2.prepare_channel()\n", + "myctrl.channels.append(chan1)\n", + "myctrl.channels.append(chan2)\n", + "\n", + "\n", + "#plot = qc.MatPlot(data6.my_controller_mybufvssamples_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\jens\\qcodes\\qcodes\\instrument\\parameter.py:1092: UserWarning: MultiParameters do not support set at this time.\n", + " warnings.warn('MultiParameters do not support set at this time.')\n", + "INFO:qcodes.instrument_drivers.AlazarTech.acq_controllers.alazar_multidim_parameters:calling acquire with {'samples_per_record': 4096, 'records_per_buffer': 1000, 'buffers_per_acquisition': 1, 'allocated_buffers': 1}\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:made buffer list length 1\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capturing 1 buffers.\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:buffers cleared\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1 buffers (10.196575 buffers per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Captured 1000 records (10196.574501 records per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Transferred 1.6384e+07 bytes (1.67061e+08 bytes per sec)\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Pre capture setup took 0.002226346606903462\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:Capture took 0.003388199248604451\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:abort took 0.03470162351459294\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:handling took 0.05353172998451328\n", + "INFO:qcodes.instrument_drivers.AlazarTech.ATS:free mem took 0.003974697301032393\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " location = 'data/2017-10-25/#062_{name}_11-01-07'\n", + " | | | \n", + " Setpoint | time_set | time | (4096,)\n", + " Measured | my_controller_mychan1_data | my_controller_mychan1_data | (4096,)\n", + " Measured | my_controller_mychan2_data | my_controller_mychan2_data | (4096,)\n", + "acquired at 2017-10-25 11:01:08\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn8AAAEdCAYAAAB9mgE3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nahGTP0mSpBYx+ZMkSWqR/wAndkFdKfKhvwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data7 = qc.Measure(myctrl.channels[-2:].data).run()\n", + "plot = qc.MatPlot(data7.my_controller_mychan1_data, data7.my_controller_mychan2_data)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Demodulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can add demodulators and remove them again, This will automatically take care of adapting the multiparameter to return multiple arrays to the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'ATS9360Controller' object and its delegates have no attribute 'demod_freqs'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmyctrl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdemod_freqs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_demodulator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m7e6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mmyctrl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdemod_freqs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_demodulator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m8e6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mmyctrl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdemod_freqs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_demodulator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m9e6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mmyctrl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdemod_freqs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_demodulator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10e6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mmyctrl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdemod_freqs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_demodulator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m11e6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mc:\\users\\jens\\qcodes\\qcodes\\utils\\helpers.py\u001b[0m in \u001b[0;36m__getattr__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 344\u001b[0m raise AttributeError(\n\u001b[0;32m 345\u001b[0m \"'{}' object and its delegates have no attribute '{}'\".format(\n\u001b[1;32m--> 346\u001b[1;33m self.__class__.__name__, key))\n\u001b[0m\u001b[0;32m 347\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 348\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m__dir__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: 'ATS9360Controller' object and its delegates have no attribute 'demod_freqs'" + ] + } + ], + "source": [ + "myctrl.demod_freqs.add_demodulator(7e6)\n", + "myctrl.demod_freqs.add_demodulator(8e6)\n", + "myctrl.demod_freqs.add_demodulator(9e6)\n", + "myctrl.demod_freqs.add_demodulator(10e6)\n", + "myctrl.demod_freqs.add_demodulator(11e6)\n", + "myctrl.demod_freqs.add_demodulator(12e6)\n", + "myctrl.demod_freqs.add_demodulator(13e6)\n", + "print(myctrl.demod_freqs.get())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example we are demodulating a 10 MHz Signal from the Tektronix AWG" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " mode = DataMode.LOCAL\n", + " location = 'data/2017-03-08/#060_{name}_15-55-39'\n", + " | | | \n", + " Setpoint | time_set | time | (1664,)\n", + " Measured | my_controller_raw_output | raw_output | (1664,)\n", + " Measured | my_controller_demod_freq_0_mag | demod_freq_0_mag | (1664,)\n", + " Measured | my_controller_demod_freq_0_phase | demod_freq_0_phase | (1664,)\n", + " Measured | my_controller_demod_freq_1_mag | demod_freq_1_mag | (1664,)\n", + " Measured | my_controller_demod_freq_1_phase | demod_freq_1_phase | (1664,)\n", + " Measured | my_controller_demod_freq_2_mag | demod_freq_2_mag | (1664,)\n", + " Measured | my_controller_demod_freq_2_phase | demod_freq_2_phase | (1664,)\n", + " Measured | my_controller_demod_freq_3_mag | demod_freq_3_mag | (1664,)\n", + " Measured | my_controller_demod_freq_3_phase | demod_freq_3_phase | (1664,)\n", + " Measured | my_controller_demod_freq_4_mag | demod_freq_4_mag | (1664,)\n", + " Measured | my_controller_demod_freq_4_phase | demod_freq_4_phase | (1664,)\n", + " Measured | my_controller_demod_freq_5_mag | demod_freq_5_mag | (1664,)\n", + " Measured | my_controller_demod_freq_5_phase | demod_freq_5_phase | (1664,)\n", + " Measured | my_controller_demod_freq_6_mag | demod_freq_6_mag | (1664,)\n", + " Measured | my_controller_demod_freq_6_phase | demod_freq_6_phase | (1664,)\n", + "acquired at 2017-03-08 15:55:40\n" + ] + } + ], + "source": [ + "# Do this in as qcodes measurement (ie the same but makes a data set)\n", + "data2 = qc.Measure(myctrl.acquisition).run(station=station)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\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 = $('
');\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", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\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", + " };\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", + " '
');\n", + " var titletext = $(\n", + " '
');\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 = $('
');\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 = $('');\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 backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\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 * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\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 = $('
')\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 = $('');\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 = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\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", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\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= 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": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot = qc.MatPlot(data2.my_controller_demod_freq_0_mag)\n", + "plot.add(data2.my_controller_demod_freq_1_mag)\n", + "plot.add(data2.my_controller_demod_freq_2_mag)\n", + "plot.add(data2.my_controller_demod_freq_3_mag)\n", + "plot.add(data2.my_controller_demod_freq_4_mag)\n", + "plot.add(data2.my_controller_demod_freq_5_mag)\n", + "plot.add(data2.my_controller_demod_freq_6_mag)\n", + "plot.fig.axes[0].legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is currently a bug when plotting more than one lineplot the labels are missing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's possible to change int_time, int_delay and num_avg in an already created acq_controller" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:4.0 oscillation measured for largest demod freq, recommend at least 10: decrease sampling rate, take more samples or increase demodulation freq\n" + ] + } + ], + "source": [ + "myctrl.int_delay(2e-7)\n", + "myctrl.int_time(3e-6)\n", + "myctrl.num_avg(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " mode = DataMode.LOCAL\n", + " location = 'data/2017-03-07/#032_{name}_12-36-13'\n", + " | | | \n", + " Setpoint | time_set | time | (3200,)\n", + " Measured | my_controller_raw_output | raw_output | (3200,)\n", + " Measured | my_controller_demod_freq_0_mag | demod_freq_0_mag | (3200,)\n", + " Measured | my_controller_demod_freq_0_phase | demod_freq_0_phase | (3200,)\n", + "acquired at 2017-03-07 12:36:14\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgoAAAFhCAYAAAARGoJRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data3 = qc.Measure(myctrl.acquisition).run()\n", + "plot = qc.MatPlot(data3.my_controller_raw_output)\n", + "plot.fig" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Assuming that you have establised the correct int time and delay we can integrate over samples. To change averaging and integrating setting you currently have to create a new controller" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also chose to not average over records. You currently have to either integrate over samples or average over records (the returned data must be 1D)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create the acquisition controller which will take care of the data handling and tell it which \n", + "# alazar instrument to talk to.\n", + "myintctrl = ATS9360Controller(name='my_controller_int', alazar_name='Alazar', integrate_samples=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "myintctrl.int_delay(2e-7)\n", + "myintctrl.int_time(3e-6)\n", + "myintctrl.num_avg(100)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " mode = DataMode.LOCAL\n", + " location = 'data/2017-03-08/#061_{name}_16-00-40'\n", + " | | | \n", + " Setpoint | single_set | single | (1,)\n", + " Measured | my_controller_int_raw_output | raw_output | (1,)\n", + "acquired at 2017-03-08 16:00:40\n" + ] + } + ], + "source": [ + "data4 = qc.Measure(myintctrl.acquisition).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can add the same demodulator freqs and look at the integrated samples " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[7000000.0, 8000000.0, 9000000.0, 10000000.0, 11000000.0, 12000000.0, 13000000.0]\n" + ] + } + ], + "source": [ + "myintctrl.demod_freqs.add_demodulator(7e6)\n", + "myintctrl.demod_freqs.add_demodulator(8e6)\n", + "myintctrl.demod_freqs.add_demodulator(9e6)\n", + "myintctrl.demod_freqs.add_demodulator(10e6)\n", + "myintctrl.demod_freqs.add_demodulator(11e6)\n", + "myintctrl.demod_freqs.add_demodulator(12e6)\n", + "myintctrl.demod_freqs.add_demodulator(13e6)\n", + "print(myintctrl.demod_freqs.get())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " mode = DataMode.LOCAL\n", + " location = 'data/2017-03-08/#062_{name}_16-00-42'\n", + " | | | \n", + " Setpoint | single_set | single | (1,)\n", + " Measured | my_controller_int_raw_output | raw_output | (1,)\n", + " Measured | my_controller_int_demod_freq_0_mag | demod_freq_0_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_0_phase | demod_freq_0_phase | (1,)\n", + " Measured | my_controller_int_demod_freq_1_mag | demod_freq_1_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_1_phase | demod_freq_1_phase | (1,)\n", + " Measured | my_controller_int_demod_freq_2_mag | demod_freq_2_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_2_phase | demod_freq_2_phase | (1,)\n", + " Measured | my_controller_int_demod_freq_3_mag | demod_freq_3_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_3_phase | demod_freq_3_phase | (1,)\n", + " Measured | my_controller_int_demod_freq_4_mag | demod_freq_4_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_4_phase | demod_freq_4_phase | (1,)\n", + " Measured | my_controller_int_demod_freq_5_mag | demod_freq_5_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_5_phase | demod_freq_5_phase | (1,)\n", + " Measured | my_controller_int_demod_freq_6_mag | demod_freq_6_mag | (1,)\n", + " Measured | my_controller_int_demod_freq_6_phase | demod_freq_6_phase | (1,)\n", + "acquired at 2017-03-08 16:00:43\n" + ] + } + ], + "source": [ + "data5 = qc.Measure(myintctrl.acquisition).run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also chose to not average over records. You currently have to either integrate over samples or average over records (the returned data must be 1D)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataArray[1]: my_controller_int_demod_freq_0_mag\n", + "array([ 0.1037831])\n", + "DataArray[1]: my_controller_int_demod_freq_1_mag\n", + "array([ 0.14285908])\n", + "DataArray[1]: my_controller_int_demod_freq_2_mag\n", + "array([ 0.18105679])\n", + "DataArray[1]: my_controller_int_demod_freq_3_mag\n", + "array([ 0.21327569])\n", + "DataArray[1]: my_controller_int_demod_freq_4_mag\n", + "array([ 0.23483571])\n", + "DataArray[1]: my_controller_int_demod_freq_5_mag\n", + "array([ 0.24245093])\n", + "DataArray[1]: my_controller_int_demod_freq_6_mag\n", + "array([ 0.23493526])\n" + ] + } + ], + "source": [ + "print(data5.my_controller_int_demod_freq_0_mag)\n", + "print(data5.my_controller_int_demod_freq_1_mag)\n", + "print(data5.my_controller_int_demod_freq_2_mag)\n", + "print(data5.my_controller_int_demod_freq_3_mag)\n", + "print(data5.my_controller_int_demod_freq_4_mag)\n", + "print(data5.my_controller_int_demod_freq_5_mag)\n", + "print(data5.my_controller_int_demod_freq_6_mag)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see the integrated samples seems consistent with the plots above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the last example we are running the AWG in sequencing mode. To do this we need to change the trigger to setup to enable a secondary trigger on the aux input. We change the alazar config here. " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "alazar.config(clock_source='INTERNAL_CLOCK',\n", + " sample_rate=500000000,\n", + " clock_edge='CLOCK_EDGE_RISING',\n", + " decimation=1,\n", + " coupling=['DC','DC'],\n", + " channel_range=[.4,.4],\n", + " impedance=[50,50],\n", + " trigger_operation='TRIG_ENGINE_OP_J',\n", + " trigger_engine1='TRIG_ENGINE_J',\n", + " trigger_source1='EXTERNAL',\n", + " trigger_slope1='TRIG_SLOPE_POSITIVE',\n", + " trigger_level1=160,\n", + " trigger_engine2='TRIG_ENGINE_K',\n", + " trigger_source2='DISABLE',\n", + " trigger_slope2='TRIG_SLOPE_POSITIVE',\n", + " trigger_level2=128,\n", + " external_trigger_coupling='DC',\n", + " external_trigger_range='ETR_2V5',\n", + " trigger_delay=0,\n", + " timeout_ticks=0,\n", + " aux_io_mode='AUX_IN_TRIGGER_ENABLE', # AUX_IN_TRIGGER_ENABLE for seq mode on\n", + " aux_io_param='TRIG_SLOPE_POSITIVE' # TRIG_SLOPE_POSITIVE for seq mode on\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'Another instrument has the name: my_controller_rec'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m myrecctrl = ATS9360Controller(name='my_controller_rec', alazar_name='Alazar', \n\u001b[1;32m----> 2\u001b[1;33m integrate_samples=True, average_records=False)\n\u001b[0m", + "\u001b[1;32mc:\\users\\jhn\\qcodes\\qcodes\\instrument\\metaclass.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(cls, server_name, *args, **kwargs)\u001b[0m\n\u001b[0;32m 41\u001b[0m \u001b[1;31m# for RemoteInstrument, we want to record this instance with the\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 42\u001b[0m \u001b[1;31m# class that it proxies, not with RemoteInstrument itself\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 43\u001b[1;33m \u001b[0mcls\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrecord_instance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minstrument\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 44\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 45\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0minstrument\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mc:\\users\\jhn\\qcodes\\qcodes\\instrument\\base.py\u001b[0m in \u001b[0;36mrecord_instance\u001b[1;34m(cls, instance)\u001b[0m\n\u001b[0;32m 225\u001b[0m \u001b[0mexisting_wr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_all_instruments\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 226\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mexisting_wr\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mexisting_wr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 227\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Another instrument has the name: {}'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 228\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 229\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_all_instruments\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mwr\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: 'Another instrument has the name: my_controller_rec'" + ] + } + ], + "source": [ + "myrecctrl = ATS9360Controller(name='my_controller_rec', alazar_name='Alazar', \n", + " integrate_samples=True, average_records=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When not averaging over records averaging is implemented by averaging over buffers and records_per_buffer can be set independently " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " mode = DataMode.LOCAL\n", + " location = 'data/2017-03-08/#065_{name}_16-19-12'\n", + " | | | \n", + " Setpoint | record_num_set | record_num | (8,)\n", + " Measured | my_controller_rec_raw_output | raw_output | (8,)\n", + "acquired at 2017-03-08 16:19:13\n" + ] + } + ], + "source": [ + "myrecctrl.int_delay(2e-7)\n", + "myrecctrl.int_time(3e-6)\n", + "myrecctrl.num_avg(100)\n", + "myrecctrl.records_per_buffer(8)\n", + "data6 = qc.Measure(myrecctrl.acquisition).run()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we are changing the driving freq of the AWG between the freqs below. We demodulate with the same frequencies in 8 records" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "demod_freqs = [5e6, 7e6, 9e6, 11e6, 13e6, 15e6, 17e6, 19e6]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "for freq in demod_freqs:\n", + " myrecctrl.demod_freqs.add_demodulator(freq)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the setpoints along a records axis is expected to be dependent on an external instrument\n", + "which the driver has no way of knowing there is support for setting the base name, unit and start and stop of setpoints (the number of setpoints is automatically set from the number of records) as shown below" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet:\n", + " mode = DataMode.LOCAL\n", + " location = 'data/2017-03-08/#069_{name}_16-29-43'\n", + " | | | \n", + " Setpoint | awg_freq_set | awg_freq | (8,)\n", + " Measured | my_controller_rec_raw_output | raw_output | (8,)\n", + " Measured | my_controller_rec_demod_freq_0_mag | demod_freq_0_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_0_phase | demod_freq_0_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_1_mag | demod_freq_1_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_1_phase | demod_freq_1_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_2_mag | demod_freq_2_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_2_phase | demod_freq_2_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_3_mag | demod_freq_3_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_3_phase | demod_freq_3_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_4_mag | demod_freq_4_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_4_phase | demod_freq_4_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_5_mag | demod_freq_5_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_5_phase | demod_freq_5_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_6_mag | demod_freq_6_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_6_phase | demod_freq_6_phase | (8,)\n", + " Measured | my_controller_rec_demod_freq_7_mag | demod_freq_7_mag | (8,)\n", + " Measured | my_controller_rec_demod_freq_7_phase | demod_freq_7_phase | (8,)\n", + "acquired at 2017-03-08 16:29:44\n" + ] + } + ], + "source": [ + "myrecctrl.acquisition.set_base_setpoints(base_name='awg_freq', base_label='awg freq', base_unit='Hz',\n", + " setpoints_start=5e6, setpoints_stop = 19e6)\n", + "data6 = qc.Measure(myrecctrl.acquisition).run()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\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 = $('
');\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", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\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", + " };\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", + " '
');\n", + " var titletext = $(\n", + " '
');\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 = $('
');\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 = $('');\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 backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\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 * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\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 = $('
')\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 = $('');\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 = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\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", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\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= 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": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot = qc.MatPlot(data6.my_controller_rec_demod_freq_0_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_1_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_2_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_3_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_4_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_5_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_6_mag)\n", + "plot.add(data6.my_controller_rec_demod_freq_7_mag)\n", + "plot.fig.axes[0].legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class Demodulator:\n", + "\n", + "\n", + "\n", + " def __init__(self,\n", + " buffers_per_acquisition: int,\n", + " records_per_buffer: int,\n", + " samples_per_record: int,\n", + " sample_rate: float,\n", + " filter_settings,\n", + " active_channels):\n", + "\n", + " self.filter_settings = filter_settings\n", + " self.active_channels = active_channels\n", + " self.sample_rate = sample_rate\n", + " settings = active_channels[0]\n", + " if settings['average_buffers']:\n", + " len_buffers = 1\n", + " else:\n", + " len_buffers = buffers_per_acquisition\n", + "\n", + " if settings['average_records']:\n", + " len_records = 1\n", + " else:\n", + " len_records = records_per_buffer\n", + "\n", + " num_demods = 1\n", + " demod_freqs = np.array(settings['demod_freq'])\n", + " mat_shape = (num_demods, len_buffers,\n", + " len_records, samples_per_record)\n", + " self.mat_shape = mat_shape\n", + " integer_list = np.arange(samples_per_record)\n", + " integer_mat = (np.outer(np.ones(len_buffers),\n", + " np.outer(np.ones(len_records), integer_list)))\n", + " angle_mat = 2 * np.pi * \\\n", + " np.outer(demod_freqs, integer_mat).reshape(mat_shape) / sample_rate\n", + " self.cos_mat = np.cos(angle_mat)\n", + " self.sin_mat = np.sin(angle_mat)\n", + "\n", + "\n", + " def demodulate(self, volt_rec, int_delay, int_time):\n", + " \"\"\"\n", + " Applies low bandpass filter and demodulation fit,\n", + " and integration limits to samples array\n", + "\n", + " Args:\n", + " record (numpy array): record from alazar to be multiplied\n", + " with the software signal, filtered and limited\n", + " to ifantegration limits shape = (samples_taken, )\n", + "\n", + " Returns:\n", + " magnitude (numpy array): shape = (demod_length, samples_after_limiting)\n", + " phase (numpy array): shape = (demod_length, samples_after_limiting)\n", + " \"\"\"\n", + "\n", + " # volt_rec to matrix and multiply with demodulation signal matrices\n", + " demod_length = 1 #self.demod_freqs.get_num_demods()\n", + " volt_rec_mat = np.outer(np.ones(demod_length), volt_rec).reshape(self.mat_shape)\n", + " re_mat = np.multiply(volt_rec_mat, self.cos_mat)\n", + " im_mat = np.multiply(volt_rec_mat, self.sin_mat)*0\n", + "\n", + " # filter out higher freq component\n", + " cutoff = self.active_channels[0]['demod_freq']/10\n", + " # self.demod_freqs.get_max_demod_freq() / 10\n", + " if self.filter_settings['filter'] == 0:\n", + " re_filtered = helpers.filter_win(re_mat, cutoff,\n", + " self.sample_rate,\n", + " self.filter_settings['numtaps'],\n", + " axis=-1)\n", + " im_filtered = helpers.filter_win(im_mat, cutoff,\n", + " self.sample_rate,\n", + " self.filter_settings['numtaps'],\n", + " axis=-1)\n", + " elif self.filter_settings['filter'] == 1:\n", + " re_filtered = helpers.filter_ls(re_mat, cutoff,\n", + " self.sample_rate,\n", + " self.filter_settings['numtaps'],\n", + " axis=-1)\n", + " im_filtered = helpers.filter_ls(im_mat, cutoff,\n", + " self.sample_rate,\n", + " self.filter_settings['numtaps'],\n", + " axis=-1)\n", + " elif self.filter_settings['filter'] == 2:\n", + " re_filtered = re_mat\n", + " im_filtered = im_mat\n", + " else:\n", + " raise RuntimeError(\"Filter setting: {} not implemented\".format(self.filter_settings['filter']))\n", + "\n", + " if self.active_channels[0]['integrate_samples']:\n", + " # apply integration limits\n", + " beginning = int(int_delay * self.sample_rate)\n", + " end = beginning + int(int_time * self.sample_rate)\n", + "\n", + " re_limited = re_filtered[..., beginning:end]\n", + " im_limited = im_filtered[..., beginning:end]\n", + " else:\n", + " re_limited = re_filtered\n", + " im_limited = im_filtered\n", + "\n", + " # convert to magnitude and phase\n", + " complex_mat = re_limited + im_limited * 1j\n", + " magnitude = abs(complex_mat)\n", + " phase = np.angle(complex_mat, deg=True)\n", + "\n", + " \n", + " return magnitude, phase" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "myctrl.close()\n", + "alazar.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From b8089adb09acc934a0684923a7316279fe8fea3e Mon Sep 17 00:00:00 2001 From: "Jens H. Nielsen" Date: Thu, 9 Nov 2017 18:10:24 +0100 Subject: [PATCH 09/22] Working notebook --- .../Qcodes example with Alazar 9360.ipynb | 1618 +++++++++++++++++ 1 file changed, 1618 insertions(+) create mode 100644 docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb diff --git a/docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb b/docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb new file mode 100644 index 000000000000..d0a023aae1d7 --- /dev/null +++ b/docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb @@ -0,0 +1,1618 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Qcodes example with Alazar ATS 9360" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# import all necessary things\n", + "%matplotlib nbagg\n", + "\n", + "import qcodes as qc\n", + "import qcodes.instrument.parameter as parameter\n", + "import qcodes.instrument_drivers.AlazarTech.ATS9360 as ATSdriver\n", + "import qcodes.instrument_drivers.AlazarTech.ATS_acquisition_controllers as ats_contr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'bits_per_sample': 12,\n", + " 'board_id': 1,\n", + " 'board_kind': 'ATS9360',\n", + " 'max_samples': 4294967294,\n", + " 'system_id': 1}]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Command to list all alazar boards connected to the system\n", + "ATSdriver.AlazarTech_ATS.find_boards()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'CPLD_version': '25.16',\n", + " 'SDK_version': '6.0.0',\n", + " 'asopc_type': '1779729248',\n", + " 'bits_per_sample': 12,\n", + " 'driver_version': '6.0.0',\n", + " 'firmware': None,\n", + " 'latest_cal_date': '25-01-17',\n", + " 'max_samples': 4294967294,\n", + " 'memory_size': '4294967294',\n", + " 'model': 'ATS9360',\n", + " 'pcie_link_speed': '0.5GB/s',\n", + " 'pcie_link_width': '8',\n", + " 'serial': '970396',\n", + " 'vendor': 'AlazarTech'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create the ATS9870 instrument on the new server \"alazar_server\"\n", + "ats_inst = ATSdriver.AlazarTech_ATS9360(name='Alazar1')\n", + "# Print all information about this Alazar card\n", + "ats_inst.get_idn()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate an acquisition controller (In this case we are doing a simple DFT) on the same server (\"alazar_server\") and \n", + "# provide the name of the name of the alazar card that this controller should control\n", + "acquisition_controller = ats_contr.Demodulation_AcquisitionController(name='acquisition_controller', \n", + " demodulation_frequency=10e6, \n", + " alazar_name='Alazar1')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Configure all settings in the Alazar card\n", + "ats_inst.config(clock_source='INTERNAL_CLOCK',\n", + " sample_rate=1_000_000_000,\n", + " clock_edge='CLOCK_EDGE_RISING',\n", + " decimation=1,\n", + " coupling=['DC','DC'],\n", + " channel_range=[.4,.4],\n", + " impedance=[50,50],\n", + " trigger_operation='TRIG_ENGINE_OP_J',\n", + " trigger_engine1='TRIG_ENGINE_J',\n", + " trigger_source1='EXTERNAL',\n", + " trigger_slope1='TRIG_SLOPE_POSITIVE',\n", + " trigger_level1=160,\n", + " trigger_engine2='TRIG_ENGINE_K',\n", + " trigger_source2='DISABLE',\n", + " trigger_slope2='TRIG_SLOPE_POSITIVE',\n", + " trigger_level2=128,\n", + " external_trigger_coupling='DC',\n", + " external_trigger_range='ETR_2V5',\n", + " trigger_delay=0,\n", + " timeout_ticks=0,\n", + " aux_io_mode='AUX_IN_AUXILIARY', # AUX_IN_TRIGGER_ENABLE for seq mode on\n", + " aux_io_param='NONE' # TRIG_SLOPE_POSITIVE for seq mode on\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# This command is specific to this acquisition controller. The kwargs provided here are being forwarded to ats_inst.acquire\n", + "# This way, it becomes easy to change acquisition specific settings from the ipython notebook\n", + "acquisition_controller.update_acquisitionkwargs(#mode='NPT',\n", + " samples_per_record=1024,\n", + " records_per_buffer=70,\n", + " buffers_per_acquisition=1,\n", + " #channel_selection='AB',\n", + " #transfer_offset=0,\n", + " #external_startcapture='ENABLED',\n", + " #enable_record_headers='DISABLED',\n", + " #alloc_buffers='DISABLED',\n", + " #fifo_only_streaming='DISABLED',\n", + " #interleave_samples='DISABLED',\n", + " #get_processed_data='DISABLED',\n", + " allocated_buffers=1,\n", + " #buffer_timeout=1000\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.502616118642945" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the value of the parameter 'acquisition' of the instrument 'acquisition_controller' performes the entire acquisition \n", + "# protocol. This again depends on the specific implementation of the acquisition controller\n", + "acquisition_controller.acquisition()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'functions': {},\n", + " 'name': 'Alazar1',\n", + " 'parameters': {'IDN': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", + " 'full_name': 'Alazar1_IDN',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'IDN',\n", + " 'name': 'IDN',\n", + " 'post_delay': 0,\n", + " 'raw_value': None,\n", + " 'ts': None,\n", + " 'unit': '',\n", + " 'vals': '',\n", + " 'value': None},\n", + " 'alloc_buffers': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_alloc_buffers',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Alloc Buffers',\n", + " 'name': 'alloc_buffers',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DISABLED',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DISABLED'},\n", + " 'allocated_buffers': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_allocated_buffers',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Allocated Buffers',\n", + " 'name': 'allocated_buffers',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '=0>',\n", + " 'value': 1},\n", + " 'aux_io_mode': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_aux_io_mode',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'AUX I/O Mode',\n", + " 'name': 'aux_io_mode',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'AUX_IN_AUXILIARY',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'AUX_IN_AUXILIARY'},\n", + " 'aux_io_param': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_aux_io_param',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'aux_io_param',\n", + " 'name': 'aux_io_param',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'NONE',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'NONE'},\n", + " 'buffer_timeout': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_buffer_timeout',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Buffer Timeout',\n", + " 'name': 'buffer_timeout',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1000,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'ms',\n", + " 'vals': '=0>',\n", + " 'value': 1000},\n", + " 'buffers_per_acquisition': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_buffers_per_acquisition',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Buffers per Acquisition',\n", + " 'name': 'buffers_per_acquisition',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '=0>',\n", + " 'value': 1},\n", + " 'channel_range1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_channel_range1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Range channel 1',\n", + " 'name': 'channel_range1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 0.4,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'V',\n", + " 'vals': '',\n", + " 'value': 0.4},\n", + " 'channel_range2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_channel_range2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Range channel 2',\n", + " 'name': 'channel_range2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 0.4,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'V',\n", + " 'vals': '',\n", + " 'value': 0.4},\n", + " 'channel_selection': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_channel_selection',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Channel Selection',\n", + " 'name': 'channel_selection',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'AB',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'AB'},\n", + " 'clock_edge': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_clock_edge',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Clock Edge',\n", + " 'name': 'clock_edge',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'CLOCK_EDGE_RISING',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'CLOCK_EDGE_RISING'},\n", + " 'clock_source': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_clock_source',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Clock Source',\n", + " 'name': 'clock_source',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'INTERNAL_CLOCK',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'INTERNAL_CLOCK'},\n", + " 'coupling1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_coupling1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Coupling channel 1',\n", + " 'name': 'coupling1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DC',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DC'},\n", + " 'coupling2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_coupling2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Coupling channel 2',\n", + " 'name': 'coupling2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DC',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DC'},\n", + " 'decimation': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_decimation',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Decimation',\n", + " 'name': 'decimation',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '',\n", + " 'value': 1},\n", + " 'effective_sample_rate': {'__class__': 'qcodes.instrument_drivers.AlazarTech.acquisition_parameters.EffectiveSampleRateParameter',\n", + " 'full_name': 'Alazar1_effective_sample_rate',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'effective_sample_rate',\n", + " 'name': 'effective_sample_rate',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1000000000.0,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'Hz',\n", + " 'value': 1000000000.0},\n", + " 'enable_record_headers': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_enable_record_headers',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Enable Record Headers',\n", + " 'name': 'enable_record_headers',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DISABLED',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DISABLED'},\n", + " 'external_sample_rate': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_external_sample_rate',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'External Sample Rate',\n", + " 'name': 'external_sample_rate',\n", + " 'post_delay': 0,\n", + " 'raw_value': 500000000,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'S/s',\n", + " 'vals': '',\n", + " 'value': 500000000},\n", + " 'external_startcapture': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_external_startcapture',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'External Startcapture',\n", + " 'name': 'external_startcapture',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'ENABLED',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'ENABLED'},\n", + " 'external_trigger_coupling': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_external_trigger_coupling',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'External Trigger Coupling',\n", + " 'name': 'external_trigger_coupling',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DC',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DC'},\n", + " 'external_trigger_range': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_external_trigger_range',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'External Trigger Range',\n", + " 'name': 'external_trigger_range',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'ETR_2V5',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'ETR_2V5'},\n", + " 'fifo_only_streaming': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_fifo_only_streaming',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Fifo Only Streaming',\n", + " 'name': 'fifo_only_streaming',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DISABLED',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DISABLED'},\n", + " 'get_processed_data': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_get_processed_data',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Get Processed Data',\n", + " 'name': 'get_processed_data',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DISABLED',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DISABLED'},\n", + " 'impedance1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_impedance1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Impedance channel 1',\n", + " 'name': 'impedance1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 50,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'Ohm',\n", + " 'vals': '',\n", + " 'value': 50},\n", + " 'impedance2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_impedance2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Impedance channel 2',\n", + " 'name': 'impedance2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 50,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'Ohm',\n", + " 'vals': '',\n", + " 'value': 50},\n", + " 'interleave_samples': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_interleave_samples',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Interleave Samples',\n", + " 'name': 'interleave_samples',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DISABLED',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DISABLED'},\n", + " 'mode': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_mode',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Acquisition mode',\n", + " 'name': 'mode',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'NPT',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'NPT'},\n", + " 'records_per_buffer': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_records_per_buffer',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Records per Buffer',\n", + " 'name': 'records_per_buffer',\n", + " 'post_delay': 0,\n", + " 'raw_value': 70,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '=0>',\n", + " 'value': 70},\n", + " 'sample_rate': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_sample_rate',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Internal Sample Rate',\n", + " 'name': 'sample_rate',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1000000000,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'S/s',\n", + " 'vals': '',\n", + " 'value': 1000000000},\n", + " 'samples_per_record': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_samples_per_record',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Samples per Record',\n", + " 'name': 'samples_per_record',\n", + " 'post_delay': 0,\n", + " 'raw_value': 1024,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '=256, Multiples of 128>',\n", + " 'value': 1024},\n", + " 'timeout_ticks': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_timeout_ticks',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Timeout Ticks',\n", + " 'name': 'timeout_ticks',\n", + " 'post_delay': 0,\n", + " 'raw_value': 0,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '10 us',\n", + " 'vals': '=0>',\n", + " 'value': 0},\n", + " 'transfer_offset': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_transfer_offset',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Transfer Offset',\n", + " 'name': 'transfer_offset',\n", + " 'post_delay': 0,\n", + " 'raw_value': 0,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'Samples',\n", + " 'vals': '=0>',\n", + " 'value': 0},\n", + " 'trigger_delay': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_delay',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Delay',\n", + " 'name': 'trigger_delay',\n", + " 'post_delay': 0,\n", + " 'raw_value': 0,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': 'Sample clock cycles',\n", + " 'vals': '=0>',\n", + " 'value': 0},\n", + " 'trigger_engine1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_engine1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Engine 1',\n", + " 'name': 'trigger_engine1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'TRIG_ENGINE_J',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'TRIG_ENGINE_J'},\n", + " 'trigger_engine2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_engine2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Engine 2',\n", + " 'name': 'trigger_engine2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'TRIG_ENGINE_K',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'TRIG_ENGINE_K'},\n", + " 'trigger_level1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_level1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Level 1',\n", + " 'name': 'trigger_level1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 160,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '',\n", + " 'value': 160},\n", + " 'trigger_level2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_level2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Level 2',\n", + " 'name': 'trigger_level2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 128,\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': '',\n", + " 'value': 128},\n", + " 'trigger_operation': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_operation',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Operation',\n", + " 'name': 'trigger_operation',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'TRIG_ENGINE_OP_J',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'TRIG_ENGINE_OP_J'},\n", + " 'trigger_slope1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_slope1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Slope 1',\n", + " 'name': 'trigger_slope1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'TRIG_SLOPE_POSITIVE',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'TRIG_SLOPE_POSITIVE'},\n", + " 'trigger_slope2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_slope2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Slope 2',\n", + " 'name': 'trigger_slope2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'TRIG_SLOPE_POSITIVE',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'TRIG_SLOPE_POSITIVE'},\n", + " 'trigger_source1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_source1',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Source 1',\n", + " 'name': 'trigger_source1',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'EXTERNAL',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'EXTERNAL'},\n", + " 'trigger_source2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n", + " 'full_name': 'Alazar1_trigger_source2',\n", + " 'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n", + " 'instrument_name': 'Alazar1',\n", + " 'inter_delay': 0,\n", + " 'label': 'Trigger Source 2',\n", + " 'name': 'trigger_source2',\n", + " 'post_delay': 0,\n", + " 'raw_value': 'DISABLE',\n", + " 'ts': '2017-11-09 18:08:02',\n", + " 'unit': '',\n", + " 'vals': \"\",\n", + " 'value': 'DISABLE'}},\n", + " 'submodules': {}}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make a snapshot of the 'ats_inst' instrument\n", + "ats_inst.snapshot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Started at 2017-11-09 18:08:04\n", + "DataSet:\n", + " location = 'data/2017-11-09/#005_AlazarTest_18-08-04'\n", + " | | | \n", + " Setpoint | dummy_set | dummy | (50,)\n", + " Measured | acquisition_controller_acquisition | acquisition | (50,)\n", + "Finished at 2017-11-09 18:08:08\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\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 = $('
');\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", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\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", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.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", + " '
');\n", + " var titletext = $(\n", + " '
');\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 = $('
');\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 = $('');\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 backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\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 * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\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 = $('
')\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 = $('');\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 = $('');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('
');\n", - " var button = $('');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(el){\n", - " var fig = this\n", - " el.on(\"remove\", function(){\n", - "\tfig.close_ws(fig, {});\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", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\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= 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": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plot = qc.MatPlot()\n", - "plot.add(data2.my_controller_demod_freq_0_mag)\n", - "plot.fig.axes[0].legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\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 = $('
');\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", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\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", - " };\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", - " '
');\n", - " var titletext = $(\n", - " '
');\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 = $('
');\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 = $('');\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 backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\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 * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\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 = $('
')\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 = $('');\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 = $('');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('
');\n", - " var button = $('');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(el){\n", - " var fig = this\n", - " el.on(\"remove\", function(){\n", - "\tfig.close_ws(fig, {});\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", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\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= 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": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot = qc.MatPlot(data6.my_controller_rec_demod_freq_5_mag)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\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 = $('
');\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", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\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", - " };\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", - " '
');\n", - " var titletext = $(\n", - " '
');\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 = $('
');\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 = $('');\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 backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\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 * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\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 = $('
')\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 = $('