From 4064983bbab6cc0e43b555e5da5420bc355df033 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 11 Dec 2018 11:41:51 +0000 Subject: [PATCH 01/83] Add system import --- Controllers/main.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index d54a52d..0061b9e 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -1,9 +1,10 @@ import sys +sys.path.insert(0, "C:\\Users\\warnert\\Documents\\GitHub") +sys.path.insert(0, "C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy") from PyPulse import PulseInterface import numpy as np from PyQt5 import QtWidgets - import Models.Experiment as Experiment from Controllers import QueueControl, QueueControl from Designs import mainDesign From 80367f3acd76e6988c01101efe467b0cfb0c65e6 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 17 Jan 2019 16:37:25 +0000 Subject: [PATCH 02/83] Add randomise trials and anti plume --- Controllers/main.py | 7 + Designs/mainDesign.py | 17 +- Models/Experiment.py | 5 +- UI/PulseBoyUI_v2.py | 339 +++++++++++++++++++++++++ UI/PulseBoyUI_v2.ui | 569 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 930 insertions(+), 7 deletions(-) create mode 100644 UI/PulseBoyUI_v2.py create mode 100644 UI/PulseBoyUI_v2.ui diff --git a/Controllers/main.py b/Controllers/main.py index 0061b9e..45591cc 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -45,6 +45,7 @@ def __init__(self): self.removeTrialButton.clicked.connect(self.remove_trial) self.moveUpButton.clicked.connect(self.move_trial_up) self.moveDownButton.clicked.connect(self.move_trial_down) + self.randomiseTrialsButton.clicked.connect(self.randomise_trials) self.actionSave.triggered.connect(self.save) self.actionLoad.triggered.connect(self.load) @@ -60,6 +61,7 @@ def __init__(self): self.pauseQueueButton.clicked.connect(self.queue_controller.pause) self.runSelectedButton.clicked.connect(lambda x: self.queue_controller.run_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) + def add_valve(self, v_type='Simple', params=None): if v_type == 'Simple': new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) @@ -67,6 +69,8 @@ def add_valve(self, v_type='Simple', params=None): new_valve = PBWidgets.NoiseValveWidget(self.valveBankContents) elif v_type == 'Plume': new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents) + elif v_type == 'Anti Plume': + new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents) else: new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) @@ -121,6 +125,9 @@ def move_trial_down(self): if idx < len(self.trialBankModel.arraydata): self.select_trial(idx + 1) + def randomise_trials(self): + self.trialBankModel.randomise_trials() + def trial_selected(self): try: selected_trial = self.trialBankTable.selectionModel().selectedRows()[0].row() diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index ea5d4b5..5223cb7 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -1,8 +1,8 @@ # -*- coding: utf-8 -*- -# Form implementation generated from reading ui file 'UI/PulseBoyUI.ui' +# Form implementation generated from reading ui file 'PulseBoyUI_v2.ui' # -# Created by: PyQt5 UI code generator 5.5.1 +# Created by: PyQt5 UI code generator 5.9 # # WARNING! All changes made in this file will be lost! @@ -38,6 +38,7 @@ def setupUi(self, MainWindow): self.valveBankContents.setObjectName("valveBankContents") self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) self.valveBankLayout.setObjectName("valveBankLayout") self.valveBankScrollArea.setWidget(self.valveBankContents) self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) @@ -163,6 +164,7 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) self.addTrialButton.setObjectName("addTrialButton") @@ -195,9 +197,12 @@ def setupUi(self, MainWindow): self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveDownButton.setObjectName("moveDownButton") self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 6, 1, 1, 1) self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") - self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 6, 1, 1, 1) + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 6, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -303,8 +308,9 @@ def retranslateUi(self, MainWindow): self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) - self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Noise")) - self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Plume")) + self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Anti Plume")) + self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Noise")) + self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Plume")) self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.addValveButton.setText(_translate("MainWindow", "Add Valve")) self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) @@ -314,6 +320,7 @@ def retranslateUi(self, MainWindow): self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) self.moveUpButton.setText(_translate("MainWindow", "Move Up")) self.moveDownButton.setText(_translate("MainWindow", "Move Down")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_13.setText(_translate("MainWindow", "Export Suffix")) diff --git a/Models/Experiment.py b/Models/Experiment.py index aaa56d9..4281649 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -1,5 +1,6 @@ from PyQt5 import QtCore, QtGui import pickle as pickle +import random default_row = [[0, [], '']] @@ -104,5 +105,5 @@ def reset_trials(self): def total_trials(self): return len(self.arraydata) - - + def randomise_trials(self): + self.arraydata = random.shuffle(self.arraydata) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py new file mode 100644 index 0000000..5223cb7 --- /dev/null +++ b/UI/PulseBoyUI_v2.py @@ -0,0 +1,339 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'PulseBoyUI_v2.ui' +# +# Created by: PyQt5 UI code generator 5.9 +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore, QtGui, QtWidgets + +class Ui_MainWindow(object): + def setupUi(self, MainWindow): + MainWindow.setObjectName("MainWindow") + MainWindow.resize(1229, 856) + self.centralwidget = QtWidgets.QWidget(MainWindow) + self.centralwidget.setObjectName("centralwidget") + self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) + self.gridLayout.setObjectName("gridLayout") + self.label = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label.setFont(font) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 0, 1, 1) + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 372)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) + self.trialBankTable = QtWidgets.QTableView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialBankTable.sizePolicy().hasHeightForWidth()) + self.trialBankTable.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + self.trialBankTable.setFont(font) + self.trialBankTable.setContextMenuPolicy(QtCore.Qt.DefaultContextMenu) + self.trialBankTable.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows) + self.trialBankTable.setObjectName("trialBankTable") + self.trialBankTable.horizontalHeader().setStretchLastSection(False) + self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) + self.label_8 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_8.setFont(font) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) + self.setupTabs = QtWidgets.QTabWidget(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.setupTabs.sizePolicy().hasHeightForWidth()) + self.setupTabs.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(10) + self.setupTabs.setFont(font) + self.setupTabs.setObjectName("setupTabs") + self.hardwareTab = QtWidgets.QWidget() + self.hardwareTab.setObjectName("hardwareTab") + self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) + self.gridLayout_2.setObjectName("gridLayout_2") + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) + self.label_9 = QtWidgets.QLabel(self.hardwareTab) + self.label_9.setObjectName("label_9") + self.gridLayout_2.addWidget(self.label_9, 9, 0, 1, 1) + self.label_2 = QtWidgets.QLabel(self.hardwareTab) + self.label_2.setObjectName("label_2") + self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) + self.label_4 = QtWidgets.QLabel(self.hardwareTab) + self.label_4.setObjectName("label_4") + self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) + self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") + self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) + self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) + self.analogChannelsLabel.setObjectName("analogChannelsLabel") + self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) + self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogChannelsEdit.setObjectName("analogChannelsEdit") + self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) + self.label_5 = QtWidgets.QLabel(self.hardwareTab) + self.label_5.setObjectName("label_5") + self.gridLayout_2.addWidget(self.label_5, 6, 0, 1, 1) + self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.sampRateEdit.setObjectName("sampRateEdit") + self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) + spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) + self.label_11 = QtWidgets.QLabel(self.hardwareTab) + self.label_11.setObjectName("label_11") + self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.triggerInEdit.setObjectName("triggerInEdit") + self.gridLayout_2.addWidget(self.triggerInEdit, 10, 0, 1, 1) + self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.syncClockEdit.setObjectName("syncClockEdit") + self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.setupTabs.addTab(self.hardwareTab, "") + self.globalParametersTab = QtWidgets.QWidget() + self.globalParametersTab.setObjectName("globalParametersTab") + self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) + self.gridLayout_3.setObjectName("gridLayout_3") + self.label_6 = QtWidgets.QLabel(self.globalParametersTab) + self.label_6.setObjectName("label_6") + self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.globalOnsetEdit.setObjectName("globalOnsetEdit") + self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) + self.label_7 = QtWidgets.QLabel(self.globalParametersTab) + self.label_7.setObjectName("label_7") + self.gridLayout_3.addWidget(self.label_7, 0, 1, 1, 1) + self.globalOffsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.globalOffsetEdit.setObjectName("globalOffsetEdit") + self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) + spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem1, 2, 0, 1, 1) + self.setupTabs.addTab(self.globalParametersTab, "") + self.experimentSetupTab = QtWidgets.QWidget() + self.experimentSetupTab.setObjectName("experimentSetupTab") + self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) + self.gridLayout_4.setObjectName("gridLayout_4") + self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialNameEdit.sizePolicy().hasHeightForWidth()) + self.trialNameEdit.setSizePolicy(sizePolicy) + self.trialNameEdit.setObjectName("trialNameEdit") + self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 5, 0, 1, 1) + self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) + self.valveTypeCombo.setObjectName("valveTypeCombo") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) + self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.removeTrialButton.setObjectName("removeTrialButton") + self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) + spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) + self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.runSelectedButton.setObjectName("runSelectedButton") + self.gridLayout_4.addWidget(self.runSelectedButton, 6, 0, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 5, 2, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 5, 1, 1, 1) + self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveUpButton.setObjectName("moveUpButton") + self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveDownButton.setObjectName("moveDownButton") + self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 6, 1, 1, 1) + self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 6, 2, 1, 1) + self.setupTabs.addTab(self.experimentSetupTab, "") + self.dataExportTab = QtWidgets.QWidget() + self.dataExportTab.setObjectName("dataExportTab") + self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) + self.gridLayout_7.setObjectName("gridLayout_7") + self.label_13 = QtWidgets.QLabel(self.dataExportTab) + self.label_13.setObjectName("label_13") + self.gridLayout_7.addWidget(self.label_13, 1, 0, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 0, 0, 1, 1) + self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setObjectName("exportPathEdit") + self.gridLayout_7.addWidget(self.exportPathEdit, 0, 1, 1, 1) + self.exportSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportSuffixEdit.setObjectName("exportSuffixEdit") + self.gridLayout_7.addWidget(self.exportSuffixEdit, 1, 1, 1, 1) + self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) + self.exportPathDirButton.setObjectName("exportPathDirButton") + self.gridLayout_7.addWidget(self.exportPathDirButton, 0, 2, 1, 1) + self.setupTabs.addTab(self.dataExportTab, "") + self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) + self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) + self.viewWidgetTab.setObjectName("viewWidgetTab") + self.pulseTab = QtWidgets.QWidget() + self.pulseTab.setObjectName("pulseTab") + self.gridLayout_5 = QtWidgets.QGridLayout(self.pulseTab) + self.gridLayout_5.setObjectName("gridLayout_5") + self.graphicsView = PlotWidget(self.pulseTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.graphicsView.sizePolicy().hasHeightForWidth()) + self.graphicsView.setSizePolicy(sizePolicy) + self.graphicsView.setObjectName("graphicsView") + self.gridLayout_5.addWidget(self.graphicsView, 0, 0, 1, 1) + self.viewWidgetTab.addTab(self.pulseTab, "") + self.analogDataTab = QtWidgets.QWidget() + self.analogDataTab.setObjectName("analogDataTab") + self.gridLayout_6 = QtWidgets.QGridLayout(self.analogDataTab) + self.gridLayout_6.setObjectName("gridLayout_6") + self.analogView = PlotWidget(self.analogDataTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.analogView.sizePolicy().hasHeightForWidth()) + self.analogView.setSizePolicy(sizePolicy) + self.analogView.setObjectName("analogView") + self.gridLayout_6.addWidget(self.analogView, 0, 0, 1, 1) + self.viewWidgetTab.addTab(self.analogDataTab, "") + self.gridLayout.addWidget(self.viewWidgetTab, 3, 2, 1, 1) + MainWindow.setCentralWidget(self.centralwidget) + self.menubar = QtWidgets.QMenuBar(MainWindow) + self.menubar.setGeometry(QtCore.QRect(0, 0, 1229, 21)) + self.menubar.setObjectName("menubar") + self.menuFile = QtWidgets.QMenu(self.menubar) + self.menuFile.setObjectName("menuFile") + MainWindow.setMenuBar(self.menubar) + self.statusbar = QtWidgets.QStatusBar(MainWindow) + self.statusbar.setObjectName("statusbar") + MainWindow.setStatusBar(self.statusbar) + self.actionSave = QtWidgets.QAction(MainWindow) + self.actionSave.setObjectName("actionSave") + self.actionLoad = QtWidgets.QAction(MainWindow) + self.actionLoad.setObjectName("actionLoad") + self.actionSave_Configuration = QtWidgets.QAction(MainWindow) + self.actionSave_Configuration.setObjectName("actionSave_Configuration") + self.menuFile.addAction(self.actionSave) + self.menuFile.addAction(self.actionLoad) + self.menuFile.addAction(self.actionSave_Configuration) + self.menubar.addAction(self.menuFile.menuAction()) + + self.retranslateUi(MainWindow) + self.setupTabs.setCurrentIndex(2) + self.viewWidgetTab.setCurrentIndex(0) + QtCore.QMetaObject.connectSlotsByName(MainWindow) + + def retranslateUi(self, MainWindow): + _translate = QtCore.QCoreApplication.translate + MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.label.setText(_translate("MainWindow", "Valve Bank")) + self.label_8.setText(_translate("MainWindow", "Trial Bank")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) + self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.label_2.setText(_translate("MainWindow", "Digital Out Device")) + self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) + self.analogChannelsEdit.setText(_translate("MainWindow", "1")) + self.label_5.setText(_translate("MainWindow", "Sampling Rate")) + self.sampRateEdit.setText(_translate("MainWindow", "20000")) + self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) + self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) + self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) + self.label_6.setText(_translate("MainWindow", "Onset")) + self.globalOnsetEdit.setText(_translate("MainWindow", "0")) + self.label_7.setText(_translate("MainWindow", "Offset")) + self.globalOffsetEdit.setText(_translate("MainWindow", "0")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) + self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) + self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Anti Plume")) + self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Noise")) + self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Plume")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) + self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) + self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.moveDownButton.setText(_translate("MainWindow", "Move Down")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) + self.label_13.setText(_translate("MainWindow", "Export Suffix")) + self.label_12.setText(_translate("MainWindow", "Export Path")) + self.exportPathEdit.setText(_translate("MainWindow", "C:/Users/erskina/PycharmProjects/PulseBoy/Data/")) + self.exportSuffixEdit.setText(_translate("MainWindow", "data")) + self.exportPathDirButton.setText(_translate("MainWindow", "...")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) + self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) + self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) + self.menuFile.setTitle(_translate("MainWindow", "File")) + self.actionSave.setText(_translate("MainWindow", "Save")) + self.actionLoad.setText(_translate("MainWindow", "Load")) + self.actionSave_Configuration.setText(_translate("MainWindow", "Save Configuration")) + +from pyqtgraph import PlotWidget diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui new file mode 100644 index 0000000..97318fb --- /dev/null +++ b/UI/PulseBoyUI_v2.ui @@ -0,0 +1,569 @@ + + + MainWindow + + + + 0 + 0 + 1229 + 856 + + + + MainWindow + + + + + + + + Lucida Console + 12 + 75 + true + + + + Valve Bank + + + + + + + true + + + + + 0 + 0 + 18 + 372 + + + + + 0 + 0 + + + + + QLayout::SetFixedSize + + + + + + + + + + 0 + 0 + + + + + Lucida Console + + + + Qt::DefaultContextMenu + + + QAbstractItemView::SelectRows + + + false + + + + + + + + Lucida Console + 12 + 75 + true + + + + Trial Bank + + + + + + + + 0 + 0 + + + + + Lucida Console + 10 + + + + 2 + + + + Hardware + + + + + + 4 + + + + + + + Trigger In Source + + + + + + + Digital Out Device + + + + + + + Digital Channels + + + + + + + dev2/port0/line0:3 + + + + + + + Analog Input Device + + + + + + + Analog Channels + + + + + + + dev2/ai4 + + + + + + + 1 + + + + + + + Sampling Rate + + + + + + + 20000 + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Synchronisation Clock + + + + + + + cDAQ1Mod2/ai3 + + + + + + + /dev2/ai/SampleClock + + + + + + + + Global Parameters + + + + + + Onset + + + + + + + 0 + + + + + + + Offset + + + + + + + 0 + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + Experiment + + + + + + + 0 + 0 + + + + Trial Name + + + + + + + Start Queue + + + + + + + + Simple + + + + + Anti Plume + + + + + Noise + + + + + Plume + + + + + + + + Add To Trials + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Add Valve + + + + + + + Update Trial + + + + + + + Remove Trial + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Run Selected + + + + + + + Stop Queue + + + + + + + Pause Queue + + + + + + + Move Up + + + + + + + Move Down + + + + + + + Randomise trials + + + + + + + Wait for trigger + + + + + + + + Data + + + + + + Export Suffix + + + + + + + Export Path + + + + + + + C:/Users/erskina/PycharmProjects/PulseBoy/Data/ + + + + + + + data + + + + + + + ... + + + + + + + + + + + 0 + + + + Pulses + + + + + + + 0 + 0 + + + + + + + + + Analog Data + + + + + + + 0 + 0 + + + + + + + + + + + + + + 0 + 0 + 1229 + 21 + + + + + File + + + + + + + + + + + Save + + + + + Load + + + + + Save Configuration + + + + + + PlotWidget + QGraphicsView +
pyqtgraph
+
+
+ + +
From 29b37d97e508c52c00e955cb8e2d2c29583883b8 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 17 Jan 2019 17:10:43 +0000 Subject: [PATCH 03/83] fixed randomisation --- Controllers/main.py | 2 +- Models/Experiment.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index 45591cc..3c96d22 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -1,6 +1,6 @@ import sys sys.path.insert(0, "C:\\Users\\warnert\\Documents\\GitHub") -sys.path.insert(0, "C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy") +sys.path.insert(0, "C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy_old") from PyPulse import PulseInterface import numpy as np diff --git a/Models/Experiment.py b/Models/Experiment.py index 4281649..fc1572f 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -106,4 +106,4 @@ def total_trials(self): return len(self.arraydata) def randomise_trials(self): - self.arraydata = random.shuffle(self.arraydata) + random.shuffle(self.arraydata) From 2f2d74171b26d83f78f84a12ba3b5a21e22c3525 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 17 Jan 2019 18:08:55 +0000 Subject: [PATCH 04/83] Add anti plume widget --- Controllers/main.py | 2 +- Models/PBWidgets.py | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index 3c96d22..07f717c 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -70,7 +70,7 @@ def add_valve(self, v_type='Simple', params=None): elif v_type == 'Plume': new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents) elif v_type == 'Anti Plume': - new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents) + new_valve = PBWidgets.AntiPlumeValveWidget(self.valveBankContents) else: new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 09e280f..7a9bf3c 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -150,6 +150,45 @@ def load_plume_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') self.plumeDataLabel.setText(fname) +class AntiPlumeValveWidget(QtWidgets.QWidget, plumeValveDesign.Ui_Form): + def __init__(self, parentUi=None): + super(self.__class__, self).__init__() + self.setupUi(self) + + self.parentUi = parentUi + + self.removeButton.clicked.connect(self.remove_from_parent) + self.openPlumeDataButton.clicked.connect(self.load_plume_data) + + def remove_from_parent(self): + self.parentUi.layout().removeWidget(self) + self.deleteLater() + + def get_parameters(self): + params = dict() + + params['type'] = 'Anti Plume' + + params['onset'] = float(self.onsetEdit.text()) + params['offset'] = float(self.offsetEdit.text()) + params['shatter_frequency'] = float(self.shatterHzEdit.text()) + params['data_fs'] = float(self.dataSamplingRateEdit.text()) + params['data_path'] = str(self.plumeDataLabel.text()) + params['target_max'] = float(self.targetMaxEdit.text()) + + return params + + def set_parameters(self, params): + self.onsetEdit.setText(str(params['onset'])) + self.offsetEdit.setText(str(params['offset'])) + self.shatterHzEdit.setText(str(params['shatter_frequency'])) + self.plumeDataLabel.setText(params['data_path']) + self.dataSamplingRateEdit.setText(str(params['data_fs'])) + self.targetMaxEdit.setText(str(params['target_max'])) + + def load_plume_data(self): + fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') + self.plumeDataLabel.setText(fname) class TrialWidget(QtWidgets.QWidget, trialDesign.Ui_Form): def __init__(self, n_valves, parent=None): From b1136dd0dd47db4268ed5bb79e13df02bccc27a5 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Tue, 18 Jun 2019 18:20:28 +0100 Subject: [PATCH 05/83] Add some ipython notebooks for testing --- .../Binary sequence creating-checkpoint.ipynb | 6 + .../Plume_analysis.py-checkpoint.ipynb | 4831 +++++++++++++++++ Binary sequence creating.ipynb | 3119 +++++++++++ Plume_analysis.py.ipynb | 4831 +++++++++++++++++ test.npy | Bin 0 -> 32128 bytes 5 files changed, 12787 insertions(+) create mode 100644 .ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/Plume_analysis.py-checkpoint.ipynb create mode 100644 Binary sequence creating.ipynb create mode 100644 Plume_analysis.py.ipynb create mode 100644 test.npy diff --git a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb new file mode 100644 index 0000000..2fd6442 --- /dev/null +++ b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/Plume_analysis.py-checkpoint.ipynb b/.ipynb_checkpoints/Plume_analysis.py-checkpoint.ipynb new file mode 100644 index 0000000..b4c8af9 --- /dev/null +++ b/.ipynb_checkpoints/Plume_analysis.py-checkpoint.ipynb @@ -0,0 +1,4831 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Analysis for plumes taken on 190118, only 4 different plumes recorded\n", + "- All are 5s long\n", + "- All plumes are from /Volumes/lab-schaefera/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_5.mat\n", + "- Order are:\n", + " 1. 1Hz square pulses from two channels, total flow should be 1\n", + " 2. plume on ch3\n", + " 3. Anti plume on ch4\n", + " 4. Combination of both on Ch3 and Ch4" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.io as sio\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import normalize\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "flowmeter = sio.loadmat('/Volumes/lab-schaefera/working/warnert/Recordings/Set up recordings/190118/flowmeter_plumes.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__header__\n", + "__version__\n", + "__globals__\n", + "flowmeter_plumes_Ch31\n", + "flowmeter_plumes_Ch5\n", + "flowmeter_plumes_Ch4\n", + "flowmeter_plumes_Ch3\n", + "flowmeter_plumes_Ch2\n", + "flowmeter_plumes_Ch1\n" + ] + } + ], + "source": [ + "for i in flowmeter:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(3, 1, sharex=True)\n", + "ax[0].plot(flowmeter['flowmeter_plumes_Ch1'][0][0][-1])\n", + "ax[1].plot(flowmeter['flowmeter_plumes_Ch4'][0][0][-1])\n", + "ax[2].plot(flowmeter['flowmeter_plumes_Ch5'][0][0][-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "Ch3 = flowmeter['flowmeter_plumes_Ch4'][0][0][-1]\n", + "Ch4 = flowmeter['flowmeter_plumes_Ch5'][0][0][-1]\n", + "flow = flowmeter['flowmeter_plumes_Ch1'][0][0][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "baseline = np.mean(flow[:276463])\n", + "flow = [i-baseline for i in flow]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "x = lambda a: 1 if a > 1 else 0\n", + "Ch3 = [x(i) for i in Ch3]\n", + "Ch4 = [x(i) for i in Ch4]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "print(max(Ch3))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "mix= [i+j for i, j in zip(Ch3, Ch4)]\n", + "print(max(mix))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "276463\n", + "326463\n" + ] + } + ], + "source": [ + "found_pulse = False\n", + "for index, i in enumerate(mix):\n", + " if i > 0 and not found_pulse:\n", + " print(index)\n", + " found_pulse = True\n", + " if i < 1 and found_pulse:\n", + " print(index)\n", + " break\n", + "# Difference in the two, divided by 5 is the fs = 10000" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "raw_plume = sio.loadmat('/Volumes/lab-schaefera/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_5.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50000\n" + ] + } + ], + "source": [ + "print(len(raw_plume['plume'][0])) # Plume is 5s long" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "Ch3_plumes_only = Ch3[326500:]\n", + "Ch4_plumes_only = Ch4[326500:]\n", + "mix_plumes_only = mix[326500:]\n", + "flow_plumes_only = flow[326500:]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Ch3_plumes_only)\n", + "plt.plot(Ch4_plumes_only)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "plume_length = 5\n", + "fs = 10000\n", + "plume_starts = []\n", + "last_plume = 0\n", + "for index, i in enumerate(mix_plumes_only):\n", + " if i > 0 and index-last_plume > 50000:\n", + " found_plume = True\n", + " plume_starts.append(index)\n", + " last_plume = index\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(len(plume_starts))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[143483, 526552, 777451]\n" + ] + } + ], + "source": [ + "print(plume_starts)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.plot(mix_plumes_only[plume_starts[2]:plume_starts[2]+50000])\n", + "plt.plot(Ch3_plumes_only[plume_starts[2]:plume_starts[2]+50000])\n", + "plt.plot(Ch4_plumes_only[plume_starts[2]:plume_starts[2]+50000])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "143483\n", + "50000\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plume_start = plume_starts[0]\n", + "plume_end = plume_start + 50000\n", + "print(plume_start)\n", + "\n", + "x = np.arange(0, 5, 1/10000)\n", + "print(len(x))\n", + "plt.plot(x, flow_plumes_only[plume_start:plume_end]/max(flow_plumes_only[plume_start:plume_end]), label='Recon plume')\n", + "plt.plot(x, raw_plume['plume'][0]/max(raw_plume['plume'][0]), label='Plume')\n", + "plt.ylabel('Flow (normalised)')\n", + "plt.title('Plume vs reconstructed plume')\n", + "plt.xlabel('Time (s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "526552\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXeY1NTawH/vbKVL77D0JgKKYgcVFcF6rajXdm3Xz2u7FiwodvRaru3aFXvvghQFUQSUDgKClEV6ZxfYvnO+P5LMJJlkJjM7s8su+T3PPDNJTk7OtLznvFWUUvj4+Pj4+AAEqnoAPj4+Pj77Dr5Q8PHx8fEJ4QsFHx8fH58QvlDw8fHx8QnhCwUfHx8fnxC+UPDx8fHxCeELhRqAiBwjIssSPDdXRAYne0w+1Q8RyRERJSLpKej7OxG5NEl9pWycPr5QqFJE5EcR2SkiWXGep0Sks7GtlPpZKdUtRvu9IrJHRNaLyFMiklaRsfvEj4hcJiLTUtj/KBF5N1X9VwSl1ClKqbcg9Z+DT8XwhUIVISI5wDGAAk6vhEv2UUrVBU4ALgSuqoRrVinVcSbpC2ufqsYXClXHJcBMYAxgWVaLyBgReUFExorIbhH5VUQ66cd+0pst0Gf+54vIIBFZ5+WiSqk/gJ+BA+3H9Os+ZNq29Kurmm4TkYX6yuN1EWmuqwZ2i8j3ItLQ1P5wEZkuIrtEZIGIDHIak4iMEJFPbfueEZFn9deXicgq/RqrReQil35GicinIvKuiOQDl4lIQO9/pYhsF5GPRaSR6ZyjTWNcKyKX6fsbiMjbIrJVRNaIyD0iEjCNZ5qIPKGv9FaLyCmmPiPGKyI9gJeAI/TvbZfpM39RRMaJyF7gOH0FeaWtv2mm7V4iMklEdojIZhG5S0SGAHcB5+v9LzC9j9dFZKO+SnzIEDwikqa/h20isgoY5vS52r6nlfr7WiIiZ9nHGOUz+VFErnT7HByu9aOIPCoiv4lInoh8Zf7ebG0tKlAxrZgkrGq6XP9+d4rItSJyqP473iUiz9v6u0JEluptJ4hI+2ifS41DKeU/quABrACuAw4BSoHmpmNjgB3AYUA68B7woem4AjqbtgcB66JcK9Qe6AlsAv6hb+cCg03XfcitX73tTKA50BrYAswF+gFZwGTgPr1ta2A7MBRt8nGivt3UYXztgQKgvr6dBmwEDgfqAPlAN/1YS6CXy/scpX+WZ+rXrAXcpI+5jT7Gl4EP9PbtgN3AcCADaAz01Y+9DXwF1ANygOWmz+wy/TpX6WP9J7ABkGjj1c+bZhvzGCAPOEofczbwI3ClqU3oPH08G4F/623rAQNM7/9dW/9f6u+5DtAM+A24Rj92LfAH0BZoBExB+62ku3y+5wKt9HGeD+wFWsb6TPTjoffk9Dk4XOtHYD3a5KUO8Jnx3vTvIzROTL9h++dgavuS/nmdBBTpn0szwr/jgXr7M9H+mz3Q/nv3ANOr+n5RmQ9/pVAFiMjRaDfCj5VSc4CVaCodM58rpX5TSpWhCYW+FbzsXBHZCXwDvAa8mWA/zymlNiul1qOtOH5VSs1TShUDX6AJCICLgXFKqXFKqaBSahIwG01IWFBKrUETLmfqu44HCpRSM/XtIHCgiNRSSm1USi2OMr4ZSqkv9WsWAtcAdyul1uljHAWcI5pq6SLge6XUB0qpUqXUdqXUfH0mfT5wp1Jqt1IqF3gS+LvpOmuUUq8qpcqBt9Bu/s0TGC/AV0qpX/QxF8VoeyqwSSn1pFKqSB/fr04NRaQ5cApwk1Jqr1JqC/A0cIHe5Dzgv0qptUqpHcCj0S6slPpEKbVBH+dHwJ9oExeDaJ9JIryjlPpdKbUXGAmcJ4mr1x7UP6+JaMLsA6XUFtPv2PjdXgM8qpRaqv/3HgH67k+rBV8oVA2XAhOVUtv07fexqZDQZvMGBUDdCl7zYKVUQ6VUJ6XUPUqpYIL9bDa9LnTYNsbZHjhXX57v0tUER6PdKJx4H23GDpqAfB9AvyGcjzar3SiaSq17lPGttW23B74wjWEpUI52s2qLJpDtNAEygTWmfWvQZpUGoe9HKVWgv6ybwHidxhwNtzE70R5tBbTR9P5fRpshgzbrN197DVEQkUtEZL6prwPRPisDx8/E41idsI8tw3a9eIjnd/uM6T3uQFsBmr/7Go0vFCoZEamFNkMbKCKbRGQTcDPQR0T6VO3o2AvUNm23qEBfa9FmegeYHnWUUqNd2n8CDBKRNsBZ6EIBQCk1QSl1IppA+QN4Ncp17Wl/1wKn2MaRrc8Q1wKdHPrYhqYKMc8O26GpM2ISZbxuKYnt+6N9D25jdupnLVAMNDG99/pKqV768Y1oQsagnUu/6DPlV4HrgcZKqQOA39FumPHiNTWzfWylaN+NnWT/bq+x/V5qKaWmV6DPaoUvFCqfM9Fmqj3RVEJ90fSXP6MZn72wGeiYgrHNB4aKSCMRaYGmj0+Ud4HTRORk3aCZLZrhuo1TY6XUVjQ98pvAaqXUUtBUICJyuojUQbvB7UH7/LzyEvCwsfwXkaYicoZ+7D1gsIicJyLpItJYRPrq6o+P9fPq6efeor+nqMQY72agjYhkxuhmPvA3EaktmuvxP0zHvgVaiMhNIpKlj2+Aqf8c0Q3iSqmNwETgSRGpL5rRvZOIDNTbfwzcICJtRHMQGBFlTHXQbuZb9fd5OQ7OCh7x+jlcLCI9RaQ28ADwqf7d2JkPXCAiGSLSHzgnwXGB9nu5U0R6QchQf24F+qt2+EKh8rkUeFMp9ZdSapPxAJ4HLhJvbpSjgLf0Je55SRzbO8ACNMPdROCjRDtSSq0FzkDziNmKNgO7jei/ufeBwZhWCXr7f6MZLXcAA9EM9F55BvgamCgiu9GMzgP0Mf6FZuP4t973fMBYrf0LbQa6Cpimj+kND9eLNt7JwGJgk4g4zXgNngZK0G6eb6EJL/Qx70Yz2p+Gpq75EzhOP/yJ/rxdRObqry9BU4UtAXYCnxJW4b0KTED7zucCn7sNSCm1BM2uMkMfV2/glyjvIRpeP4d30Azxm9CMxDe4tBuJtnraCdyP9fcTF0qpL4DHgA9F82D7Hc0us99geAb4+Pj47DOIyI9oHkSvVfVY9jf8lYKPj4+PTwhfKPj4+Pj4hPDVRz4+Pj4+IfyVgo+Pj49PiGqXMKxJkyYqJyenqofh4+PjU62YM2fONqVU01jtqp1QyMnJYfbs2VU9DB8fH59qhYhEjVg38NVHPj4+Pj4hfKHg4+Pj4xPCFwo+Pj4+PiF8oeDj4+PjE8IXCj4+Pj4+IXyh4OPj4+MTwhcKPj4+Pj4hfKHg4+PjU5msnAw7VlX1KFypdsFrPj4+PtWad87SnkflVe04XPBXCj4+Pj5VQf7Gqh6BI75Q8PHx8akKfvpPVY/AEV8o+Pj4+FQGyydA3rrw9uzXYdK9MKoB5OqVTUe3g3G3V834dKpdPYX+/fsrPyGej49PtWL9XHj1uOhtAhkQLNVep8DeICJzlFL9Y7XzVwo+Pj4+qSaWQICwQKhifKHg4+Pjk0qqmTbGFwo+Pj4+yaZ4t2YbKCmA8gRWAM8enPwxecQXCj4+Pj7JZvpz8NvL8Hx/KCuM//wdK5M/Jo/4QsHHx8cn2ezM1Z7z18OMF6p0KPHiCwUfHx+fZLJlKSz8KLw99bHINv+cEbuf8rLkjSkOfKHg4+Pjk0x2b4rdplFH6Hxi9DaLv0jOeOLEFwo+Pj4+yaRge/Tjl3wFGdlwzuvhfbUaRbZb+2tyx+URXyj4+Pj4JJPv7nDe36ynFpTWcZC2nd1Ae+56Cgx1SHkx69VUjC4mfpZUHx8fn2RSsM15f8OcyH23rtCEQ+EObfsfk+D1GGqlFOMLBR8fH59kES1Q7eibI/fVbao912uxz6TSTpn6SETeEJEtIvK7y3ERkWdFZIWILBSRqovW8PHx8UkGu9a4H0vP8tZH9gHJGUuCpNKmMAYYEuX4KUAX/XE18GIKx+Lj4+OTeiQt/Pq8t+GoG8PbtRt76+OaqeHXwWByxhUHKVMfKaV+EpGcKE3OAN5WWprWmSJygIi0VErtm5UnfHx8fGJRXqI9n/4c9DxDe3Q6QUt216CN62lXvjWLhevy+O3uwVbbw+ZF0LJPasdsoyq9j1oDa03b6/R9EYjI1SIyW0Rmb926tVIG5+Pj4xM3Rp6jzDrhfR0HQufBUU/7fukWtuwupqi03HrAsFEU7IBXj4clXydxsM5UpVAQh32OVhql1CtKqf5Kqf5NmzZN8bB8fHx8EmS9Vutl/ZqV5IwYy+jv/ojr9Pu+Wmzd8cpA7bm8BNbPgb2pnxRXpVBYB7Q1bbcBNlTRWHx8fHwqzpalALw1fRUAL02Nndhud1E4i2pWRuQt+ePZa8MrBnGaSyeXqhQKXwOX6F5IhwN5vj3Bx8enWlNf04D/HIhZ4CxEYUlYZXRI+4YRx2//dCFhJUo1Fgoi8gEwA+gmIutE5B8icq2IXKs3GQesAlYArwLXpWosPj4+PpXChDsB+PshzT2fMnP1jsidh1xm3a7ElUIqvY+GxziugP9L1fV9fHx8qoritDqAtzoKN3wwL/R65da92ovMupY2peXlZADVeqXg4+Pjs7+yNaNV6LVSisKSco589Ae25BdFPe/ZH/7UXnSxproIqZhquE2hRjFnzU7+9cE8gsHqVY/Vx8engmxfCZ9dCWUloV2l5eGgs+KyIPd9/Tsb8oo47JEfIk6/7eRuodfHdGmiveg4yNJm2p+G15EvFKoNZ784nW8WbGBnQUnsxj4+PjWHL66BRZ/AnxMh5xho2oOSMqtQ6Nysruvpf20vCL3u2zac4kLV14Ld+smfLN6wS9spqb9l+0IhyazflUA9Vh8fn+rLulna80cXacFrdZtSYlkplNOwdqbllPG/byRnxFiKy8pZtW0PAFnpAYpNwkRl1gbgi6z7mLdAtzv46qPqx/SVMQps+Pj41FxKCyCjNnuLw26mJWVBMtOtt9pr350LwFvTc0kLCM3qZZGdkUaxKaJZTBXc3s98xNiburHr+EIhHnashjljojaJN4LRx8enBrFpIQTLKTTd3IvLgpSWa7bGBrUyLM0fGfcHM1ftYMvuYrIzAhSVmlYKTrdnf6Wwj/HGyfDNjY4FtTs20XKd9GxZv7JH5ePjsy+xYpIlh1FxaTBkeDZsCwe1aRBxWnZGGkVl4fM2n/B0RJuiTamfdPpCIR6MvCM/jIo41EEXCmf1c8zplzBl5UGm/elSycnHx2ef5GfTf7a4rDwkFIJ6ENqmvEjX1DXbC/hqfjjTz45WgyLa5P7yaZJHGolfeS0WpYVaZsKdq0HpS7vpz8FJD1maGV92oT3LYQU5+MFJ5BeV8f6VAziyc5Ok9u3j45MCBt0J48ObV709h217ioFwYPKW3cUxuykORqqKAqS+voK/UojFxHvgi6vhx0ejNivT4xOemrTcsv+XFdsoLktcUOQXaaqqmat8A7aPz77Gtt0OwWiz37C22RMWAPPX7mLRuuhlN5VSXPX2bBavj2zXpmGtxAYaB75QiEW+S+JWWy3W4tJICT4rdwcXvfYrF776a4WHUSvTX9T5+OxrHP3wuMidezYjAsd1c07zf9rz06L2+dLUVUxaspmRXy1mTrCL5Vjtlt0THqtXfKEQjeUTYZnDlw58u3CdZXt3caTxedwiLenrnDU7KzyUbi3cg198fHwqH6UU96S/63IMtu1JLJD1sfFhY/I5JfdZDw57KqE+48EXCm4Ey+H9c10PT/zoRcvNfq9NKCil+HahJhQMI3QidG2uCYPN+bF1kD4+PpVHQUk5F6dHpq0YXXoBAF2iRDHbqZuVHvJgNKMI8Gn5sQD8u+RaqOc9+2qi+ELBiTUz4IFGUZs8m/kCIz5bGNq2C4UOd45jq25MSg+4+xb/vj6PqcvD1ZQmLdnM4KemonT11Bo9BP7OzxfF9x58fHxSyqxch5TXwF6yAejSvJ6nfq44qgPz7z2RK47u4Hj81tJrySl6n8+CxyY20DjxhYKZWa/D2t/gzSGemvfYNiH0eo8uFPo7FMlo16i24/kf/PYXpz43jUvf+C2USO+qt2ezYsseFm/IBwiFyx/WIbqQ8vHxqVwue3NWeCMrHHcwLdgbgKb1sjz1k9OkNulpAepkpSV1fIniCwWAxV/Cqh9h7C3w+okxmxs8m/kCAJvzi0I5S2Y72A+c7A1gnf0X2FxZ56/VEmAZ9uwVW/Z4HpePj09q+flPW63knKNDL3OVpuKxRy+7UUd3IqmV4exMclLP1KuMzOy/QiFYHk51+8ml8PYZMU/5rPwYx/2rjMIYLvxmq6w09JmfOe/lGZZ99jzrm/OLQoIBoHn97Jjj89H4fslm+j0w0RJVmiqUUiFVn8/+w00fzrfu6D4UgK/rDw+lp9hqikUY2LUp3VuE1UkrHxkaer23RJs01sp0XilUxCaZCPunUCgrgZePhYeaQm509zCDa0pu5onS8yL2fzTrL4a/OtOyz5wK14klG/MjBMXxT061bG/MK+LMF34JbQ/w1Ueeueqd2ewsKKX7yPGxG1eQDneO4wb7DcKnxrN9r82z6MCzYVQeXzS8IrRrs2miN7hHM1o2CE/s0kx2xt16LFKxyyTm/EPbJmPIntl/hMKSr+H986EoD14ZCJt/1/aPGRbz1Bfr3cCE4KFspDHcs8VybM6Xz4ZeG1/0zNWRgWbxzibtYfDmlLo+0ansifs3C1xiWXxqLBcOaEcnWR/aLkJLjW2+2V9wWFu+uV5TK/39iBxGn30QAG9c1t/Sl2FzNE8U7z+9V+i1OQ13ZbD/CIWdubB8PIxuB1uWxHXqM1v7hV7vKbcu8R7PeDX0+shOjQEY80tuaF/bRloEYpFDcFs0pq2w5juqSFT0/kaTupmxG/ns14z6enEojigR8gpLacTu0Hb3keMpLQ9Sbqq82LB2Jr3bNCB3tDbxbF4/m9zRwzi+u2YjGHVaTwBO6qVtn2iyHWw0TQoN9ZFTEr1UsP8IhUDiEcFFhL0Inpq43LXdzWuuIzf7Qv6+9UkCBLn/9F6hSOex+g+wzCb1Tz2opacxlPgrBc+c1qdV7EZJwC+9Wn0ZMz2X696b63r8x2VbLCU1zdz2yQLGLtxIj8Aay/4ud3/HlGVhA3RWevTb62VHdSB39DCy0rWJ5oCOjXn/ygH88eAQ9hSXmvpJI3f0ML6+/mi3rpKKLxSisDXQlBfLTrPse+OX1bxUdqpl3y3pH9NeNnFwYAUAw9OnMDxtMuf1b0udLO26u/QynRttaqETejSLOY6GtTN89VEcxLsqS5TKXtb7JIfyGMJ8du4OLntzFv+ZsMzx+CdztGwGw9Kip6+RBGofHNm5CdkZadwzrCdtG9Vi5p0nxN1HRdl/hEI8X9C1v8A/p3N5wzd5rGx4xOHHyi6wbN+Q/iVTs26x7Dsn7SdqZaaFohSNpeqyTbst7YxZgkH7xtaYhoBAu8Z1HFcKN304j3U7oxu190fcDHbJxhcK1ZNYmYyNVf0rP61yPH54R83pY0BAS0dxT+nlluPHd28WUhklSnZGGj/ffjwtGlS+1+H+IxS2uat9ImhxIDTv5ZjkDlwqItnop68amumupCt1t9Ur355taZeZZu3LLrqCCrLSAhabwpRlW8gZMZYv52/g6MemxBzL/oa5UEnutujuwhXB7ffhs29TWBJdKHyzINLWsHrb3lAE81Zb2usp5X0t2/b/dHWjeo8+HhZ8GLvNHbkW76IKq2yUolEdLYAlr7DUsUlWRsBiYDJSZRv8c1AnsjKsBb0vN0dS7scEg4qHxy5hw65Cy/5xi8K1bctT6IrkrxSqJ7HiV/6hp5s4oHY4+Oy4J37k3Je02KITe7awtC/EGrlsr8dc3ajeo4+HcuebMhKAI2+AUXlQqyGka19wYUk5f+1wV80cVvRC7Guu/ZVjujinzzXISk9j0pLNoe0dNv/na4/tRGZawDc0OzB+8SZe/Xk1R46e7Nom30UYJwPzdxJLT+2z7xDLk8+4qZ/h4rBg10Qb7qgG2RnV+7aa0tGLyBARWSYiK0RkhMPxdiIyRUTmichCERnq1E9SUA4/hPZHw3074aQHIw71uDd64NPVw46Mfc2ifIsbWc6IsRFNMtMDXHpEe8DqmXR4x0asfnQoDWpnkJURYPGGfMfzAd78ZXXssdRAxupZaKO5oJrTECcb881l+14/i211wZzSesvuIn5cZo09MlYSAZdElsZk4OvyIwAowKr3Lyuv3hOElAkFEUkDXgBOAXoCw0Wkp63ZPcDHSql+wAXA/1I1HtoOsG4PHgUXf5ZQV29edmio0lpUgmVkp0dPcpUekFDirIn6iuHuoT348OojQt4Ldh2l/SZ4/zdLeNXFKLav8d2ijeSMGMv2PRW/iRoGwWirqJmrnDNZJgPzdXO3+Qb/qmbcoo0s3hC9qhnABa+EMxAc9vAPXPbmLMtKz8h4vGNviWMaE+N7P6Fna/4KRmoCUqmyrAxSuVI4DFihlFqllCoBPgTsCYYUUF9/3QBIXWjohR/BEdfD0bdoKqNDr4QMq4Sfv3YXk//YHNMQNahbU87o24oRpVdGHPu4bGB4o14Lx9nGyb3CNoSm9bJ4bZo20zf8pu05UL40FfMOBhXN6kV6JDw8bmnUMe8r/FN/j5P/2BKjpXfMKrqlG/OT1m8szELBT1gYH6XlQXJGjOX5yX8mrc/r3pvLsGcj09as3VEQ044w/vewHapA//9/NX8DT09abrHnKaUoKCmnVYNs6qQHKZNIV3d7NoLqRiqFQmtgrWl7nb7PzCjgYhFZB4wD/uXUkYhcLSKzRWT21q1bnZrEJrMOnPwwDL5PUxllWXOd/997cznzhV+4YsxsV9XR+f3b0qVZXUSElg1q8WH58XQqeocnSsPFeG4vuyZ8QtD5h2j+kWVnpLGrwKr3ru2SGAtg7c4CRze1R87q7XrOvkRdPW6jUZ2KRx0bfa3ZsZeHvtWi1E955ucK9+sVs1BIxvvZnzDqhDwRJRjUjXU7CyISSLoFEpaWBznm8SmhPFhu9oT/ez8cyFZQEnb2eHbyCksOrfKgoqi0XJu4/TWTthJ5P/p1depWp5VBKoWCk0LO/s0NB8YopdoAQ4F3RCRiTEqpV5RS/ZVS/Zs2jW64TZSxHkLeHzvnICbdEl4JLH/oFMpJ4/nyszi/eCSc/TrjbzqGi0ru1BoEnY2cP5qiHmtlpHFU58aW43aXNzPrdxZavCLCfSZv5p1KmtfXVGXJWGGf3lczBP6+Pp/Xpq2u9GylZu+j6m5crGy+mr8+diMXjn5sCoc9Yq14ll/k/F+zqxan/bnNsZ2Zj2evcz322dx1jF20UQuQ3L2BDJzT4ldnUvlLXgeY0/u1IVI99A/gYwCl1AwgG2iSwjG5cnC7Axz3N9P1/ZP/PTDiWGZ6gNzRw8gdPYyPHr0Vep9D12b1KFX6krLQuTbzdYM6Wfo4LMcqFMYtWAd54R/m3w4OL7Aue3OWox/0RJMH076MkQI8LUo1Oq/Yq92Vmgx88+/1XhcjUcwGxYrk0dkfMSL9u3moTjZnzY6Q+sc80zerhOxeewZ2t/L/fu+urlJKxVQz3fGZVgNlvc0N2kzrA2pF7WNfx1PuBxHpDxwDtAIKgd+B75VS0dZJs4AuItIBWI9mSL7Q1uYv4ARgjIj0QBMKCeqHKkZO4zrM/WtXxP7f7h4cVz+BgPDx8PbwOfD51XBXeEb01Hl9GHZQS7LS0xAJp7y44LC2PP19eBn9UpuJ8PTz2saoPA7v2JjP52r9lJQH+XCWWSunkZFW8ZtsZRDQjed7Syo+w7ILBXPQ2gG1w+qc0vIgGSkIKCoLhm84H89ex5ADW4SSnflEZ5u+Go41OVi1dQ9nv6jFB9x2cjdL6on3f/0rVMJyZ0HslcLr01azaL27IXpXQSn9Hpzk7Q3obM1oBSZN1gsXHswpB7ZwP6EaEPWfIiKXichc4E6gFrAM2AIcDUwSkbdEpJ3TuUqpMuB6YAKwFM3LaLGIPCAip+vN/g1cJSILgA+Ay1QVVSzJcShkcUGieczL9F9JidX4WDszLZTW4raTu/PUeVokpLmATj0KaLnw+fBJSvHlvNhL7WsHdnLcv68lbTNmes9PXlHhvvYWW2d1dlXBXUO7A7GDlRKl1OZ6+MuKyJTpPs50bKoVtW9YJ3p1MnMBK3suIvPqzH2lEP7uH/w2nB3ZaTa/aluczgKBDBYfcJxl15ADnZ1LqhOxpk91gKOUUmcrpR5RSr2mlHpeKXWDUuoQ4Gmgi9vJSqlxSqmuSqlOSqmH9X33KqW+1l8vUUodpZTqo5Tqq5SamKw3Fi9Obo33n9HLoaUHsuo67q6ll93j25vhYWt21HMPaQPArekfWU9aPZV0D7PcgpJyptvSbX82Zx0d7xq3T+VHMgKD/rDlgEoEew4bQ1Vg2GgMNZv95p0s7AFrr0/bP+NFEsEQ1LEE6RMTrYLg+O7hBJJG6dt5f+3kKlP6GPMkwC054sm9Imfz63YWcs3AjjFGrpFBGQRLadDAqnZOhlq0qol6t1FKvaCUclWeKaXmK6V+cDtenXBKk2tPVueZ7npm1eZWj6BaGXp/s9+A0gJY+HHI4vqfcw5icbsnuTTdtnx9+wzO7OscWfnFdeEAutenrebC137lh6Vh28K/P1kAwB2fLQS04LhUrhy8zMjrZWkzw/7tG1boWlP+2GIpVwpaIrx6Wel01fXUmfr355YCuaKkqt/9AbcUMu//+ldUV1+7K/OVb82OEByXvPFb6LXTd9S8fhYjTukesf/GD+fzq8e4lroBTf3VrW0LerSsH6N19SKW+ujZaI/KGmRlYP+RGlHGCZGmrwg2L4LSsEwtKSmC10wG0M+vgoeaw/aVsOpH6myZ49jd6X1aRRQBXzjqJPq1a0ju6GE0qRvOvTJmem7E+b+s2E5eQSmd7/6OjneNS/x9RWHyH5vpPnJ8ZEFzG8bsvluL2AbGaFw+JjL/0y8rtrG7uCy0QjDsLKlKEeIpgNEHpRQ5I8bS74GwIsBpAnHFmFnc9cUiut7zHQAb8wpjfsbfL90csdpYujEfpRTlQeUofPrnNCIzPcAsm73wiI6NQznVQp6wAAAgAElEQVTK5o6M7qjQUmm/89p16/Pdjc6126srsfQSc/RHNnAw8Kf+6AvUqFJg9h/PQW2cvZHiJmgYQxVHf9AD1v1mPV5eDM8dDO+c6dpF+uLPWHDfSVw4IGy+Ca06sLpDGsm8LOcHhD4PpEYzV1IWRCnFFWO05fvj451z0BsYN4Nk3qgNF92RXy0Gwioq4zlVtShSZauoabz361+A1RhsOAX0MaWBmb7Sqv4sLUtM6N5+cjdOeGoqne4a5/g7q6d7PjWtl8XdQ3uESmbO+Wsn/ds3pGWD7JhxJ89lPKe92FI9gkbjIZb66C2l1FtodoPjlFLPKaWeQ/MY6hvt3OpEflEpH/z2l2VfVrL8zl/WXFn/nhafV4OFz7XIafMM2OxNEysrY6pmtOt3FdL1nu844ampoX27XfzFDYwbtNONujyomJ0bffl+z5eLLDmg+rdvyAsXHgzAofIHRwcW0awoF8qKTTaFVAkFrd83Lz80Jf3XFD6ZHektZ6QdN/8Obj2pm6VNUZTEdc9f2M/12MivFocM1Ft2R0YXG+6wAFcd25HeumC6/MgcisuCERXTGtfJ5LGzrargnHR9dZJW84IWvd75WgHm9X5dfV+N4KBRkbPoKX8kyTN2x0p+vHUQpx3dP3bbGBg3/+wMq63D7KFhzIzs7ppXHaOtIHJsRXwSoai0nIfHLmHRul0R1z+rX5uo5xo3aKfI0qcnLeecl2bwwhR3z6R3Z1qF95Pn9QkJyE+yHuDdzEf5+9zz4Ot/hT6vVKmPjJXCQFOajSpyntsnePS7peSMGBsx41+wLtIN1Pj+zd+N3W042kqsVoY3e59TdLFTGooGtTIoLC3n6wUbyN1eAJ9eQW72hQQIcskROZYSr69d0p+0oO7tlFUxNei+iFehMBqYJyJjRGQMMBd4JGWjqkTcDK9tG1UwAKVe2LsoJ7iWw369vmL9EV4pRPtDGFG2u211GV79WfOMMfvvJ8qZL/zCqz+v5nnTzdv40xjJ/dwIC4XIG7WxWnMrg+jcn+KXFQ5RqiunhIRCylYKZeVkpgcIBIQbT9Cc8PILy/ZLwbBtTzEvT9WSMl74qnuZyp17S8grKI1YKXw8ay1vmLL9rt9VyHYXN1OInBi5tnNwFnHKXpBXWMq00O9Iwe9asszesor0NLH0UzvL1GeGNsmaO/LECBtFdcWTUFBKvQkMAL7QH0foaqVqzxSX9BC9Wzdw3J8Q/xsQu42Zug4BUD/9JzSTiqYuCv/ZnGdZwSTcsAwjsdnX21hyF8QISjPcQ52qlnVq6uzKG43m9bM4rnszOojtj753S+jzStVKobg0rGowHAH6PDCRv7/+W7TTksbaHQVc+dbsmJ95ZfDHxtguxrUy0uj34CT6PDAxpBoyhMLtny0M5UMCOGr05FAxqU+uPYIbdKF76kEtyR09zFEorHxkKPWz0y1uq2/EkVbeWPFenf5daF+vwBrmrNlpiT2ok2mK+e1yEqDlvoo1IaoueBIKouVwHgz0UUp9BWSKyGEpHVklUd/m1TNv5Incd1pPTuhRwchUt6I+Xrh+tpbR1czkh9hZoM2covlCGysFu3+2YVxLxg2ytv6nSA+Efz6f6sXMHxob3fC2Wi+POWNVpH/6b7o9weuf6+zAT9Qb3YS+r7dnSta/I45n697UxSlaKZQFg+HVmymJ4TSnlUsKeHjsUr5futlSpKmqiGaYNSYx5rgSY1KwfW9xzJVVdnpa6DdhrPrsuaaG9m5BWkDILyqLmYH3Tgd3VDOHy++h149kvB7RnyWLcdOuUfuqjnhVH/0POAItgR3AbrRaCdUe4wZ7WE4j3rtyAA3rZHL5UZEePHFTK4b3UmY9rdqbE9n1tYyux4+07DbcTc0zKjvGTd9eonK3bmNIhieO8Sd2+/M9bipss2hdHqO+XoxSylJEKBoXHuYYJB/ByMbfRz3efLlWgrU0RSuF0jJFuu72WhUJ8cYv1tI936t7XVUl0YzCvVpF+vH/oP92lIJTn4tMd20mOyPAG3pg4ITFm/V91pXChl3O6ar7tLX+D1c/OpRrHKL/0/X7QFZ6gJxG1izElx2ZY9mu/uFp0fH6Sx6glPo/9CwfSqmdQLU3u381fz1/+990AIYPaMtRnZOYi++4u533Xz0VDrkM/vmL8/HrTbEKx1hnvw1xrhVw28ndOLarZuxcoBt/DTfAUFddtPdWnAQ3SiOS1x5RbPC/H1eGXp//ygzGTM9lb0k5o75xv3k9Om5pyI7jrZKcokFR9PIb9bZoahyvtZTjEVwAjQtW0Ew0wb7aZGxPhJFf/p5wRHReYSnPT/6TJRsqr5aEnaIoNUhirU4Xxxh3dkZaRG4vuy1wUDfn7MkLbAGOYq+lqWN46BWXBUnDOt57bToRly5qDF6FQqleSU0BiEhTIDXTr0rkxg/nh163a1RxrxwL2Q5RjgdfAq36wmnPQEM9OO5u29K/SefwaxG4M5wtdV72tQC0aWg1gv/fcZ157RLNu8lInNfTNjv7WU8ZvCEJBUCMylJeCpQbBUtKy4IRnkMGSile/mkVa3doq5v8Incdeb3sdOpQyN8CPyOl0dN31F09Qbu2xxv9QfdPpPPd33ku1HP7qsv5tFj7TrbusRpFzSqdLflFfLswugB7Z+YaS24eLxyn3wiP7NSYJyYuZ+izlVNL4tp35jBh8SbLPrcJAlTc0J+dkcaJPa3qXLMK585TunPT4NhqnI5NI/ObGfQ1rSja51ltQoHPrcW0zLnKaiJehcKzaAbmZiLyMDCNGuJ9ZNC0bpK/6A6RqbY5YVTkvoxsuOAD7XVdh+yKNpe32hSFMo1autFnUoZn0rQYkcUVwVABZ8SR58VJvVBQUkbOiLG8+Uuu53561NnD4ux/8FTmS57PKSkLsmNvCfd+9XtU/bXhsXX3F4s8952FJgzOOcTqinvV27NDK6rDHvmB69+fFzOGI14M47ZZVbhya2orwBWXlTN+8SaueccafR9dKFTMuSE7I8AVukr3wTMPBKBNw/AkzqwOOrxjI8c+Ftx3EpNudvhP6nRtHsXJocBq//IyGarOePU+eg+4HXgU2AicqZT6JJUDq2yS/kWnZcAVtviHOo2d23YfCiO3w82xdcNTs25GRdQqCi+LjT+nm6FcpOK+9MZSe2+MsqW7CsKzZ7O30b9P1GZ1xo3lAYcZstsYDyiNYVQdsRa6ngJAUVet+uuGXUUc/OAk3p6xxjENiJ1LbTpkM0Wl5azdEblCcbIpnP3idMv2bw4+8+//+hcjv/w9Yr8XDA1KrsnGdMKTU11aV5y8wlLH9w5ElLBdvjnsjeSmPopWYdBMrYw0GtfNInf0MP5+eDj9zG93n8AfDw6xtD37YOc4mQa1MqI6aETNc7ZnM3xwIfNGnsiblx1K1roZnsZdXfHqfdQJWK2UegGtlsKJIpKkPBBVgz0wJj0V9QjaDXA3JttJSw/nTIpCU8kjGGM1XlYeZKaDdw9os/yKRjhP9VDl7T8T/qDvA+EobrOBu2629j5/jlIF652ZayKiUYe/MpOtu9191xmVp6nthmsrr/LGmhvjMz+EC6vYk+iZMQotRfOB7z5yPMc8PiWUI8dAHMyP9mvZhejuolLu+mIR78xcE9oXj8A2brbdK5hHygul5UH63D+RwU/95Hh83U6rY8NNJtWsm3PDXUN7eLq2W5bgZvWyI76rfu0SS7Ro/g4cWTaWhgtf1VR2Y4YldI3qgtfp8WdAuYh0Bl4DOgDvp2xUlYC9LnIqirCEuGoyXPpN0ro7d887UY93vvu70A3XPLMyluCJ6ngXb8jjk9lro+r8DV6YstKy/Y+3wgns5jkUM7Jz71eLOflp6w1oxqrtpHtJuaWvmrI2z4s49NX8Da6RssZq0UtOo4151pugl1lvpm3i0dshkj4eVYsRi2KevTdOcq3onBFjyRkxlqcmRa+lbBa8AEtMdhm3mBlzRcFkUScrwczGIUyf/6FXWQ9NuAvmV+vbnie83gmDetGcvwHPKKVuBlrGOGefxl75K6WVy1ofAh2OTfz85gdaNm9K/9zzj9M8A2qtG6hLyoI8NXGZq0F1594Si+rHYNiz07jt04VeR23BPJOM5UceGkdBKQt1byqjBvUnWQ84N/5HpHtq+iotq/sZttTjbmk0DPWCeYa/bNNubv90QYSgqB+w1tFub0ofMrS3c+Utc2U/t0j6aK6dBo+M09JJGDNw8wrk8I4uKsoK8uKPKyP2xUpumDNiLPd/szgiut6gdmY6uaO1WXe9bE9FIGNSOzOyn6m3DYp53oAOmi3inDTTRMQpr9FX1yU6tGpDPN5Hw4FLgG/1fdFLJu3j2H/I5kCsfY7Tn4vc9+U/XZsf7eJaayQmW7Auj2cnr+CUZ5y9Vfo9OCmk+lm0Lo+cEWN5eGx8njFunN+/LSf1cg8MtNdZOP15zXX3sjcjU2VbaOuclK5edjoNbak9fv5zG7nb9vLod0v5ZkHYK8jQi5sN3yf/9yc+nr2O7iPHW/r4aaHpJrl+DjL1sdDm88MPtrRt2UBzYjBHybu5yXoJLnzlp1WubVOiBnUhXzecfzTL2asM8OREkDt6GPPvPSm0/em1R3DPMG+qJTvmFduT5/Yhd/Qw2jd29zoyMHIkdZGwtx/dh0LT6IFuNRGvd8LL0YLXHlZKrdbrLr+bumGlHvsfap+ucdz64Nht0ML8wT2i1vBS+dhU47nbPeGQ/tXb9vK0TU3wof6HN3InVZS9JWUc3sF9NnvZUTnxd3pXZC4bg6y0QIROe/7aXQx64kdenrqKf30QVjHZo9uj8doPC8Ibrx4PPz5Kbb1Yrzklwpw1O0K1uM1JCp3SfICz/v2x8X+QM2JsRAzFQod6w/YMn6nEeA8jkxA8lxYQljxwMisePoX+OY248piO/PnwKax4+JS4+jGrgeNZfRgOfZmYVjU5R8PhUVYGF34c19iqC169j5boJTg/0LdXK6VGp3ZoqcU+U3MLaqlOOHlXLBylzcCm3DqIe0/TyouaE4KZb0LHPfFjhG7YHgQXDx9fcwQTb7aqzb5duJGte4pdzoA+DnUs7NW3LBzQHjLdY0zaZuykuLScZjFSZyilohqhAYtx+aZ2qyKOm+0dhk+8UXQeYI9JKPyxyVl15xRcaKhu5tpsMXaX4Ia1M6jMYnCGCtYc42NMrhIxftfOTLcYlTPSAp5K0boRj0fh97do7qrHtLadc/Al7id1Ocn9WDUmVuW1j/XnRSKy0P6onCGmhlQlSUsZCf4A62dnkDt6GB2a1OGr+evjOteeftuJIQ61bg1qZaQ5zlw7NnFezr908SG0dQgiHPyUg5vl0Cf0F9ENs+cVfUbu9r1s2e0uiMqDig53jgs5H7jND343zcy/Wxupb/72gCdC8Qr92obVYC30YKe3ZuSG9jnpviF6GpLlm3dbbBsFNgFSNzvdc/R2MjCElZEY8efbj+PPh4eSFpAIR45nh2v1D4Yf1lZ/9pbKpCLEIxQ6Na1L7uhhdG6oq58MtZEInP2680k1YCLpRKxP7Ub9+VTgNIdHtaUgho/9PsfwDyvchdtyetkm5wyXXgTneFtkq5nsjIBjoJ0Rbd3BJhyO6+6cqsBAzEH0fS/Uno+9zblxA+3mk1FeEJphuwmjS96wpnoe3KM53yzYwJfz1lsqg11rCthyEkXtipbxxLl9APjhj3A8xaZ8TX20dkdh6KbuFi8RTSgs3ZhP7vZwOg2792rtjHR+X5+X1IpwDWu7q9S25GuCdpe+gjLUbxlpEnrPBks35pM7ehgXDdC84Y7tksSUMi4UFCfwOZTp4840/VY614yU2F6JVXlto/68xulROUNMDftCuuG4CKTBrX/CoDvD+2L4tJ/Vz+ryt8flT3Lyf519z726rnZrXo8z+0bWXMrOSKNuVqQgat+4Dm9fcRhfX3+UZX/UACJgcDvT8cw6WlyC2/JejwSvR9hdc9U25/xE9hq/e4vL+NcH87jpo/mWAjG7TSsni+7ZAftM2cAwWHdu5hxBuznfPQ3Jprwi0qLMTvcUl7F6217OeN4lr1YCRKu/YWS6Hdi1KZnpgVCEtZN795+bNRXgga0bsGjUSZzSO/XOi25p8aOSrasvWx9i2pfENPrVgFjqo90iku/w2C0iVZd9KwnYIzCrBXWbwaAR4W2Tx4sTdg+Ouz0GCxkYro5uNzCDCTcfy38v6MecewZzYOtwzqWsjAANbX7zD+lpCo7t2pR62Rkh4/jrl4Yr0w3u0Yym9bIictVkpcexXM/SxmEWCm6c0bdVKGEgwPSVzoF/ZjKlYikrDN37jDuPt+x/4Bt3L6/1uwojUqLbjwMs2xy7toFXSsqCnHqQdgN/Ul8FmVm1dQ+vT1tlWVVmOgiFfu3CtqJ62Ul2XCwvwymi054vyRN19VoMJ9wb3ldD1URuxFop1FNK1Xd41FNKOWR8qz5UO/WRExvmRz1sz3EfLb9Lzoix2O3UhlrJydB7iO46+tk/jwjta1w3izcvC6eUNKJNbzyhC29fcRjLHhrCxaZgOtCM47mjh1nScrx26aHMuntwRK6aVjvcK3pF0EITPrVrhZMHDu7RLKJZQKB9o9qOZRsB6malc7mDR1QLdka9/Pe3uMelFJWWh+pO2MMV7GM0T1425hV5imNIJsVl5dSvpdmlzj4kMoWE01rVSZffpG4Kkyo/2BheCf9WFt9/Ms8O78egbpHfd0xm/k97zrDZtm62CeuKxB3t48QVMSIizYBQ5jilVOKuKVVMtARe1Ybl30U9bPeoEhEeOKOXa/79AR0aM2PVdg5udwBz/9oVISSAULCRG+bslYaR+eYTEytEYvem6lV7l5a83S0tuZmTH4FZr1FaFJ41n9mvNd8vtaoU6mVnkF9UFprparmhwsdLyoKOaq1bMj6NevnOzerx4JkHOuY1MhusW9oybva2eV+ZgyzzCktdXVmvOKpDXFXGvFJcFnSc+RssWpcXEYXtpD46r3/bpI/Nwqaw30udrHRO75NACXnzaiNg+84btIZLvtbSqBTlQ8vIVVNNwWvuo9NF5E9gNTAVyAWi35H2cQpKyhxvejWdS47IcT22YN0ujujYmOsGaem7Q8n1unufcZnrR8eyEcRLrtL10D1Oj904XXNBPTQQjrtwiqzNK9Sipvu0aUDv1g049SDrzaSkPEhmeiBkQI6JSaK4ZZE1p4AI2NrYJyv9H7JGal/8uvNqaf2usJrsmCQacUvKgmQ5JPsz1ITTV0bGxNhjfhbcd1LqXL5jJQKLh8WfRz/ecSC06qc9xyqiVY3x6rP1IHA4sFwp1QE4AUieNasKKCgpt9ZarU50Odn10PKH4gv2MVNQohWiN5b/hl9952hphW2kBYTuLepx/+m9Eh6HG6s36376aYnppI/sFA6aO61PK1Y/qtkz5v61iwXr8vh9Q54lwtkgv7CUxl7VH2Vh11cjK6r9JvmHi7cXYFlZ2AvERMOoRZFMlFIUlwXJcpj5G67IH8/WIoBbNQiveOwrhZRWpSvy/hlFpWQvfPaP5PRVzfGc5kIptR0IiEhAKTUF6BvrJBEZIiLLRGSFiIxwaXOeiCwRkcUiUmnZpgpLyq21VqsTF+gfk4M7ZmZ6gNzRw2KqedzITA+Ekr3d/YV2g3LKABqN8TcdGzX9dKK0qa9/X16FQoveLKRLaLO+ycD5zYINEbNXN2euMdNzXd1ZufVPrab2yXp5kbKw99Dn87S4kNJyxXtXDgjtN/z6DX6+/biQAd7MGS/EnncdmqPZdp46vw+/3XUCtTPTKKtg/QIDQy3kZCPo29aajqRj0/DEwd4+YsW4ezOMagCT7qXCPG4qnbt8gvfzgkEoM+X3yq3Wc9yk4lUo7BKRusBPwHsi8gxE98nTK7W9AJwC9ASGi0hPW5suwJ3AUUqpXsBNcY4/YfaWlHvO577PYaTY/uk/EIzfNpI7ehiXHtHe8dikJZsjZp0HRPFVTzXm+r43HqurdjI9rlzqtkCZPp9Y72NgV+c4iWb1sixqMes1mkGTLjBTL/qzNqzeMWr7DunVgqM6N+H9qzTB8J8Jy4BwnEbbRrUjDPBeOaFHc3JHD6N7i/o0q59Nv3YHVLjSmYGR3dR8U5838kTm33siB7XV3DSN2hjm1CqGLenwjo2sk5PlEzRh8KRuY/rlGdgVTrkCaDfrwuhGfFfePy92m/JSGH8nvHgEPGT6vpd+ldg1ayBehcIZQCFwMzAeWEns4LXDgBVKqVVKqRLgQ70fM1cBL+g1n1FKJeBYnBiFJWXUykxn8r8HMu2O4yrrssnnuzsSOm3U6b2YN/JEx2On9rH6kJ/QvRkn9WzuXa+eRIz6vZnpATLK9DgDr0IhI5uGGWGhICKh5HRjLtcS6P3nnINCx6cud65W989BnciONYHofIJ+kXC7O4Z054qjOvDEedrnZl6p1M9OdxVC8fCGra5zRlogaVHNhvHdPPNvWCeTA2pnhozPG/RV5U2Dwysyo33ECsHppj35ofDrXWvhh/vhsRwocPYGsxBvsaiSAnjpaM3DaOsf4Wt+PwrmVetUbknFk1JdKbUXQETqA14LA7QGzNOAdcAAW5uuer+/AGnAKKXUeFsbRORq4GqAdu2SEx5foK8UzMveasmsV7UHwL07wWO2VxGJiCEA7QZo1wlnpafxyiX9I9pWBpcdmcOY6bmaq2bxHi2dcbpH/X56NplYU4BPve04Vm7dQ4+W2grEnGp6QIdGjq6pa7YXWFYKU24dBK/UhYMvDTfqdSbMedOSh6lWZhr3nhZeHJvzAZWWK89JGJvVy3JN02Hfn5kWSFoKFyO62ilVibHvg9+0v7g5SNEQBr+uNsV7rLOW7wyx8EM45FIoyoMPLgjvL9wJtZ1La4Z424PDgZlXBsI2W12I/0aq7eh3cXz91jC8eh9dIyKbgYXAbGCO/hz1NId9dtGeDnQBBgHDgdecKroppV5RSvVXSvVv2rTisysIC4UaRYxC9k4sHHUSj58dni1np6dFuCBWvHBJ4hi1F8Yt2gQLPoDyKJXX7KRnUytg1XJmpgdCAgGs8SpDXaJsrx1oFZTtG9XW1BDmSnlpesK9MveIZHNyt7JgMGphJ3O9hZf/fohrO7N6DSAjPbUrBQO7PcZcAc34/YRsUb9/Dq9Zg/QsvHmKVSB4ZbVDJP72yLoPAEx/PlIguNGqX/xjqUF4VR/dCvRSSuUopToqpToopTrGOGcdYHZObgPYXTvWAV8ppUqVUquBZWCyDKaQwpooFNbGEdylUz87g/MODX9NOwtKqGNLTWEPgqtMjKjUVg2ytVq58ZCeTZ1A9Mhjc3GcCS55nFo0sMYSBAICwVIImGwU6YZQcE+8Z6a0XEXkBzJj3NhvH9KNfu0a8sZl/S1R3wbPXGC9gWWlBZJiUygqLQ8JTC+uxVtM78XIz2REQvPFNfEPYMEH8Z8D8JxLmvmJHmJbDBrFurXVbLwKhZXgIV+AlVlAFxHpICKZwAXA17Y2XwLHAYhIEzR1UmRO4iQy96+d5IwYy/a9xa6ZKqst7/5Nm8EmgOER06/dARHCsirTit8zrAd3DOnO1NsTsPukZ5Ee1FYWNw92DqAzz3DtFdruO62npTB8k7qZWmF4pUAFrQFOcQoFgM/nWrPWpusxC+/OXBMSCsas+/juzTmhR3NeuvgQTjKlb7CnIMlIkvqo+8jxDHtOK8Lklm3UqFYG8OzkcDU7w+U2VAs8ntWdwU//gecP1TyVyk2rvXnvwhfXxt9fPHSKsqrZD/B6V7wTmC4ivwKhX71S6ga3E5RSZSJyPTABzV7whlJqsYg8AMxWSn2tHztJRJYA5cBtuutryvjb/6YDsG1PSfV1SQVodwT8NSNy/+5NcED80aNG3pz3fv0rsWjQFCEi/HNQp8ROzqgFpYXkPjo0av6a1Y8OZWNeEa0OqMUdny0K7b/8qA6WdrPv0Q3zxk0qYPr7pOuriTiEwt1De2i69KJ8OKBt6CZ6z5e/c7IeB5Bl83oacmALhhzYgrU7ChyzoWamB+Kq8xwNw47rVrjnmoEdQzYYp/oJX8xbz9Pnx/Rcd2fbcs1T6ZDL4bT/avu++j/t+ayXEu83Gme9kpp+qxFeVwovA5OBmWj2BOMRFaXUOKVUV6VUJ6XUw/q+e3WBgNK4RSnVUynVWylV8fzQcVDbzc2wOnCxS/RlBWf1R3ZqbFkZLHnAPVDOwrLv4KcnYrerTDJqASrmjVpEaKWvlMy5nFxR+s1YTH8fY6VQ7l0odCpcCKPbORo7jZWCU+AYaG6sXZpH3oiTsVJQNq8et5VC24Zh1dtH17h8bjtcFv7DP/I+oKW6gmHtb+F9efHVBvFMt8SDP2sKXoVCmX7zflMp9ZbxSOnIUoR5RlOtbQpRqo1VBHN958NyGnlXsX1wAUx+MCVjslAnjiRn6XqQWJn3aN9D2sfweIFwbIhZfWQYmhd6L9F4/IxLLduPnNU79Hr1Vk0vH0+hGICMdKmwodle08HNIN7cZGtpYCpleq6eOG/qbYNg/F3Wky79Bm5bBd2GwACPaqCC7VpMw/vnh/c9bQp5sufCKrKVKR0VR+rr7Gqd5zMpeP3FTRGRq0WkpYg0Mh4pHVmK2GYqBVmrptkUIKFgNoA2DbUbaDddaOaOHsbH13qYNQNsWRq7Tbkt1nHyQ5pXSlyI5r7olQxdKJS6G3SdGP233twxJErBdsPDKN0UmWwIiNyf47qWmQsHhN2trxgzC4CtUSrGOfHmL7mUlAV5YcqK2I1dsKeVd3OdredQKwPg4bN6M+nmY2nfuA6s/MF6sMOxUEd3A+46xHrshihZfyfdC4UusQsDb7dufxzHb8QnAq9C4UJ0uwJh1VEsl9R9kq7Na8hKAaC2Q+IzlZhQmPzvQUy9bVD8ue6D5fC/w8Pb5lmZUjD/A1j8pZbe+L1zwwnMfvoPfHp5fNdBWT1+YhESCrdbYUMAACAASURBVPH5SFxwWLvodozSQmv/EC7OkiSM2b6KUW404jx9lm9ETSeCPSlfzg/Xad/rCusNXkQY2rsFD9pSdGSmB8KqLbORecA/rRfqdBxcZMo228hqw4mLO03qpNxp4df2+Ag3tdX577pX8dvPiDlVFpEAcLFSqkYkBzGrS6u1oRng9pWwYzU8azLmJZg1MjM9oM3s4sUw/JmZcDec/DD8MRa+NKkI/pwIDzSEY26N/zr5ujfzxug1JCwYxt/SJCeLC60UTK6qRtBgvYoZ6ds2qsWmvKKQsbhNw9SoCaNhFgqNyaP+6rHaxrt/06rdmfjfRbYYipkvQt46OPGByPTTOdZKe0C41GUnPSL8gHawK4GM/FkmL6xgKcz4HxxxXeRKpdsQGKIXp6rdCHqfG7bD9ajWFYaTRsyVglIqCOxjFsTECZqkQrXNkmqmUQcYsRaOvlnbXjuzcq/v5E8+43ltZvmri4fIz6af0w8PeBNkq6dqz8vGeR9byPibgEtkNAyhkGGNX6BZT2jt4idvNKmXFfV479YNLML5lANbxDU0I3tpRdi+J/x5Tc9ydTB0ZvwI7ft/oJGWVsKMvXANaDfkf83VZuoA18X5+z39eef9U/QEhWYX7V5/054Pv1Z7HHTefldVzQte1UcTReRsqUqH9SRhXoxXe/WRQXb9cBW22W9W3nV35kY/7kW//vOTmvqpLMaNO5hATW3DZVQlMec+OK8UQJsZx7DptG3kMvPXPaSy0tMsOv14/3L/uyi6UPLCf78PR/5m2cuOLomSOM5uZLfnOnLz/2/cKew4YdTeHunRM92cksK8iinR05ObI8yHPemtz/0cr0LhFuAToKS612g2u9tVe/WRmVBx8eT4qMdk82J4JkkJ8rYtgx8fid6mnh4dG4/qyXAZTUSgRMNwcU23zfoD6bDDJc2CjmHQj2DeO4AWE2DEjCSCvWhPIhwdrUjPdNvMPBiEpd9qCew+v8p6zDwpuPy7+GblaR5W8Uf+K7LPLieFX485FaY/G96OlUvJB/AoFPSazAGlVEZ1r9E8KzeclrfGrBQAhjyqPXcbmtrrbFwAv70KLye5Rm0sPbJhPGwTR2I+Y6WQoEeWK4aNIt12g98wTwu4WjPd9VRXoVCkzbHcAsXiYWjvFu7X8UCrBlHOXfebdXvak/DRRda6Bk60PzL+gdjsFxEc7OBldOaL4dcV8ATbn/H8C9RLcj6hP05N5aAqixolFIyZ9JYl0dtVhF+e0YTBuFudZ9+GsTARguWaR9KoBrDXQXVQv7X23OKgyGNuGIbOylopGBhpmR1wNRzrHlJvzVgT2nXl0Yl54+wuKmPdzsRXG0YdhRzZ6NzAiAMoLbSmvk4FdfWUHic/CoPutN70nVJnp7nk6TrtmeSPrYbiydIqIqOBQ4H39F03isjRSinHamr7KvZIzxoVp2Aso3//DM55IzXXiFYpa/iHWjRoPIFCZpZ8qT1AK8LeyZbraLxeN8Kux49GyKaQ5JWCm03BA23dhIJDYZl2jRPzPPr5z8i6yfHw+HjNnTVHXBIQ/jEW+l7ofQKSwOcU4ia9PKk5XXqznpotyilxndu1uteIeWyl4HWlMBQ4USn1hlLqDWCIvq9asbvIajRzraZV3dntnO0zguI93nP1TImh86+s9ABZcdS/MAreJFt95OZ95AFXtc6s1wAseaeGH5ZY7RAj86tTttS8wlKGvzLTMW+Swfa9Dkb/NoeFX4dsNR4/17Nf99bOiXSH+hmt+sL57zjbHdxKtdaJYifxsRCPAtMcnZPgdLBqMQrRG6S0oHhV8mS36MeXT4AXj4JHW8MrHrKPznsPpj7m7don2dQJF38O93qoomXml/+6H3NTDziRKvVRiV4BLsMlriNvHSz52lG90biuNv4mOOvL+7QN/82i1VuwsGM1fH1DKGr873ppT3sQGkCf+ycyY9V2uo+MqGUVHXONAUMoeP1NJGJPSJTq7yBZ5Xi9Kz4KzBORMSLyFlpEc4yp477H3L+sS3QveeJrHOvnaq6Cm/Vl+ZbFsMVdBw7AV9dFP37FxPDrI/8Vfj0qTytTGUjTXp//Hpz6X7g7Rl2EVT9G5q8xiOdPn0xDc/5G7aZr2FRAc5904ucn4eO/w5+TIg4ZFcpaibOKZ9G6XfGP7Z0zYe5bISOw4VVXVFKx910Xk13CLOw/vwqe6gkrvvfWUWV7/djtTkffUrnXr+Z49T76ADgc+Fx/HFHZGU2TgX3mlZYE971qRVE+vOqwMvifvUpqnLTzeH6PU6H/5d7ULoUJ3BztJGulULgTnuquPTYuCO/PiOHh45Crx4g7CDoWJoTN+fHlOgLC8SK68DPUogUVFAp3Z+gmxLrNI1U4+VGylJ78aIWuW2HOscXq+JlP4yIe/UkA2AbsBLqKSJJ9ElNPvHW+qx3mJf5eh5lolFKRrqycHP14m0Pj79NM/TbO++0+74mQLEOzYQTeu9W6P9aqZYJ7ta9Sw8fjjBcs+2esqkA5kbG3gFKhyc+uQveCS0d1bmzZ3phXaEm+N7hHM1qKLtQO13MWeTEYn/mill4iljtpKmnSGe422dXaHube1icCrzWaHwN+Ae4GbtMfCSSwqVqMSNEz+7ZyLApS7TELgv84JHSLt5wlwDtnRT/uJGlPfjS2cfH21XBHLtyy2Pm4ubRonFlOQyTL0Jzo+QXuXkBXp3+rvahtvTkb9RyuS6Sw0LblUFbE1wu0PFF3fb7ItekvK6zC54hHJ3Pow5o66IDaGaFKfNoYdSPtIR4SGHZMoEJeKkjPhkOvhH94VHH5hPDqk3km0E0plcDadt9hb4mmRhh1ei8OqF11dYdThoNbo4W5b1f8GsfdraUq3rwEXjwC+l0U2eaIGDYI8KZnVkqbjT+bYCH1QJKEwuIvvLWr3zpSrRIMhpPlmTg7TQ/GMxfqUYpD2jdi7sgTE6+LHSzj2K5NmbRkM0s2xk46sHDdLhasDavqgkHFroJSq1tr34tCfbvyf79BU5uDw8ARyTfye0XET2uRIF7VR6uAOHMq73sYOtYald7CTKz0zXGUinTFyF3fvKemIuh/RcX7dPMhNyKHd29IrN9k2BRKC2HKw97annBf5L6fY+SS3LhAqzEAoeRtcQkE+0otWE6HOLLdnv78L4z8Krxay9fdti32N0Oo9T7XuZODLogUCADH3QknjPQ8Fp99A69CoQCYLyIvi8izxiOVA0sFBSVlpAckVAy9xjH0ceu2OftoeanmoeLG6p9i9395nG6MXrngPef9Fc1uGvI+qoBQ+Op6723F4XcVK6trIC0cCR602QBmvwFfOqQmNwgG4UWbu6cKhuwFh7RvaDlUHoxtVDNqLvdu4+B17uZQ8LeXY/brU33wenf8GngQa5GdmDWa9zX2FpdTOzMt7syT1YZWNjXL1yb30GXfRbbPMqWvesshl7xd7dLeYyW2RDj7dfjnDOj39/C+x9pXzDsgGYbm9S61pJxSPDu5qG6YF7Hry/8z1RXocnI44KrcJhS+vRnmv6sVt7FXrgMtnbg9qri8BBGh9QG1aG/LyGqoT0NNHYTENe9of+v5a5Pg/eVTLfHqkvqW0yPVg0s2hSXl3msOV0fq2wq8zH83/No+W75xIdy5Nnp/P44Ov051or3e52gqqaE2dUtFVF5JMTS7TCCa9Yjc1+0UGHhHzB77mgLUkEC4mpzbiubdv8H3DqopJ88wvU52nay0CJfU3UVa/4YROT+Kd9KJPfRa2PaJhk+NJ6pQEJFvROQ0EYmwJ4hIRxF5QESSoFSuHPaWlFE7q4baE+Lhvl3QsH3sdj+Z1FFNuqZuPGbsMQx5JsF14wLiws2mkL/Bm7DZvNj5Ru0WySwCx90F547xPkaRcLoG+0rBzKJPI/fNfz9y3zxtIlArM50CW0Tz7FxNNWSk5u73YGRwXTt9dXH7iXpeoe7DrA1O0X8TOcdoz6lSKfpUGbFWClcBxwB/iMgsERknIpNFZDXwMjBHz4VULSgpC9Zce4LBrS4F2831kM3qs3/NDb8u3uPeb8s4spNWFPNq4a8Z4ddGJlivpDnMwJWCp3rAZ1dGP3fFD5q+Ps9hNTXgmujn9jgDBt0VvU1DPQNqo45aWgyArUvd2zsVCori8lo7I42lG/P5dmHYSH/jh7FLmbY6IJsmdbOQTbo76/IJ1gYDrtEcDC77VntOpUrRp0qIeodUSm1SSt2ulOoEnItmV7gF6KWUOlEpFaUM075HUO0HUcx1m2pZJA3mvBW9RnHjTtBON1Y62RVAWyUceHbyxhiL/v8IvzbbReLJewTOhmYjgG/p184z8/wNWuruL66NPGYEbzkZlC3XDYS9tNxocyg0zNHSb8/XS5rOdClfCrB3i3V7e/RiPrUz09i6u5jr358XkR24bSP3SOyZq3awbU8xrNXrJqybFfU6PjUPz9NmpVSuUmqGUmq+Uqog9hn7HkopAjXVyGzmSlOx8m9uCBVwcSVfn6lumOt83K0Obqpw8Oun29D4k5055T5a+k349W6HegFP9YD/dIy8CQPcslRzwT3qxtjXNo/VyVgeLA3bEoxU573Pid2vwaofrds2m4/Z7brrPVYng8fP9lAxL9l1rX2qDTVcl2IlqBQ1faEAhOvdGphVDy37RraPVfXMFnVbKXS15as5+JL4+zBm9OYVgTl9hl01Eo3bVmkBd6c+rdXEjgen9CLBsrDQaqAXEDLbCNa7CGgD+037NKuHuFMBqW7NtSj++rWszhZ3ntI9sv9k16DwqTakVCiIyBARWSYiK0TEtSCPiJwjIkpE4qi1GD9BFX8h9BqBobMGOC+G05hhV9ixOryvgUt+olRi94l3y5MfDRHtxmv3/zcYF0emljoVEIwlDgvr8rKwgdlQS62aEj7uZFg2UnYDbFwYfi0ByLKmbXHyslu2WStmn22qI/LUeX24ZqBDSg1jTBWpheBTLfGa++h4EYmrDJSIpAEvAKcAPYHhItLToV094AbgV/uxZLPfrBQAmvcOv359cPh1w5zo5xk3yg8uCO9LoJhMhek82Lodrz3BIJBRdakWDEocDPjLvwPDmOuUaG6mniiv93nhfa8eH369wLSq6DpE+466nxpSSZlv/P93nHbT79++IZlpAbaZEt8d3VnLa9SyQXgM5xzSBibohnKn6mY+NRqvK4XL0CKaZ4jI47qbasMY5xwGrFBKrVJKlQAfAmc4tHsQeBxIMOuZd5Ri/7ApQGQ5y2iYfevzdW+VHauSO554adHbuu1WXyEWaRnhwC+nzLFmNv3uvD/RjJ+G26Z5hu9EtBTc5jQRbrWfjVTRTboCmv1iqSnvUZkepJadkcaBrevTsWm4ep2RzmLaHWGBY4mETlQY+1RbvAavXaKU6gqcDaxDWwFsjX4WrQGzP986fV8IEekHtFVKfRutIxG5WkRmi8jsrVtjXdad4P5iaIZwEjMvHHlD+HX+Bk167muGxoI4q7cZmNVHTjUaDC8bgJeOijxeEYyCQ27eX0auqmiqsUA69HDxCjMwVnL5G7RVUVkJU5eH/ydGsZ29JWXUyUqnSd3wjb5BLe3aZq+8xRtMQtAXCvsdXtVHF4vIy8CnwGDgebT4hainOewLuWGISAB4Gvh3rOsrpV5RSvVXSvVv2rSplyE7Uh5U+0+1vkYdvLc11z0u2A6/f5b88VSUOgl+72kZYUOzk/E0GZlj3TAMyaUONoX6rb0Vkw+kR8ZnLJ/o3HahXvdqozXIzyjLWVhSTq0Ma5qXgIM+tVcrU96jRGw5PtUar+qj/wJ9gVeBG5RSjyulZsQ4Zx3Q1rTdBjCnu6wHHAj8KCK5aJXdvk6lsXm/Uh+lZ0Xua9Yr9nkiViNnZcYnRKPryYmdF0gPu6Q6zdid9P1mKpLmYdty7fkth5t/WXFkNTMnAumRY1hiCg8yCwyj4ll2fYtHUWGp5n32x6bdrNgS4/0CXZubJgn+SmG/w6v6qAlwBZANPCwiv4nIOzFOmwV0EZEOIpIJXICWWM/oM08p1UQplaOUygFmAqcrpVwykFWcoFKOLvA1luttOQvtWVSdKNgeLu8IEa6OVUYgwfQkZvXRNzdEHo+WF6n/Fdb60/ESTeVVXgJpJsFtqJL2bLGqudIyoM/w8Pb2lVYX1+tMczNjdVhawDUDO5E7ehg9W9YPFZcCaFbfYbJgI7/QZJj3hcJ+h6fscCJSH2gHtAdygAaAQ9x9GKVUmYhcD0wA0oA3lFKLReQBYLZS6uto56eC/cqmAFpZQjNe/+DmdAtm1VJl07S7u3HVK2b1kVmtYvTtFMBmcOrTFbt2iwPdj9lXCkW6INj2p1UAZta1BsI9d7C1n1omo7BhsDatiErKgyzXXVEz0wL0a6e1n3PPYNzyz1pUSr76aL/D67x5Gvx/e3ceJlV9Jnr8+/bebQPKIoOCNiJCMIDGRkAyBAwkGkFNohcYM5G5zjAqGNwyjxlHQwz3jhO4GDU+ZjRqR4OGiIhojAtuExUGGmz2RVCQHvVhCUG2pu3u9/5xTlWdqj5dVb2cru467+d5eKrOUnV+RVf3e37b+2MysB6YoqqDVPXaVC9S1ZdV9RxVHaCq/8fdd7dfQFDVcUHWEsCZpxCqoJAo2XrKmVxTtymRdBep8gglk5PvP09hpjsCOsg0Dk0tTakK9SeaWPNY49NoNOf7mhcJCrE+jB17j/DJX45RV99AbX0DRXlOwOlRWkjP0vhaw4X9ndXwxg7sGdtpQSF00qopqOowiM4paEWC+8zSMM1TiPjeb2CJm/ytuQHx8gfbvjzNceE/wQXT02t7b0puXuO1CEakSIY3/Y/xd+AtldPEr1ek5uJXczt2ALqmOVkw8efjU1OIeHaNM4GxML/p+8A//LM3uZ0ACvnNmp5kskC6o4++KiIfABuBzSKyRkSS1I07plDWFIZd7eTs+XHyBGq+vAveZIJI6wIC+NcUTm00hzJe2dehdxqd8imv3URQOOoOF/3Qp7/ihVnpB+/E1B+RRX58ZlD/ZIkzUS7tLMGFXeGM0c2/kTCdXrrNR48At6rqmap6Bs4w0keCK1YwGlTDmeai62lwUs/U5yXKhv8rb59CRGKw8y5F2stn8ZzWXNtPpKN44MTGx2qP+nd+N7U+slckKHwZmyw36qzu8afkpfkrf+JQfNpyExrpBoWTVDWamEVV3wbSXx28g6hvCGHzUXOU9s50Cdqed0hqRGLt48AOp4MXYIjfpPsWaiqoRoJCj4GxfSPdVN25+fD2/238mkvTGDkWrSnEgsKv/i6+YzqtoBDJ6jr871Kfa7JOukHhIxG5S0TK3H//Bnyc8lUdTKjmKbTEjHdiz8f9JHPlaEs5ealzH2kD/MbNtXT8YDDl2Lc99jzS5u9trz/5DOexria2zGZzM8NG3m/9H6K7upfEB8C0mo8iq9Iljl4zoZBuUPjfQC9gCfC8+/wfkr6iAwrdPIXm8nZ8lneaVVaTiwSFSG2hzDMR/4LpzmNBaWxI6Kr/DKYcdZ7O38joIG/OI+9chIiveQb4+a3JkCgylPXzWAbVxBnLadUU6nyClgmNdEcfHcTJZNqphbZPIV25nq9D6amZK0dbikxei0zI2/Xn2LGLfgRrKuKHgBYENS/D873zqyn4rebm7ahuxdDQkoJcTikp4H/+ejyaAC+pXe85j75DZk22SxoURORFkgxBVdXL27xEAVKFXAsKTSvqBl+/BU77WupzO4vcfKeWEFloqNjT8RqpGdXFUknz90uDKYf4BQVPTcHvj7632StxYZ9mzLTud0oJB485CQ7zc9P4/i9ykylaUAilVDWF+SmOdyqhWk+hpSbMyXQJ2lZOrvPHNdL5Ovn+2LFIUKj3BIWExWrajLf5xy8oFPiM20j2RzlxEaIkivJzOFzjBJi0h6QC7N2c/rkma6T6hnysqu809a9dStiGQjlPIexy3CGpkT4D7x13ZBRSXS0MudJ5fqrP0pSt8bduEmDvXIlIn0LiH/2e58RvJ6bJuHSe85gs/UaPxp3Dhfm50Uypec0JCp+sTP9ckzVSfUOidWkR6YD5lJvH+hRCKNLR/KQ71NTbdh9JSFdf6/yBjowAaktlX3ev4QkKkbUqEjPZDr4s9nzANxu/14X/BNcthwuSjPE4a1x8Exmw6uNYYr60mo8ifAKMyX6pgoL3G9Tp1+VrsHkK4ZObME/BmwIi2nxU62YtDSAjaCRT6sYlsX2RPozEoBAZDQX+iQhFoN+I5JMKUyw/mlZH8yA3OI1rcll1k8VSfUO0ieedkjUfhZA3dTbEJwXMzXNqDnUnnFFJB3a0/fUjWV5XeRIARGoKuQlBwbt+9hkXtex6fjO4PfLSqSkUdYVuZ8ApZ7asDKZTS9XRPFxEvsCpMRS7z3G3VVW7Nv3SjsfmKYRQXlH8+gOJie5yC52O5qMtX+Y1qcha070GxfbVnXCCUW6SX7+R/9yy6x3+zJlnoOpbo8hL5xdg3TMtu7bJCkm/Iaqaq6pdVbWLqua5zyPbnSoggFNTsD6FkMkviU8Ql/jzzytIemfdav1Gxh7fvjeWNjuxlpCopd/TDc86jwf9Ew4Uf/ERzOkWmzUN8MVnzj5vDigTWqG6bw5l6uywKyjxX08hIrcgfp5CWxN3lvHa38Lb/+70MdTVNp39taVrUUdcfJfzuOvd6K6x58Te8/TfuTO6n/pu7DWPXuw8rnokvZnTJqulNaM5WzSo2uS1sMlPkbcxtzDWxh+ExGVE/7oreSqNG96HQ9Utv15RN+dx2U3R3Ek1XyZZcnT7a3DYXTp9y4vw56yammRaIFQ1BWs+CiHvBDE/X1RD1cLgrp+YviJyV96U0lPh9FbMKPfpG/nRxQN9TnQ9nZCS+825Lb+2yQohCwohW6PZxAeFYVPb//p+OY2C9I3Gw0iLC0L1a25aKVTfFpunEELeWcORZpKmjL+z7a+fmLMoaD6ji+rdtE+nsT/+gPUfGB/hCgraOJWwyXLemkKq0TVnjgm2LF4tnYfQAps/PQTAqfLX+AN+K7xFtGT5VpMVQhYUNCtWmDTNkDhrOJF3zYL8dswKundTu11q/GAnDXoDCV/+E1/4nO0q7HQjzk0bCVVQsJXXQujzjcmPe9csyEvRKd2Wag6126V6lDqBcXreq7GdPQfBWz7LfkY0NWTWZL1QBQVLnR1CZ30j9vyM0Y2Pb/LkJOqZZJROawz8VjDvm6aSfGdY7PdyY3MXqK+NH6mULPOqCZXQzVOwmkLIdOsbe37pLxof967J3IrVzZJq7xFICXz70Q5+HD/ruWxs+xXIdGghqylY81HoFHgWzYlM7GpvftctDLAsfS9s/mvs98K4QhMU1B1+Z0EhZLxJ5/zu2Mf+S/BliDQfdTkttq84wKBQ0r3Rrn/8ev/kr0mceW1CK9CgICKXiMg2EdkhIo1m1YjIrSKyWUTWi8gbIhJYrt76hkhQCOoKpsOa+jSMvAFO7tf4WJfewV//q9+H69+FW9tpecvtrziPdbH0Hf82aUjs+ISfNX5NZC2JnDy48/MAC2c6usCCgojkAg8BlwJDgGkiMiThtA+AclUdBiwGfBp924YbE2yeQhgNvgwuvdf/2NEDwV9fxEmhLQKX/T9nn3cobFuLrNpWd9z/eNfTffad5pTt5g2pU4OYrBZkR/OFwA5V/QhARH4PXAFEb5dU9S3P+SuBHwRVmAa3+chaj0ycVPMY2lr5dc4CNmf7LLfZVgZ/B3a+AV/WNNGf4bOqG8CIfwyuTKbTCLL56HRgj2e72t3XlOuAP/kdEJEZIlIpIpX79rVsMZTIjH7rUzBx8tpxwho4dyXnfCvYNvy/uKOKmprBffiz+O2Zq4Mri+l0ggwKfn99fZOtiMgPgHJgnt9xVX1EVctVtbxXr5blm29Q61MwPtq7ptAePn7HeVy/qPGxwm5ODSKioBR6ndM+5TKdQpBBoRrw9uz1BRplJBORCcCdwOWqGthqJw02+sj4yS/JdAna3gA3PfeO12P7IlXlE4fi527UHmm/cplOIcigsBoYKCL9RaQAmAos854gIucD/4kTEPYGWJZoR7Otp2Di9HPH9Jf+TWbL0Zb8ZlA31MWeDxjffmUxnU5gHc2qWicis4BXgVzgcVXdJCL3AJWqugynuagUeNb9Y/2Jql4eUHkAyLWYYLy694e79seWzcxWkSVHzxoX/1lHz8pEaUwHFmiaC1V9GXg5Yd/dnucTgry+V3SegnUqmERBpbfIFL91EiJBYdB34pMA9ji7fcpkOo3QzGi25iMTGn79JPVuUMgtiA8K3c9qnzKZTiM0QUFt9JEJi74XOI89B8X21bkjjvKK4ldn82aRNYYQBYUGm6dgwmTgt+NnJkdSXkTWScj2PhTTYqFJnW3zFEyofOguqNPQ4NQMPDWFL7/8kuppf6am5gRs2ZK5MppAFBUV0bdvX/LzW9ZXFrqgYH0KJlS0AciBV//V2c4tpLq6mi7de1PWo4f9PmQZVeXAgQNUV1fTv3+KzLhNCE3zkaW5MKGk9c7j7vecx7xCampq6GEBISuJCD169KCmpib1yU0ITVCw5iMTSg318dtuWg8LCNmrtT/b0ASF2HoK9stgQmTz0vjtnNC0GJsWCk1QsPUUTCgtvSF+u5OusPbrX/+aJ598EoCKigo+/TSWRm3cuHEMGjSI4cOHM2LECKqqqjJVTF9z5sxh/vz5mS5G2kITFGyeggmlfqPit/2WJO0Err/+en74wx8CjYMCwMKFC1m3bh033ngjP/7xjzNRxKwRmrqkzVMwobRnZfx2wvyEn724ic2fftGmlxxyWld+OvncpOdceeWV7Nmzh5qaGmbPns2MGTMAKC0tZfbs2bz00ksUFxfzwgsv0Lt3b+bMmUNpaSllZWVUVlZyzTXXUFxczIoVK+Led/To0cybF8vA/9prr/HTn/6UEydOMGDAAJ544glKS0tZvXo1s2fPRl4YRwAADeNJREFU5ujRoxQWFvLGG2+Qn5/PDTfcQGVlJXl5eSxYsIDx48dTUVHBsmXLOHbsGDt37uS73/0uv/hF40Uiy8rKmDJlCm+95awd9vTTT3P22fFpRMaNG8f8+fMpLy9n//79lJeXs2vXLioqKli6dCn19fVs3LiR2267jdraWp566ikKCwt5+eWX6d69Ozt37mTmzJns27ePkpISHn30UQYPHtyin1NTOudtQwtYR7MJla9eFb8dWYKzg6S1ePzxx1mzZg2VlZU88MADHDjgLIt69OhRRo0axbp16xg7diyPPvpo3OuuuuoqysvLWbhwIVVVVRQXxy8d+sorr3DllVcCsH//fubOncvy5ctZu3Yt5eXlLFiwgNraWqZMmcL999/PunXrWL58OcXFxTz00EMAbNiwgWeeeYZrr702OoqnqqqKRYsWsWHDBhYtWsSePXvw07VrV1atWsWsWbO4+eabm/V/snHjRp5++mlWrVrFnXfeSUlJCR988AGjR4+ONp3NmDGDBx98kDVr1jB//nxuvPHGZl0jHSGqKdg8BRMi33sUNi6GIc4fSPqWw74ukB+/0lyqO/qgPPDAAzz//PMA7Nmzhw8//JAePXpQUFDApEmTALjgggt4/fXXk71N1DXXXMPRo0epr69n7dq1AKxcuZLNmzczZswYAGpraxk9ejTbtm2jT58+jBgxAnD+kAO8++673HTTTQAMHjyYM888k+3btwPwzW9+k27dnKVNhwwZwu7du+nXrx+Jpk2bFn285ZZbmvV/Mn78eLp06UKXLl3o1q0bkydPBmDo0KGsX7+eI0eO8P7773P11VdHX3PiRNsvQROaoGDzFEyo5ORA9wGxjuUvj8envcigt99+m+XLl7NixQpKSkoYN25c9I48Pz8/euOWm5tLXV1dsreKWrhwIcOHD+eOO+5g5syZLFmyBFVl4sSJPPPMM3Hnrl+/3vfmUP2yy7oKC2Mr9CUrl/d9/a6Rl5dHQ0MDQKO5BN5r5OTkRLdzcnKoq6ujoaGBk08+OfCOdGs+MiZb5RfHlt788niHWWXu0KFDnHLKKZSUlLB161ZWrlyZ+kUeXbp04fDhw4325+fnM3fuXFauXMmWLVsYNWoU7733Hjt27ADg2LFjbN++ncGDB/Ppp5+yerWzNvXhw4epq6tj7NixLFy4EIDt27fzySefMGjQoEbXSWbRokXRx9GjRzc6XlZWxpo1awBYvHhxs967a9eu9O/fn2effRZwgti6deua9R7pCFFQcB6tpmBCIzcfju13nn95rMPUFC655BLq6uoYNmwYd911F6NGjUr9Io/p06dz/fXXc95553H8+PG4Y8XFxdx2223Mnz+fXr16UVFRwbRp0xg2bBijRo1i69atFBQUsGjRIm666SaGDx/OxIkTqamp4cYbb6S+vp6hQ4cyZcoUKioq4u7e03HixAlGjhzJ/fffz3333dfo+O23387DDz/MRRddxP79+5v13uDUiB577DGGDx/OueeeywsvvNDs90hFklWZOqLy8nKtrKxs9uvW7D7I9x9+n4p/GMG4QacGUDJjOpg53dzHQ/DQKOh5Nkz5HVu2bOErX/lKZsuWhSIjo3r27Jnpovj+jEVkjaqWp3ptiGoK7nKc1n5kwubzjU5NIa9j1BRMxxaajuZImotcaz4yYSE5TpbUx78NtUegV/Pax03z7Nq1K9NFaBPhqSnYGs0mbNQZ5ULtEefxw9cyVxbTaYQmKNRb85ExxqQUmqBgo49M6PQ4O/U5xiQIT1BosHkKJmRKMj8KxnQ+oQkK0Y5miwomLK56LNMlaDNLly5l8+bN0e27776b5cuXA/Gps8eMGcO2bdui+1syfD3swhMU1BbZMSHTrW+mS9BmEoPCPffcw4QJE6LbkdTZ1157raXObqXQDEltsJqCCbuR1zfe96c74PMNbXudvxkKl96b8jS/9Nl+qbN37tzJsmXLeOedd5g7dy7PPfccP//5z5k0aRJXXRWfDXbs2LH88pe/bHSt0tJSjhxxRmEtXryYl156iYqKCqZPn05xcTFbt25l9+7dPPHEE/z2t79lxYoVjBw5koqKCqDpFNzZKNCagohcIiLbRGSHiNzhc7xQRBa5x/9bRMqCKkuko9mCggmtCT/LdAni+KXP9kudfdFFF3H55Zczb948qqqqGDBgQJPv+eKLLzJ06NBmlePgwYO8+eab3HfffUyePJlbbrmFTZs2sWHDBqqqqppMwZ2tAqspiEgu8BAwEagGVovIMlXd7DntOuCgqp4tIlOB/wCmBFGeekuIZ8IuIW02kNYdfVD80me3JnV2cXExZWVlPPjgg80qx+TJkxERhg4dSu/evaNB5dxzz2XXrl1UV1f7puDOVkE2H10I7FDVjwBE5PfAFYA3KFwBzHGfLwZ+JSKiASRkOnSsFrA+BRMysyrhVynT3bS7ptJntyZ1dnl505/Tm8a6qZTV3nTVke26ujpyc3N9U3BnqyCbj04HvMsTVbv7fM9R1TrgENAj8Y1EZIaIVIpI5b59+1pUmLte2ATAgaO1LXq9MZ3SSe6w1EGXZbYcCZqbPrupdNnp6t27N1u2bKGhoSFaO0lXUym4s1WQQcHvljyxBpDOOajqI6parqrlvXr1alWh6uo7V1ZYY1ql+BS4dSv8ryczXZI4zU2fPXXqVObNm8f555/Pzp07m329e++9l0mTJnHxxRfTp0+fZr22qRTc2Sqw1NkiMhqYo6rfdrd/AqCq/+4551X3nBUikgd8DvRK1nzU0tTZe7+o4ckVu7l14jmW/8iEmqXOzn4dNXX2amCgiPQXkQJgKrAs4ZxlwLXu86uAN4PoTwA4tWsRt397kAUEY4xJIrCOZlWtE5FZwKtALvC4qm4SkXuASlVdBjwGPCUiO4C/4AQOY4wxGRLo5DVVfRl4OWHf3Z7nNcDVQZbBGNOYqvouLG86v9Y2toQmzYUxxlFUVMSBAwda/cfDdDyqyoEDBygq8pmTkqbQpLkwxjj69u1LdXU1LR3ebTq2oqIi+vZted4rCwrGhEx+fj79+/fPdDFMB2XNR8YYY6IsKBhjjImyoGCMMSYqsBnNQRGRfcDuFr68J7C/DYvTGdhnDgf7zOHQms98pqqmzBPU6YJCa4hIZTrTvLOJfeZwsM8cDu3xma35yBhjTJQFBWOMMVFhCwqPZLoAGWCfORzsM4dD4J85VH0KxhhjkgtbTcEYY0wSFhSMMcZEhSYoiMglIrJNRHaIyB2ZLk/QRORxEdkrIhszXZb2IiL9ROQtEdkiIptEZHamyxQ0ESkSkVUiss79zD/LdJnag4jkisgHIvJSpsvSHkRkl4hsEJEqEWn+0pPNuVYY+hREJBfYDkwEqnFWhZumqpszWrAAichY4AjwpKp+NdPlaQ8i0gfoo6prRaQLsAa4Mst/zgKcpKpHRCQfeBeYraorM1y0QInIrUA50FVVJ2W6PEETkV1AuaoGPlkvLDWFC4EdqvqRqtYCvweuyHCZAqWq/4Wzml1oqOpnqrrWfX4Y2AKcntlSBUsdR9zNfPdfVt/piUhf4DLgN5kuSzYKS1A4Hdjj2a4my/9YhJ2IlAHnA/+d2ZIEz21KqQL2Aq+rarZ/5l8C/wI0ZLog7UiB10RkjYjMCPJCYQkKfusOZvXdVJiJSCnwHHCzqn6R6fIETVXrVfU8oC9woYhkbXOhiEwC9qrqmkyXpZ2NUdWvAZcCM93m4UCEJShUA/08232BTzNUFhMgt139OWChqi7JdHnak6r+FXgbuCTDRQnSGOByt43998DFIvK7zBYpeKr6qfu4F3gep0k8EGEJCquBgSLSX0QKgKnAsgyXybQxt9P1MWCLqi7IdHnag4j0EpGT3efFwARga2ZLFRxV/Ymq9lXVMpzf4zdV9QcZLlagROQkd+AEInIS8C0gsFGFoQgKqloHzAJexel8/IOqbspsqYIlIs8AK4BBIlItItdlukztYAzw9zh3j1Xuv+9kulAB6wO8JSLrcW5+XlfVUAzTDJHewLsisg5YBfxRVV8J6mKhGJJqjDEmPaGoKRhjjEmPBQVjjDFRFhSMMcZEWVAwxhgTZUHBGGNMlAUFE1oi0sMzdPVzEfkfz/b7AV3zfBFpMmePO+8gsOGGxqSSl+kCGJMpqnoAOA9AROYAR1R1fsCX/VdgbpIy7RORz0RkjKq+F3BZjGnEagrG+BCRI+7jOBF5R0T+ICLbReReEbnGXcNgg4gMcM/rJSLPichq998Yn/fsAgxT1XXu9jc8NZMPIrNWgaXANe30UY2JY0HBmNSGA7OBoTgzps9R1QtxUjff5J5zP3Cfqo4Avo9/Wudy4tMT3A7MdJPZ/S1w3N1f6W4b0+6s+ciY1Far6mcAIrITeM3dvwEY7z6fAAxx0i8B0FVEurjrOkT0AfZ5tt8DFojIQmCJqla7+/cCp7X9xzAmNQsKxqR2wvO8wbPdQOx3KAcYrarHadpxoCiyoar3isgfge8AK0Vkgqpudc9J9j7GBMaaj4xpG6/hJF0EQETO8zlnC3C255wBqrpBVf8Dp8losHvoHALMgmlMMhYUjGkbPwLKRWS9iGwGrk88wa0FdPN0KN8sIhvd7JfHgT+5+8cDf2yPQhuTyLKkGtOOROQW4LCqJpur8F/AFap6sP1KZozDagrGtK+Hie+jiCMivYAFFhBMplhNwRhjTJTVFIwxxkRZUDDGGBNlQcEYY0yUBQVjjDFRFhSMMcZE/X/HewKP7dyeFgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plume_start = plume_starts[1]\n", + "plume_end = plume_start + 50000\n", + "print(plume_start)\n", + "\n", + "plt.plot(x, flow_plumes_only[plume_start:plume_end]/max(flow_plumes_only[plume_start:plume_end]), label='anitRecon plume')\n", + "plt.plot(x, 1-(raw_plume['plume'][0]/max(raw_plume['plume'][0])), label='antiPlume')\n", + "plt.ylabel('Flow (normalised)')\n", + "plt.title('Anti Plume vs reconstructed anit plume')\n", + "plt.xlabel('Time (s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "777451\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plume_start = plume_starts[2]\n", + "plume_end = plume_start + 50000\n", + "print(plume_start)\n", + "\n", + "plt.plot(x, flow_plumes_only[plume_start:plume_end]/max(flow_plumes_only[plume_start:plume_end]), label='anitRecon plume')\n", + "plt.ylabel('Flow (normalised)')\n", + "plt.title('Combined anti and plume')\n", + "plt.xlabel('Time (s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Now repeating the same analysis but with repeats of plumes, and across all channels\n", + "- 10 different plumes\n", + "- Order:\n", + " 1. Ch1 Plume\n", + " 2. Ch2 Plume\n", + " 3. Ch3 Plume\n", + " 4. Ch4 Plume\n", + " 5. Ch1 plume - Ch2 anti plume\n", + " 6. Ch3 Plume - Ch4 anti plume\n", + " 7. Ch4 anti plume\n", + " 8. Ch3 Anti plume\n", + " 9. Ch2 Anti plume\n", + " 10. Ch1 Anti plume\n", + "- 3 Repeats" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "flowmeter = sio.loadmat('/Volumes/lab-schaefera/working/warnert/Recordings/Set up recordings/190118/flowmeter_plumes_longer_all_chans.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__header__\n", + "__version__\n", + "__globals__\n", + "flowmeter_plumes_longer_all_chans_Keyboard\n", + "flowmeter_plumes_longer_all_chans_Ch4\n", + "flowmeter_plumes_longer_all_chans_Ch3\n", + "flowmeter_plumes_longer_all_chans_Ch2\n", + "flowmeter_plumes_longer_all_chans_Ch1\n", + "flowmeter_plumes_longer_all_chans_Flowmete\n" + ] + } + ], + "source": [ + "for i in flowmeter:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "flow = flowmeter['flowmeter_plumes_longer_all_chans_Flowmete'][0][0][-1]\n", + "ch1 = flowmeter['flowmeter_plumes_longer_all_chans_Ch1'][0][0][-1]\n", + "ch2 = flowmeter['flowmeter_plumes_longer_all_chans_Ch2'][0][0][-1]\n", + "ch3 = flowmeter['flowmeter_plumes_longer_all_chans_Ch3'][0][0][-1]\n", + "ch4 = flowmeter['flowmeter_plumes_longer_all_chans_Ch4'][0][0][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "push = lambda a: 1 if a > 1 else 0\n", + "ch1 = [push(i) for i in ch1]\n", + "ch2 = [push(i) for i in ch2]\n", + "ch3 = [push(i) for i in ch3]\n", + "ch4 = [push(i) for i in ch4]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "mix = [i+j+k+l for i, j, k, l in zip(ch1, ch2, ch3, ch4)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(5, 1)\n", + "ax[0].plot(ch1)\n", + "ax[1].plot(ch2)\n", + "ax[2].plot(ch3)\n", + "ax[3].plot(ch4)\n", + "ax[4].plot(mix)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "plume_starts = []\n", + "prev_plume = 0\n", + "for index, i in enumerate(mix):\n", + " if i > 0 and index-prev_plume > 50000:\n", + " plume_starts.append(index)\n", + " prev_plume = index" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30\n" + ] + } + ], + "source": [ + "print(len(plume_starts))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "baseline= np.mean(flow[:plume_starts[0]])\n", + "flow_baselined = [i-baseline for i in flow]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEJCAYAAABv6GdPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXeYVdW5/7/vNIYy9EE6A0gRsICo0XgVSxJRozHxJhiTaK5Xo+nlZx41scTEG2+a10SvStSoN4lGTWJXBIWAAsKA9Dr0oU1hej8z6/fHOWdmTzl7v3vP2vW8n+fhYWbOOmu/u6zvWvtd73oXKaUgCIIgRIsMvw0QBEEQ9CPiLgiCEEFE3AVBECKIiLsgCEIEEXEXBEGIICLugiAIEUTEXRAEIYKIuAuCIEQQEXdBEIQIkuXXgYcPH64KCgr8OrwgCEIoWbduXZlSKt+qnG/iXlBQgMLCQr8OLwiCEEqI6ACnnLhlBEEQIoiIuyAIQgQRcRcEQYggIu6CIAgRRMRdEAQhgoi4C4IgRBARd0EQhAgi4u4SsdY2vLj2EFrbZBtDQRC8R8TdJZ5ZuR8//vsm3PKcLNQKMr94Yxvue22r32YIgnZE3F1iyfbjAID3dpTghTUHfbZGSMWTH+zDMyv3+22GkGD13nLpbDUh4u4Sq/eeaP/5gTe3+2iJIISHBQtXS2erCRF3DyAy//zDojIU3PEmthyu8sYgoRs7j9X4bYJgQOaqeo+IuwdkZJire9KFs3pvuRfmCAlirW3tP//izW0+WiJ05aXCQ36bEHpE3D2gsr7F9HOCxdBecAUZHAaXmsaY3yaEHhH3AJB02ygRG99obGn12wTBgII0ht4i4h4AXlwbfwVdvrvUZ0vSl7X7K/w2QTBg9bYrWCPiHgBqmuKvoPvK6ny2JL2Q0WFw2Xa02m8TQo+Iu880x9qsCwlCmrFsp7zF9hZLcSeicUS0lIi2E9FWIvpeD2XmEVEVEW1I/LvHHXOjR01jx+tncUWDj5YIghAlOHuoxgD8SCm1nojyAKwjosVKqa6xYyuUUlfqN1EQBEGwi+XIXSl1VCm1PvFzDYDtAMa4bZgguI1EJwlRxpbPnYgKAMwG8FEPH59LRBuJ6G0imqnBNkFwlTZRdyHCcNwyAAAiGgDg7wC+r5TqOpW9HsAEpVQtEV0O4BUAU3qo4xYAtwDA+PHjHRsdJWKyksY3nlqxz28TBME1WCN3IspGXNj/opT6R9fPlVLVSqnaxM9vAcgmouE9lFuolJqrlJqbn5/fS9OjwT8/Puy3CWnLH1fs9dsEwSFtbUoWnlnAiZYhAE8B2K6U+l2KMiMT5UBEZyfqlUQpDF7feMRvE9KWalniHlrueW0Lpt/9DtrkzTclHLfMJwF8FcBmItqQ+NtdAMYDgFLqcQDXAriNiGIAGgAsUEocmhy2HpHFGoJglz+vlj0SrLAUd6XUB4B5Ziul1CMAHtFllCAIAgerdNrpjKxQFQRBiCAi7oIgBAKZINWLiLsgMPhobzkWLt/jtxmRpslBniUSv0xK2HHugpCutLS24UsLVwMAZo0ehPNO7hblK+jAQQhGSU0jRuTl6rclAsjIXRAsaDFsx1checZdw0kKZsmqmhoRd0GwwBjUK14A93ASPC0B16kRcRcEG/z1I4mvDhKvb5JFgKkQcRcEC4yDww+KynyzI+rUNtlfMfzYMpnkToWIuyAIgWB3SY3t79RIComUiLgLggWSScMb5DLrRcRdEIRAIOKuFxF3QRACgWi7XkTcBUEIBOL+0ouIuyBY4CSKQ7CPSLteRNwFwYL9ZfV+m5AWyMBdLyLugmDBS4WH/DYhTRB114mIuyBYUFrb5LcJaYGM3PUi4u4Bp48b7LcJghB4RNv1IuLuAS2SuS7UtMmQUgghIu4esO2obIIdZtqkb/aEqScN8NuESCHinuZsOVzF2t7sSGUD2trScwTbKiN3T8iQfMpaEXFPY8pqm3DlHz7Aj1/eZFquuKIe5z34Ph5asssjy4KFLK7xhqhd5fkPr8Cd/9js2/FF3B2weNtxPLq0yG8zek1dYnHOhkOVpuWOV8ejRZbuLHHdpiCSpi8sQgoOltdjX1mdZbntR6vx/Br/8v/LHqoOuPm5QgDAty462WdLegd3QLr7eDwV65bD6Tl3IM4CwcgFv14KANj/4BU+W2JOqEfub2w6gkt+u8xvM0KPlauzvK7ZG0MCyvxTR/ltgiDYJtTi/u2/fow9pdavR8eqGrHuwAkPLAoPz63aj3m/WcYqG1Wf86hBuaxy2ZnBHrsv21mC2fe/i1c3HEZJdaPf5jgmoo+Zb4Ra3JNYic8lv12GLzy2yiNrwsE9r25ll41qoztzwhC/TdDCr97ZiYr6FnzvhQ1YsHC13+Y4Zv3BCr9NiBSW4k5E44hoKRFtJ6KtRPS9HsoQEf2eiIqIaBMRzXHHXGfUNVuH+qUzB8pTJ8YqqWnEmv3RfOvh9llBDwHNMLTiQxXhTXL2y7e2+22CNgoD0GY4E6oxAD9SSq0nojwA64hosVJqm6HMfABTEv/OAfBY4n9PUMrabyw44+wH3vPbBNfIzcpklQu2tHeODydpCL5zsLwe1z7uv6fAcuSulDqqlFqf+LkGwHYAY7oUuxrAcyrOagCDiUhmoYRAc86koaxyfrulvvjEKryz5WjKz42C3qwx1UVpTVPg31qCyMIVe/w2AYBNnzsRFQCYDeCjLh+NAWDMi1qM7h0AiOgWIiokosLS0lJ7lpqQLo9frLUNBXe8iSf+FYyHR/CGNftO4NY/r0/5uRu5i0qqG3HWA0sCuXBNZwdmh1hrGx5ntL2ymmBEl7HFnYgGAPg7gO8rpboGPPf0LthNc5VSC5VSc5VSc/Pz8+1ZakJUozm60pR4qB9+b7dpOaUUfvvuTuxKxKcLvcOvp2vZzhIU3PGmZTk3chclF669v8O7hWvc61zf7M/OWM+s3I8H397hy7GdwBJ3IspGXNj/opT6Rw9FigGMM/w+FsCR3psnOKG6IYY/vF+ETz+03G9Tgg1TTfwaPLwYgE1CvHThB90F9OtFO/02wRacaBkC8BSA7Uqp36Uo9hqAryWiZj4BoEopldpJqJlgPxLes1NG7Frx68XQzxdSZaNVrdl3Ak0x7yLSyKU1w39efcA0rUjYHAScaJlPAvgqgM1EtCHxt7sAjAcApdTjAN4CcDmAIgD1AL6u31QhSb1FaKfkH+fBFTC/rqefK4OTp2yVqXH38Rp88YlVuP6c8XjgmlM9sMw9fvrKFgC9Tytip2N0E0txV0p9AIv0Gir+3votXUZxKDbE86aLlpUxtnv7r7e2Y+HyvR5Ykz745S1Ys8+/WOnkKVuNkSvqWwDA2/kdFwbuDZy1MCGLMg3tClVjVrag9JRBQIRdP5X1wYh+8BI/5hn8asVHKhtwyj3vaKvPLbeRXUIr7kt36AulFMJDrLUNq/eWa6mLq19PRKzDvP2ljdhyuMq0TPulsXDLaO0EmFXpnuQ9eCK8q3rNCK24p6NbJoy8t/04Cu54EzWNLablqhtb8J/PFiLWah7D/LvFu7Bg4WqsOxDuPCRltU0ouONN/Ox1fo4fHdQ2xfDSumJc+YcPTMt1+Nw9MCoBd27jcEWD1uM2RXSP49CKuxtbclU1tOCgSZ4VwT43PRvPff/syv2m5U67710s2X7ccueawoSol9ZYzz9Y4deYoDnWhq88GV8H+KcP93t67NZW7lnHy3npYDBaNmZw35TljlbpFffHl/EWBXIXTwXFTRxecXfB8ssfXtGeiF/Qy8ZiczdAkqLSWtPPk5OMVm6FIPPLt7djxzF/wlW5wmP3bdhLP7PuY5XUhDdNshmhFXc3HqbDlXpHBHa58bwC08+DMlHjhMXbjrPKcc+wTsMqxR0urOzk8JeP/Nt6jRv5kyzGfUPWMVr1y72a5cZIMQCE96wMz9xexoYdQrRo1RCf+OyqAxossY9fuVEA/gRocrWolytU2R2EZpsyvZxY8JDQirvxdvz3O+HJ9xBEgrTTEHdyS4e4pyN2rxr3bdHLt0rd8226O7CgvGGHV9zTLG/10aoGvL7JnXQ9E4f3d6VeJ2w9wnOVyCpcZ3Cvm71pVz1wb6nulq+7s5AJ1V5ivB3HQ7xv5M3/NhEAMKhvtmm5Lz2x2rXERbuOm09iBpEYO+rDeyrrm311veig/Q0qgGMo3eO6DHHLBAvjDd5fHjyf+7VnjmWVy8rMQE6m9W04VhXeDswNrKT90Il6/PjljWixiJt3gzPuX4ybnyv0/LgsmH3iDU+vAWCdAkFn1NKk/AGscrpH2lki7sHCeIPN3K+PvG+e+9wt+udkYkAfTl42Hs0+iFSQsXIv/PjlTXixsBhrmflZ5s8aqcOsdv61K5grqHVPVfziTX37np4xbnD7z2YTv7rFXbe2B2WCNrTibsRscm3ZzmA2MqF3iMvdGa7FdHuoZ7q1U/f8nZ8J34yEVtyNt8NsFGf8xJhszAuC0X9HE6uR+6pE/pnaJl48fLp0FhsPVbpTMeP61TfHLEIxeTfBro+8rU2ZbgSSqXtCNSDPUmjF3aicZhfT+DDpzkkh+AfXvVCiIU1BlPj5G/rcKHbYX1aHGfcswt/Wpt5dyq1omU/+9/uY84vFKT/X7UYJSiBfaMXdid8tzFE1Thg7JHV+jrCTLvvm6satuRureotK4hFZZiuV2eJus+0frWpEZX3qxHVccecGSQSF0Io79/ZWN3a8li/ZzlsCb4atfR597sGLQ/Km4kSouV+RTsAbyuvM35BaE/ehRcOMrvZFR8z6AjIgZxNaceeO3I1hhmbtvLGl1VAudUHdmxaL9jhD/2IcuRFu8lKi3SxnRhGZ3Q2/FjHxn5BgdAOhFXdub/vZ00e3/2zWgKsaOl7bzF4xV+wuYx1XwcYtDsaz4BtOOjiuuNt60xIcY3U7qht6n+gtie7oFq5bRvfEq9tEXtyN64PMHsDXNx5hlbMjxOmWIsEpTuSXq9mi7d5g5tPWje5WxV3EFLaVrKEVdye32Kyh77HII97TUcWfqwdnPne9115uZe+wDDllNFeua8yv9AM7j3FTRAfjYQqtuJ82dhCrXOcMbakvOneUbSwnguAfdvOSe0FVfQue+mCfh0dMT4wrvyfl9z7pHbevOF4drrBafevjPWZY/xxWOW4v78Q3a/UN8crwcCLAMeb98vLt6s5/bsJbm495drwk/XIyUd/cal0wRHg5cOIP7Hj1BWXQF9qRO/eGGC+02UV/wWRxReq6A3IXQ46Ty9jCzLroZWpgL/3ORkYOzPXluHYI8jiH60rnRtW0BkQXQivujvy07Lp55YKSQyLsOAlD5GZ7ZMfD27agOyv3lGuoxQFBVs4EHF10pIkabhxXtLmdwLmThvXCGn2EVtxrGnmhVcb7xu0QzMTGeH/v+udm82OzjiY4adRct4xuLpqW78txzYjKNpN+bBBiB24ncO7kkIg7ET1NRCVEtCXF5/OIqIqINiT+3aPfzJ6Oa/87Oh6Kznnk6zXUKDiBHeeuWQmyGLn3BWcExJuREjfn79yAM6H6DIBHADxnUmaFUupKLRYxcZJbxsuHJ+gPapBwcxGTrDwNBjr3FdXdtrhSojuPvNtYDkOUUssBBM657GTmuqGFF1Fg9vC8uoG/j6ksYuLhRID5uWWsyxBJZ+w2du8xt7yO28YV7T7Z4Xpr02XtuUS0kYjeJqKZmurUDncCNCiz3emCs5E7t27rgna6YHk0nLF6r3Xbs9sBcDR53YEKW3Wa8YU56ZcVcj2ACUqp0wH8AcArqQoS0S1EVEhEhaWlvdshyc1R8Ts+xCqnM9wmXVbbsYiEPTkuYhxB+Df1C4+ttCzDVZLc7ExWuaA8cr0Wd6VUtVKqNvHzWwCyiWh4irILlVJzlVJz8/N7F3WgI/IlFbJfqbdw72WtIULKzOde39xRjlNzfKDQ+yZ58fQRva5D4KNreMcdJ/bL4Yl7UOi1uBPRSEoMo4no7ESdrgf8/uWjg67VHZSeV+iMUdDN9s1tMKzW5Ey86hIJbn4iQR9mA4NG5hwb1+feL4e3oD8ob4ucUMjnAawCMI2IionoJiK6lYhuTRS5FsAWItoI4PcAFigPlm6WMHdVcrYwIiB3J03gXm2jnnN97iuLdI8zUh/4gITGasN868z4/1au2Z3HaljHiupmHZZdkVLqOovPH0E8VNJT3FzwYDYqdIuqhha8VHgI910V2Plo1+D3pR0FuaGQa/YHLtBLSIXNZmcltrpTT4Qt+C1csT0GuPftSKX9reZ0aLsTX39dxJI/sXEQ1qhzlJxBJC9rIcXstq0/WMmqgxucwXXfDOqbzSrnNqEVd26v/NyqA7br3l+uZzl3yDp63+B2hK69UMmNCgR238attHbDIaa4M4/LLTi4n4h7r3BzpOWkQ3BKEFZQnjlhiK/H5yf34m7mIGodRuxO1Vmteq2z2kAkAXdEHranKrTiHiX8fmiC8hppRZuLEaq6M4YK/qN9ty72cbUe1jEi7oLv8F/H3Wk1fneuQhyV4udu5dr9MuZCynXjRfVFL7Ti7uUmDFHH72db92pTu+cT1cYddXRFy+i+/UFRptCKe1amtMio4Pfrrs6MhYL76H6Di+ocTWjFvbLOny3NBP3onlB1ZkNQxlsCFytN9uvtPijPUmjFvYY5Ey5Y4/ejyE7vyjS0utFex28lEj+4dCoAYNSgXN+vldAZs2eHOwEfFDHWTWjFPehE9HlxB+a14o7E7O6QZfVSPqR/PJoobJs1hA3uZvbt6Qcs7tzIQcHfONxNIiHuukP5dLXhsGgBd+Nft3CSW8a0Prvx0mG5UUInrG7bnPGDvTGkC0EZ10VC3HW3zcn5A/RWGHBOG8trBH2Z+aztwveNurc7T1AapBM+MWmo3yYEkjDfUx1EQ9w115duYZbc6zdrzEBXjs8fkTMr1JyAKgj0yUrdVLMjsmm33agpAs99Y4XutBZBkY9IPBW6X6uDcnN6Sw6z0XNP97JZo5wbY3Z89sYrPNzsnP2afMsy8Z1Fxa2k252W7puoR0LcdWB0OURl9vy0sYO01ueWhLBHWMwhlu2RWAg2yDabzPV7zkQXum+BD5m7AQCZAbkhkRD3Wy6Y1Os68nI7Utv79VDoJiynwY9z59ZnNwFV8DEbpOZmhWv7Nx6p72FypG3tlglLC3CHSIj7gD687a/M+M7FJ7f/7MdmHW4wexxvotTvNsB+fXbJhxoGt4aZjVNH5nloSYCwuG1++dyDQiTEXce9Me6PqKPHD8LzkmMyCecFun3p/Bw0dn23/LI67uuMUfYnpkPQ/wQO3YOGQDRqG0RC3HUz3UHj65lwtEj2ClGXjs9thOyoGgc2cLIQ6hLYguH92n8emMt76zRdQOX3q5fHpPuInIuIewJj28mOSFIyv0d7bF+65qgGu9Ey3Mukb3FbR0XcybeAzNG5i+YQ1nQLae5KNMRdhxuFufRZ4KN75Sm3XHGFvX1zvfa5G0fh7F2A/O6pPYbTBq2uiUyoCt345MnDWeVG5PVx2RJv8LsN7DxWwyrHbawn6pp7Y47rGCWJvzlz6s/SW8JSk5fLS0uifccmvxtUgkiIu+5LOW5oX++OG4znwBXqmnmZO1taeen7uJfKSbST7g1DzDAKtdnipM7fSa+ROwerS8LdGzggWqydSIi7X+h6KNxqt9xNKNyKH+duUDxyIC97H/f4rvncNU2QG0fr3HtvJu52TtduColRAcys2Dn9QESVWQMi7gmMj8jyXWWs7/iVdc6M+bNG+m1CO9wBNP/1mVffsP45vII+YVwwd7SqkfUdXQOAZCfBdSn2zfFugZTtTlneZkyJhLjr7rxfLDzEKve52WNSfubXgGKgQSj9fvb56QL0ukSGDbA3F+K1SIwe3OH246arHtJPT4cV5IGuX7ZFNaomEuK+t7RWa326/Jt+iyt/cYY7DzfX9+0kIdhN509klePg530aNoAn2hOG9Uv5mZ3EV8myQZcz03UHxvQDLh8rzFiKOxE9TUQlRLQlxedERL8noiIi2kREc/Sbac6zqw5orY/b2CPa4WuDvzjJfidgNhFpO/2AjbJaxMRQSeAdCwF+xv0ePAUdzsj9GQCXmXw+H8CUxL9bADzWe7O858W1Ha4YiUzQA9/dYr+c2Te47iC7ROGxCPKARHfq3SCfqxdYirtSajmAEyZFrgbwnIqzGsBgInIn8beLrNnfcYo6EpHpZrhNP7Id3GoDzAjHTiPtz50xOmW5Z1buZ9Zn3y3jlxDo8PfbsT1ZNszCp9v2MF8LM3T43McAMM5AFif+1g0iuoWIComosLS0VMOh3eF7l05hlfMyyX9ZbZNnx9IF2+fOvIxr91cYvpP6S/bdMsFf6ahr0vd4NS86JxyQFmHWvohJa23O0SHuPT11PZ6fUmqhUmquUmpufn6+hkO7Q65Le4V6DTshmEtPo26f+8zRvBhtt8TYjrxyc8Z47ekpb1+962+yOMvjMu5hFNxkbqJD3IsBjDP8PhbAEQ31+kYQRmpRgDty54r7dGbe8iBss2dWzskbn5mOBeFpPXmEd5vK+9bhBOJK89Eh7q8B+FoiauYTAKqUUkc11CuEnFbNWywZ+wqzqp3Mp3Iarhvx8FEZfXLTKJhht0+OyKVzDcuZQyJ6HsA8AMOJqBjAvQCyAUAp9TiAtwBcDqAIQD2Ar7tlbNAwfxjD08u75b7RveepbjdPEjfS6XIt0JHSwMmLSlReTs2eXbdSRIcFS3FXSl1n8bkC8C1tFkUIP0YWQXp1dOKWMV28Yhy5M8txcGNEHhW98NJFaTfHka7bFpFb1Y1IrFAVeodb7dfNFao6jtvJhqi2cIecNND7dNb23TLimDFDxL0HNLuKfcNvweL63LlbzXFFu6GllVXOLrqkpNMKVQ2VOnlbs/qG38+OefoBgYOIu+AaXDEeysziyN0t6/k1B1n1JQnDpKbXNuoUUL5rx5/FZ1FdFCXibpPB/XhZ/MKEW8+i7myP3PqaY8ylsWmMleDqFCi3xE5XfxfVCVUR9x4we839xgWTO8pF9KFIhd3X/1ir3uvTeeI1dd12fe5+ph/Qgiu2K1tVm10/40dnFwx1bBHnWE7KRRURd8E1nGR7NPsKP1eNTXG3MQb0SzAOnaj39Hh6R+4urRgmEv+7CSLuPeClH8/Nh1PHqKs3cAfQlfXcDa31xs1zaa/OBb83Nwxz/cFKrce1nFDVeKxOi898TomRToi428SOa4I7CRbVkC7uCPrFwmJmfR0/m69QdeCW4axQtVUr89ga6nBDB+2OtnUsJuIfUu8ZR7Ujiby4cxM4cYnig+DWwicn8eZm6J6gTRLNrrV3JC+h7rdYne1H3yKmCDZqpIG4f/diXvpeI1EUcD9YWVSutb6DLvmd3Vihyo3d9zLEsSnWEf9v9YzrbAO6O3kj3IncdCTy4u5m40m3TsDu+b63o4RbM6vU3tI6ewa4AHeUN25o6j1PjXgp7vY29dD3cHPTS3BJVud57H/I2nvkxd1RUiX9ZgQbl044TKGiHFPtjPBNR5QhuC7VjTFb5XVk6bR7VXTNVbVpXxYRjPsbeXHXTRgaZhK/TXXiI+dH+Og7OTdGgEF/Srx8jo1hnOY7aClWOd2Izz2kbD1SpbU+vwXTiiC9qbjoatWKnxOqelL+uujTNouCYR7X6OvXSXOsDRXsMNr0I3g7QWvm3W3HbX+Huz9nVHt8XXDzuQepQ9JF0N/wzKzj7zbFq8+4+Ix7VczcQsk6jkVqP1j9RH7krpuHluxilQtC2378X3u01mf3lMKSs8POSscgJqrSje4FeDlZ/shM0DtYtxFxd5GwLE7iNoK9pbW26o2aW8aVRUwBfER0z3uMyOvIDR9EvQ3Lc2oXEfce8HvZflDhriRNwh25rz9YYduWoF/7oNtn9pAb56nMzqOslufvdqs9aVvEFPR75RARd8E1cjJ5j9fuEt4bwdSTBrDKcfPDJyGCqQK52fgDOHBHfTNvAtQ4mWk2ijd+pvNSThkxAHl9Ij9t6BgR956IaE+eCrfEa86EIba/YyYSxpWOZpPZbmWFtJMamD3ZrmH4qfv+6d6I3K3NMMLi9vQLEfdeENXXuaDC3nDbJSeqrtTAQXhsTG3gdmDMcq3cjG82iSd86z26J16Dogsi7kIgxIbD/nJebpmgNK6wwr183LQCMZ9mLNm+flet8I/Ii/vn54yx/R2JX9eDm1fRTMBrmuwtnQf033NubX45Fsx95D3/3BWuZnM7ASehs+ke7mhG5MV9gIsTLqYLQaSDYDe8fEOonB+4kn6Aee5BDIXU7XNfst3+QkIzktfWjWyeUSLy4u4EXYOBsDx7rm1gzLwATi6TX11nVDrtuuZWxFLsW9jKnijlLVHdcbTGjmlsLIKc2DhZkRsGRNwF12A3GpftsILdCbkQV+3nTkwn6nqOU+dOSHM3QI8Z0i7q3qxDR31pvYiJiC4jop1EVEREd/Tw+Y1EVEpEGxL//lO/qcFDh78vCD5Dv0ejTrJCumlDusMVu+KKBla5zAx3xpBWnW2631PLq05EmQAeBTAfwAwA1xHRjB6K/k0pdUbi35Oa7ezGzf820bW6vX4mdLpvwvg8O5tI03d8N7xn7AlVD3133a5ZikNzBxzc+zbMsKjMPMskq7rO3wnlE+8NnC71bABFSqm9SqlmAC8AuNpds6zJzc702wRBE6ncA6EmxJrjZELVy9NNHksWMZnDEfcxAA4Zfi9O/K0rXyCiTUT0MhGN02KdBZxBj6PRgOaseEEn3V9fAd69LK9rZudT4RJEeRo5qC+r3JB+vDQPndIPBNLn7k8YrNtwxL2n56+r/a8DKFBKnQZgCYBne6yI6BYiKiSiwtLSUnuWCkIn9K505ByptKYJRcw8OGEIk0018s3N7pAFMxeNX6l8kwSxYwwSnLtTDMA4Eh8L4IixgFKqXCnVlPj1jwDO7KkipdRCpdRcpdTc/Px8J/Z2QufNPXXMII21CemOp9vEac53w66v02InE1+6g7qt6uypbqEzHHFfC2AKEU0kohwACwC8ZixARKMMv14FYLs+E3tGd9uZctKA9iyG3EZgFgomrg5nvLlGjdZzAAAXKElEQVTpKKtcmK9vp1BIH4efqY5tdFMcqUq92xG3nbQwQyZtdz6WFy/ED4kGLMVdKRUD8G0AixAX7ReVUluJ6H4iuipR7LtEtJWINgL4LoAb3TLYiPZIA5vV3fXPzTqrEywwugF0+knjvlu/0g8E7ynhXoq2ntdAdeOdLR0dtp2rbGUH2a0wBWHZMcwuLKeZUuotpdRUpdRkpdQDib/do5R6LfHznUqpmUqp05VSFymldrhptJ/08dnP6AZuuRCumW0/r48pBjPtbhxihhsCG/SskGZ0jURL9XxwRZE9cu9SzKp+2azDnNAqlZuTUmY3+1MzTnLtuBzGDO6LL8wZ66sNXPJys7XW59Y9D6JrxClmm1d0fa5THdo4odrT99r/nuJnM7gJy7h1BmVyOoiEehsT3W0yeC/IPWP1QI8Z3BeHK3mrBwf30yvAbuLWMvGqhhbtdZreI4OK9dG0XiOvTxbyB/bBKaMGaqnPSKoz4edk6Si341jqPDNdr1nqTiWROIx19PQl1OLOgd2zq45RVJDHAq5kMNRfZbxeze+7bvlGDzDzxNvB0l9MwOljB+tJYWEUOxcuUdzG7g+esbN14xpau2Uosi4VHYTXLePCTW33vTLDunwj4Evv3SIqDZkd7GEHSoid2fL+rl/ppQF+L/azjJXhTgxrTnAXlOc0tOIO6B/FNidSoP5q0U69FWtE19ZiRoLyMEYJVqSHZtzqqFOdittRJpzqdVgQ1ec/1OKum+RejzWNJjv5+D5a0duE3UxcpfsaXHHqKOtCIcBNMXGj7lR1ui3uVnnlw7Jfgl+EVtzD0Nm6JZx2Ig6ixLxpvV/VHBSI9Adg2s21wj1+byNSnKx4BUw6j8SfCRSIlNlBJbTiDgRzAYjbuOKWCUVX6R9OBMR8Ob5LIZ2w8Lk73HHIr5G7ZfUS525KqMVdN6wskz4LYZjCP6PaaHRAANYfrMSK3WW9rit5nW2P3Ht587krVM+dPMxh/b3LLcOeAI3o4Ca04u70Vc+MjJA48dJVNLmnPaiv/7H7GRmpnyV3Ir0SdeuvOiXckXt2prN2ZRkKifRtCxxCK+4AtA87TdpjO34/TPFwN734fU66uW3eZFvlzz95OKaMGKDVhuED+ph+7sY4wr05nhR/132cLr+nGrgn/xyL6uanmgi3uGvGDx++XWGNj1b0PdQheVmxhd1T0j2PMX1knunnbkqSnZw2vU0V7NSHn7pc1xWq5l9cd6ACAFDfbBLd5oDetq+guHlCK+5uXEC/hM7WYUO0QlV7zS6GoXoddeHGQCJeo/7zSD2hyvy+w+Ny669vbjX9/LSxg0xdQ12PE5UXgtCKO6Bf5zIZfpkguDB0mlDdGENTC3NmLCTYfhvS7Oqyqs+tZ0jXtnNc3Jj3MsLey9VCja1Xsnb+flRSAIda3HWjs7NwrQEDWtW9OdaGv6/Xlz43CNh9q9N9TVnPkSs+d3fewnq/QtWZVa3MIXQq37txUw877VHEPYJwJqT89qe5uaJUN7rbiO5t4pJkaBZFsgjjcMelSJauHicpdePf653P3SkpJ3K7/N2qEyDYu7/8zUqC3QmENyuki+FkOpmU3x8zNKdh9buDiRrx7ILeTlITgAum5mtPN8w5jwnD+tnK4ph65M61yVk5tluGkabA7Lp097nzj5sR4IWUoR658xYd8VCAayt6tI4KEQy/vx84jbqwwu7IrtckDpah+WZy3TJ2D5l6BM18k7J3ONvfsxq5f3ywEm3K5A2ky+8pQzC7+eaZBvpEqMWdS3J3GrNdagCetjsJXdTqz6Xw+ASTVo4f2g8Th/f37ri2J1TdcCFZH5OgVyAs+4rEZwdPxEftR5gbuqSCP3J31+duFS2TpJEZOMA9btDbYWjF3c5l7ZOdiZysDHz5E+NNy7nhz7bKsW2XXcdrsWjr8ZSfB9Flk51JyOKsENOE3Sug+x5Z+r5dOi5sRv3sLavjFUwZCunuyH1fCvu6XrOmGE/cm2N6xT3oUWbh9bnDXqywLmlRAE4a2AfHq5tYoZN+uFFCNOdqC/4EoL16Cfw8KRw2H65iHJO0PRvJkbHdBW6tzJP2a8BQ08ibj2iO8SZ8m1pbAXRPTdG1XGMLr7MorW3CoB62qQzKgD60I3c34Iri0P7xpeW3XjiJVWdQbrbXdCS00p8yQSfrDlSw95zVQbsYa9wmjgjYcMheIjJuh9bbrJBOd0TiDJ4AfrtNNdLuat+m4kpWfTGLC2i1UtltQjtyd+TH06gwVg9ex76Wml+9Q4jXE5Z2r3d5XbNLlqSGCFiyPbV7zQ26XherzTA6vtczuleodi03ZnBf3veYB2hiumW45xVrNS84alCuK3vLcgn1yN2O+0GXq6J9NMo8ZlhH7tWNLXjPY/Gxwu0VkV4RFPus4rQLhvUz/z575O7shIdZJF9L0tDCyy3D9c1zfe652ebyqX1OxSahFnfdcH1t7elVGfdtx7EavLstLpJbDlfhzn9sCsXuMT94YQNuerawV3X49WCnOuqJumbt7pcdx6rZYmBEx1hjc3EVth2pdvx9q5WdydTJqRcxOT40i5ysnuWp63GX7+K5ovgj9+4nVtPYglv+b12nv+VmZ1rWw43QcYNQumX2lNbijyv2scom71NjSxueWL4Xd15+SsqyLRavWYkaAdh/E1i6swRf/9NaAMDYIf1w24WTU+b83lxchZfXHcJzqw9g/qyR+NlVs0xsbkNmwqfdk6vof5bswvcvndr+e2NLK/aU1nYr9/n//RDrD1bilW99EhsPVeK9HSU9Hq+xpRXZmRmob46hujHGenXeXRI/XlOsFQRK2Wid0NjSiqaWNgzsm4Vlu0oxb2p+t9Z/rKoR2ZmEuQ8sgVLA/gev6FGw2toUqhpaMKR/Tru92RndbTXeyyTv/uCC9p+H9s/BibpmlNc2obVNIT8vPgL9w/tFKBjeH09+sA/9c8yFYe3+E93+FmttQ11za7vofvaRDwAAX5o7zrSuVCiloJTC798rwlVnjO4WrpoMMVSIR5ocqqjH2CF9kZOZgfrmVvy6y0bySilbEWfvbDmG/LwcnDlhKABg17GaTp8n3ywWbT2GPlkZmDdtRI/1JDe2B4DSmias2F2KOeOHdOt0u0bL1DfHMOOeRd3qa21TKCqpwaW/W47bPzMNQ/rlYF9Z9zbz5Ip9uOG8AuRmZyA3KxPHqhuRnZmBloQ9y3aWAgD2ltZi/NB++KCoDHVNrbjiNG/2AibOKJKILgPwMIBMAE8qpR7s8nkfAM8BOBNAOYAvKaX2m9U5d+5cVVjobGRYcMeb3f62/u5P4aevbMbBE/W477MzMX5YPzz49g5kEGHxtuPdVgL+/HOzcO2csSiuqEdtUwzPrTqAVXvKcay6EQDw0q3n4khlAx54czv+65pT0dLahlc2HMairccxY9RAbDtajfy8Pnjgc7PQFGvDh0VluPGTBdh6uBo7j9dg3YEKHK9uRHGFvZHimMF9WaPLC6fm4xsXTMKXn/yo/W/jhvbFoRM9f7dvdiYamG8mdtnys88gK4OwqbgKZ08c2v73NzYdwbf/+nG38jedPxEbDlW2p2w148vnjEdJdRPmTBiMD3aXYeWe8vbPnr/5E7juj6s7lc/rk4WappipO+z2z0zDwNws3P3q1k5/Hzukr+37pYtpJ+XhaFUDJg7vj43F1tE2Zqz5ySUYkZfb7e8Vdc2Y/fPF7b//9IpTcNrYwfjiE6s6lfvuJVPw+/d22z7uwq+e2T66nTctH8t2lmLaSXnYebzG4ps83vjO+Zg1ZhD+tasUNzy9xnE937hgEkYOysXPXt+mxS4n3H3lDNx0/kRH3yWidUqpuZblrMSdiDIB7ALwKQDFANYCuE4ptc1Q5psATlNK3UpECwBco5T6klm9TsX97+uK8aOXNtr+nuA9Ohu2YI8/ff0szB43GM+uPICLp49AeV0TJg7vjwt/vcxv04QE+x+8wtH3uOLOccucDaBIKbU3UfELAK4GYOz2rgZwX+LnlwE8QkSkXHAu3/3qFt1VCi4hwu4fRrfRQ0t2+WiJ4Bcc5+cYAIcMvxcn/tZjGaVUDEAVAGe74lrAXWosCIKQznDEvacZkq4jck4ZENEtRFRIRIWlpaUc+wRBEAQHcMS9GIBxOn4sgCOpyhBRFoBBALpN9yulFiql5iql5ubn5zuzWBAEQbCEI+5rAUwhoolElANgAYDXupR5DcANiZ+vBfC+G/52AJ4moBIEI//9hVP9NiEtGJYIRQ0qY4fwVs5Oyk+dCfWx6+foMiclluKe8KF/G8AiANsBvKiU2kpE9xPRVYliTwEYRkRFAH4I4A63DF591yXtP8+fNdKtw2hj2km8/BKfn911GqM7A3P9WZYwb1rv3rIWnOUsDru3rLrzYla5ogfm49xJ5lNEH9/9KXzpLPOsogDwzXmTWce0w8Z7Pm1Z5uozRms/7ub7rI8LAHddPt308+kj8/Dsf5yNPsz1DY98eQ4euCb12o4ki39wAZ6+sXPQSNcY8ie+eibW/OQSWHHT+RNx/TnW9/f0cYOx/PaLuv39s6ePxoxRA9sHAH+68Sw8dcNZAIDLZnbo1CmjBuKq00fjMg+0ixXn7ga9iXNfuacMX3nyI2y7/zIs21mCW/+8HkB8OfCd80/Bva/F45eH9c9BeV0zfv65WRjaLwff+mu83G/+/XS8s+VYe26P+6+eiXte3Yo/ff0sNDS34pt/WY+BuVkY2Dcb9352Jt7fUYLn1xzEjFEDcfH0Ebh13mQ8tqwIjy7dY2nr/gevwKNLizot+Lhm9hj88+PDAIAnvzYXl844qf2z3y3ehRvOnYD7Xt+G1zd2eL/65WRi7U8uxcx744suHl5wBg6W1+PiU0Zg5MBcnPmLJfj552bh8lkjUdMYw7zfLGv/7t9vOxfPrzmEM8YNxk9fiUcbXTg1H18+Zzy+kYhLXvfTS3GkshED+2bh9Y1H8Jt3OyIsbv/MNFQ1tGDh8r1Y9v/mYXC/bJxxf0e8tBUr77gY5z34fvvvZ08cistmjsTbW47ixvMm4n+W7MLLt56HzYer8JWnOuL2775yBibn98e8aSOglMK2o9WYOXoQlFKYeOdbKY+3/PaLMD6xdH770WrMf3hF+2ePfnkOYm1t+N4LGwB0D0fbdbwGn35oOTIIWPzDC9HWpjDF0EG3tilMvqvnYyfr+rCoDNcb1h90Zcaogbjp/InIycrAyj1l+OXnT8OafScwalAuqhtbMHZIPzTH2lDbFOsxD35dUwzbj1Yj1qaw7kAFvjlvMogIq/eWY8HC1T0csTP3fnYGlmw/jg+L4msGPjPzJDx2/ZmoqG9GUUktcrIy8Mamo7j7yhmd1pRcesoIPP6VM9GqFHIyM7B0ZwkunDoCmRmEyx9egW1Hq/HY9XMw/9RRUEqhor4FQw2j8LY2hase/QBbDsdX1WZlEGJtCtfMHoOzCobirn9uxsXTR+DpG89q/059cwybi6tw/ZMfdVtRm7zezbE2ZGYQMjMIsdY2zLx3Ee6/emanzth4Hot/cAGmnJSHXcdrsGxnCT4zcyQmDOsPpRRKa5uQP6APmmJtePDtHXhm5X4AwJQRA7C7pBZXnT4av79utuU1dhNtce5u0Rtxt6Kstgn9c7LQ12IVoC6OVTViSP9s9Mnq+XhV9S04/f53AcQ7nFV3XoKNxZUYPqCP6SYWLxUewoiBubhwasfIOfmQWsXILtp6DPe+uhU/+NSUTg/5rHsXobYphs33fRp5udl4a/NRNMVacc3ssT3a+9j1c3DZrJHdVh4ermxAQ3MMJ4/IQ3VjC5bvKsXowX0xe9xgAPG8Gmv2ncDcCUOQkUFobGlFS2sb8nK7p0jtdr0aWkAEDDQpa8ys6DXJe2BccPanr5+FiwwrKKvqWzAgN6t91XB5bRM7V0pveHPTUeTlZuGsgqHYdrQKM0cPAhBfyVvf3IqGllZMzh/QXn7joUpMG5lnuZTeiqqGFry9+SgWnG09+k2ilEKsTSE7k79ied2BCswaMzBlW9NNsqP+1bWn4ccvb8Kd86fjGxfqfzuzQ1qLexBZtPUY5k4Y0usGfqC8DqU1TZhbMNS6cA+c/cASlNQ0tYt7Kv53WRGOVTXi/qutX4/TjZrGFhRXNOCUUQOx7kAFzhg3mJ2eVggv245UY/rIvJRpQ7xCxF3okb2l8Z2cbnPBNywIgvvoXKEqRIhJ+QNw27wB1gUFQQg1kvJXEAQhgoi4C4IgRBARd0EQhAgi4i4IghBBRNwFQRAiiIi7IAhCBBFxFwRBiCAi7oIgCBHEtxWqRFQK4IDDrw8HUKbRnDCS7tcg3c8fkGuQruc/QSllmarVN3HvDURUyFl+G2XS/Rqk+/kDcg3S/fytELeMIAhCBBFxFwRBiCBhFfeFfhsQANL9GqT7+QNyDdL9/E0Jpc9dEARBMCesI3dBEATBhECLOxFdRkQ7iaiIiLptuk1EfYjob4nPPyKiAu+tdBfGNfghEW0jok1E9B4RTfDDTrewOn9DuWuJSBFR5KInONeAiL6YeA62EtFfvbbRTRhtYDwRLSWijxPt4HI/7AwcSqlA/gOQCWAPgEkAcgBsBDCjS5lvAng88fMCAH/z224frsFFAPolfr4tSteAc/6JcnkAlgNYDWCu33b78AxMAfAxgCGJ30f4bbfH578QwG2Jn2cA2O+33UH4F+SR+9kAipRSe5VSzQBeAHB1lzJXA3g28fPLAC4hP3ZMdg/La6CUWqqUqk/8uhrAWEQHzjMAAD8H8CsAjV4a5xGca3AzgEeVUhUAoJQq8dhGN+GcvwIwMPHzIABHPLQvsARZ3McAOGT4vTjxtx7LKKViAKoADPPEOm/gXAMjNwF421WLvMXy/IloNoBxSqk3vDTMQzjPwFQAU4noQyJaTUSXeWad+3DO/z4AXyGiYgBvAfiON6YFmyDvodrTCLxraA+nTJhhnx8RfQXAXAAXumqRt5iePxFlAHgIwI1eGeQDnGcgC3HXzDzE39xWENEspVSly7Z5Aef8rwPwjFLqt0R0LoD/S5x/m/vmBZcgj9yLAYwz/D4W3V+32ssQURbir2QnPLHOGzjXAER0KYCfALhKKdXkkW1eYHX+eQBmAVhGRPsBfALAaxGbVOW2g1eVUi1KqX0AdiIu9lGAc/43AXgRAJRSqwDkIp53Jq0JsrivBTCFiCYSUQ7iE6avdSnzGoAbEj9fC+B9lZhViQiW1yDhlngCcWGPkq8VsDh/pVSVUmq4UqpAKVWA+JzDVUqpQn/MdQVOO3gF8Yl1ENFwxN00ez210j04538QwCUAQESnIC7upZ5aGUACK+4JH/q3ASwCsB3Ai0qprUR0PxFdlSj2FIBhRFQE4IcAUobKhRHmNfg1gAEAXiKiDUTU9cEPLczzjzTMa7AIQDkRbQOwFMDtSqlyfyzWC/P8fwTgZiLaCOB5ADdGbJDnCFmhKgiCEEECO3IXBEEQnCPiLgiCEEFE3AVBECKIiLsgCEIEEXEXBEHwACJ6mohKiGgLo+xDiei3DUS0i4hsL0iTaBlBEAQPIKILANQCeE4pNcvG974DYLZS6j/sHE9G7oIgCB6glFqOLivoiWgyEb1DROuIaAURTe/hq9chHr9viyDnlhEEQYg6CwHcqpTaTUTnAPhfABcnP0zszzARwPt2KxZxFwRB8AEiGgDgPMRXlyf/3KdLsQUAXlZKtdqtX8RdEATBHzIAVCqlzjApswDAt5xWLgiCIHiMUqoawD4i+ncAoDinJz8nomkAhgBY5aR+EXdBEAQPIKLnERfqaURUTEQ3AbgewE2JpGdb0XmXqesAvOA0CZqEQgqCIEQQGbkLgiBEEBF3QRCECCLiLgiCEEFE3AVBECKIiLsgCEIEEXEXBEGIICLugiAIEUTEXRAEIYL8f96FBP4F1p1BAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(flow_baselined)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": [ + "plt.plot(raw_plume['plume'][0]/max(raw_plume['plume'][0]))\n", + "for i in avg_chans:\n", + " plt.plot(i/max(i))" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": [ + "plt.plot(1-(raw_plume['plume'][0]/max(raw_plume['plume'][0])))\n", + "for i in avg_anti_chans:\n", + " plt.plot(i/max(i))" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": [ + "plt.plot(output[1], output[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + } + ], + "source": [ + "\n", + "print(len(bin(255)[2:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "00000000\n", + "00000001\n", + "00000010\n", + "00000011\n", + "00000100\n", + "00000101\n", + "00000110\n", + "00000111\n", + "00001000\n", + "00001001\n", + "00001010\n", + "00001011\n", + "00001100\n", + "00001101\n", + "00001110\n", + "00001111\n", + "00010000\n", + "00010001\n", + "00010010\n", + "00010011\n", + "00010100\n", + "00010101\n", + "00010110\n", + "00010111\n", + "00011000\n", + "00011001\n", + "00011010\n", + "00011011\n", + "00011100\n", + "00011101\n", + "00011110\n", + "00011111\n", + "00100000\n", + "00100001\n", + "00100010\n", + "00100011\n", + "00100100\n", + "00100101\n", + "00100110\n", + "00100111\n", + "00101000\n", + "00101001\n", + "00101010\n", + "00101011\n", + "00101100\n", + "00101101\n", + "00101110\n", + "00101111\n", + "00110000\n", + "00110001\n", + "00110010\n", + "00110011\n", + "00110100\n", + "00110101\n", + "00110110\n", + "00110111\n", + "00111000\n", + "00111001\n", + "00111010\n", + "00111011\n", + "00111100\n", + "00111101\n", + "00111110\n", + "00111111\n", + "01000000\n", + "01000001\n", + "01000010\n", + "01000011\n", + "01000100\n", + "01000101\n", + "01000110\n", + "01000111\n", + "01001000\n", + "01001001\n", + "01001010\n", + "01001011\n", + "01001100\n", + "01001101\n", + "01001110\n", + "01001111\n", + "01010000\n", + "01010001\n", + "01010010\n", + "01010011\n", + "01010100\n", + "01010101\n", + "01010110\n", + "01010111\n", + "01011000\n", + "01011001\n", + "01011010\n", + "01011011\n", + "01011100\n", + "01011101\n", + "01011110\n", + "01011111\n", + "01100000\n", + "01100001\n", + "01100010\n", + "01100011\n", + "01100100\n", + "01100101\n", + "01100110\n", + "01100111\n", + "01101000\n", + "01101001\n", + "01101010\n", + "01101011\n", + "01101100\n", + "01101101\n", + "01101110\n", + "01101111\n", + "01110000\n", + "01110001\n", + "01110010\n", + "01110011\n", + "01110100\n", + "01110101\n", + "01110110\n", + "01110111\n", + "01111000\n", + "01111001\n", + "01111010\n", + "01111011\n", + "01111100\n", + "01111101\n", + "01111110\n", + "01111111\n", + "10000000\n", + "10000001\n", + "10000010\n", + "10000011\n", + "10000100\n", + "10000101\n", + "10000110\n", + "10000111\n", + "10001000\n", + "10001001\n", + "10001010\n", + "10001011\n", + "10001100\n", + "10001101\n", + "10001110\n", + "10001111\n", + "10010000\n", + "10010001\n", + "10010010\n", + "10010011\n", + "10010100\n", + "10010101\n", + "10010110\n", + "10010111\n", + "10011000\n", + "10011001\n", + "10011010\n", + "10011011\n", + "10011100\n", + "10011101\n", + "10011110\n", + "10011111\n", + "10100000\n", + "10100001\n", + "10100010\n", + "10100011\n", + "10100100\n", + "10100101\n", + "10100110\n", + "10100111\n", + "10101000\n", + "10101001\n", + "10101010\n", + "10101011\n", + "10101100\n", + "10101101\n", + "10101110\n", + "10101111\n", + "10110000\n", + "10110001\n", + "10110010\n", + "10110011\n", + "10110100\n", + "10110101\n", + "10110110\n", + "10110111\n", + "10111000\n", + "10111001\n", + "10111010\n", + "10111011\n", + "10111100\n", + "10111101\n", + "10111110\n", + "10111111\n", + "11000000\n", + "11000001\n", + "11000010\n", + "11000011\n", + "11000100\n", + "11000101\n", + "11000110\n", + "11000111\n", + "11001000\n", + "11001001\n", + "11001010\n", + "11001011\n", + "11001100\n", + "11001101\n", + "11001110\n", + "11001111\n", + "11010000\n", + "11010001\n", + "11010010\n", + "11010011\n", + "11010100\n", + "11010101\n", + "11010110\n", + "11010111\n", + "11011000\n", + "11011001\n", + "11011010\n", + "11011011\n", + "11011100\n", + "11011101\n", + "11011110\n", + "11011111\n", + "11100000\n", + "11100001\n", + "11100010\n", + "11100011\n", + "11100100\n", + "11100101\n", + "11100110\n", + "11100111\n", + "11101000\n", + "11101001\n", + "11101010\n", + "11101011\n", + "11101100\n", + "11101101\n", + "11101110\n", + "11101111\n", + "11110000\n", + "11110001\n", + "11110010\n", + "11110011\n", + "11110100\n", + "11110101\n", + "11110110\n", + "11110111\n", + "11111000\n", + "11111001\n", + "11111010\n", + "11111011\n", + "11111100\n", + "11111101\n", + "11111110\n", + "11111111\n" + ] + } + ], + "source": [ + "bin_numbers = []\n", + "for i in range(256):\n", + " bin_num = bin(i)[2:]\n", + " while len(bin_num) < 8:\n", + " bin_num = '0'+ bin_num\n", + " print(bin_num)\n", + " bin_numbers.append(bin_num)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "500.0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n" + ] + } + ], + "source": [ + "bin_width = 0.05\n", + "sf = 10000\n", + "shatter_frequency = 500\n", + "plume = []\n", + "print(bin_width*sf)\n", + "for i in bin_numbers[200]:\n", + " print(int(i))\n", + " plume.extend([int(i) for j in range(int(sf*bin_width))])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(pulse)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:6: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", + " \n" + ] + }, + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (4000,) (8000,) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mduration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msampling_rate\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mduration\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mpulse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mshatter_frequency\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mduty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplume\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0;31m#pulse = (np.array(signal.square(2 * np.pi * 500 * t, duty=resampled)) / 2) + 0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/local/lib/python3.7/site-packages/scipy/signal/waveforms.py\u001b[0m in \u001b[0;36msquare\u001b[0;34m(t, duty)\u001b[0m\n\u001b[1;32m 138\u001b[0m \"\"\"\n\u001b[1;32m 139\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mduty\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchar\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'fFdD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4000,) (8000,) " + ] + } + ], + "source": [ + "duration = len(pulse) / sf\n", + "print(duration)\n", + "sampling_rate = 20000\n", + "resampled = signal.resample(plume, len(plume)*int(sampling_rate / sf))\n", + "\n", + "t = np.linspace(0, duration, sampling_rate*duration)\n", + "pulse = (np.array(signal.square(2*np.pi*shatter_frequency * t, duty = plume))/2) + 0.5\n", + "#pulse = (np.array(signal.square(2 * np.pi * 500 * t, duty=resampled)) / 2) + 0.5\n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def plume_pulse(sampling_rate, params, plume):\n", + " #plume = plume\n", + "# plume = plume['plume'][0]\n", + "\n", + " # resample to match sampling rate\n", + " resampled = signal.resample(plume, int(len(plume)*(sampling_rate / params['data_fs'])))\n", + " # zero out negative values\n", + " resampled[resampled < 0] = 0\n", + " # normalise\n", + " resampled = (resampled - min(resampled)) / (max(resampled) - min(resampled))\n", + " resampled = resampled * params['target_max']\n", + "\n", + " duration = len(resampled) / sampling_rate\n", + " t = np.linspace(0, duration, sampling_rate * duration)\n", + " pulse = (np.array(signal.square(2 * np.pi * params['shatter_frequency'] * t, duty=resampled)) / 2) + 0.5\n", + " print(len(pulse))\n", + "\n", + " # Attach onset and offset\n", + " onset = np.zeros(int(sampling_rate * params['onset']))\n", + " offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + " total_length = round(params['onset'] + params['offset'] + len(pulse) / sampling_rate, 10)\n", + " return np.hstack((onset, pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:15: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", + " from ipykernel import kernelapp as app\n", + "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:24: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n" + ] + } + ], + "source": [ + "params['shatter_frequency'] = 500\n", + "params['onset'] = 0\n", + "params['offset'] = 0\n", + "test = plume_pulse(10000, params, plume)" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": 171, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(retest)\n", + "plt.plot(plume)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Plume_analysis.py.ipynb b/Plume_analysis.py.ipynb new file mode 100644 index 0000000..b4c8af9 --- /dev/null +++ b/Plume_analysis.py.ipynb @@ -0,0 +1,4831 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Analysis for plumes taken on 190118, only 4 different plumes recorded\n", + "- All are 5s long\n", + "- All plumes are from /Volumes/lab-schaefera/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_5.mat\n", + "- Order are:\n", + " 1. 1Hz square pulses from two channels, total flow should be 1\n", + " 2. plume on ch3\n", + " 3. Anti plume on ch4\n", + " 4. Combination of both on Ch3 and Ch4" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.io as sio\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import normalize\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "flowmeter = sio.loadmat('/Volumes/lab-schaefera/working/warnert/Recordings/Set up recordings/190118/flowmeter_plumes.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__header__\n", + "__version__\n", + "__globals__\n", + "flowmeter_plumes_Ch31\n", + "flowmeter_plumes_Ch5\n", + "flowmeter_plumes_Ch4\n", + "flowmeter_plumes_Ch3\n", + "flowmeter_plumes_Ch2\n", + "flowmeter_plumes_Ch1\n" + ] + } + ], + "source": [ + "for i in flowmeter:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(3, 1, sharex=True)\n", + "ax[0].plot(flowmeter['flowmeter_plumes_Ch1'][0][0][-1])\n", + "ax[1].plot(flowmeter['flowmeter_plumes_Ch4'][0][0][-1])\n", + "ax[2].plot(flowmeter['flowmeter_plumes_Ch5'][0][0][-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "Ch3 = flowmeter['flowmeter_plumes_Ch4'][0][0][-1]\n", + "Ch4 = flowmeter['flowmeter_plumes_Ch5'][0][0][-1]\n", + "flow = flowmeter['flowmeter_plumes_Ch1'][0][0][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "baseline = np.mean(flow[:276463])\n", + "flow = [i-baseline for i in flow]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "x = lambda a: 1 if a > 1 else 0\n", + "Ch3 = [x(i) for i in Ch3]\n", + "Ch4 = [x(i) for i in Ch4]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "print(max(Ch3))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "mix= [i+j for i, j in zip(Ch3, Ch4)]\n", + "print(max(mix))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "276463\n", + "326463\n" + ] + } + ], + "source": [ + "found_pulse = False\n", + "for index, i in enumerate(mix):\n", + " if i > 0 and not found_pulse:\n", + " print(index)\n", + " found_pulse = True\n", + " if i < 1 and found_pulse:\n", + " print(index)\n", + " break\n", + "# Difference in the two, divided by 5 is the fs = 10000" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "raw_plume = sio.loadmat('/Volumes/lab-schaefera/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_5.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50000\n" + ] + } + ], + "source": [ + "print(len(raw_plume['plume'][0])) # Plume is 5s long" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "Ch3_plumes_only = Ch3[326500:]\n", + "Ch4_plumes_only = Ch4[326500:]\n", + "mix_plumes_only = mix[326500:]\n", + "flow_plumes_only = flow[326500:]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Ch3_plumes_only)\n", + "plt.plot(Ch4_plumes_only)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "plume_length = 5\n", + "fs = 10000\n", + "plume_starts = []\n", + "last_plume = 0\n", + "for index, i in enumerate(mix_plumes_only):\n", + " if i > 0 and index-last_plume > 50000:\n", + " found_plume = True\n", + " plume_starts.append(index)\n", + " last_plume = index\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(len(plume_starts))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[143483, 526552, 777451]\n" + ] + } + ], + "source": [ + "print(plume_starts)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.plot(mix_plumes_only[plume_starts[2]:plume_starts[2]+50000])\n", + "plt.plot(Ch3_plumes_only[plume_starts[2]:plume_starts[2]+50000])\n", + "plt.plot(Ch4_plumes_only[plume_starts[2]:plume_starts[2]+50000])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "143483\n", + "50000\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plume_start = plume_starts[0]\n", + "plume_end = plume_start + 50000\n", + "print(plume_start)\n", + "\n", + "x = np.arange(0, 5, 1/10000)\n", + "print(len(x))\n", + "plt.plot(x, flow_plumes_only[plume_start:plume_end]/max(flow_plumes_only[plume_start:plume_end]), label='Recon plume')\n", + "plt.plot(x, raw_plume['plume'][0]/max(raw_plume['plume'][0]), label='Plume')\n", + "plt.ylabel('Flow (normalised)')\n", + "plt.title('Plume vs reconstructed plume')\n", + "plt.xlabel('Time (s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "526552\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plume_start = plume_starts[1]\n", + "plume_end = plume_start + 50000\n", + "print(plume_start)\n", + "\n", + "plt.plot(x, flow_plumes_only[plume_start:plume_end]/max(flow_plumes_only[plume_start:plume_end]), label='anitRecon plume')\n", + "plt.plot(x, 1-(raw_plume['plume'][0]/max(raw_plume['plume'][0])), label='antiPlume')\n", + "plt.ylabel('Flow (normalised)')\n", + "plt.title('Anti Plume vs reconstructed anit plume')\n", + "plt.xlabel('Time (s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "777451\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plume_start = plume_starts[2]\n", + "plume_end = plume_start + 50000\n", + "print(plume_start)\n", + "\n", + "plt.plot(x, flow_plumes_only[plume_start:plume_end]/max(flow_plumes_only[plume_start:plume_end]), label='anitRecon plume')\n", + "plt.ylabel('Flow (normalised)')\n", + "plt.title('Combined anti and plume')\n", + "plt.xlabel('Time (s)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Now repeating the same analysis but with repeats of plumes, and across all channels\n", + "- 10 different plumes\n", + "- Order:\n", + " 1. Ch1 Plume\n", + " 2. Ch2 Plume\n", + " 3. Ch3 Plume\n", + " 4. Ch4 Plume\n", + " 5. Ch1 plume - Ch2 anti plume\n", + " 6. Ch3 Plume - Ch4 anti plume\n", + " 7. Ch4 anti plume\n", + " 8. Ch3 Anti plume\n", + " 9. Ch2 Anti plume\n", + " 10. Ch1 Anti plume\n", + "- 3 Repeats" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "flowmeter = sio.loadmat('/Volumes/lab-schaefera/working/warnert/Recordings/Set up recordings/190118/flowmeter_plumes_longer_all_chans.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__header__\n", + "__version__\n", + "__globals__\n", + "flowmeter_plumes_longer_all_chans_Keyboard\n", + "flowmeter_plumes_longer_all_chans_Ch4\n", + "flowmeter_plumes_longer_all_chans_Ch3\n", + "flowmeter_plumes_longer_all_chans_Ch2\n", + "flowmeter_plumes_longer_all_chans_Ch1\n", + "flowmeter_plumes_longer_all_chans_Flowmete\n" + ] + } + ], + "source": [ + "for i in flowmeter:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "flow = flowmeter['flowmeter_plumes_longer_all_chans_Flowmete'][0][0][-1]\n", + "ch1 = flowmeter['flowmeter_plumes_longer_all_chans_Ch1'][0][0][-1]\n", + "ch2 = flowmeter['flowmeter_plumes_longer_all_chans_Ch2'][0][0][-1]\n", + "ch3 = flowmeter['flowmeter_plumes_longer_all_chans_Ch3'][0][0][-1]\n", + "ch4 = flowmeter['flowmeter_plumes_longer_all_chans_Ch4'][0][0][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "push = lambda a: 1 if a > 1 else 0\n", + "ch1 = [push(i) for i in ch1]\n", + "ch2 = [push(i) for i in ch2]\n", + "ch3 = [push(i) for i in ch3]\n", + "ch4 = [push(i) for i in ch4]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "mix = [i+j+k+l for i, j, k, l in zip(ch1, ch2, ch3, ch4)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(5, 1)\n", + "ax[0].plot(ch1)\n", + "ax[1].plot(ch2)\n", + "ax[2].plot(ch3)\n", + "ax[3].plot(ch4)\n", + "ax[4].plot(mix)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "plume_starts = []\n", + "prev_plume = 0\n", + "for index, i in enumerate(mix):\n", + " if i > 0 and index-prev_plume > 50000:\n", + " plume_starts.append(index)\n", + " prev_plume = index" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30\n" + ] + } + ], + "source": [ + "print(len(plume_starts))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "baseline= np.mean(flow[:plume_starts[0]])\n", + "flow_baselined = [i-baseline for i in flow]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(flow_baselined)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": [ + "plt.plot(raw_plume['plume'][0]/max(raw_plume['plume'][0]))\n", + "for i in avg_chans:\n", + " plt.plot(i/max(i))" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": [ + "plt.plot(1-(raw_plume['plume'][0]/max(raw_plume['plume'][0])))\n", + "for i in avg_anti_chans:\n", + " plt.plot(i/max(i))" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": [ + "plt.plot(output[1], output[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + } + ], + "source": [ + "\n", + "print(len(bin(255)[2:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "00000000\n", + "00000001\n", + "00000010\n", + "00000011\n", + "00000100\n", + "00000101\n", + "00000110\n", + "00000111\n", + "00001000\n", + "00001001\n", + "00001010\n", + "00001011\n", + "00001100\n", + "00001101\n", + "00001110\n", + "00001111\n", + "00010000\n", + "00010001\n", + "00010010\n", + "00010011\n", + "00010100\n", + "00010101\n", + "00010110\n", + "00010111\n", + "00011000\n", + "00011001\n", + "00011010\n", + "00011011\n", + "00011100\n", + "00011101\n", + "00011110\n", + "00011111\n", + "00100000\n", + "00100001\n", + "00100010\n", + "00100011\n", + "00100100\n", + "00100101\n", + "00100110\n", + "00100111\n", + "00101000\n", + "00101001\n", + "00101010\n", + "00101011\n", + "00101100\n", + "00101101\n", + "00101110\n", + "00101111\n", + "00110000\n", + "00110001\n", + "00110010\n", + "00110011\n", + "00110100\n", + "00110101\n", + "00110110\n", + "00110111\n", + "00111000\n", + "00111001\n", + "00111010\n", + "00111011\n", + "00111100\n", + "00111101\n", + "00111110\n", + "00111111\n", + "01000000\n", + "01000001\n", + "01000010\n", + "01000011\n", + "01000100\n", + "01000101\n", + "01000110\n", + "01000111\n", + "01001000\n", + "01001001\n", + "01001010\n", + "01001011\n", + "01001100\n", + "01001101\n", + "01001110\n", + "01001111\n", + "01010000\n", + "01010001\n", + "01010010\n", + "01010011\n", + "01010100\n", + "01010101\n", + "01010110\n", + "01010111\n", + "01011000\n", + "01011001\n", + "01011010\n", + "01011011\n", + "01011100\n", + "01011101\n", + "01011110\n", + "01011111\n", + "01100000\n", + "01100001\n", + "01100010\n", + "01100011\n", + "01100100\n", + "01100101\n", + "01100110\n", + "01100111\n", + "01101000\n", + "01101001\n", + "01101010\n", + "01101011\n", + "01101100\n", + "01101101\n", + "01101110\n", + "01101111\n", + "01110000\n", + "01110001\n", + "01110010\n", + "01110011\n", + "01110100\n", + "01110101\n", + "01110110\n", + "01110111\n", + "01111000\n", + "01111001\n", + "01111010\n", + "01111011\n", + "01111100\n", + "01111101\n", + "01111110\n", + "01111111\n", + "10000000\n", + "10000001\n", + "10000010\n", + "10000011\n", + "10000100\n", + "10000101\n", + "10000110\n", + "10000111\n", + "10001000\n", + "10001001\n", + "10001010\n", + "10001011\n", + "10001100\n", + "10001101\n", + "10001110\n", + "10001111\n", + "10010000\n", + "10010001\n", + "10010010\n", + "10010011\n", + "10010100\n", + "10010101\n", + "10010110\n", + "10010111\n", + "10011000\n", + "10011001\n", + "10011010\n", + "10011011\n", + "10011100\n", + "10011101\n", + "10011110\n", + "10011111\n", + "10100000\n", + "10100001\n", + "10100010\n", + "10100011\n", + "10100100\n", + "10100101\n", + "10100110\n", + "10100111\n", + "10101000\n", + "10101001\n", + "10101010\n", + "10101011\n", + "10101100\n", + "10101101\n", + "10101110\n", + "10101111\n", + "10110000\n", + "10110001\n", + "10110010\n", + "10110011\n", + "10110100\n", + "10110101\n", + "10110110\n", + "10110111\n", + "10111000\n", + "10111001\n", + "10111010\n", + "10111011\n", + "10111100\n", + "10111101\n", + "10111110\n", + "10111111\n", + "11000000\n", + "11000001\n", + "11000010\n", + "11000011\n", + "11000100\n", + "11000101\n", + "11000110\n", + "11000111\n", + "11001000\n", + "11001001\n", + "11001010\n", + "11001011\n", + "11001100\n", + "11001101\n", + "11001110\n", + "11001111\n", + "11010000\n", + "11010001\n", + "11010010\n", + "11010011\n", + "11010100\n", + "11010101\n", + "11010110\n", + "11010111\n", + "11011000\n", + "11011001\n", + "11011010\n", + "11011011\n", + "11011100\n", + "11011101\n", + "11011110\n", + "11011111\n", + "11100000\n", + "11100001\n", + "11100010\n", + "11100011\n", + "11100100\n", + "11100101\n", + "11100110\n", + "11100111\n", + "11101000\n", + "11101001\n", + "11101010\n", + "11101011\n", + "11101100\n", + "11101101\n", + "11101110\n", + "11101111\n", + "11110000\n", + "11110001\n", + "11110010\n", + "11110011\n", + "11110100\n", + "11110101\n", + "11110110\n", + "11110111\n", + "11111000\n", + "11111001\n", + "11111010\n", + "11111011\n", + "11111100\n", + "11111101\n", + "11111110\n", + "11111111\n" + ] + } + ], + "source": [ + "bin_numbers = []\n", + "for i in range(256):\n", + " bin_num = bin(i)[2:]\n", + " while len(bin_num) < 8:\n", + " bin_num = '0'+ bin_num\n", + " print(bin_num)\n", + " bin_numbers.append(bin_num)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "500.0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n" + ] + } + ], + "source": [ + "bin_width = 0.05\n", + "sf = 10000\n", + "shatter_frequency = 500\n", + "plume = []\n", + "print(bin_width*sf)\n", + "for i in bin_numbers[200]:\n", + " print(int(i))\n", + " plume.extend([int(i) for j in range(int(sf*bin_width))])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(pulse)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:6: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", + " \n" + ] + }, + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (4000,) (8000,) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mduration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msampling_rate\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mduration\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mpulse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mshatter_frequency\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mduty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplume\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0;31m#pulse = (np.array(signal.square(2 * np.pi * 500 * t, duty=resampled)) / 2) + 0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/local/lib/python3.7/site-packages/scipy/signal/waveforms.py\u001b[0m in \u001b[0;36msquare\u001b[0;34m(t, duty)\u001b[0m\n\u001b[1;32m 138\u001b[0m \"\"\"\n\u001b[1;32m 139\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mduty\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchar\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'fFdD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4000,) (8000,) " + ] + } + ], + "source": [ + "duration = len(pulse) / sf\n", + "print(duration)\n", + "sampling_rate = 20000\n", + "resampled = signal.resample(plume, len(plume)*int(sampling_rate / sf))\n", + "\n", + "t = np.linspace(0, duration, sampling_rate*duration)\n", + "pulse = (np.array(signal.square(2*np.pi*shatter_frequency * t, duty = plume))/2) + 0.5\n", + "#pulse = (np.array(signal.square(2 * np.pi * 500 * t, duty=resampled)) / 2) + 0.5\n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def plume_pulse(sampling_rate, params, plume):\n", + " #plume = plume\n", + "# plume = plume['plume'][0]\n", + "\n", + " # resample to match sampling rate\n", + " resampled = signal.resample(plume, int(len(plume)*(sampling_rate / params['data_fs'])))\n", + " # zero out negative values\n", + " resampled[resampled < 0] = 0\n", + " # normalise\n", + " resampled = (resampled - min(resampled)) / (max(resampled) - min(resampled))\n", + " resampled = resampled * params['target_max']\n", + "\n", + " duration = len(resampled) / sampling_rate\n", + " t = np.linspace(0, duration, sampling_rate * duration)\n", + " pulse = (np.array(signal.square(2 * np.pi * params['shatter_frequency'] * t, duty=resampled)) / 2) + 0.5\n", + " print(len(pulse))\n", + "\n", + " # Attach onset and offset\n", + " onset = np.zeros(int(sampling_rate * params['onset']))\n", + " offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + " total_length = round(params['onset'] + params['offset'] + len(pulse) / sampling_rate, 10)\n", + " return np.hstack((onset, pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:15: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", + " from ipykernel import kernelapp as app\n", + "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:24: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n" + ] + } + ], + "source": [ + "params['shatter_frequency'] = 500\n", + "params['onset'] = 0\n", + "params['offset'] = 0\n", + "test = plume_pulse(10000, params, plume)" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": 177, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(t, bin_pulse)\n", + "#plt.plot(np.load(params['data_path']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.7.3" + } + }, "nbformat": 4, "nbformat_minor": 2 } diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index cd93ea2..4497398 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -2276,7 +2276,60 @@ }, { "cell_type": "code", - "execution_count": 171, + "execution_count": 186, + "metadata": {}, + "outputs": [], + "source": [ + "def binary_pulse(sampling_rate, params):\n", + " '''\n", + " Creates a pulse using a binary valve file, e.g. a set of zeros or ones that indicate when the valve\n", + " should be open or closed\n", + " '''\n", + " binary = np.load(params['data_path'])\n", + " assert min(binary) == 0, 'Binary minimum should be zero'\n", + " assert max(binary) == 1, 'Binary maximum should be one'\n", + " assert params['data_fs'] == sampling_rate, 'Need to have the same sampling rate for now'\n", + " if sampling_rate > params['data_fs']:\n", + " resampled = np.zeros(int(len(binary)/params['data_fs']*sampling_rate))\n", + " factor = int(sampling_rate/params['data_fs'])\n", + " \n", + " print(len(resampled))\n", + " #resampled = signal.resample(binary, int(len(binary) * (sampling_rate / params['data_fs'])))\n", + " \n", + "# onset = np.zeros(int(sampling_rate * params['onset']))\n", + "# offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + "# total_length = round(params['onset'] + params['offset'] + len(resampled)/sampling_rate, 10)\n", + "# return np.hstack((onset, resampled, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "8000\n" + ] + } + ], + "source": [ + "params['data_path'] = os.path.join('/Users/warnert/Documents/GitHub/PulseBoy', 'test.npy')\n", + "params['data_fs'] = 10000\n", + "params['onset'] = 0\n", + "params['offset'] = 0\n", + "samping_rate = 20000\n", + "binary_pulse(samping_rate, params)" + ] + }, + { + "cell_type": "code", + "execution_count": 177, "metadata": {}, "outputs": [ { @@ -3062,7 +3115,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -3074,17 +3127,17 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 171, + "execution_count": 177, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt.plot(retest)\n", - "plt.plot(plume)" + "plt.plot(t, bin_pulse)\n", + "#plt.plot(np.load(params['data_path']))" ] }, { diff --git a/Controllers/main.py b/Controllers/main.py index 9ab0df7..6c122b2 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -1,5 +1,6 @@ import sys - +#sys.path.append('Path/to/github/here') +#sys.path.append('path/to/pulseboy/here') from PyPulse import PulseInterface import numpy as np from PyQt5 import QtWidgets diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index d60e658..9e951b0 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -150,6 +150,7 @@ def load_plume_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') self.plumeDataLabel.setText(fname) + class AntiPlumeValveWidget(QtWidgets.QWidget, plumeValveDesign.Ui_Form): def __init__(self, parentUi=None): super(self.__class__, self).__init__() From e643cfe3d1d550db1ed7ca9c93849fd1a5fce9a1 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Fri, 12 Jul 2019 13:25:02 +0100 Subject: [PATCH 17/83] update for binary pulse --- Designs/binaryValveDesign.py | 72 ++++++++++++++++++++---------------- Models/PBWidgets.py | 11 +++--- UI/BinaryValveWidget.ui | 70 +++++++++++++++++++++-------------- UI/binaryValveDesign.py | 72 ++++++++++++++++++++---------------- 4 files changed, 128 insertions(+), 97 deletions(-) diff --git a/Designs/binaryValveDesign.py b/Designs/binaryValveDesign.py index 5953e15..7379cd1 100644 --- a/Designs/binaryValveDesign.py +++ b/Designs/binaryValveDesign.py @@ -22,38 +22,44 @@ def setupUi(self, Form): Form.setFont(font) self.gridLayout = QtWidgets.QGridLayout(Form) self.gridLayout.setObjectName("gridLayout") + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) + self.label_2 = QtWidgets.QLabel(Form) + self.label_2.setObjectName("label_2") + self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.valuetobinariseEdit = QtWidgets.QLineEdit(Form) + self.valuetobinariseEdit.setObjectName("valuetobinariseEdit") + self.gridLayout.addWidget(self.valuetobinariseEdit, 1, 5, 1, 1) + self.label_3 = QtWidgets.QLabel(Form) + self.label_3.setObjectName("label_3") + self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) + self.onsetEdit = QtWidgets.QLineEdit(Form) + self.onsetEdit.setObjectName("onsetEdit") + self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) - self.openBinaryDataButton = QtWidgets.QPushButton(Form) - self.openBinaryDataButton.setObjectName("openBinaryDataButton") - self.gridLayout.addWidget(self.openBinaryDataButton, 0, 3, 1, 1) - self.binaryDataLabel = QtWidgets.QLabel(Form) - self.binaryDataLabel.setObjectName("binaryDataLabel") - self.gridLayout.addWidget(self.binaryDataLabel, 1, 3, 1, 1) - self.label_5 = QtWidgets.QLabel(Form) - self.label_5.setObjectName("label_5") - self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) + self.label = QtWidgets.QLabel(Form) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 1, 1, 1) self.line_2 = QtWidgets.QFrame(Form) self.line_2.setFrameShape(QtWidgets.QFrame.HLine) self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") - self.gridLayout.addWidget(self.line_2, 2, 1, 1, 5) - self.label = QtWidgets.QLabel(Form) - self.label.setObjectName("label") - self.gridLayout.addWidget(self.label, 0, 1, 1, 1) - self.onsetEdit = QtWidgets.QLineEdit(Form) - self.onsetEdit.setObjectName("onsetEdit") - self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) - self.dataSamplingRateEdit = QtWidgets.QLineEdit(Form) - self.dataSamplingRateEdit.setObjectName("dataSamplingRateEdit") - self.gridLayout.addWidget(self.dataSamplingRateEdit, 1, 4, 1, 1) - self.offsetEdit = QtWidgets.QLineEdit(Form) - self.offsetEdit.setObjectName("offsetEdit") - self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) - self.label_2 = QtWidgets.QLabel(Form) - self.label_2.setObjectName("label_2") - self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) + self.numofbinsEdit = QtWidgets.QLineEdit(Form) + self.numofbinsEdit.setObjectName("numofbinsEdit") + self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.binsizeEdit = QtWidgets.QLineEdit(Form) + self.binsizeEdit.setObjectName("binsizeEdit") + self.gridLayout.addWidget(self.binsizeEdit, 1, 4, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -61,13 +67,15 @@ def setupUi(self, Form): def retranslateUi(self, Form): _translate = QtCore.QCoreApplication.translate Form.setWindowTitle(_translate("Form", "Form")) - self.removeButton.setText(_translate("Form", "-")) - self.openBinaryDataButton.setText(_translate("Form", "Open Binary Data")) - self.binaryDataLabel.setText(_translate("Form", "-")) - self.label_5.setText(_translate("Form", "Data Sampling Rate")) - self.label.setText(_translate("Form", "Onset")) - self.onsetEdit.setText(_translate("Form", "0.1")) - self.dataSamplingRateEdit.setText(_translate("Form", "10000")) self.offsetEdit.setText(_translate("Form", "0.1")) self.label_2.setText(_translate("Form", "Offset")) + self.valuetobinariseEdit.setText(_translate("Form", "2")) + self.label_3.setText(_translate("Form", "Value to binarise")) + self.onsetEdit.setText(_translate("Form", "0.1")) + self.removeButton.setText(_translate("Form", "-")) + self.label.setText(_translate("Form", "Onset")) + self.label_4.setText(_translate("Form", "Number of bins")) + self.numofbinsEdit.setText(_translate("Form", "8")) + self.binsizeEdit.setText(_translate("Form", "0.05")) + self.label_5.setText(_translate("Form", "Bin size")) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index d60e658..83a52c0 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -212,16 +212,17 @@ def get_parameters(self): params['onset'] = float(self.onsetEdit.text()) params['offset'] = float(self.offsetEdit.text()) - params['data_fs'] = float(self.dataSamplingRateEdit.text()) - params['data_path'] = str(self.binaryDataLabel.text()) - + params['num_of_bins'] = float(self.numofbinsEdit.text()) + params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) + params['bin_size'] = flost(self.binsizeEdit.text()) return params def set_parameters(self, params): self.onsetEdit.setText(str(params['onset'])) self.offsetEdit.setText(str(params['offset'])) - self.binaryDataLabel.setText(str(params['data_path'])) - self.dataSamplingRateEdit.setText(str(params['data_fs'])) + self.numofbinsEdit.setText(str(params['num_of_bins'])) + self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) + self.binsizeEdit.setText(str(params['bin_size'])) def load_binary_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', '', '*.npy') diff --git a/UI/BinaryValveWidget.ui b/UI/BinaryValveWidget.ui index ad5cea5..adaf525 100644 --- a/UI/BinaryValveWidget.ui +++ b/UI/BinaryValveWidget.ui @@ -25,38 +25,45 @@ Form - - + + - - + 0.1 - - + + - Open Binary Data + Offset - - + + - - + 2 - - + + - Data Sampling Rate + Value to binarise - - - - Qt::Horizontal + + + + 0.1 + + + + + + + - @@ -67,31 +74,38 @@ - - + + + + Qt::Horizontal + + + + + - 0.1 + Number of bins - - + + - 10000 + 8 - - + + - 0.1 + 0.05 - - + + - Offset + Bin size diff --git a/UI/binaryValveDesign.py b/UI/binaryValveDesign.py index 5953e15..7379cd1 100644 --- a/UI/binaryValveDesign.py +++ b/UI/binaryValveDesign.py @@ -22,38 +22,44 @@ def setupUi(self, Form): Form.setFont(font) self.gridLayout = QtWidgets.QGridLayout(Form) self.gridLayout.setObjectName("gridLayout") + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) + self.label_2 = QtWidgets.QLabel(Form) + self.label_2.setObjectName("label_2") + self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.valuetobinariseEdit = QtWidgets.QLineEdit(Form) + self.valuetobinariseEdit.setObjectName("valuetobinariseEdit") + self.gridLayout.addWidget(self.valuetobinariseEdit, 1, 5, 1, 1) + self.label_3 = QtWidgets.QLabel(Form) + self.label_3.setObjectName("label_3") + self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) + self.onsetEdit = QtWidgets.QLineEdit(Form) + self.onsetEdit.setObjectName("onsetEdit") + self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) - self.openBinaryDataButton = QtWidgets.QPushButton(Form) - self.openBinaryDataButton.setObjectName("openBinaryDataButton") - self.gridLayout.addWidget(self.openBinaryDataButton, 0, 3, 1, 1) - self.binaryDataLabel = QtWidgets.QLabel(Form) - self.binaryDataLabel.setObjectName("binaryDataLabel") - self.gridLayout.addWidget(self.binaryDataLabel, 1, 3, 1, 1) - self.label_5 = QtWidgets.QLabel(Form) - self.label_5.setObjectName("label_5") - self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) + self.label = QtWidgets.QLabel(Form) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 1, 1, 1) self.line_2 = QtWidgets.QFrame(Form) self.line_2.setFrameShape(QtWidgets.QFrame.HLine) self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") - self.gridLayout.addWidget(self.line_2, 2, 1, 1, 5) - self.label = QtWidgets.QLabel(Form) - self.label.setObjectName("label") - self.gridLayout.addWidget(self.label, 0, 1, 1, 1) - self.onsetEdit = QtWidgets.QLineEdit(Form) - self.onsetEdit.setObjectName("onsetEdit") - self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) - self.dataSamplingRateEdit = QtWidgets.QLineEdit(Form) - self.dataSamplingRateEdit.setObjectName("dataSamplingRateEdit") - self.gridLayout.addWidget(self.dataSamplingRateEdit, 1, 4, 1, 1) - self.offsetEdit = QtWidgets.QLineEdit(Form) - self.offsetEdit.setObjectName("offsetEdit") - self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) - self.label_2 = QtWidgets.QLabel(Form) - self.label_2.setObjectName("label_2") - self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) + self.numofbinsEdit = QtWidgets.QLineEdit(Form) + self.numofbinsEdit.setObjectName("numofbinsEdit") + self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.binsizeEdit = QtWidgets.QLineEdit(Form) + self.binsizeEdit.setObjectName("binsizeEdit") + self.gridLayout.addWidget(self.binsizeEdit, 1, 4, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -61,13 +67,15 @@ def setupUi(self, Form): def retranslateUi(self, Form): _translate = QtCore.QCoreApplication.translate Form.setWindowTitle(_translate("Form", "Form")) - self.removeButton.setText(_translate("Form", "-")) - self.openBinaryDataButton.setText(_translate("Form", "Open Binary Data")) - self.binaryDataLabel.setText(_translate("Form", "-")) - self.label_5.setText(_translate("Form", "Data Sampling Rate")) - self.label.setText(_translate("Form", "Onset")) - self.onsetEdit.setText(_translate("Form", "0.1")) - self.dataSamplingRateEdit.setText(_translate("Form", "10000")) self.offsetEdit.setText(_translate("Form", "0.1")) self.label_2.setText(_translate("Form", "Offset")) + self.valuetobinariseEdit.setText(_translate("Form", "2")) + self.label_3.setText(_translate("Form", "Value to binarise")) + self.onsetEdit.setText(_translate("Form", "0.1")) + self.removeButton.setText(_translate("Form", "-")) + self.label.setText(_translate("Form", "Onset")) + self.label_4.setText(_translate("Form", "Number of bins")) + self.numofbinsEdit.setText(_translate("Form", "8")) + self.binsizeEdit.setText(_translate("Form", "0.05")) + self.label_5.setText(_translate("Form", "Bin size")) From 25468a83a8152ac2535d665c90dbb7359b098746 Mon Sep 17 00:00:00 2001 From: Tom Date: Fri, 12 Jul 2019 13:50:11 +0100 Subject: [PATCH 18/83] remove binary load and floating a float --- Models/PBWidgets.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 6be3231..c91c6d0 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -200,7 +200,6 @@ def __init__(self, parentUi=None): self.parentUi = parentUi self.removeButton.clicked.connect(self.remove_from_parent) - self.openBinaryDataButton.clicked.connect(self.load_binary_data) def remove_from_parent(self): self.parentUi.layout().removeWidget(self) @@ -215,7 +214,7 @@ def get_parameters(self): params['offset'] = float(self.offsetEdit.text()) params['num_of_bins'] = float(self.numofbinsEdit.text()) params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) - params['bin_size'] = flost(self.binsizeEdit.text()) + params['bin_size'] = float(self.binsizeEdit.text()) return params def set_parameters(self, params): From 30b7dc02b45ca681b2eb8a944d14cb7931f62394 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 12 Jul 2019 13:59:38 +0100 Subject: [PATCH 19/83] add test binary trialbank --- .DS_Store | Bin 10244 -> 10244 bytes Binary sequence creating.ipynb | 2207 +++++++++++++++++++++++- test.npy => TestData/test.npy | Bin TestData/testbinarytrialbank.trialbank | Bin 0 -> 14415 bytes 4 files changed, 2160 insertions(+), 47 deletions(-) rename test.npy => TestData/test.npy (100%) create mode 100644 TestData/testbinarytrialbank.trialbank diff --git a/.DS_Store b/.DS_Store index 543753f9956152aeb8259f5c851b7839597c841b..8657a995d1466f5dcb7fbffad623a7c37c4594d2 100644 GIT binary patch delta 1323 zcmd6mPfQa*6vpSX#m>?-475VKv`A`WMXOd4KnaQju__W9(+WjG(y|MzKoPc7Bx<9< z7*Bv}Jeg=D=)pw9;!*I=g@ZSV-aL6T(RlGX(q4CgU ziC`tfoKJ|uI#up-n+PG`gYm(i`As89a*)LM9Ge@OHt7Mc*_q8S^Fc|ND8FaupNl;f zSMYF?!u4VU zWz7OxZ^&-3Ne~#(7aYN80M$5vLkQw1n$d!jXhjt5=zxN5^g=}+k{Ce>qqv027{?V{ z#U!Sn;|6ZxHtygqrZIzun8h3(V;)bjfJMF2xmAC_PUu#ftMKoAsY9MRyfRRw zzqakkSg4t9w5+zL8HeqI1vDeFQq#XHHLQ|SVfW-o9Ew{H+2_+XyC}A+vXV%u-KsMD zCzzkW!im^`lEot|7qG%2PDpASiK{~+YVsW0OldCaE|bI#IhIsf2IXuunFBNOJ!O(~ zDyuXOD}0t$KG@<*OJZ14#}tmw$lUH1#c&_D14m{=0=q>i(jSW}{T!;%sH$3&T2sof zrVb`JN+Vcn7p1nY!GQt(FWO3Mf4wAiX8RtCY02YflmuVX(n|A2zNV-(D>le-c1ik% z;+np9M$0ID_IbPr;Uf~Vi>a)e$^nL7^eoaa_^EhmNmGkpQn)p%s fbq?o-KAH3a?-9MjJCj~pSW?{)-{t7aKbTcq0a03ZfpaDEUP2ZU(^Q(AH_UGZ4 N9HX*uGp7(UGXQ{77ux^; diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index 4497398..b1ce7dc 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -44,26 +44,26 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 114, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}\n" + "\n" ] } ], "source": [ - "params = trialbank[0][1][0]\n", - "print(params)\n", + "params = trialbank\n", + "print(type(params))\n", "sampling_rate = 20000" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -86,24 +86,18 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 12, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "(40000,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", - " import sys\n", - "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:14: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", - " \n" + "ename": "KeyError", + "evalue": "'fromDuty'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'fromDuty'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mfrequency\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'frequency'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mduty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'duty'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'fromValues'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'fromDuty'" ] } ], @@ -2276,25 +2270,44 @@ }, { "cell_type": "code", - "execution_count": 186, + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "params = {'onset': 0.0, 'offset':0.0, 'num_of_bins':8, 'bin_size':0.05,'value_to_binarise':256}" + ] + }, + { + "cell_type": "code", + "execution_count": 109, "metadata": {}, "outputs": [], "source": [ "def binary_pulse(sampling_rate, params):\n", " '''\n", - " Creates a pulse using a binary valve file, e.g. a set of zeros or ones that indicate when the valve\n", - " should be open or closed\n", + " Creates a pulse from a value passed to it. Value should be less than the maximum \n", " '''\n", - " binary = np.load(params['data_path'])\n", - " assert min(binary) == 0, 'Binary minimum should be zero'\n", - " assert max(binary) == 1, 'Binary maximum should be one'\n", - " assert params['data_fs'] == sampling_rate, 'Need to have the same sampling rate for now'\n", - " if sampling_rate > params['data_fs']:\n", - " resampled = np.zeros(int(len(binary)/params['data_fs']*sampling_rate))\n", - " factor = int(sampling_rate/params['data_fs'])\n", + " binary = params['value_to_binarise']\n", + " \n", + " assert binary >= 0, 'Binary minimum should be zero'\n", + " assert binary <= 2**params['num_of_bins'] - 1, 'Binary maximum should be less than %s' % str(2**params['num_of_bins'])\n", + " bin_width = params['bin_size']*sampling_rate\n", + " binned = bin(binary)[2:]\n", + " while len(binned) < params['num_of_bins']:\n", + " binned = '0' + binned\n", + " bin_output = []\n", + " print(binned, bin_width)\n", + " onset = np.zeros(int(sampling_rate * params['onset']))\n", + " offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + " \n", + " \n", + " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", + " total_length = round(params['onset'] + params['offset'] + len(bin_pulse)/sampling_rate, 10)\n", + " return np.hstack((onset, bin_pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n", + "\n", " \n", - " print(len(resampled))\n", - " #resampled = signal.resample(binary, int(len(binary) * (sampling_rate / params['data_fs'])))\n", + "#resampled = signal.resample(binary, int(len(binary) * (sampling_rate / params['data_fs'])))\n", " \n", "# onset = np.zeros(int(sampling_rate * params['onset']))\n", "# offset = np.zeros(int(sampling_rate * params['offset']))\n", @@ -2306,25 +2319,25 @@ }, { "cell_type": "code", - "execution_count": 187, + "execution_count": 110, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n", - "8000\n" + "ename": "AssertionError", + "evalue": "Binary maximum should be less than 256", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbin_pulse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbinary_pulse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m20000\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbin_pulse\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbin_pulse\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mbinary_pulse\u001b[0;34m(sampling_rate, params)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mbinary\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Binary minimum should be zero'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mbinary\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'num_of_bins'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Binary maximum should be less than %s'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'num_of_bins'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0mbin_width\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'bin_size'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msampling_rate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mbinned\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbinary\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: Binary maximum should be less than 256" ] } ], "source": [ - "params['data_path'] = os.path.join('/Users/warnert/Documents/GitHub/PulseBoy', 'test.npy')\n", - "params['data_fs'] = 10000\n", - "params['onset'] = 0\n", - "params['offset'] = 0\n", - "samping_rate = 20000\n", - "binary_pulse(samping_rate, params)" + "bin_pulse = binary_pulse(20000, params)\n", + "plt.plot(bin_pulse[1], bin_pulse[0])" ] }, { @@ -3140,6 +3153,2106 @@ "#plt.plot(np.load(params['data_path']))" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n" + ] + } + ], + "source": [ + "bin_window = 50\n", + "fs = 20000\n", + "num_of_bins = 8\n", + "for i in range(2**num_of_bins):\n", + " binned = bin(i)[2:]\n", + " while len(binned) < num_of_bins:\n", + " binned = '0' + binned\n", + " for j in binned:\n", + " print(j)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "trial = [1, [{}], 'Trial Name']\n", + "trialbank = []\n", + "for i in range(256):\n", + " params = {}\n", + " params['onset'] = 0.1\n", + " params['offset'] = 0.1\n", + " params['num_of_bins'] = 8\n", + " params['bin_size'] = 0.05\n", + " params['value_to_binarise'] = i\n", + " trialbank.append([1, [params], 'Trial Name'])" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [], + "source": [ + "pickle.dump(trialbank, open('/Users/warnert/Documents/GitHub/PulseBoy/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/test.npy b/TestData/test.npy similarity index 100% rename from test.npy rename to TestData/test.npy diff --git a/TestData/testbinarytrialbank.trialbank b/TestData/testbinarytrialbank.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..31752e94c3a9b0630be2fb827b64b7901788e861 GIT binary patch literal 14415 zcmbWwd7KOc6bEp!yT;K$MJPul+u=x(PKlz%k&q5+jG8r*-JR_0P)aGcrb44~h1^oP z3OPEQUDBP(RZ15riVm`T`tb4Z_kG?U@AE$I`+og1Mz?5E;z;GBvx_@eGAG?Hot?^z z7bGG@>6T5Gj5%CmQ(5uc+~YUp3X=Jucy6eBtRRsN22z3IA(V*qjTEa{|EmhU!+FU_ zs3?B;DqI*#MAE?$$#AM{$HG`RuV&kDek2_^78}ht8W_zyHf99_(b7ksMgzf;$#Ap` zxD(KoLYILq6I~X%(&z%{%AhNYt{l4Z=uSj;61tPoor10cx{BydMRyvy)6rEzR~g+I z=&GQrimn>EGtr%et~$CJ=xU;?h3;&0=b$?mU2Sydp{s)~8{PTnE;#^^3X*96_==&nF_CAzE7U5)M?{E>(Dhv*8<)3 z=x#vQ5?w2FH=?@ry9HebbRE%kLU${=&ggDKcRRW}(A|ly z3%VS1UD1Wmbwd|M*B#wm=&<#a54Bc>a zkD*JUdmP;p=$=G30^LY-qtHEtE{$$9x~I`SgYH>$W6+I7HxAu+bQ91$hi)ReN$4h{ zdmh~sbW_nyLpL4W40JQm%|bUD-3#dEpnDPBOXyxkHy7PJbo0?IK(`RxE9hQDw+P*0 zbW6~^hHfdkW$2cpTY>I%bZ?-06Wv?rR-#*lZZ*0!=+>fJhwg23@1T1Z-FxWXN4Fl` z2k17S`w-nn=srgG3A#_weTMFHbYGy`i0(^tU!nUN-6nLK(QQGu72P&;-=O;z-F9@} zq5B@)4s<`D`w`tw=zd1`3%Z@?cA@(f-EMThq5B=(9&~%r{ekXJbockg-w_w7cL)Uk5VrsT literal 0 HcmV?d00001 From 388b28c659f1ca4decc2ffdaf8abe40b3bc20fdc Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 12 Jul 2019 14:03:23 +0100 Subject: [PATCH 20/83] update test trialbank --- .../Binary sequence creating-checkpoint.ipynb | 2208 ++++++++++++++++- Binary sequence creating.ipynb | 7 +- TestData/testbinarytrialbank.trialbank | Bin 14415 -> 15451 bytes 3 files changed, 2165 insertions(+), 50 deletions(-) diff --git a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb index 4497398..b023199 100644 --- a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb +++ b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -44,26 +44,26 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 114, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}\n" + "\n" ] } ], "source": [ - "params = trialbank[0][1][0]\n", - "print(params)\n", + "params = trialbank\n", + "print(type(params))\n", "sampling_rate = 20000" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -86,24 +86,18 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 12, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "(40000,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", - " import sys\n", - "/Users/warnert/miniconda3/envs/local/lib/python3.7/site-packages/ipykernel_launcher.py:14: DeprecationWarning: object of type cannot be safely interpreted as an integer.\n", - " \n" + "ename": "KeyError", + "evalue": "'fromDuty'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'fromDuty'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mfrequency\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'frequency'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mduty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'duty'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'fromValues'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'fromDuty'" ] } ], @@ -2276,25 +2270,44 @@ }, { "cell_type": "code", - "execution_count": 186, + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "params = {'onset': 0.0, 'offset':0.0, 'num_of_bins':8, 'bin_size':0.05,'value_to_binarise':256}" + ] + }, + { + "cell_type": "code", + "execution_count": 109, "metadata": {}, "outputs": [], "source": [ "def binary_pulse(sampling_rate, params):\n", " '''\n", - " Creates a pulse using a binary valve file, e.g. a set of zeros or ones that indicate when the valve\n", - " should be open or closed\n", + " Creates a pulse from a value passed to it. Value should be less than the maximum \n", " '''\n", - " binary = np.load(params['data_path'])\n", - " assert min(binary) == 0, 'Binary minimum should be zero'\n", - " assert max(binary) == 1, 'Binary maximum should be one'\n", - " assert params['data_fs'] == sampling_rate, 'Need to have the same sampling rate for now'\n", - " if sampling_rate > params['data_fs']:\n", - " resampled = np.zeros(int(len(binary)/params['data_fs']*sampling_rate))\n", - " factor = int(sampling_rate/params['data_fs'])\n", + " binary = params['value_to_binarise']\n", + " \n", + " assert binary >= 0, 'Binary minimum should be zero'\n", + " assert binary <= 2**params['num_of_bins'] - 1, 'Binary maximum should be less than %s' % str(2**params['num_of_bins'])\n", + " bin_width = params['bin_size']*sampling_rate\n", + " binned = bin(binary)[2:]\n", + " while len(binned) < params['num_of_bins']:\n", + " binned = '0' + binned\n", + " bin_output = []\n", + " print(binned, bin_width)\n", + " onset = np.zeros(int(sampling_rate * params['onset']))\n", + " offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + " \n", + " \n", + " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", + " total_length = round(params['onset'] + params['offset'] + len(bin_pulse)/sampling_rate, 10)\n", + " return np.hstack((onset, bin_pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n", + "\n", " \n", - " print(len(resampled))\n", - " #resampled = signal.resample(binary, int(len(binary) * (sampling_rate / params['data_fs'])))\n", + "#resampled = signal.resample(binary, int(len(binary) * (sampling_rate / params['data_fs'])))\n", " \n", "# onset = np.zeros(int(sampling_rate * params['onset']))\n", "# offset = np.zeros(int(sampling_rate * params['offset']))\n", @@ -2306,25 +2319,25 @@ }, { "cell_type": "code", - "execution_count": 187, + "execution_count": 110, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n", - "8000\n" + "ename": "AssertionError", + "evalue": "Binary maximum should be less than 256", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbin_pulse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbinary_pulse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m20000\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbin_pulse\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbin_pulse\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mbinary_pulse\u001b[0;34m(sampling_rate, params)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mbinary\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Binary minimum should be zero'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mbinary\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'num_of_bins'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Binary maximum should be less than %s'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'num_of_bins'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0mbin_width\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'bin_size'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msampling_rate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mbinned\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbinary\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: Binary maximum should be less than 256" ] } ], "source": [ - "params['data_path'] = os.path.join('/Users/warnert/Documents/GitHub/PulseBoy', 'test.npy')\n", - "params['data_fs'] = 10000\n", - "params['onset'] = 0\n", - "params['offset'] = 0\n", - "samping_rate = 20000\n", - "binary_pulse(samping_rate, params)" + "bin_pulse = binary_pulse(20000, params)\n", + "plt.plot(bin_pulse[1], bin_pulse[0])" ] }, { @@ -3140,6 +3153,2107 @@ "#plt.plot(np.load(params['data_path']))" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n", + "1\n" + ] + } + ], + "source": [ + "bin_window = 50\n", + "fs = 20000\n", + "num_of_bins = 8\n", + "for i in range(2**num_of_bins):\n", + " binned = bin(i)[2:]\n", + " while len(binned) < num_of_bins:\n", + " binned = '0' + binned\n", + " for j in binned:\n", + " print(j)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "trial = [1, [{}], 'Trial Name']\n", + "trialbank = []\n", + "for i in range(256):\n", + " params = {}\n", + " params['type']='binary'\n", + " params['onset'] = 0.1\n", + " params['offset'] = 0.1\n", + " params['num_of_bins'] = 8\n", + " params['bin_size'] = 0.05\n", + " params['value_to_binarise'] = i\n", + " trialbank.append([1, [params], 'Trial Name'])" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [], + "source": [ + "pickle.dump(trialbank, open('/Users/warnert/Documents/GitHub/PulseBoy/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index b1ce7dc..4212f83 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,7 +5228,7 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 124, "metadata": {}, "outputs": [], "source": [ @@ -5236,6 +5236,7 @@ "trialbank = []\n", "for i in range(256):\n", " params = {}\n", + " params['type']='binary'\n", " params['onset'] = 0.1\n", " params['offset'] = 0.1\n", " params['num_of_bins'] = 8\n", @@ -5246,11 +5247,11 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 126, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank, open('/Users/warnert/Documents/GitHub/PulseBoy/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { diff --git a/TestData/testbinarytrialbank.trialbank b/TestData/testbinarytrialbank.trialbank index 31752e94c3a9b0630be2fb827b64b7901788e861..a58d7263629b7752302167580e7d2828fb399974 100644 GIT binary patch literal 15451 zcmbu(d6bO>6aa8CGoG1LR7xQ#H7&GBn-qXxH&6_79N?F<-ZJ(V= zRJ5VANQHLVvqhz7UrCG5HXMiJU%z|qANSmIfA`)YIitI`s$Ynz3Eg=^ro21hImIyD!-N!0r#W9@qoG9tgHR*n_|x47LH-hF}|kJp^oHuuZ@o3idFthl6bj_6V>? zf-MAl6xgG|9s~ARu+6|W2YVdY}V9x~G4s3g{XMybi_H3}{fb9tOT(F(Mo(DDxwlml+V7r3t2DUrc^TA#Kwg=dr zU@ruF5!hZ}F9zEi>?L3?1$!CTBCwZ(je)%aY#eMKuvdb;3Tyzj80^(x6JV2I`+~g& zYzf#>uw`IVVEci+7Hm1#G}sET8L<7qUI%sn*h;Vi!Cnt`5ZJ+BZvcBE*dbtV0(&#q zpWDu%p1<3HC0qcZ0nL?7d(^u%p3_0Xr7#II!cv zP5?U*>?E+0!QKb^nh7}&?bJ^}VgurtBV z0y`V*Q(&J4I|uADV4ns19N6c<&IS7d*m+=I1p5-$m%+{ly8!G$u&;o973^zZUkCdJ z*f+tx1$GhG#bDnC`wrN5!M+FfeXt*Z{SfR&V3&Yh3U(RT@u&cm+0`^m| zpMhNs_H(dbfL#N2E!Z!?eg*bxu-}0F7VLLmzX$sR*dM|E1omgJzkpo_c0Jf%!EONi l8`$5${sHz+up7bt1$GnI&0x2H{Tu8*VE+aC-!>aG{~w4)`*Q#Q literal 14415 zcmbWwd7KOc6bEp!yT;K$MJPul+u=x(PKlz%k&q5+jG8r*-JR_0P)aGcrb44~h1^oP z3OPEQUDBP(RZ15riVm`T`tb4Z_kG?U@AE$I`+og1Mz?5E;z;GBvx_@eGAG?Hot?^z z7bGG@>6T5Gj5%CmQ(5uc+~YUp3X=Jucy6eBtRRsN22z3IA(V*qjTEa{|EmhU!+FU_ zs3?B;DqI*#MAE?$$#AM{$HG`RuV&kDek2_^78}ht8W_zyHf99_(b7ksMgzf;$#Ap` zxD(KoLYILq6I~X%(&z%{%AhNYt{l4Z=uSj;61tPoor10cx{BydMRyvy)6rEzR~g+I z=&GQrimn>EGtr%et~$CJ=xU;?h3;&0=b$?mU2Sydp{s)~8{PTnE;#^^3X*96_==&nF_CAzE7U5)M?{E>(Dhv*8<)3 z=x#vQ5?w2FH=?@ry9HebbRE%kLU${=&ggDKcRRW}(A|ly z3%VS1UD1Wmbwd|M*B#wm=&<#a54Bc>a zkD*JUdmP;p=$=G30^LY-qtHEtE{$$9x~I`SgYH>$W6+I7HxAu+bQ91$hi)ReN$4h{ zdmh~sbW_nyLpL4W40JQm%|bUD-3#dEpnDPBOXyxkHy7PJbo0?IK(`RxE9hQDw+P*0 zbW6~^hHfdkW$2cpTY>I%bZ?-06Wv?rR-#*lZZ*0!=+>fJhwg23@1T1Z-FxWXN4Fl` z2k17S`w-nn=srgG3A#_weTMFHbYGy`i0(^tU!nUN-6nLK(QQGu72P&;-=O;z-F9@} zq5B@)4s<`D`w`tw=zd1`3%Z@?cA@(f-EMThq5B=(9&~%r{ekXJbockg-w_w7cL)Uk5VrsT From 675f4b7dcf1fcfd442be4159f04be6a0ad18c998 Mon Sep 17 00:00:00 2001 From: Tom Date: Fri, 12 Jul 2019 14:09:25 +0100 Subject: [PATCH 21/83] add second test trialbank --- TestData/2_binary_pulses.trialbank | Bin 0 -> 270 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 TestData/2_binary_pulses.trialbank diff --git a/TestData/2_binary_pulses.trialbank b/TestData/2_binary_pulses.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..bdf06a4cb7b92685c49bfea20a195edcb83674d7 GIT binary patch literal 270 zcmZo*jxA)+h%IE)@MerHWU4J>)`(zXU|=YzEJ!V6iC_aVoig(hiz*9QBUpi){Ji4S zl0r6j`<*jEU=~=7N3-vS6s;9?w|k^0)hxZAW@c>Q<@rI zk`IzhEXpiSE#&lOir@gs00rWUGpkYyx!mnnLaZoFjNk&wgcM~a<|z0j=B5^Mr^XiY lfE~%AcC52LP&(Q-A;f literal 0 HcmV?d00001 From cedb949b9242a839a1d2aea55d9627bec1b8aa43 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 12 Jul 2019 14:11:29 +0100 Subject: [PATCH 22/83] update binary_test_trialbank --- Binary sequence creating.ipynb | 71 ++++++++++++++++++++----- TestData/testbinarytrialbank.trialbank | Bin 15451 -> 15451 bytes 2 files changed, 59 insertions(+), 12 deletions(-) diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index 4212f83..111d049 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 130, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 131, "metadata": {}, "outputs": [], "source": [ @@ -44,20 +44,20 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 133, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n" + "[4, [{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}], 'Trial Name']\n" ] } ], "source": [ - "params = trialbank\n", - "print(type(params))\n", + "params = trialbank[0]\n", + "print(params)\n", "sampling_rate = 20000" ] }, @@ -5228,30 +5228,77 @@ }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 141, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", - "trialbank = []\n", + "trialbank_out = []\n", "for i in range(256):\n", " params = {}\n", - " params['type']='binary'\n", + " params['type']='Binary'\n", " params['onset'] = 0.1\n", " params['offset'] = 0.1\n", " params['num_of_bins'] = 8\n", " params['bin_size'] = 0.05\n", " params['value_to_binarise'] = i\n", - " trialbank.append([1, [params], 'Trial Name'])" + " trialbank_out.append([1, [params], 'Trial Name'])" ] }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}]\n", + "[{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}]\n" + ] + } + ], + "source": [ + "print(trialbank[0][1])\n", + "print(trialbank_out[0][1])" + ] + }, + { + "cell_type": "code", + "execution_count": 143, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "test_trialbank = pickle.Unpickler(open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/2_binary_pulses.trialbank', 'rb')).load()" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 2, 'bin_size': 0.05}], 'Trial Name'], [1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 10, 'bin_size': 0.05}], 'Trial Name']]\n", + "[[1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 1}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 2}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 3}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 4}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 5}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 6}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 7}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 8}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 9}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 10}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 11}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 12}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 13}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 14}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 15}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 16}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 17}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 18}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 19}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 20}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 21}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 22}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 23}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 24}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 25}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 26}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 27}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 28}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 29}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 30}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 31}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 32}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 33}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 34}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 35}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 36}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 37}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 38}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 39}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 40}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 41}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 42}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 43}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 44}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 45}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 46}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 47}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 48}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 49}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 50}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 51}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 52}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 53}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 54}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 55}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 56}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 57}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 58}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 59}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 60}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 61}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 62}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 63}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 64}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 65}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 66}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 67}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 68}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 69}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 70}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 71}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 72}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 73}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 74}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 75}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 76}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 77}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 78}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 79}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 80}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 81}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 82}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 83}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 84}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 85}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 86}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 87}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 88}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 89}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 90}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 91}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 92}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 93}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 94}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 95}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 96}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 97}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 98}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 99}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 100}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 101}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 102}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 103}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 104}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 105}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 106}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 107}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 108}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 109}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 110}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 111}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 112}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 113}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 114}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 115}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 116}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 117}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 118}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 119}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 120}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 121}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 122}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 123}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 124}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 125}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 126}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 127}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 128}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 129}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 130}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 131}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 132}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 133}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 134}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 135}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 136}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 137}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 138}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 139}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 140}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 141}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 142}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 143}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 144}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 145}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 146}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 147}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 148}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 149}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 150}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 151}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 152}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 153}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 154}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 155}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 156}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 157}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 158}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 159}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 160}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 161}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 162}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 163}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 164}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 165}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 166}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 167}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 168}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 169}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 170}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 171}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 172}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 173}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 174}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 175}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 176}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 177}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 178}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 179}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 180}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 181}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 182}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 183}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 184}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 185}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 186}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 187}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 188}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 189}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 190}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 191}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 192}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 193}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 194}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 195}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 196}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 197}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 198}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 199}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 200}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 201}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 202}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 203}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 204}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 205}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 206}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 207}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 208}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 209}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 210}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 211}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 212}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 213}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 214}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 215}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 216}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 217}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 218}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 219}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 220}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 221}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 222}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 223}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 224}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 225}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 226}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 227}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 228}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 229}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 230}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 231}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 232}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 233}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 234}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 235}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 236}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 237}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 238}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 239}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 240}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 241}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 242}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 243}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 244}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 245}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 246}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 247}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 248}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 249}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 250}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 251}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 252}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 253}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 254}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 255}], 'Trial Name']]\n" + ] + } + ], + "source": [ + "print(test_trialbank)\n", + "print(trialbank_out)" ] }, { diff --git a/TestData/testbinarytrialbank.trialbank b/TestData/testbinarytrialbank.trialbank index a58d7263629b7752302167580e7d2828fb399974..789fe92a18e7c6c91522655692ae0fd07e39bb41 100644 GIT binary patch delta 12 Tcmcazal2xIBBRqrB}*FsCd~xn delta 12 Tcmcazal2xIB4g4 Date: Fri, 12 Jul 2019 14:22:01 +0100 Subject: [PATCH 23/83] even more test trialbanks --- .../Binary sequence creating-checkpoint.ipynb | 105 +++++++++++++++--- Binary sequence creating.ipynb | 34 +++++- .../testbinarytrialbank_no_onsets.trialbank | Bin 0 -> 15451 bytes 3 files changed, 123 insertions(+), 16 deletions(-) create mode 100644 TestData/testbinarytrialbank_no_onsets.trialbank diff --git a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb index b023199..cd63628 100644 --- a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb +++ b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 130, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 131, "metadata": {}, "outputs": [], "source": [ @@ -44,20 +44,20 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 133, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n" + "[4, [{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}], 'Trial Name']\n" ] } ], "source": [ - "params = trialbank\n", - "print(type(params))\n", + "params = trialbank[0]\n", + "print(params)\n", "sampling_rate = 20000" ] }, @@ -5228,30 +5228,107 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 141, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", - "trialbank = []\n", + "trialbank_out = []\n", "for i in range(256):\n", " params = {}\n", - " params['type']='binary'\n", - " params['onset'] = 0.1\n", - " params['offset'] = 0.1\n", + " params['type']='Binary'\n", + " params['onset'] = 0.0\n", + " params['offset'] = 0.0\n", " params['num_of_bins'] = 8\n", " params['bin_size'] = 0.05\n", " params['value_to_binarise'] = i\n", - " trialbank.append([1, [params], 'Trial Name'])" + " trialbank_out.append([1, [params], 'Trial Name'])" ] }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}]\n", + "[{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}]\n" + ] + } + ], + "source": [ + "print(trialbank[0][1])\n", + "print(trialbank_out[0][1])" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [], + "source": [ + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "test_trialbank = pickle.Unpickler(open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/2_binary_pulses.trialbank', 'rb')).load()" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 2, 'bin_size': 0.05}], 'Trial Name'], [1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 10, 'bin_size': 0.05}], 'Trial Name']]\n", + "[[1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 1}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 2}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 3}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 4}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 5}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 6}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 7}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 8}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 9}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 10}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 11}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 12}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 13}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 14}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 15}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 16}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 17}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 18}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 19}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 20}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 21}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 22}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 23}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 24}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 25}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 26}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 27}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 28}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 29}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 30}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 31}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 32}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 33}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 34}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 35}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 36}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 37}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 38}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 39}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 40}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 41}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 42}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 43}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 44}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 45}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 46}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 47}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 48}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 49}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 50}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 51}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 52}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 53}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 54}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 55}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 56}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 57}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 58}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 59}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 60}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 61}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 62}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 63}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 64}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 65}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 66}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 67}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 68}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 69}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 70}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 71}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 72}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 73}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 74}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 75}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 76}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 77}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 78}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 79}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 80}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 81}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 82}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 83}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 84}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 85}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 86}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 87}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 88}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 89}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 90}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 91}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 92}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 93}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 94}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 95}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 96}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 97}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 98}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 99}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 100}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 101}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 102}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 103}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 104}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 105}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 106}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 107}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 108}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 109}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 110}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 111}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 112}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 113}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 114}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 115}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 116}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 117}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 118}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 119}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 120}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 121}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 122}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 123}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 124}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 125}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 126}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 127}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 128}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 129}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 130}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 131}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 132}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 133}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 134}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 135}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 136}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 137}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 138}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 139}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 140}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 141}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 142}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 143}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 144}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 145}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 146}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 147}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 148}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 149}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 150}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 151}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 152}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 153}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 154}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 155}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 156}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 157}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 158}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 159}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 160}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 161}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 162}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 163}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 164}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 165}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 166}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 167}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 168}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 169}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 170}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 171}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 172}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 173}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 174}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 175}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 176}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 177}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 178}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 179}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 180}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 181}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 182}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 183}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 184}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 185}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 186}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 187}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 188}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 189}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 190}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 191}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 192}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 193}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 194}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 195}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 196}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 197}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 198}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 199}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 200}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 201}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 202}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 203}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 204}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 205}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 206}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 207}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 208}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 209}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 210}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 211}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 212}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 213}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 214}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 215}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 216}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 217}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 218}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 219}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 220}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 221}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 222}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 223}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 224}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 225}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 226}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 227}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 228}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 229}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 230}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 231}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 232}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 233}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 234}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 235}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 236}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 237}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 238}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 239}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 240}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 241}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 242}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 243}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 244}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 245}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 246}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 247}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 248}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 249}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 250}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 251}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 252}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 253}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 254}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 255}], 'Trial Name']]\n" + ] + } + ], + "source": [ + "print(test_trialbank)\n", + "print(trialbank_out)" + ] + }, + { + "cell_type": "code", + "execution_count": 145, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank, open('/Users/warnert/Documents/GitHub/PulseBoy/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "full_binned = []\n", + "for i in range(256):\n", + " binned = bin(i)[2:]\n", + " if not len(binned) < 8:\n", + " full_binned.append(binned)" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['10000000', '10000001', '10000010', '10000011', '10000100', '10000101', '10000110', '10000111', '10001000', '10001001', '10001010', '10001011', '10001100', '10001101', '10001110', '10001111', '10010000', '10010001', '10010010', '10010011', '10010100', '10010101', '10010110', '10010111', '10011000', '10011001', '10011010', '10011011', '10011100', '10011101', '10011110', '10011111', '10100000', '10100001', '10100010', '10100011', '10100100', '10100101', '10100110', '10100111', '10101000', '10101001', '10101010', '10101011', '10101100', '10101101', '10101110', '10101111', '10110000', '10110001', '10110010', '10110011', '10110100', '10110101', '10110110', '10110111', '10111000', '10111001', '10111010', '10111011', '10111100', '10111101', '10111110', '10111111', '11000000', '11000001', '11000010', '11000011', '11000100', '11000101', '11000110', '11000111', '11001000', '11001001', '11001010', '11001011', '11001100', '11001101', '11001110', '11001111', '11010000', '11010001', '11010010', '11010011', '11010100', '11010101', '11010110', '11010111', '11011000', '11011001', '11011010', '11011011', '11011100', '11011101', '11011110', '11011111', '11100000', '11100001', '11100010', '11100011', '11100100', '11100101', '11100110', '11100111', '11101000', '11101001', '11101010', '11101011', '11101100', '11101101', '11101110', '11101111', '11110000', '11110001', '11110010', '11110011', '11110100', '11110101', '11110110', '11110111', '11111000', '11111001', '11111010', '11111011', '11111100', '11111101', '11111110', '11111111']\n" + ] + } + ], + "source": [ + "print(full_binned)" ] }, { diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index 111d049..cd63628 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5237,8 +5237,8 @@ "for i in range(256):\n", " params = {}\n", " params['type']='Binary'\n", - " params['onset'] = 0.1\n", - " params['offset'] = 0.1\n", + " params['onset'] = 0.0\n", + " params['offset'] = 0.0\n", " params['num_of_bins'] = 8\n", " params['bin_size'] = 0.05\n", " params['value_to_binarise'] = i\n", @@ -5301,6 +5301,36 @@ "print(trialbank_out)" ] }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [], + "source": [ + "full_binned = []\n", + "for i in range(256):\n", + " binned = bin(i)[2:]\n", + " if not len(binned) < 8:\n", + " full_binned.append(binned)" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['10000000', '10000001', '10000010', '10000011', '10000100', '10000101', '10000110', '10000111', '10001000', '10001001', '10001010', '10001011', '10001100', '10001101', '10001110', '10001111', '10010000', '10010001', '10010010', '10010011', '10010100', '10010101', '10010110', '10010111', '10011000', '10011001', '10011010', '10011011', '10011100', '10011101', '10011110', '10011111', '10100000', '10100001', '10100010', '10100011', '10100100', '10100101', '10100110', '10100111', '10101000', '10101001', '10101010', '10101011', '10101100', '10101101', '10101110', '10101111', '10110000', '10110001', '10110010', '10110011', '10110100', '10110101', '10110110', '10110111', '10111000', '10111001', '10111010', '10111011', '10111100', '10111101', '10111110', '10111111', '11000000', '11000001', '11000010', '11000011', '11000100', '11000101', '11000110', '11000111', '11001000', '11001001', '11001010', '11001011', '11001100', '11001101', '11001110', '11001111', '11010000', '11010001', '11010010', '11010011', '11010100', '11010101', '11010110', '11010111', '11011000', '11011001', '11011010', '11011011', '11011100', '11011101', '11011110', '11011111', '11100000', '11100001', '11100010', '11100011', '11100100', '11100101', '11100110', '11100111', '11101000', '11101001', '11101010', '11101011', '11101100', '11101101', '11101110', '11101111', '11110000', '11110001', '11110010', '11110011', '11110100', '11110101', '11110110', '11110111', '11111000', '11111001', '11111010', '11111011', '11111100', '11111101', '11111110', '11111111']\n" + ] + } + ], + "source": [ + "print(full_binned)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/TestData/testbinarytrialbank_no_onsets.trialbank b/TestData/testbinarytrialbank_no_onsets.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..cedd434564b4b0c5bb45ea9421d97ebdb2d1dee9 GIT binary patch literal 15451 zcmbu(Wl&TB5Ww+6kK+IfyTv{WyHOMa^%POD#q*)>e5c$UUZ97f*!Ap(3U-U#-QC^Y z-Q5Z}1LIf!JNsd0XMejJtBwotSEWRlqDxA>TbL4~=w!9S6)7sRCeUONY%WE1w_5C? zLkapjt5V4ttI_yx$J^pG8>~h{xXEHy^jcY)R2b~0Xi*6YNQ_U81lcD_h;WJqhc$Uh zu$kUks$z9T<9+f=OO08Zid8RIwy!38PLGu1jn-19Y zz^Z|D2UY{D2e4XTJ%RNC)*ILiz-9zC6R??q%>t|suvvl425fdUUY&l^4fGrPf z1z;-zTM5|8z*YgaDzMdntqyDrU~2+f3)tGg`U6`B*t)<509y~(`oIPP+W^>xz%~N5 zF|a|vHUYLNu+4zg1KS+f7QhAr+Y;CiU|Rv(8rU|#h639b*ml6S2et#S9f9oxY-eD* z02>BuS6~gmb^}%bHXPXQ!1e%E1l9;_PhcfrO~Cd7wl}a5z?y-z0BZ#{64*Y#+JLnK z>j2gXY!tA4f$ayZ3)pC2`vW@w*cf030y_xUSYQVOI|SIFzzzd;IItst9SQ6xU`GQx z2H3H{%D|2Tc08~XfSm~JBw!~4I|Wz;*f?OP0y_=Z>A=PVn*i(#U}pk53)tDf&H;8V zu=9YO59|V97XrHo*u}su0d^^{iNG!cb~&&sfL#gfDqvRwy9U^`z^(&!J+K>q-3aU^ zU^fH11=y{?ZUc5ZuseX=3G6OlcLTcz*uB8+19m^K2Y@{Y>>*$e1A7G6qre^m_BgO7 zfISK9DPT_ndj{CEz@7v4Jg^sly$I|jU@rrE1=y>=UIX?zus49c3G6LkZv%S=*t@{q z1NJ_!4}g6L>?2?w1N#Knr@%e~_BpUGfPD$ Date: Fri, 12 Jul 2019 14:42:15 +0100 Subject: [PATCH 24/83] another test trialbank --- Binary sequence creating.ipynb | 6 +++--- .../testbinarytrialbank_no_onsets2.trialbank | Bin 0 -> 15451 bytes 2 files changed, 3 insertions(+), 3 deletions(-) create mode 100644 TestData/testbinarytrialbank_no_onsets2.trialbank diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index cd63628..c46beed 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,7 +5228,7 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 147, "metadata": {}, "outputs": [], "source": [ @@ -5266,11 +5266,11 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 148, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_no_onsets.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { diff --git a/TestData/testbinarytrialbank_no_onsets2.trialbank b/TestData/testbinarytrialbank_no_onsets2.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..eb727b2a5376a96acba11e656dd0f0f4a1adab8b GIT binary patch literal 15451 zcmbu(d6bm{6aerkGt+B^h@?Ww)=09H3MC?gN1|w9dS3a)dzyK#=FN*q(Pr&s{X*G= z%3iXReU~j2D!V94i=_w^Wjd#hfBW5Y|G4L#`@8p!%AeS?b6#zfg(aIaTBj@=8J6Vo zt80b?VXm-SG8M0?33CPMR3@knOSjDC<>d;~<>mkH6sNM4v2=NCU^0~nqmf)>a}moV zhX-M4*GaW8IoEJlydoRKs?+~X#jBE;AdKc^k;qRJBnr14 zP1M^~Mxv2K{jG}=MbSFhc%pbaZC$WCfXxS60JacpJ+Kk5^}!Z_Ee5+I*qy*O0J}5T zUBEU3yDQk;z%~NAJJ`lx_W;`jY*Vn!!0rilFR*)qZ4P!Hur0v01iLTT{lM-I_5iR4 zf^7x11nfazTZ26qY#XqLfNcx*P_T!AJsj*2VB3Lh5B5l~9l&-3+X?JZV2=iS4A{_D)Cz+M1009y|BLa+(2Nw61z z9SpVtY$ezf*fiK7V26UO0-FI_4K@pQ7}$%!UIMlT>~OG`f*k>NB-qQqUJiB?*wJ9e zfE^2V9M~(sUJ3Rpuvde<2JE$9$Ais*odEVau-AjV0ql)nZvuNW*bwYQu(yD{73^(b zCxM*|_I9v$fV~s!U10A9dk@%q!QKaU3fTL>J^=PXuv5WK13Mk;Ltq~U`v}-a!9E7| zaj;K-odI?x*eAix0{ax$r@=l0_F1sA!Oj8u9N6cZ-IRq>|C(#fPEM2dtl!O`vKT_U_S&qAM66K3&DN__G7T0fL#Q3G1w(wKLz_4 z*w4X!0rpF^ESSg8dfkcVL%+T@Lnpus?wP5$sQ3SAbm!b`{vwV1EYt3)o-5 o{swjp*tKAP2m1%ubzuJl`xn^1!LA3p0qjPw|A76s)&^}i0oer1%m4rY literal 0 HcmV?d00001 From a10d7f64eba35e2fda55c50164b11874dd56c659 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 12 Jul 2019 14:46:21 +0100 Subject: [PATCH 25/83] another trialbank 0.01 s bins --- Binary sequence creating.ipynb | 8 ++++---- .../testbinarytrialbank_no_onsets3.trialbank | Bin 0 -> 15451 bytes 2 files changed, 4 insertions(+), 4 deletions(-) create mode 100644 TestData/testbinarytrialbank_no_onsets3.trialbank diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index c46beed..64db9f7 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,7 +5228,7 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": 149, "metadata": {}, "outputs": [], "source": [ @@ -5240,7 +5240,7 @@ " params['onset'] = 0.0\n", " params['offset'] = 0.0\n", " params['num_of_bins'] = 8\n", - " params['bin_size'] = 0.05\n", + " params['bin_size'] = 0.025\n", " params['value_to_binarise'] = i\n", " trialbank_out.append([1, [params], 'Trial Name'])" ] @@ -5266,11 +5266,11 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": 150, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_no_onsets.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_no_onsets2.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { diff --git a/TestData/testbinarytrialbank_no_onsets3.trialbank b/TestData/testbinarytrialbank_no_onsets3.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..08c14c2e56f685578db4425a5f844d323a390d10 GIT binary patch literal 15451 zcmbu(Wl&TB5Ww+6kK+If#V%|t>_$X z05&7AYG7S~)d1@TtQJ^zU_F5K1U3_}nSsp$Y*t{i0qX^9c3^V=>kVv9U~>VR8`wO+ z<^?t%u=#;40Bk{E3jtdgSRY`E09zE;V!##$wgj*xfh`5BFR-P7Edy*>V9Nnp9#}tM zD*#&&*h;`w2DS>YRe`MrY;|C309zB-TENx@whplVz}5w}9|+ZNamVA}!P9@q}Rb_BK)u$_VJ z0&G`c4ZwB-)(C8OUBuIItFAt-wYA+ZR|H zuy$Y_z&e4A1hyZr{eg`FHX7I%U;DOkigLI~&+J zz|IAB9$JtU>5}p`w0J|30b-=C%b_1{* zf!ze`W?;7fyA{}Nz-|Y22e3PV-39D!VD|vK7ubEk?g#b&um^!X1ngm8j{tiV*kiyR z2lfQ8CxJZ$>}g=n0DBhLbHJVl_5!dMfxQImWnixWdllGgz+MOT2Cz4Qy#?%TVDA8% z4D4NC?*V%s*ayHq1ojcIkAZyx>{DQ$0s9=-7r?#*_7$+Nfqet)TVUS-`ySX2z Date: Fri, 12 Jul 2019 15:25:25 +0100 Subject: [PATCH 26/83] add shatter to binary pulse --- Designs/binaryValveDesign.py | 24 ++++++++++++++++-------- Models/PBWidgets.py | 5 ++--- UI/BinaryValveWidget.ui | 32 +++++++++++++++++++++++--------- UI/binaryValveDesign.py | 24 ++++++++++++++++-------- 4 files changed, 57 insertions(+), 28 deletions(-) diff --git a/Designs/binaryValveDesign.py b/Designs/binaryValveDesign.py index 7379cd1..d75dc95 100644 --- a/Designs/binaryValveDesign.py +++ b/Designs/binaryValveDesign.py @@ -34,6 +34,9 @@ def setupUi(self, Form): self.label_3 = QtWidgets.QLabel(Form) self.label_3.setObjectName("label_3") self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) + self.shatterEdit = QtWidgets.QLineEdit(Form) + self.shatterEdit.setObjectName("shatterEdit") + self.gridLayout.addWidget(self.shatterEdit, 1, 6, 1, 1) self.onsetEdit = QtWidgets.QLineEdit(Form) self.onsetEdit.setObjectName("onsetEdit") self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) @@ -48,18 +51,21 @@ def setupUi(self, Form): self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) - self.label_4 = QtWidgets.QLabel(Form) - self.label_4.setObjectName("label_4") - self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) - self.numofbinsEdit = QtWidgets.QLineEdit(Form) - self.numofbinsEdit.setObjectName("numofbinsEdit") - self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.label_6 = QtWidgets.QLabel(Form) + self.label_6.setObjectName("label_6") + self.gridLayout.addWidget(self.label_6, 0, 6, 1, 1) self.binsizeEdit = QtWidgets.QLineEdit(Form) self.binsizeEdit.setObjectName("binsizeEdit") self.gridLayout.addWidget(self.binsizeEdit, 1, 4, 1, 1) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) self.label_5 = QtWidgets.QLabel(Form) self.label_5.setObjectName("label_5") self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) + self.numofbinsEdit = QtWidgets.QLineEdit(Form) + self.numofbinsEdit.setObjectName("numofbinsEdit") + self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -71,11 +77,13 @@ def retranslateUi(self, Form): self.label_2.setText(_translate("Form", "Offset")) self.valuetobinariseEdit.setText(_translate("Form", "2")) self.label_3.setText(_translate("Form", "Value to binarise")) + self.shatterEdit.setText(_translate("Form", "500")) self.onsetEdit.setText(_translate("Form", "0.1")) self.removeButton.setText(_translate("Form", "-")) self.label.setText(_translate("Form", "Onset")) - self.label_4.setText(_translate("Form", "Number of bins")) - self.numofbinsEdit.setText(_translate("Form", "8")) + self.label_6.setText(_translate("Form", "Shatter (Hz)")) self.binsizeEdit.setText(_translate("Form", "0.05")) + self.label_4.setText(_translate("Form", "Number of bins")) self.label_5.setText(_translate("Form", "Bin size")) + self.numofbinsEdit.setText(_translate("Form", "8")) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index c91c6d0..436a7cf 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -215,6 +215,7 @@ def get_parameters(self): params['num_of_bins'] = float(self.numofbinsEdit.text()) params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) params['bin_size'] = float(self.binsizeEdit.text()) + params['shatter_frequency'] = float(self.shatterEdit.text()) return params def set_parameters(self, params): @@ -223,10 +224,8 @@ def set_parameters(self, params): self.numofbinsEdit.setText(str(params['num_of_bins'])) self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) self.binsizeEdit.setText(str(params['bin_size'])) + self.shatterEdit.setText(str(params['shatter_frequency'])) - def load_binary_data(self): - fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', '', '*.npy') - self.binaryDataLabel.setText(fname) class TrialWidget(QtWidgets.QWidget, trialDesign.Ui_Form): diff --git a/UI/BinaryValveWidget.ui b/UI/BinaryValveWidget.ui index adaf525..72c6362 100644 --- a/UI/BinaryValveWidget.ui +++ b/UI/BinaryValveWidget.ui @@ -53,6 +53,13 @@ + + + + 500 + + + @@ -81,24 +88,24 @@ - - + + - Number of bins + Shatter (Hz) - - + + - 8 + 0.05 - - + + - 0.05 + Number of bins @@ -109,6 +116,13 @@ + + + + 8 + + + diff --git a/UI/binaryValveDesign.py b/UI/binaryValveDesign.py index 7379cd1..d75dc95 100644 --- a/UI/binaryValveDesign.py +++ b/UI/binaryValveDesign.py @@ -34,6 +34,9 @@ def setupUi(self, Form): self.label_3 = QtWidgets.QLabel(Form) self.label_3.setObjectName("label_3") self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) + self.shatterEdit = QtWidgets.QLineEdit(Form) + self.shatterEdit.setObjectName("shatterEdit") + self.gridLayout.addWidget(self.shatterEdit, 1, 6, 1, 1) self.onsetEdit = QtWidgets.QLineEdit(Form) self.onsetEdit.setObjectName("onsetEdit") self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) @@ -48,18 +51,21 @@ def setupUi(self, Form): self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) - self.label_4 = QtWidgets.QLabel(Form) - self.label_4.setObjectName("label_4") - self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) - self.numofbinsEdit = QtWidgets.QLineEdit(Form) - self.numofbinsEdit.setObjectName("numofbinsEdit") - self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.label_6 = QtWidgets.QLabel(Form) + self.label_6.setObjectName("label_6") + self.gridLayout.addWidget(self.label_6, 0, 6, 1, 1) self.binsizeEdit = QtWidgets.QLineEdit(Form) self.binsizeEdit.setObjectName("binsizeEdit") self.gridLayout.addWidget(self.binsizeEdit, 1, 4, 1, 1) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) self.label_5 = QtWidgets.QLabel(Form) self.label_5.setObjectName("label_5") self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) + self.numofbinsEdit = QtWidgets.QLineEdit(Form) + self.numofbinsEdit.setObjectName("numofbinsEdit") + self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -71,11 +77,13 @@ def retranslateUi(self, Form): self.label_2.setText(_translate("Form", "Offset")) self.valuetobinariseEdit.setText(_translate("Form", "2")) self.label_3.setText(_translate("Form", "Value to binarise")) + self.shatterEdit.setText(_translate("Form", "500")) self.onsetEdit.setText(_translate("Form", "0.1")) self.removeButton.setText(_translate("Form", "-")) self.label.setText(_translate("Form", "Onset")) - self.label_4.setText(_translate("Form", "Number of bins")) - self.numofbinsEdit.setText(_translate("Form", "8")) + self.label_6.setText(_translate("Form", "Shatter (Hz)")) self.binsizeEdit.setText(_translate("Form", "0.05")) + self.label_4.setText(_translate("Form", "Number of bins")) self.label_5.setText(_translate("Form", "Bin size")) + self.numofbinsEdit.setText(_translate("Form", "8")) From 55e30c61425eedfd5b946bbcb4b855df5a100be6 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 12 Jul 2019 15:27:08 +0100 Subject: [PATCH 27/83] new trialbanks --- Binary sequence creating.ipynb | 10 +++++----- ...inarytrialbank_shatter_small_onset.trialbank | Bin 0 -> 16749 bytes .../testbinarytrialbank_small_onset.trialbank | Bin 0 -> 15451 bytes 3 files changed, 5 insertions(+), 5 deletions(-) create mode 100644 TestData/testbinarytrialbank_shatter_small_onset.trialbank create mode 100644 TestData/testbinarytrialbank_small_onset.trialbank diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index 64db9f7..de8fd1c 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,7 +5228,7 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": 153, "metadata": {}, "outputs": [], "source": [ @@ -5237,10 +5237,10 @@ "for i in range(256):\n", " params = {}\n", " params['type']='Binary'\n", - " params['onset'] = 0.0\n", + " params['onset'] = 0.01\n", " params['offset'] = 0.0\n", " params['num_of_bins'] = 8\n", - " params['bin_size'] = 0.025\n", + " params['bin_size'] = 0.01\n", " params['value_to_binarise'] = i\n", " trialbank_out.append([1, [params], 'Trial Name'])" ] @@ -5266,11 +5266,11 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": 154, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_no_onsets2.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_small_onset.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { diff --git a/TestData/testbinarytrialbank_shatter_small_onset.trialbank b/TestData/testbinarytrialbank_shatter_small_onset.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..6760aaedeb4411e7e19d1337affd2747b5e3bb0b GIT binary patch literal 16749 zcmbu(WmFVV7{>8M7g)kTu?rguy92>kbp;DsTnC(WR$&)5&;?QK8hfz26T7>+yT$Ir zPQ;`5+5bKF!#(eNpWk^B)QMpMsYTJ_{wUVBT7_cmq4RQus9Ui*=(|k zHbv_{I5t_E0fC~j&DWIW%8wK1c;6VXT3S^={ zW(s7XKvoKPQ6L)yvQxmD0y!vL4lGK@TEX03Y4Zm848r8KsgHdQJ_2pDo~&z1u9XXG6kwopehBbQJ^{n zYEYmi1!_^CHU;WXpe_aKQNW)9^(hcQfj|m0pg=R0s;lX zC=gD8?i3IyV4y$`3P=<%QlKXVdQl*P0+AFjQNT=rC<;VVz(N5l1#A?sQy_){y(!R# z0uBnqQXq~3eJK!6fqoR|Pk{sq44}Y33JjvaUb3S6MTMG9P^z-0Jf$1)fvj1qEJG;1va4Q{W8+-clfi0`DmB fo&p~z@R0(aDDasAUnuaE0^ca`odQ470nzU#!?Iu( literal 0 HcmV?d00001 diff --git a/TestData/testbinarytrialbank_small_onset.trialbank b/TestData/testbinarytrialbank_small_onset.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..9b21126fd690e1b2a201afce97b9ebe9b732c4fd GIT binary patch literal 15451 zcmbu(WmFUa5Ww+6kK+If#V%|t>_$q?TMI&EKPvo9@pwNvqdN?r9Sby^B+jJpa?C z12#RdYG7S~)d1@TtQJ^zU_F5K1U3V(8G+3NY-V7y0P6*8R$#LM>kVvnU~>SQ6WCn9 z<_0zouz7*a2W);|3jkXXSRY^u0b3Z@BES{}wivL*fh_^7FR&$nEd^|8V9Nko7Fa)E z%K=*+*b2Z_1hx{em4U4SY*k>Z0b3o|8o<^BwidAdz}5z~4zK~h)&;g6uz|qV2etvQ z4S{V0tPa@5z%~K4DX@BAn*rM#*dSnA02>T!OJG|8+ZxyqVA}xO7T9*cwgI0ox7O?!bz`8iDNrtOTqH*q*@l0@e&{IItFAt-wYA+Z$LL zuy$Y_z&e4A1hx;beSwVvHX7I%VEX|Z3v7R2F05+p5ZFb)E(Uf9uuFkm2JCWRR{)y?>`Gu)0lOO5HNdU~b{(+m zf!zS?MqoDqyBXLmz-|S08?f7f-2v=QV0Qt#8`wR-?ge%qu={~M0PI0v4*`1^*dxFm z1@;)Q$ALWo>`7ox0ec$QGr*n&_8hS1fxQ6iMPM%hdl}d(z+MIR8nD-ay#ee^U~d7N z4D4-S?*Mxj*n7a<2lfH54}pCI>| Date: Fri, 12 Jul 2019 15:45:09 +0100 Subject: [PATCH 28/83] add trialbank With channel 2 indicator for trial being run --- Binary sequence creating.ipynb | 31 +++++++++++++----- ...atter_small_onset_indicator_chan.trialbank | Bin 0 -> 17779 bytes 2 files changed, 22 insertions(+), 9 deletions(-) create mode 100644 TestData/testbinarytrialbank_shatter_small_onset_indicator_chan.trialbank diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index de8fd1c..61f16ed 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,12 +5228,15 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": 155, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", "trialbank_out = []\n", + "ind_params = {'type':'Simple', 'fromValues':False, 'fromDuty':True, 'isClean':True, 'isShatter':False, 'fromRepeats':False,\n", + " 'fromLength':True, 'onset':0.01, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", + " 'duty':0.5, 'shatter_frequency':500.0, 'shatter_d'}\n", "for i in range(256):\n", " params = {}\n", " params['type']='Binary'\n", @@ -5242,35 +5245,45 @@ " params['num_of_bins'] = 8\n", " params['bin_size'] = 0.01\n", " params['value_to_binarise'] = i\n", - " trialbank_out.append([1, [params], 'Trial Name'])" + " params['shatter_frequency'] = 500\n", + " \n", + " trialbank_out.append([2, [params, ], 'Trial Name'])" ] }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 158, + "metadata": {}, + "outputs": [], + "source": [ + "simp_trialbank = pickle.Unpickler(open('/Volumes/lab-schaefera/working/warnert/Recordings/190222/2Hz_20Hz_corr_anti_corr_reorder.trialbank', 'rb')).load()" + ] + }, + { + "cell_type": "code", + "execution_count": 162, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}]\n", - "[{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}]\n" + "{'type': 'Simple', 'fromValues': False, 'fromDuty': True, 'isClean': False, 'isShatter': True, 'fromRepeats': False, 'fromLength': True, 'onset': 0.1, 'offset': 0.1, 'pulse_width': 0.1, 'pulse_delay': 0.1, 'frequency': 10.0, 'duty': 0.5, 'shatter_frequency': 500.0, 'shatter_duty': 0.5, 'repeats': 5, 'length': 2.0}\n" ] } ], "source": [ - "print(trialbank[0][1])\n", - "print(trialbank_out[0][1])" + "print(simp_trialbank[0][1][0])\n", + "#print(trialbank_out[0][1])" ] }, { "cell_type": "code", - "execution_count": 154, + "execution_count": 156, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_small_onset.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_shatter_small_onset.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { diff --git a/TestData/testbinarytrialbank_shatter_small_onset_indicator_chan.trialbank b/TestData/testbinarytrialbank_shatter_small_onset_indicator_chan.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..5714e6f479556fe34a81a999a54b1ded6bbf7513 GIT binary patch literal 17779 zcmb`^cW@MC7{~DhE|*I#lqiTuZyFE~1VrjZ+5$&Wf+!*!OY&ZJ;TpGlzy&D+0)eG3 zRVh}QU;_auDk>-n7CIKXp!5#XyvqTJGyLUzcXoE(edc*S^Za&)Tc#_m9iTP$ibzlIikQ+>Hygj5-!~z?UIA4CQN6Xk*X=Ou8W|{9TfdT!j~B~J6?s zg((XBCdHy8+&_q7bJ~=o{D{fUc*P$5s7i`Z%KTrW5MUGr3=3c+0EQJX5&^>o7)gMU z3>bF6NCAu@fKe1MiUCG(z(@s*2LR(iz$gJ2B?03hz$gV64+BPNz<2~O$^b@Lz$gb8 z@$RV}Owc7}Wuz24Fl67&QT-7GTr{j3)r24q(&; zj3)u39$?f5j0S-56ks$2jHdyk5nwb1j3$856fl|rMsvV$07g1sJOdal0HY;fv;vIQ zfYAmpB*17380`R~JzzKiqXS@c1dL9A(HStF1&rqaqYGeU07h59cpfmi0mch}@giV! z2aJ~hqX%HT3>ZBDqZeSf0HZfx$biuYFfsun3ory=xB(*@FciR00i!Qq^aBhJV0Zz; z2N-_92mnTZzz70{1{gYEgaBgzUdEf#t^_53K+uxV>n>E3K$~* zVDol0gSPLkqa2(0AoC07=SSWFeU=VB*2&q7*haaDqu_l3==S>1I7%% zm@d03b2pAs$#>as131F-MjFo`#DPXJujMad#1~5JYjJ1HV4lvdO z#s;R0NfUyfOb_2#9z}O2I`vBut!1xU?eg}*{0AoL38~}`ifN=;g4g Date: Fri, 12 Jul 2019 16:39:57 +0100 Subject: [PATCH 29/83] more trialbanks --- Binary sequence creating.ipynb | 87 ++++++++++++++---- ...atter_small_onset_0.005_bin_size.trialbank | Bin 0 -> 17779 bytes 2 files changed, 67 insertions(+), 20 deletions(-) create mode 100644 TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index 61f16ed..d56993c 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,26 +5228,26 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": 163, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", "trialbank_out = []\n", - "ind_params = {'type':'Simple', 'fromValues':False, 'fromDuty':True, 'isClean':True, 'isShatter':False, 'fromRepeats':False,\n", - " 'fromLength':True, 'onset':0.01, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", - " 'duty':0.5, 'shatter_frequency':500.0, 'shatter_d'}\n", + "ind_params = {'type':'Simple', 'fromValues':True, 'fromDuty':False, 'isClean':True, 'isShatter':False, 'fromRepeats':True,\n", + " 'fromLength':False, 'onset':0.01, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", + " 'duty':0.5, 'shatter_frequency':500.0, 'shatter_duty':0.5, 'repeats':1, 'length':1.0}\n", "for i in range(256):\n", " params = {}\n", " params['type']='Binary'\n", - " params['onset'] = 0.01\n", + " params['onset'] = 0.1\n", " params['offset'] = 0.0\n", - " params['num_of_bins'] = 8\n", - " params['bin_size'] = 0.01\n", + " params['num_of_bins'] = 16\n", + " params['bin_size'] = 0.005\n", " params['value_to_binarise'] = i\n", " params['shatter_frequency'] = 500\n", " \n", - " trialbank_out.append([2, [params, ], 'Trial Name'])" + " trialbank_out.append([2, [params, ind_params], 'Trial Name'])" ] }, { @@ -5279,11 +5279,11 @@ }, { "cell_type": "code", - "execution_count": 156, + "execution_count": 164, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_shatter_small_onset.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_shatter_small_onset_indicator_chan.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { @@ -5297,21 +5297,22 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 181, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 2, 'bin_size': 0.05}], 'Trial Name'], [1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 10, 'bin_size': 0.05}], 'Trial Name']]\n", - "[[1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 1}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 2}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 3}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 4}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 5}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 6}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 7}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 8}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 9}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 10}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 11}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 12}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 13}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 14}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 15}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 16}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 17}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 18}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 19}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 20}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 21}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 22}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 23}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 24}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 25}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 26}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 27}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 28}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 29}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 30}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 31}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 32}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 33}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 34}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 35}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 36}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 37}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 38}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 39}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 40}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 41}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 42}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 43}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 44}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 45}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 46}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 47}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 48}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 49}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 50}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 51}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 52}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 53}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 54}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 55}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 56}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 57}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 58}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 59}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 60}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 61}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 62}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 63}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 64}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 65}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 66}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 67}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 68}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 69}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 70}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 71}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 72}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 73}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 74}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 75}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 76}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 77}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 78}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 79}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 80}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 81}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 82}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 83}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 84}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 85}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 86}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 87}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 88}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 89}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 90}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 91}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 92}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 93}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 94}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 95}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 96}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 97}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 98}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 99}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 100}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 101}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 102}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 103}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 104}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 105}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 106}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 107}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 108}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 109}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 110}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 111}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 112}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 113}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 114}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 115}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 116}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 117}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 118}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 119}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 120}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 121}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 122}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 123}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 124}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 125}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 126}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 127}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 128}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 129}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 130}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 131}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 132}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 133}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 134}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 135}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 136}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 137}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 138}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 139}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 140}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 141}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 142}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 143}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 144}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 145}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 146}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 147}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 148}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 149}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 150}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 151}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 152}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 153}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 154}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 155}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 156}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 157}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 158}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 159}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 160}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 161}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 162}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 163}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 164}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 165}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 166}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 167}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 168}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 169}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 170}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 171}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 172}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 173}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 174}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 175}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 176}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 177}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 178}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 179}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 180}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 181}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 182}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 183}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 184}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 185}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 186}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 187}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 188}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 189}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 190}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 191}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 192}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 193}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 194}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 195}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 196}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 197}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 198}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 199}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 200}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 201}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 202}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 203}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 204}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 205}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 206}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 207}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 208}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 209}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 210}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 211}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 212}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 213}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 214}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 215}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 216}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 217}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 218}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 219}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 220}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 221}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 222}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 223}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 224}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 225}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 226}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 227}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 228}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 229}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 230}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 231}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 232}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 233}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 234}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 235}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 236}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 237}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 238}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 239}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 240}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 241}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 242}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 243}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 244}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 245}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 246}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 247}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 248}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 249}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 250}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 251}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 252}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 253}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 254}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 255}], 'Trial Name']]\n" - ] + "data": { + "text/plain": [ + "32768.0" + ] + }, + "execution_count": 181, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "print(test_trialbank)\n", - "print(trialbank_out)" + "(2**16)/2" ] }, { @@ -5344,12 +5345,58 @@ "print(full_binned)" ] }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n" + ] + } + ], + "source": [ + "for i in range(2**num_of_bins):\n", + " bin_width = params['bin_size']*sampling_rate\n", + " binary = bin(i)[2:]\n", + " #print(binary)\n", + " full_pulse = []\n", + " while len(binary) < num_of_bins:\n", + " binary = '0'+binary\n", + " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", + " \n", + " full_pulse.extend(bin_pulse)\n", + "print(full_pulse)" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def full_binary_sequence(sampling_rate, params):\n", + " \n", + " \n", + " bin_width = params['bin_size']*sampling_rate\n", + " for i in range(2**num_of_bins):\n", + " binned = bin(binary)[2:]\n", + " while len(binned) < params['num_of_bins']:\n", + " binned = '0' + binned\n", + " bin_output = []\n", + " print(binned, bin_width)\n", + " onset = np.zeros(int(sampling_rate * params['onset']))\n", + " offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + " \n", + " \n", + " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", + " total_length = round(params['onset'] + params['offset'] + len(bin_pulse)/sampling_rate, 10)\n", + " return np.hstack((onset, bin_pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n" + ] } ], "metadata": { diff --git a/TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank b/TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..59ac0ab8b1880bf65cb38963526a0ccf2b090887 GIT binary patch literal 17779 zcmb`^cXSk06u{vGHk(a0Dxs>VAX0)90lOj_>Ie%61Q2QKK;AN=+t`@}H%Jo@f={sw zRRQT$R6vxDf(20Q1#BS2u7HSu1!l65gnv1|cjnA_@1A?VbMJd&TvN67X(elbm1lqc z3ifZLl_y8x4O9SsIcBB}DUH0g~b!hvWoFi4LW zmfs^i_9kHHMZ&H!iw-EOs*aGk!_-hh1k9+DrN(tbSpGDbYiO!zig+Lx7ef;wGB{~< zIgy^Q`_Np{U7&|!A-k9CU_2V`?bI9AB6DZJoke7bsaeIETk(xgb){u0WkbXgAwvX)>xFib;#*tVw>K3o6d^Tfm1Sp@ zHLT>MfZ+m+48U*$ zMkZi*03!=9vH`;j7&(A(31D0b7?%M?CBVo9jLLvf1u&`tMm4~w4j456<8r{b0x+%w zjGBOP6<}Nq7}o$sEx@P^7}o+u9l*E_FzNzEJ;10B7!3d;4=@@6#`S>F2rwE0Mianj z3K%y4Ml--@4j3%}<3_-^2{3L3j9UQXR=~IoFm4BoI{@QOz-S2=cL7E#!0-V^K47#4 zj5dJL7BJcYMti{M02m5j+zl8V0izRO_yMCcU~~bDu7Gh5U~~hF?tsw)FbV*pCt&mf zjNX88FJSZmjQaqiFJSZojQ)Tz05ApuMgTDG2MiT31_8!kz$gR^0T@BR7y=j?VCaDH z0AM@_7$Lw214aZeqJR+tjG=%L2Mhx+Ou$G0#xTGb4j2ysMiMZJ0AmDTJPa5k0b>+k zj0TJ`fH4*@9s!JTfH590CIH5xfH4s;CILnmkP0>&o5*bEq30Anj)Yy*tf0pkt8*bW#w0OL)-cndJz28?$AV<%wj0*u{&@h)Jz z2N-(*<9)#R05CoTjE?~0W5D&Z0I1Cs^0ONbW_yI6}1dN{m<7dG51u%XEjNbs`cfdFb7{>tPIAHt% o7$*SZPrx_{7=HoADZn@l7-s Date: Fri, 12 Jul 2019 17:02:36 +0100 Subject: [PATCH 30/83] update trialbank --- .../Binary sequence creating-checkpoint.ipynb | 104 +- Binary sequence creating.ipynb | 1737 ++++++++++++++++- ...atter_small_onset_0.005_bin_size.trialbank | Bin 17779 -> 17779 bytes 3 files changed, 1781 insertions(+), 60 deletions(-) diff --git a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb index cd63628..1634577 100644 --- a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb +++ b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb @@ -5228,49 +5228,62 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 182, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", "trialbank_out = []\n", + "ind_params = {'type':'Simple', 'fromValues':True, 'fromDuty':False, 'isClean':True, 'isShatter':False, 'fromRepeats':True,\n", + " 'fromLength':False, 'onset':0.01, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", + " 'duty':0.5, 'shatter_frequency':500.0, 'shatter_duty':0.5, 'repeats':1, 'length':1.0}\n", "for i in range(256):\n", " params = {}\n", " params['type']='Binary'\n", - " params['onset'] = 0.0\n", + " params['onset'] = 0.1\n", " params['offset'] = 0.0\n", " params['num_of_bins'] = 8\n", - " params['bin_size'] = 0.05\n", + " params['bin_size'] = 0.005\n", " params['value_to_binarise'] = i\n", - " trialbank_out.append([1, [params], 'Trial Name'])" + " params['shatter_frequency'] = 500\n", + " \n", + " trialbank_out.append([2, [params, ind_params], 'Trial Name'])" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [], + "source": [ + "simp_trialbank = pickle.Unpickler(open('/Volumes/lab-schaefera/working/warnert/Recordings/190222/2Hz_20Hz_corr_anti_corr_reorder.trialbank', 'rb')).load()" ] }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 162, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[{'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Near_40cm/plume_40cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}, {'type': 'Anti Plume', 'onset': 0.1, 'offset': 0.1, 'shatter_frequency': 500.0, 'data_fs': 10000.0, 'data_path': 'Z:/working/marinc/Distance_box/Far_80cm/plume_80cm_180328_9.mat', 'target_max': 1.0}]\n", - "[{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}]\n" + "{'type': 'Simple', 'fromValues': False, 'fromDuty': True, 'isClean': False, 'isShatter': True, 'fromRepeats': False, 'fromLength': True, 'onset': 0.1, 'offset': 0.1, 'pulse_width': 0.1, 'pulse_delay': 0.1, 'frequency': 10.0, 'duty': 0.5, 'shatter_frequency': 500.0, 'shatter_duty': 0.5, 'repeats': 5, 'length': 2.0}\n" ] } ], "source": [ - "print(trialbank[0][1])\n", - "print(trialbank_out[0][1])" + "print(simp_trialbank[0][1][0])\n", + "#print(trialbank_out[0][1])" ] }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 183, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { @@ -5284,21 +5297,22 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 181, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 2, 'bin_size': 0.05}], 'Trial Name'], [1, [{'type': 'Binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8.0, 'value_to_binarise': 10, 'bin_size': 0.05}], 'Trial Name']]\n", - "[[1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 0}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 1}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 2}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 3}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 4}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 5}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 6}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 7}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 8}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 9}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 10}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 11}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 12}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 13}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 14}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 15}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 16}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 17}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 18}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 19}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 20}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 21}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 22}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 23}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 24}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 25}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 26}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 27}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 28}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 29}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 30}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 31}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 32}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 33}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 34}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 35}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 36}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 37}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 38}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 39}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 40}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 41}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 42}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 43}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 44}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 45}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 46}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 47}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 48}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 49}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 50}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 51}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 52}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 53}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 54}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 55}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 56}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 57}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 58}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 59}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 60}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 61}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 62}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 63}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 64}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 65}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 66}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 67}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 68}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 69}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 70}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 71}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 72}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 73}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 74}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 75}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 76}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 77}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 78}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 79}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 80}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 81}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 82}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 83}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 84}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 85}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 86}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 87}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 88}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 89}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 90}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 91}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 92}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 93}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 94}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 95}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 96}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 97}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 98}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 99}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 100}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 101}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 102}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 103}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 104}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 105}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 106}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 107}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 108}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 109}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 110}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 111}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 112}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 113}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 114}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 115}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 116}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 117}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 118}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 119}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 120}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 121}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 122}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 123}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 124}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 125}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 126}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 127}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 128}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 129}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 130}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 131}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 132}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 133}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 134}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 135}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 136}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 137}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 138}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 139}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 140}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 141}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 142}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 143}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 144}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 145}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 146}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 147}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 148}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 149}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 150}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 151}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 152}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 153}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 154}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 155}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 156}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 157}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 158}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 159}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 160}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 161}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 162}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 163}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 164}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 165}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 166}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 167}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 168}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 169}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 170}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 171}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 172}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 173}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 174}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 175}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 176}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 177}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 178}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 179}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 180}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 181}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 182}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 183}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 184}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 185}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 186}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 187}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 188}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 189}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 190}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 191}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 192}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 193}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 194}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 195}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 196}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 197}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 198}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 199}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 200}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 201}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 202}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 203}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 204}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 205}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 206}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 207}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 208}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 209}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 210}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 211}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 212}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 213}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 214}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 215}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 216}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 217}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 218}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 219}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 220}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 221}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 222}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 223}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 224}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 225}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 226}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 227}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 228}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 229}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 230}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 231}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 232}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 233}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 234}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 235}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 236}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 237}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 238}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 239}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 240}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 241}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 242}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 243}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 244}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 245}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 246}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 247}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 248}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 249}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 250}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 251}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 252}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 253}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 254}], 'Trial Name'], [1, [{'type': 'binary', 'onset': 0.1, 'offset': 0.1, 'num_of_bins': 8, 'bin_size': 0.05, 'value_to_binarise': 255}], 'Trial Name']]\n" - ] + "data": { + "text/plain": [ + "32768.0" + ] + }, + "execution_count": 181, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "print(test_trialbank)\n", - "print(trialbank_out)" + "(2**16)/2" ] }, { @@ -5331,12 +5345,60 @@ "print(full_binned)" ] }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [], + "source": [ + "full_pulse = []\n", + "for i in range(2**num_of_bins):\n", + " bin_width = params['bin_size']*sampling_rate\n", + " binary = bin(i)[2:]\n", + " #print(binary)\n", + " \n", + " while len(binary) < num_of_bins:\n", + " binary = '0'+binary\n", + " bin_pulse = [int(i) for i in binary for j in range(int(bin_width))]\n", + " #print(bin_pulse)\n", + " \n", + " full_pulse.extend(bin_pulse)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(np.arange(0, len(full_pulse), 1/20000), full_pulse)" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def full_binary_sequence(sampling_rate, params):\n", + " \n", + " \n", + " bin_width = params['bin_size']*sampling_rate\n", + " for i in range(2**num_of_bins):\n", + " binned = bin(binary)[2:]\n", + " while len(binned) < params['num_of_bins']:\n", + " binned = '0' + binned\n", + " bin_output = []\n", + " print(binned, bin_width)\n", + " onset = np.zeros(int(sampling_rate * params['onset']))\n", + " offset = np.zeros(int(sampling_rate * params['offset']))\n", + "\n", + " \n", + " \n", + " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", + " total_length = round(params['onset'] + params['offset'] + len(bin_pulse)/sampling_rate, 10)\n", + " return np.hstack((onset, bin_pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n" + ] } ], "metadata": { diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index d56993c..39092af 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,7 +5228,7 @@ }, { "cell_type": "code", - "execution_count": 163, + "execution_count": 182, "metadata": {}, "outputs": [], "source": [ @@ -5242,7 +5242,7 @@ " params['type']='Binary'\n", " params['onset'] = 0.1\n", " params['offset'] = 0.0\n", - " params['num_of_bins'] = 16\n", + " params['num_of_bins'] = 8\n", " params['bin_size'] = 0.005\n", " params['value_to_binarise'] = i\n", " params['shatter_frequency'] = 500\n", @@ -5279,11 +5279,11 @@ }, { "cell_type": "code", - "execution_count": 164, + "execution_count": 183, "metadata": {}, "outputs": [], "source": [ - "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_shatter_small_onset_indicator_chan.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" + "pickle.dump(trialbank_out, open('/Users/warnert/Documents/GitHub/PulseBoy/TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)" ] }, { @@ -5347,56 +5347,1715 @@ }, { "cell_type": "code", - "execution_count": 173, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n" - ] - } - ], + "outputs": [], "source": [ + "full_pulse = []\n", "for i in range(2**num_of_bins):\n", " bin_width = params['bin_size']*sampling_rate\n", " binary = bin(i)[2:]\n", " #print(binary)\n", - " full_pulse = []\n", + " \n", " while len(binary) < num_of_bins:\n", " binary = '0'+binary\n", - " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", - " \n", - " full_pulse.extend(bin_pulse)\n", - "print(full_pulse)" + " bin_pulse = [int(i) for i in binary for j in range(int(bin_width))]\n", + " #print(bin_pulse)\n", + " \n", + " full_pulse.extend(bin_pulse)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 197, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100.0\n" + ] + } + ], "source": [ - "def full_binary_sequence(sampling_rate, params):\n", - " \n", - " \n", - " bin_width = params['bin_size']*sampling_rate\n", - " for i in range(2**num_of_bins):\n", - " binned = bin(binary)[2:]\n", - " while len(binned) < params['num_of_bins']:\n", - " binned = '0' + binned\n", - " bin_output = []\n", - " print(binned, bin_width)\n", - " onset = np.zeros(int(sampling_rate * params['onset']))\n", - " offset = np.zeros(int(sampling_rate * params['offset']))\n", - "\n", - " \n", - " \n", - " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", - " total_length = round(params['onset'] + params['offset'] + len(bin_pulse)/sampling_rate, 10)\n", - " return np.hstack((onset, bin_pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n" + "print(bin_width)" ] + }, + { + "cell_type": "code", + "execution_count": 199, + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": 203, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(test[1], test[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank b/TestData/testbinarytrialbank_shatter_small_onset_0.005_bin_size.trialbank index 59ac0ab8b1880bf65cb38963526a0ccf2b090887..31c143597ee2cae6714749c80c81caf724f9c102 100644 GIT binary patch delta 17 Zcmey|#rV04al-$}Q<#J{3o<6T002yM2QmNv delta 21 dcmey|#rV04al(K0ma2#D>qM$IvoYqn004A331I*L From 1463f6eb33a73c9c941fbbf27e4c5f497acd96a9 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 12 Jul 2019 17:09:19 +0100 Subject: [PATCH 31/83] new trialbank --- .../Binary sequence creating-checkpoint.ipynb | 1738 ++++++++++++++++- Binary sequence creating.ipynb | 29 +- ...ytrialbank_0.005_bin_size_10_bin.trialbank | Bin 0 -> 35699 bytes 3 files changed, 1713 insertions(+), 54 deletions(-) create mode 100644 TestData/testbinarytrialbank_0.005_bin_size_10_bin.trialbank diff --git a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb index 1634577..a5d9bab 100644 --- a/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb +++ b/.ipynb_checkpoints/Binary sequence creating-checkpoint.ipynb @@ -5228,31 +5228,32 @@ }, { "cell_type": "code", - "execution_count": 182, + "execution_count": 204, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", "trialbank_out = []\n", "ind_params = {'type':'Simple', 'fromValues':True, 'fromDuty':False, 'isClean':True, 'isShatter':False, 'fromRepeats':True,\n", - " 'fromLength':False, 'onset':0.01, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", + " 'fromLength':False, 'onset':0.1, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", " 'duty':0.5, 'shatter_frequency':500.0, 'shatter_duty':0.5, 'repeats':1, 'length':1.0}\n", "for i in range(256):\n", - " params = {}\n", - " params['type']='Binary'\n", - " params['onset'] = 0.1\n", - " params['offset'] = 0.0\n", - " params['num_of_bins'] = 8\n", - " params['bin_size'] = 0.005\n", - " params['value_to_binarise'] = i\n", - " params['shatter_frequency'] = 500\n", - " \n", - " trialbank_out.append([2, [params, ind_params], 'Trial Name'])" + " if len(bin(i)) == 10:\n", + " params = {}\n", + " params['type']='Binary'\n", + " params['onset'] = 0.1\n", + " params['offset'] = 0.0\n", + " params['num_of_bins'] = 8\n", + " params['bin_size'] = 0.005\n", + " params['value_to_binarise'] = i\n", + " params['shatter_frequency'] = 500\n", + "\n", + " trialbank_out.append([2, [params, ind_params], 'Trial Name'])" ] }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 205, "metadata": {}, "outputs": [], "source": [ @@ -5279,7 +5280,7 @@ }, { "cell_type": "code", - "execution_count": 183, + "execution_count": 206, "metadata": {}, "outputs": [], "source": [ @@ -5347,7 +5348,7 @@ }, { "cell_type": "code", - "execution_count": 191, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -5367,38 +5368,1695 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 197, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100.0\n" + ] + } + ], "source": [ - "plt.plot(np.arange(0, len(full_pulse), 1/20000), full_pulse)" + "print(bin_width)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 199, "metadata": {}, - "outputs": [], - "source": [ - "def full_binary_sequence(sampling_rate, params):\n", - " \n", - " \n", - " bin_width = params['bin_size']*sampling_rate\n", - " for i in range(2**num_of_bins):\n", - " binned = bin(binary)[2:]\n", - " while len(binned) < params['num_of_bins']:\n", - " binned = '0' + binned\n", - " bin_output = []\n", - " print(binned, bin_width)\n", - " onset = np.zeros(int(sampling_rate * params['onset']))\n", - " offset = np.zeros(int(sampling_rate * params['offset']))\n", - "\n", - " \n", - " \n", - " bin_pulse = [int(i) for i in binned for j in range(int(bin_width))]\n", - " total_length = round(params['onset'] + params['offset'] + len(bin_pulse)/sampling_rate, 10)\n", - " return np.hstack((onset, bin_pulse, offset)), np.linspace(0, total_length, total_length * sampling_rate)\n" - ] + "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", + " 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", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 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": 203, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(test[1], test[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/Binary sequence creating.ipynb b/Binary sequence creating.ipynb index 39092af..a5d9bab 100644 --- a/Binary sequence creating.ipynb +++ b/Binary sequence creating.ipynb @@ -5228,31 +5228,32 @@ }, { "cell_type": "code", - "execution_count": 182, + "execution_count": 204, "metadata": {}, "outputs": [], "source": [ "trial = [1, [{}], 'Trial Name']\n", "trialbank_out = []\n", "ind_params = {'type':'Simple', 'fromValues':True, 'fromDuty':False, 'isClean':True, 'isShatter':False, 'fromRepeats':True,\n", - " 'fromLength':False, 'onset':0.01, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", + " 'fromLength':False, 'onset':0.1, 'offset':0.0, 'pulse_width':0.08, 'pulse_delay':0.0, 'frequency':10.0,\n", " 'duty':0.5, 'shatter_frequency':500.0, 'shatter_duty':0.5, 'repeats':1, 'length':1.0}\n", "for i in range(256):\n", - " params = {}\n", - " params['type']='Binary'\n", - " params['onset'] = 0.1\n", - " params['offset'] = 0.0\n", - " params['num_of_bins'] = 8\n", - " params['bin_size'] = 0.005\n", - " params['value_to_binarise'] = i\n", - " params['shatter_frequency'] = 500\n", - " \n", - " trialbank_out.append([2, [params, ind_params], 'Trial Name'])" + " if len(bin(i)) == 10:\n", + " params = {}\n", + " params['type']='Binary'\n", + " params['onset'] = 0.1\n", + " params['offset'] = 0.0\n", + " params['num_of_bins'] = 8\n", + " params['bin_size'] = 0.005\n", + " params['value_to_binarise'] = i\n", + " params['shatter_frequency'] = 500\n", + "\n", + " trialbank_out.append([2, [params, ind_params], 'Trial Name'])" ] }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 205, "metadata": {}, "outputs": [], "source": [ @@ -5279,7 +5280,7 @@ }, { "cell_type": "code", - "execution_count": 183, + "execution_count": 206, "metadata": {}, "outputs": [], "source": [ diff --git a/TestData/testbinarytrialbank_0.005_bin_size_10_bin.trialbank b/TestData/testbinarytrialbank_0.005_bin_size_10_bin.trialbank new file mode 100644 index 0000000000000000000000000000000000000000..3dbc4a4aa6014998b8a4400261146a5f51a06286 GIT binary patch literal 35699 zcmb{4XK++i6ae55LMj#%D;88#Y}k8A1a#F9R6wj47xKbe-E6`ZFd%{*0x+_{;h3ym@o)nRC85=f3}Me97c+Qqht%B;T{})D{0m@I zNDXVv*DdOhD>M?8M5O~0O)benGnI|$=BB}IKqfySDsMaW&1GBj6Qi<3rcW}6rwZYU zL}p++R)|-%{Fa>-0kKPu5sNQzZY|Euw; z_HaXxjJM{OWmha~I9Ai69f?XB+PaEW&ul-3Rk50JHB0tU=f4O2cS=;2{;SE_4pC{c zy~9}b!ge4RM3sZmiFmSm|9Df75B~9;!jiDle-9Ft*H(rVOK(1`tm{x5R<+$~*f|Kh z{a>V5ARPr#B9Kl3DHTYWK*|MDA&^ReR0*WBK$a88@&Z{wAS()_i$GQq$jSogDv(tK zvZ_E<6UgcUSwkRe3Z$Dr))L6t0$E2O>k6d1K-Lq;`U2TNAUy=Kp+Ghg$i@QcDUeMB zvZ+8e6UgQQ*+L+_1hS<-wi3wJ0@+3&+X`emfow039R#wYKz0(y&H~v*AiD}=H-YRf zkUa!aEsz?4>?x4m0_h`=z5>}xAbSfWCXjsuvadk)6G*K<`U#{?ApHfhzd#NU$bkYG zAdrCq86=Q{1Tt742Mgp7fgCE3!vu1;K#mZ|5P=*ika~d}C6Ks4h6-euKpF%R2&7RU z!vzuwBq5Na1#*l)k^*TGNJ=2h0%;M*2!W&pk`YK&AUT1I6v!xn94nAkfs7W&7=auo zkg)_V3FHicoGFmA1ah`O z&JoDD0y$40d4Wt8$oT@fKp+H=9qAZrSwn?TkQ z$l3x~M8d>@JW!1X3-K8iDL7klq66BaprV z*-IdM3nV6xeFU@@NLC;@fs7Q$D1jU+kXC_=7RVTZ94C;m0y$nF;{-BZASVdqM1hTI|Op4K&A`iE`i)Fkb4AjuRvx9 zc|;(O3gj_?JT8zY1oEUno)XB@0(nLt&kE!@fjlpe7XDKHG#Y? zkT(SKra;~j$lC&WM Date: Wed, 21 Aug 2019 18:34:22 +0100 Subject: [PATCH 32/83] Add position of valve --- Models/PBWidgets.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 436a7cf..c08f1dc 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -39,6 +39,7 @@ def get_parameters(self): params['shatter_duty'] = float(self.shatterDutyEdit.text()) params['repeats'] = int(self.repeatsEdit.text()) params['length'] = float(self.lengthEdit.text()) + params['position'] = int(len(self.parentUi.children()) - 1) return params @@ -61,6 +62,7 @@ def set_parameters(self, params): self.shatterDutyEdit.setText(str(params['shatter_duty'])) self.repeatsEdit.setText(str(params['repeats'])) self.lengthEdit.setText(str(params['length'])) + self.position.setText(params['position']) class NoiseValveWidget(QtWidgets.QWidget, noiseValveDesign.Ui_Form): @@ -93,6 +95,8 @@ def get_parameters(self): params['repeats'] = int(self.repeatsEdit.text()) params['length'] = float(self.lengthEdit.text()) params['shatter_frequency'] = float(self.shatterHzEdit.text()) + params['position'] = int(len(self.parentUi.children()) - 1) + return params @@ -108,6 +112,7 @@ def set_parameters(self, params): self.ampMaxEdit.setText(str(params['amp_max'])) self.repeatsEdit.setText(str(params['repeats'])) self.lengthEdit.setText(str(params['length'])) + self.position.setText(params['position']) class PlumeValveWidget(QtWidgets.QWidget, plumeValveDesign.Ui_Form): @@ -135,6 +140,8 @@ def get_parameters(self): params['data_fs'] = float(self.dataSamplingRateEdit.text()) params['data_path'] = str(self.plumeDataLabel.text()) params['target_max'] = float(self.targetMaxEdit.text()) + params['position'] = int(len(self.parentUi.children()) - 1) + return params @@ -145,6 +152,7 @@ def set_parameters(self, params): self.plumeDataLabel.setText(params['data_path']) self.dataSamplingRateEdit.setText(str(params['data_fs'])) self.targetMaxEdit.setText(str(params['target_max'])) + self.position.setText(params['position']) def load_plume_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') @@ -176,6 +184,7 @@ def get_parameters(self): params['data_fs'] = float(self.dataSamplingRateEdit.text()) params['data_path'] = str(self.plumeDataLabel.text()) params['target_max'] = float(self.targetMaxEdit.text()) + params['position'] = int(len(self.parentUi.children()) - 1) return params @@ -186,6 +195,7 @@ def set_parameters(self, params): self.plumeDataLabel.setText(params['data_path']) self.dataSamplingRateEdit.setText(str(params['data_fs'])) self.targetMaxEdit.setText(str(params['target_max'])) + self.position.setText(params['position']) def load_plume_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') @@ -216,6 +226,8 @@ def get_parameters(self): params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) params['bin_size'] = float(self.binsizeEdit.text()) params['shatter_frequency'] = float(self.shatterEdit.text()) + params['position'] = int(len(self.parentUi.children()) - 1) + return params def set_parameters(self, params): @@ -225,6 +237,7 @@ def set_parameters(self, params): self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) self.binsizeEdit.setText(str(params['bin_size'])) self.shatterEdit.setText(str(params['shatter_frequency'])) + self.position.setText(params['position']) From ac3d1ea71281c7adbd011e900d9ebf91b1b650e1 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 12:48:29 +0100 Subject: [PATCH 33/83] Cast position to str --- Models/PBWidgets.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index c08f1dc..602a9c2 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -237,7 +237,7 @@ def set_parameters(self, params): self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) self.binsizeEdit.setText(str(params['bin_size'])) self.shatterEdit.setText(str(params['shatter_frequency'])) - self.position.setText(params['position']) + self.position.setText(str(params['position'])) From f60559b4a424fba19682ab68451712daa56e3e7b Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:13:43 +0100 Subject: [PATCH 34/83] attempt to indepently update valve --- Models/PBWidgets.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 602a9c2..dfa4145 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -203,12 +203,12 @@ def load_plume_data(self): class BinaryPlumeValveWidget(QtWidgets.QWidget, binaryValveDesign.Ui_Form): - def __init__(self, parentUi=None): + def __init__(self, position, parentUi=None): super(self.__class__, self).__init__() self.setupUi(self) self.parentUi = parentUi - + self.position.setText(position) self.removeButton.clicked.connect(self.remove_from_parent) def remove_from_parent(self): @@ -237,7 +237,7 @@ def set_parameters(self, params): self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) self.binsizeEdit.setText(str(params['bin_size'])) self.shatterEdit.setText(str(params['shatter_frequency'])) - self.position.setText(str(params['position'])) + #self.position.setText(str(params['position'])) From 05221766a2c41529edc28538bc9c1c2300c49008 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:15:27 +0100 Subject: [PATCH 35/83] cast to string and add position to init --- Controllers/main.py | 1 + Models/PBWidgets.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index 38e8010..82c694a 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -62,6 +62,7 @@ def __init__(self): def add_valve(self, v_type='Simple', params=None): + position = len(self.valveBankContents.children()) - 1 if v_type == 'Simple': new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) elif v_type == 'Noise': diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index dfa4145..9e9487e 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -208,7 +208,7 @@ def __init__(self, position, parentUi=None): self.setupUi(self) self.parentUi = parentUi - self.position.setText(position) + self.position.setText(str(position)) self.removeButton.clicked.connect(self.remove_from_parent) def remove_from_parent(self): From 1b31711d7e05ef8a084488724b5d1f746eced2e9 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:16:48 +0100 Subject: [PATCH 36/83] remove the main alterations --- Controllers/main.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index 82c694a..38e8010 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -62,7 +62,6 @@ def __init__(self): def add_valve(self, v_type='Simple', params=None): - position = len(self.valveBankContents.children()) - 1 if v_type == 'Simple': new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) elif v_type == 'Noise': From 4b8fa847976c178e36306ff7a6cad8c87c615410 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:19:04 +0100 Subject: [PATCH 37/83] make sure position passed to right argument --- Models/PBWidgets.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 9e9487e..78fefaa 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -203,7 +203,7 @@ def load_plume_data(self): class BinaryPlumeValveWidget(QtWidgets.QWidget, binaryValveDesign.Ui_Form): - def __init__(self, position, parentUi=None): + def __init__(self, position=0, parentUi=None): super(self.__class__, self).__init__() self.setupUi(self) @@ -226,7 +226,6 @@ def get_parameters(self): params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) params['bin_size'] = float(self.binsizeEdit.text()) params['shatter_frequency'] = float(self.shatterEdit.text()) - params['position'] = int(len(self.parentUi.children()) - 1) return params From a418938949ea2e2ebc476e4a412276311483127a Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:20:14 +0100 Subject: [PATCH 38/83] readjust argument order --- Models/PBWidgets.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 78fefaa..605267f 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -203,7 +203,7 @@ def load_plume_data(self): class BinaryPlumeValveWidget(QtWidgets.QWidget, binaryValveDesign.Ui_Form): - def __init__(self, position=0, parentUi=None): + def __init__(self, parentUi=None, position=0): super(self.__class__, self).__init__() self.setupUi(self) From 11a65927106aabe3a5aabc5e250ec76c7f980f3b Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:25:00 +0100 Subject: [PATCH 39/83] update get and set params --- Models/PBWidgets.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 605267f..35088d7 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -226,6 +226,7 @@ def get_parameters(self): params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) params['bin_size'] = float(self.binsizeEdit.text()) params['shatter_frequency'] = float(self.shatterEdit.text()) + params['position'] = float(self.position.text()) return params @@ -236,6 +237,7 @@ def set_parameters(self, params): self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) self.binsizeEdit.setText(str(params['bin_size'])) self.shatterEdit.setText(str(params['shatter_frequency'])) + self.position.setText(str(params['position'])) #self.position.setText(str(params['position'])) From 9a2acc8fe65761419e788f04afd0fb808c76731f Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:31:20 +0100 Subject: [PATCH 40/83] Add position for all valve types --- Models/PBWidgets.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 35088d7..7324f7b 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -5,7 +5,7 @@ # TODO - These widgets could inherit from a common PBWidget parent that implements remove_from_parent etc. class SimpleValveWidget(QtWidgets.QWidget, simpleValveDesign.Ui_Form): - def __init__(self, parentUi=None): + def __init__(self, parentUi=None, position=0): super(self.__class__, self).__init__() self.setupUi(self) @@ -39,7 +39,7 @@ def get_parameters(self): params['shatter_duty'] = float(self.shatterDutyEdit.text()) params['repeats'] = int(self.repeatsEdit.text()) params['length'] = float(self.lengthEdit.text()) - params['position'] = int(len(self.parentUi.children()) - 1) + params['position'] = int(self.position.text()) return params @@ -66,7 +66,7 @@ def set_parameters(self, params): class NoiseValveWidget(QtWidgets.QWidget, noiseValveDesign.Ui_Form): - def __init__(self, parentUi=None): + def __init__(self, parentUi=None, position=0): super(self.__class__, self).__init__() self.setupUi(self) @@ -95,7 +95,7 @@ def get_parameters(self): params['repeats'] = int(self.repeatsEdit.text()) params['length'] = float(self.lengthEdit.text()) params['shatter_frequency'] = float(self.shatterHzEdit.text()) - params['position'] = int(len(self.parentUi.children()) - 1) + params['position'] = int(self.position.text()) return params @@ -116,7 +116,7 @@ def set_parameters(self, params): class PlumeValveWidget(QtWidgets.QWidget, plumeValveDesign.Ui_Form): - def __init__(self, parentUi=None): + def __init__(self, parentUi=None, position=0): super(self.__class__, self).__init__() self.setupUi(self) @@ -140,7 +140,7 @@ def get_parameters(self): params['data_fs'] = float(self.dataSamplingRateEdit.text()) params['data_path'] = str(self.plumeDataLabel.text()) params['target_max'] = float(self.targetMaxEdit.text()) - params['position'] = int(len(self.parentUi.children()) - 1) + params['position'] = int(self.position.text()) return params @@ -160,7 +160,7 @@ def load_plume_data(self): class AntiPlumeValveWidget(QtWidgets.QWidget, plumeValveDesign.Ui_Form): - def __init__(self, parentUi=None): + def __init__(self, parentUi=None, position=0): super(self.__class__, self).__init__() self.setupUi(self) @@ -184,7 +184,7 @@ def get_parameters(self): params['data_fs'] = float(self.dataSamplingRateEdit.text()) params['data_path'] = str(self.plumeDataLabel.text()) params['target_max'] = float(self.targetMaxEdit.text()) - params['position'] = int(len(self.parentUi.children()) - 1) + params['position'] = int(self.position.text()) return params @@ -226,7 +226,7 @@ def get_parameters(self): params['value_to_binarise'] = int(self.valuetobinariseEdit.text()) params['bin_size'] = float(self.binsizeEdit.text()) params['shatter_frequency'] = float(self.shatterEdit.text()) - params['position'] = float(self.position.text()) + params['position'] = int(self.position.text()) return params @@ -238,7 +238,6 @@ def set_parameters(self, params): self.binsizeEdit.setText(str(params['bin_size'])) self.shatterEdit.setText(str(params['shatter_frequency'])) self.position.setText(str(params['position'])) - #self.position.setText(str(params['position'])) From a9b0a8a28278a8538e7552acd06622ae53e61c2a Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:35:05 +0100 Subject: [PATCH 41/83] Cast to string (again) --- Models/PBWidgets.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 7324f7b..1296861 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -62,7 +62,7 @@ def set_parameters(self, params): self.shatterDutyEdit.setText(str(params['shatter_duty'])) self.repeatsEdit.setText(str(params['repeats'])) self.lengthEdit.setText(str(params['length'])) - self.position.setText(params['position']) + self.position.setText(str(params['position'])) class NoiseValveWidget(QtWidgets.QWidget, noiseValveDesign.Ui_Form): @@ -112,7 +112,7 @@ def set_parameters(self, params): self.ampMaxEdit.setText(str(params['amp_max'])) self.repeatsEdit.setText(str(params['repeats'])) self.lengthEdit.setText(str(params['length'])) - self.position.setText(params['position']) + self.position.setText(str(params['position'])) class PlumeValveWidget(QtWidgets.QWidget, plumeValveDesign.Ui_Form): @@ -152,7 +152,7 @@ def set_parameters(self, params): self.plumeDataLabel.setText(params['data_path']) self.dataSamplingRateEdit.setText(str(params['data_fs'])) self.targetMaxEdit.setText(str(params['target_max'])) - self.position.setText(params['position']) + self.position.setText(str(params['position'])) def load_plume_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') @@ -195,7 +195,7 @@ def set_parameters(self, params): self.plumeDataLabel.setText(params['data_path']) self.dataSamplingRateEdit.setText(str(params['data_fs'])) self.targetMaxEdit.setText(str(params['target_max'])) - self.position.setText(params['position']) + self.position.setText(str(params['position'])) def load_plume_data(self): fname, suff = QtWidgets.QFileDialog.getOpenFileName(self, "Open File", '', '*.mat') From ed405f9dcf39e213f4278da96bd7673b779adfa3 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 13:37:35 +0100 Subject: [PATCH 42/83] update the intial position --- Models/PBWidgets.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 1296861..6044ede 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -10,6 +10,7 @@ def __init__(self, parentUi=None, position=0): self.setupUi(self) self.parentUi = parentUi + self.position.setText(str(position)) self.removeButton.clicked.connect(self.remove_from_parent) @@ -71,6 +72,7 @@ def __init__(self, parentUi=None, position=0): self.setupUi(self) self.parentUi = parentUi + self.position.setText(str(position)) self.removeButton.clicked.connect(self.remove_from_parent) @@ -121,6 +123,7 @@ def __init__(self, parentUi=None, position=0): self.setupUi(self) self.parentUi = parentUi + self.position.setText(str(position)) self.removeButton.clicked.connect(self.remove_from_parent) self.openPlumeDataButton.clicked.connect(self.load_plume_data) @@ -165,6 +168,7 @@ def __init__(self, parentUi=None, position=0): self.setupUi(self) self.parentUi = parentUi + self.position.setText(str(position)) self.removeButton.clicked.connect(self.remove_from_parent) self.openPlumeDataButton.clicked.connect(self.load_plume_data) From f6318aee869ae93a8b5c6b94767543b9f256ff97 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Thu, 22 Aug 2019 14:01:39 +0100 Subject: [PATCH 43/83] added run from selected support --- Controllers/QueueControl.py | 7 ++++++- Controllers/main.py | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 4d95882..0a01c63 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -127,9 +127,14 @@ def run_selected(self, trial): sleep(0.05) self.should_run = False + def run_from_selected(self, trial): + if not self.should_run: + self.should_run = True + self.experiment.current_trial = trial + + def finished(self): print("not implemented") def trigger_state(self): return self.trigger_control.isChecked() - diff --git a/Controllers/main.py b/Controllers/main.py index 38e8010..b2687e1 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -59,7 +59,7 @@ def __init__(self): self.stopQueueButton.clicked.connect(self.queue_controller.stop) self.pauseQueueButton.clicked.connect(self.queue_controller.pause) self.runSelectedButton.clicked.connect(lambda x: self.queue_controller.run_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) - + self.startQueueFromSelectedButton.clicked.connect(lambda x: self.queue_controller.run_from_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) def add_valve(self, v_type='Simple', params=None): if v_type == 'Simple': From 90093a5e1f3e04c60c0acc303677e4cb3e888332 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 22 Aug 2019 14:04:26 +0100 Subject: [PATCH 44/83] valve widget numbering and start queue from selected --- Controllers/main.py | 15 +- Designs/binaryValveDesign.py | 4 + Designs/mainDesign.py | 68 +++---- Designs/noiseValveDesign.py | 8 +- Designs/plumeValveDesign.py | 90 ++++----- Designs/simpleValveDesign.py | 8 +- UI/BinaryValveWidget.ui | 7 + UI/NoiseValveWidget.ui | 9 +- UI/PlumeValveWidget.ui | 85 +++++---- UI/PulseBoyUI_v2.py | 68 +++---- UI/PulseBoyUI_v2.ui | 111 +++++------ UI/SimpleValveWidget.ui | 9 +- UI/binaryValveDesign.py | 4 + UI/mainDesign.py | 345 +++++++++++++++++++++++++++++++++++ UI/noiseValveWidget.py | 125 +++++++++++++ UI/plumeValveWidget.py | 93 ++++++++++ UI/simpleValveWidget.py | 174 ++++++++++++++++++ 17 files changed, 1012 insertions(+), 211 deletions(-) create mode 100644 UI/mainDesign.py create mode 100644 UI/noiseValveWidget.py create mode 100644 UI/plumeValveWidget.py create mode 100644 UI/simpleValveWidget.py diff --git a/Controllers/main.py b/Controllers/main.py index 38e8010..84561e9 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -1,6 +1,6 @@ import sys sys.path.append('C:\\Users\\warnert\\Documents\\GitHub') -sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy_updated\\PulseBoy') +sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy') from PyPulse import PulseInterface import numpy as np from PyQt5 import QtWidgets @@ -62,18 +62,19 @@ def __init__(self): def add_valve(self, v_type='Simple', params=None): + position = len(self.valveBankContents.children()) - 1 if v_type == 'Simple': - new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) + new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents, position) elif v_type == 'Noise': - new_valve = PBWidgets.NoiseValveWidget(self.valveBankContents) + new_valve = PBWidgets.NoiseValveWidget(self.valveBankContents, position) elif v_type == 'Plume': - new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents) + new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents, position) elif v_type == 'Anti Plume': - new_valve = PBWidgets.AntiPlumeValveWidget(self.valveBankContents) + new_valve = PBWidgets.AntiPlumeValveWidget(self.valveBankContents, position) elif v_type == 'Binary': - new_valve = PBWidgets.BinaryPlumeValveWidget(self.valveBankContents) + new_valve = PBWidgets.BinaryPlumeValveWidget(self.valveBankContents, position) else: - new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents) + new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents, position) if params is not None: new_valve.set_parameters(params) diff --git a/Designs/binaryValveDesign.py b/Designs/binaryValveDesign.py index d75dc95..dbb65e0 100644 --- a/Designs/binaryValveDesign.py +++ b/Designs/binaryValveDesign.py @@ -66,6 +66,9 @@ def setupUi(self, Form): self.numofbinsEdit = QtWidgets.QLineEdit(Form) self.numofbinsEdit.setObjectName("numofbinsEdit") self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -86,4 +89,5 @@ def retranslateUi(self, Form): self.label_4.setText(_translate("Form", "Number of bins")) self.label_5.setText(_translate("Form", "Bin size")) self.numofbinsEdit.setText(_translate("Form", "8")) + self.position.setText(_translate("Form", "1")) diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index c3ad1a4..82c2a48 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -177,6 +177,8 @@ def setupUi(self, MainWindow): self.experimentSetupTab.setObjectName("experimentSetupTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) self.gridLayout_4.setObjectName("gridLayout_4") + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) @@ -185,9 +187,6 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) - self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueButton.setObjectName("startQueueButton") - self.gridLayout_4.addWidget(self.startQueueButton, 5, 0, 1, 1) self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) self.valveTypeCombo.setObjectName("valveTypeCombo") self.valveTypeCombo.addItem("") @@ -196,17 +195,6 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addTrialButton.setObjectName("addTrialButton") - self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) - self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addValveButton.setObjectName("addValveButton") - self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) - self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.updateTrialButton.setObjectName("updateTrialButton") - self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) self.removeTrialButton.setObjectName("removeTrialButton") self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) @@ -214,25 +202,40 @@ def setupUi(self, MainWindow): self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) self.runSelectedButton.setObjectName("runSelectedButton") - self.gridLayout_4.addWidget(self.runSelectedButton, 6, 0, 1, 1) - self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.stopQueueButton.setObjectName("stopQueueButton") - self.gridLayout_4.addWidget(self.stopQueueButton, 5, 2, 1, 1) - self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.pauseQueueButton.setObjectName("pauseQueueButton") - self.gridLayout_4.addWidget(self.pauseQueueButton, 5, 1, 1, 1) + self.gridLayout_4.addWidget(self.runSelectedButton, 7, 0, 1, 1) self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveUpButton.setObjectName("moveUpButton") self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 6, 0, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveDownButton.setObjectName("moveDownButton") self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) - self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") - self.gridLayout_4.addWidget(self.randomiseTrialsButton, 6, 1, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 6, 2, 1, 1) self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") - self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 6, 2, 1, 1) + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 7, 2, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 6, 1, 1, 1) + self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") + self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 7, 1, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 5, 0, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -309,23 +312,24 @@ def retranslateUi(self, MainWindow): self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) - self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) - self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) - self.addValveButton.setText(_translate("MainWindow", "Add Valve")) - self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) - self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) - self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) self.moveDownButton.setText(_translate("MainWindow", "Move Down")) - self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_13.setText(_translate("MainWindow", "Export Suffix")) self.label_12.setText(_translate("MainWindow", "Export Path")) diff --git a/Designs/noiseValveDesign.py b/Designs/noiseValveDesign.py index 8611aa0..02f4af0 100644 --- a/Designs/noiseValveDesign.py +++ b/Designs/noiseValveDesign.py @@ -2,7 +2,7 @@ # Form implementation generated from reading ui file 'NoiseValveWidget.ui' # -# Created by: PyQt5 UI code generator 5.5.1 +# Created by: PyQt5 UI code generator 5.9 # # WARNING! All changes made in this file will be lost! @@ -11,7 +11,7 @@ class Ui_Form(object): def setupUi(self, Form): Form.setObjectName("Form") - Form.resize(667, 76) + Form.resize(681, 76) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) @@ -88,6 +88,9 @@ def setupUi(self, Form): self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) self.retranslateUi(Form) self.repeatsRadio.clicked.connect(self.lengthRadio.toggle) @@ -118,4 +121,5 @@ def retranslateUi(self, Form): self.shatterHzEdit.setText(_translate("Form", "500")) self.label_5.setText(_translate("Form", "Seed")) self.removeButton.setText(_translate("Form", "-")) + self.position.setText(_translate("Form", "1")) diff --git a/Designs/plumeValveDesign.py b/Designs/plumeValveDesign.py index 32b4e60..33c157a 100644 --- a/Designs/plumeValveDesign.py +++ b/Designs/plumeValveDesign.py @@ -1,8 +1,8 @@ # -*- coding: utf-8 -*- -# Form implementation generated from reading ui file 'UI/PlumeValveWidget.ui' +# Form implementation generated from reading ui file 'PlumeValveWidget.ui' # -# Created by: PyQt5 UI code generator 5.5.1 +# Created by: PyQt5 UI code generator 5.9 # # WARNING! All changes made in this file will be lost! @@ -22,50 +22,53 @@ def setupUi(self, Form): Form.setFont(font) self.gridLayout = QtWidgets.QGridLayout(Form) self.gridLayout.setObjectName("gridLayout") - self.dataSamplingRateEdit = QtWidgets.QLineEdit(Form) - self.dataSamplingRateEdit.setObjectName("dataSamplingRateEdit") - self.gridLayout.addWidget(self.dataSamplingRateEdit, 1, 5, 1, 1) - self.onsetEdit = QtWidgets.QLineEdit(Form) - self.onsetEdit.setObjectName("onsetEdit") - self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) + self.plumeDataLabel = QtWidgets.QLabel(Form) + self.plumeDataLabel.setObjectName("plumeDataLabel") + self.gridLayout.addWidget(self.plumeDataLabel, 1, 5, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 0, 6, 1, 1) + self.targetMaxEdit = QtWidgets.QLineEdit(Form) + self.targetMaxEdit.setObjectName("targetMaxEdit") + self.gridLayout.addWidget(self.targetMaxEdit, 1, 7, 1, 1) + self.line_2 = QtWidgets.QFrame(Form) + self.line_2.setFrameShape(QtWidgets.QFrame.HLine) + self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) + self.line_2.setObjectName("line_2") + self.gridLayout.addWidget(self.line_2, 2, 2, 1, 6) self.label_2 = QtWidgets.QLabel(Form) self.label_2.setObjectName("label_2") - self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) - self.label = QtWidgets.QLabel(Form) - self.label.setObjectName("label") - self.gridLayout.addWidget(self.label, 0, 1, 1, 1) + self.gridLayout.addWidget(self.label_2, 0, 3, 1, 1) + self.label_3 = QtWidgets.QLabel(Form) + self.label_3.setObjectName("label_3") + self.gridLayout.addWidget(self.label_3, 0, 7, 1, 1) self.offsetEdit = QtWidgets.QLineEdit(Form) self.offsetEdit.setObjectName("offsetEdit") - self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) + self.gridLayout.addWidget(self.offsetEdit, 1, 3, 1, 1) + self.onsetEdit = QtWidgets.QLineEdit(Form) + self.onsetEdit.setObjectName("onsetEdit") + self.gridLayout.addWidget(self.onsetEdit, 1, 2, 1, 1) + self.label = QtWidgets.QLabel(Form) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 2, 1, 1) + self.dataSamplingRateEdit = QtWidgets.QLineEdit(Form) + self.dataSamplingRateEdit.setObjectName("dataSamplingRateEdit") + self.gridLayout.addWidget(self.dataSamplingRateEdit, 1, 6, 1, 1) self.label_8 = QtWidgets.QLabel(Form) self.label_8.setObjectName("label_8") - self.gridLayout.addWidget(self.label_8, 0, 3, 1, 1) - self.shatterHzEdit = QtWidgets.QLineEdit(Form) - self.shatterHzEdit.setObjectName("shatterHzEdit") - self.gridLayout.addWidget(self.shatterHzEdit, 1, 3, 1, 1) + self.gridLayout.addWidget(self.label_8, 0, 4, 1, 1) self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) + self.shatterHzEdit = QtWidgets.QLineEdit(Form) + self.shatterHzEdit.setObjectName("shatterHzEdit") + self.gridLayout.addWidget(self.shatterHzEdit, 1, 4, 1, 1) self.openPlumeDataButton = QtWidgets.QPushButton(Form) self.openPlumeDataButton.setObjectName("openPlumeDataButton") - self.gridLayout.addWidget(self.openPlumeDataButton, 0, 4, 1, 1) - self.plumeDataLabel = QtWidgets.QLabel(Form) - self.plumeDataLabel.setObjectName("plumeDataLabel") - self.gridLayout.addWidget(self.plumeDataLabel, 1, 4, 1, 1) - self.label_5 = QtWidgets.QLabel(Form) - self.label_5.setObjectName("label_5") - self.gridLayout.addWidget(self.label_5, 0, 5, 1, 1) - self.targetMaxEdit = QtWidgets.QLineEdit(Form) - self.targetMaxEdit.setObjectName("targetMaxEdit") - self.gridLayout.addWidget(self.targetMaxEdit, 1, 6, 1, 1) - self.label_3 = QtWidgets.QLabel(Form) - self.label_3.setObjectName("label_3") - self.gridLayout.addWidget(self.label_3, 0, 6, 1, 1) - self.line_2 = QtWidgets.QFrame(Form) - self.line_2.setFrameShape(QtWidgets.QFrame.HLine) - self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) - self.line_2.setObjectName("line_2") - self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) + self.gridLayout.addWidget(self.openPlumeDataButton, 0, 5, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -73,17 +76,18 @@ def setupUi(self, Form): def retranslateUi(self, Form): _translate = QtCore.QCoreApplication.translate Form.setWindowTitle(_translate("Form", "Form")) - self.dataSamplingRateEdit.setText(_translate("Form", "10000")) - self.onsetEdit.setText(_translate("Form", "0.1")) + self.plumeDataLabel.setText(_translate("Form", "-")) + self.label_5.setText(_translate("Form", "Data Sampling Rate")) + self.targetMaxEdit.setText(_translate("Form", "1.0")) self.label_2.setText(_translate("Form", "Offset")) - self.label.setText(_translate("Form", "Onset")) + self.label_3.setText(_translate("Form", "Target Max.")) self.offsetEdit.setText(_translate("Form", "0.1")) + self.onsetEdit.setText(_translate("Form", "0.1")) + self.label.setText(_translate("Form", "Onset")) + self.dataSamplingRateEdit.setText(_translate("Form", "10000")) self.label_8.setText(_translate("Form", "Shatter (Hz)")) - self.shatterHzEdit.setText(_translate("Form", "500")) self.removeButton.setText(_translate("Form", "-")) + self.shatterHzEdit.setText(_translate("Form", "500")) self.openPlumeDataButton.setText(_translate("Form", "Open Plume Data")) - self.plumeDataLabel.setText(_translate("Form", "-")) - self.label_5.setText(_translate("Form", "Data Sampling Rate")) - self.targetMaxEdit.setText(_translate("Form", "1.0")) - self.label_3.setText(_translate("Form", "Target Max.")) + self.position.setText(_translate("Form", "1")) diff --git a/Designs/simpleValveDesign.py b/Designs/simpleValveDesign.py index 411f4b9..21c5fd1 100644 --- a/Designs/simpleValveDesign.py +++ b/Designs/simpleValveDesign.py @@ -2,7 +2,7 @@ # Form implementation generated from reading ui file 'SimpleValveWidget.ui' # -# Created by: PyQt5 UI code generator 5.5.1 +# Created by: PyQt5 UI code generator 5.9 # # WARNING! All changes made in this file will be lost! @@ -11,7 +11,7 @@ class Ui_Form(object): def setupUi(self, Form): Form.setObjectName("Form") - Form.resize(846, 113) + Form.resize(1421, 113) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) @@ -121,6 +121,9 @@ def setupUi(self, Form): self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 2, 0, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 2, 1) self.retranslateUi(Form) self.fromValuesRadio.clicked.connect(self.fromDutyRadio.toggle) @@ -167,4 +170,5 @@ def retranslateUi(self, Form): self.frequencyEdit.setText(_translate("Form", "5")) self.label_5.setText(_translate("Form", "Frequency (Hz)")) self.removeButton.setText(_translate("Form", "-")) + self.position.setText(_translate("Form", "1")) diff --git a/UI/BinaryValveWidget.ui b/UI/BinaryValveWidget.ui index 72c6362..0755998 100644 --- a/UI/BinaryValveWidget.ui +++ b/UI/BinaryValveWidget.ui @@ -123,6 +123,13 @@ + + + + 1 + + + diff --git a/UI/NoiseValveWidget.ui b/UI/NoiseValveWidget.ui index c2e187e..7ac3f7c 100644 --- a/UI/NoiseValveWidget.ui +++ b/UI/NoiseValveWidget.ui @@ -6,7 +6,7 @@ 0 0 - 667 + 681 76 @@ -177,6 +177,13 @@ + + + + 1 + + + diff --git a/UI/PlumeValveWidget.ui b/UI/PlumeValveWidget.ui index 72be836..434b8c3 100644 --- a/UI/PlumeValveWidget.ui +++ b/UI/PlumeValveWidget.ui @@ -26,100 +26,107 @@ - + - 10000 + - - - + + - 0.1 + Data Sampling Rate - + + + + 1.0 + + + + + + + Qt::Horizontal + + + + Offset - - + + - Onset + Target Max. - + 0.1 - - + + - Shatter (Hz) + 0.1 - - + + - 500 + Onset - - + + - - + 10000 - + - Open Plume Data + Shatter (Hz) - - + + - - - + + - Data Sampling Rate + 500 - - + + - 1.0 + Open Plume Data - - + + - Target Max. - - - - - - - Qt::Horizontal + 1 diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index c3ad1a4..82c2a48 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -177,6 +177,8 @@ def setupUi(self, MainWindow): self.experimentSetupTab.setObjectName("experimentSetupTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) self.gridLayout_4.setObjectName("gridLayout_4") + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) @@ -185,9 +187,6 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) - self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueButton.setObjectName("startQueueButton") - self.gridLayout_4.addWidget(self.startQueueButton, 5, 0, 1, 1) self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) self.valveTypeCombo.setObjectName("valveTypeCombo") self.valveTypeCombo.addItem("") @@ -196,17 +195,6 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addTrialButton.setObjectName("addTrialButton") - self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) - self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addValveButton.setObjectName("addValveButton") - self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) - self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.updateTrialButton.setObjectName("updateTrialButton") - self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) self.removeTrialButton.setObjectName("removeTrialButton") self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) @@ -214,25 +202,40 @@ def setupUi(self, MainWindow): self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) self.runSelectedButton.setObjectName("runSelectedButton") - self.gridLayout_4.addWidget(self.runSelectedButton, 6, 0, 1, 1) - self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.stopQueueButton.setObjectName("stopQueueButton") - self.gridLayout_4.addWidget(self.stopQueueButton, 5, 2, 1, 1) - self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.pauseQueueButton.setObjectName("pauseQueueButton") - self.gridLayout_4.addWidget(self.pauseQueueButton, 5, 1, 1, 1) + self.gridLayout_4.addWidget(self.runSelectedButton, 7, 0, 1, 1) self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveUpButton.setObjectName("moveUpButton") self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 6, 0, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveDownButton.setObjectName("moveDownButton") self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) - self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") - self.gridLayout_4.addWidget(self.randomiseTrialsButton, 6, 1, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 6, 2, 1, 1) self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") - self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 6, 2, 1, 1) + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 7, 2, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 6, 1, 1, 1) + self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") + self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 7, 1, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 5, 0, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -309,23 +312,24 @@ def retranslateUi(self, MainWindow): self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) - self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) - self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) - self.addValveButton.setText(_translate("MainWindow", "Add Valve")) - self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) - self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) - self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) self.moveDownButton.setText(_translate("MainWindow", "Move Down")) - self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_13.setText(_translate("MainWindow", "Export Suffix")) self.label_12.setText(_translate("MainWindow", "Export Path")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index c7d5516..6ac0e8c 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -326,6 +326,19 @@ Experiment + + + + Qt::Vertical + + + + 20 + 40 + + + + @@ -339,13 +352,6 @@ - - - - Start Queue - - - @@ -375,15 +381,15 @@ - - + + - Add To Trials + Remove Trial - - + + Qt::Vertical @@ -395,86 +401,87 @@ - - + + - Add Valve + Run Selected - - + + - Update Trial + Move Up - - + + - Remove Trial + Start Queue - - - - Qt::Vertical - - - - 20 - 40 - + + + + Add To Trials - + - - + + - Run Selected + Update Trial - - + + - Stop Queue + Move Down - - + + - Pause Queue + Add Valve - - + + - Move Up + Stop Queue - - + + - Move Down + Wait for trigger - + - Randomise trials + Pause Queue - - + + - Wait for trigger + Start Queue from Selected + + + + + + + Randomise trials diff --git a/UI/SimpleValveWidget.ui b/UI/SimpleValveWidget.ui index 17ebf8f..150021a 100644 --- a/UI/SimpleValveWidget.ui +++ b/UI/SimpleValveWidget.ui @@ -6,7 +6,7 @@ 0 0 - 846 + 1421 113 @@ -255,6 +255,13 @@ + + + + 1 + + + diff --git a/UI/binaryValveDesign.py b/UI/binaryValveDesign.py index d75dc95..dbb65e0 100644 --- a/UI/binaryValveDesign.py +++ b/UI/binaryValveDesign.py @@ -66,6 +66,9 @@ def setupUi(self, Form): self.numofbinsEdit = QtWidgets.QLineEdit(Form) self.numofbinsEdit.setObjectName("numofbinsEdit") self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -86,4 +89,5 @@ def retranslateUi(self, Form): self.label_4.setText(_translate("Form", "Number of bins")) self.label_5.setText(_translate("Form", "Bin size")) self.numofbinsEdit.setText(_translate("Form", "8")) + self.position.setText(_translate("Form", "1")) diff --git a/UI/mainDesign.py b/UI/mainDesign.py new file mode 100644 index 0000000..82c2a48 --- /dev/null +++ b/UI/mainDesign.py @@ -0,0 +1,345 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'PulseBoyUI_v2.ui' +# +# Created by: PyQt5 UI code generator 5.9 +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore, QtGui, QtWidgets + +class Ui_MainWindow(object): + def setupUi(self, MainWindow): + MainWindow.setObjectName("MainWindow") + MainWindow.resize(1229, 809) + self.centralwidget = QtWidgets.QWidget(MainWindow) + self.centralwidget.setObjectName("centralwidget") + self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) + self.gridLayout.setObjectName("gridLayout") + self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) + self.viewWidgetTab.setObjectName("viewWidgetTab") + self.pulseTab = QtWidgets.QWidget() + self.pulseTab.setObjectName("pulseTab") + self.gridLayout_5 = QtWidgets.QGridLayout(self.pulseTab) + self.gridLayout_5.setObjectName("gridLayout_5") + self.graphicsView = PlotWidget(self.pulseTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.graphicsView.sizePolicy().hasHeightForWidth()) + self.graphicsView.setSizePolicy(sizePolicy) + self.graphicsView.setObjectName("graphicsView") + self.gridLayout_5.addWidget(self.graphicsView, 0, 0, 1, 1) + self.viewWidgetTab.addTab(self.pulseTab, "") + self.analogDataTab = QtWidgets.QWidget() + self.analogDataTab.setObjectName("analogDataTab") + self.gridLayout_6 = QtWidgets.QGridLayout(self.analogDataTab) + self.gridLayout_6.setObjectName("gridLayout_6") + self.analogView = PlotWidget(self.analogDataTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.analogView.sizePolicy().hasHeightForWidth()) + self.analogView.setSizePolicy(sizePolicy) + self.analogView.setObjectName("analogView") + self.gridLayout_6.addWidget(self.analogView, 0, 0, 1, 1) + self.viewWidgetTab.addTab(self.analogDataTab, "") + self.gridLayout.addWidget(self.viewWidgetTab, 3, 2, 1, 1) + self.label_8 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_8.setFont(font) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) + self.trialBankTable = QtWidgets.QTableView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialBankTable.sizePolicy().hasHeightForWidth()) + self.trialBankTable.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + self.trialBankTable.setFont(font) + self.trialBankTable.setContextMenuPolicy(QtCore.Qt.DefaultContextMenu) + self.trialBankTable.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows) + self.trialBankTable.setObjectName("trialBankTable") + self.trialBankTable.horizontalHeader().setStretchLastSection(False) + self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) + self.label = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label.setFont(font) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 0, 1, 1) + self.setupTabs = QtWidgets.QTabWidget(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.setupTabs.sizePolicy().hasHeightForWidth()) + self.setupTabs.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(10) + self.setupTabs.setFont(font) + self.setupTabs.setObjectName("setupTabs") + self.hardwareTab = QtWidgets.QWidget() + self.hardwareTab.setObjectName("hardwareTab") + self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) + self.gridLayout_2.setObjectName("gridLayout_2") + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) + self.label_9 = QtWidgets.QLabel(self.hardwareTab) + self.label_9.setObjectName("label_9") + self.gridLayout_2.addWidget(self.label_9, 9, 0, 1, 1) + self.label_2 = QtWidgets.QLabel(self.hardwareTab) + self.label_2.setObjectName("label_2") + self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) + self.label_4 = QtWidgets.QLabel(self.hardwareTab) + self.label_4.setObjectName("label_4") + self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) + self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") + self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) + self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) + self.analogChannelsLabel.setObjectName("analogChannelsLabel") + self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) + self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogChannelsEdit.setObjectName("analogChannelsEdit") + self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) + self.label_5 = QtWidgets.QLabel(self.hardwareTab) + self.label_5.setObjectName("label_5") + self.gridLayout_2.addWidget(self.label_5, 6, 0, 1, 1) + self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.sampRateEdit.setObjectName("sampRateEdit") + self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) + spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) + self.label_11 = QtWidgets.QLabel(self.hardwareTab) + self.label_11.setObjectName("label_11") + self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.triggerInEdit.setObjectName("triggerInEdit") + self.gridLayout_2.addWidget(self.triggerInEdit, 10, 0, 1, 1) + self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.syncClockEdit.setObjectName("syncClockEdit") + self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.setupTabs.addTab(self.hardwareTab, "") + self.globalParametersTab = QtWidgets.QWidget() + self.globalParametersTab.setObjectName("globalParametersTab") + self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) + self.gridLayout_3.setObjectName("gridLayout_3") + self.label_6 = QtWidgets.QLabel(self.globalParametersTab) + self.label_6.setObjectName("label_6") + self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.globalOnsetEdit.setObjectName("globalOnsetEdit") + self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) + self.label_7 = QtWidgets.QLabel(self.globalParametersTab) + self.label_7.setObjectName("label_7") + self.gridLayout_3.addWidget(self.label_7, 0, 1, 1, 1) + self.globalOffsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.globalOffsetEdit.setObjectName("globalOffsetEdit") + self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) + spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem1, 2, 0, 1, 1) + self.setupTabs.addTab(self.globalParametersTab, "") + self.experimentSetupTab = QtWidgets.QWidget() + self.experimentSetupTab.setObjectName("experimentSetupTab") + self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) + self.gridLayout_4.setObjectName("gridLayout_4") + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) + self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialNameEdit.sizePolicy().hasHeightForWidth()) + self.trialNameEdit.setSizePolicy(sizePolicy) + self.trialNameEdit.setObjectName("trialNameEdit") + self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) + self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) + self.valveTypeCombo.setObjectName("valveTypeCombo") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.valveTypeCombo.addItem("") + self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) + self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.removeTrialButton.setObjectName("removeTrialButton") + self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) + spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) + self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.runSelectedButton.setObjectName("runSelectedButton") + self.gridLayout_4.addWidget(self.runSelectedButton, 7, 0, 1, 1) + self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveUpButton.setObjectName("moveUpButton") + self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 6, 0, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) + self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveDownButton.setObjectName("moveDownButton") + self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 6, 2, 1, 1) + self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 7, 2, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 6, 1, 1, 1) + self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") + self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 7, 1, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 5, 0, 1, 1) + self.setupTabs.addTab(self.experimentSetupTab, "") + self.dataExportTab = QtWidgets.QWidget() + self.dataExportTab.setObjectName("dataExportTab") + self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) + self.gridLayout_7.setObjectName("gridLayout_7") + self.label_13 = QtWidgets.QLabel(self.dataExportTab) + self.label_13.setObjectName("label_13") + self.gridLayout_7.addWidget(self.label_13, 1, 0, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 0, 0, 1, 1) + self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setObjectName("exportPathEdit") + self.gridLayout_7.addWidget(self.exportPathEdit, 0, 1, 1, 1) + self.exportSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportSuffixEdit.setObjectName("exportSuffixEdit") + self.gridLayout_7.addWidget(self.exportSuffixEdit, 1, 1, 1, 1) + self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) + self.exportPathDirButton.setObjectName("exportPathDirButton") + self.gridLayout_7.addWidget(self.exportPathDirButton, 0, 2, 1, 1) + self.setupTabs.addTab(self.dataExportTab, "") + self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) + MainWindow.setCentralWidget(self.centralwidget) + self.menubar = QtWidgets.QMenuBar(MainWindow) + self.menubar.setGeometry(QtCore.QRect(0, 0, 1229, 21)) + self.menubar.setObjectName("menubar") + self.menuFile = QtWidgets.QMenu(self.menubar) + self.menuFile.setObjectName("menuFile") + MainWindow.setMenuBar(self.menubar) + self.statusbar = QtWidgets.QStatusBar(MainWindow) + self.statusbar.setObjectName("statusbar") + MainWindow.setStatusBar(self.statusbar) + self.actionSave = QtWidgets.QAction(MainWindow) + self.actionSave.setObjectName("actionSave") + self.actionLoad = QtWidgets.QAction(MainWindow) + self.actionLoad.setObjectName("actionLoad") + self.actionSave_Configuration = QtWidgets.QAction(MainWindow) + self.actionSave_Configuration.setObjectName("actionSave_Configuration") + self.menuFile.addAction(self.actionSave) + self.menuFile.addAction(self.actionLoad) + self.menuFile.addAction(self.actionSave_Configuration) + self.menubar.addAction(self.menuFile.menuAction()) + + self.retranslateUi(MainWindow) + self.viewWidgetTab.setCurrentIndex(0) + self.setupTabs.setCurrentIndex(2) + QtCore.QMetaObject.connectSlotsByName(MainWindow) + + def retranslateUi(self, MainWindow): + _translate = QtCore.QCoreApplication.translate + MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) + self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) + self.label_8.setText(_translate("MainWindow", "Trial Bank")) + self.label.setText(_translate("MainWindow", "Valve Bank")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) + self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.label_2.setText(_translate("MainWindow", "Digital Out Device")) + self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) + self.analogChannelsEdit.setText(_translate("MainWindow", "1")) + self.label_5.setText(_translate("MainWindow", "Sampling Rate")) + self.sampRateEdit.setText(_translate("MainWindow", "20000")) + self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) + self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) + self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) + self.label_6.setText(_translate("MainWindow", "Onset")) + self.globalOnsetEdit.setText(_translate("MainWindow", "0")) + self.label_7.setText(_translate("MainWindow", "Offset")) + self.globalOffsetEdit.setText(_translate("MainWindow", "0")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) + self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) + self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) + self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) + self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) + self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) + self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) + self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) + self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) + self.moveDownButton.setText(_translate("MainWindow", "Move Down")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) + self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) + self.label_13.setText(_translate("MainWindow", "Export Suffix")) + self.label_12.setText(_translate("MainWindow", "Export Path")) + self.exportPathEdit.setText(_translate("MainWindow", "C:/Users/erskina/PycharmProjects/PulseBoy/Data/")) + self.exportSuffixEdit.setText(_translate("MainWindow", "data")) + self.exportPathDirButton.setText(_translate("MainWindow", "...")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) + self.menuFile.setTitle(_translate("MainWindow", "File")) + self.actionSave.setText(_translate("MainWindow", "Save")) + self.actionLoad.setText(_translate("MainWindow", "Load")) + self.actionSave_Configuration.setText(_translate("MainWindow", "Save Configuration")) + +from pyqtgraph import PlotWidget diff --git a/UI/noiseValveWidget.py b/UI/noiseValveWidget.py new file mode 100644 index 0000000..02f4af0 --- /dev/null +++ b/UI/noiseValveWidget.py @@ -0,0 +1,125 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'NoiseValveWidget.ui' +# +# Created by: PyQt5 UI code generator 5.9 +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore, QtGui, QtWidgets + +class Ui_Form(object): + def setupUi(self, Form): + Form.setObjectName("Form") + Form.resize(681, 76) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(Form.sizePolicy().hasHeightForWidth()) + Form.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + Form.setFont(font) + self.gridLayout = QtWidgets.QGridLayout(Form) + self.gridLayout.setObjectName("gridLayout") + self.lengthEdit = QtWidgets.QLineEdit(Form) + self.lengthEdit.setEnabled(False) + self.lengthEdit.setObjectName("lengthEdit") + self.gridLayout.addWidget(self.lengthEdit, 1, 9, 1, 1) + self.onsetEdit = QtWidgets.QLineEdit(Form) + self.onsetEdit.setObjectName("onsetEdit") + self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) + self.label_2 = QtWidgets.QLabel(Form) + self.label_2.setObjectName("label_2") + self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.label = QtWidgets.QLabel(Form) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 1, 1, 1) + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) + self.line_2 = QtWidgets.QFrame(Form) + self.line_2.setFrameShape(QtWidgets.QFrame.HLine) + self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) + self.line_2.setObjectName("line_2") + self.gridLayout.addWidget(self.line_2, 2, 1, 1, 9) + self.label_7 = QtWidgets.QLabel(Form) + self.label_7.setObjectName("label_7") + self.gridLayout.addWidget(self.label_7, 0, 7, 1, 1) + self.label_6 = QtWidgets.QLabel(Form) + self.label_6.setObjectName("label_6") + self.gridLayout.addWidget(self.label_6, 0, 6, 1, 1) + self.seedEdit = QtWidgets.QLineEdit(Form) + self.seedEdit.setObjectName("seedEdit") + self.gridLayout.addWidget(self.seedEdit, 1, 4, 1, 1) + self.ampMaxEdit = QtWidgets.QLineEdit(Form) + self.ampMaxEdit.setObjectName("ampMaxEdit") + self.gridLayout.addWidget(self.ampMaxEdit, 1, 7, 1, 1) + self.repeatsEdit = QtWidgets.QLineEdit(Form) + self.repeatsEdit.setObjectName("repeatsEdit") + self.gridLayout.addWidget(self.repeatsEdit, 0, 9, 1, 1) + self.frequencyEdit = QtWidgets.QLineEdit(Form) + self.frequencyEdit.setObjectName("frequencyEdit") + self.gridLayout.addWidget(self.frequencyEdit, 1, 3, 1, 1) + self.repeatsRadio = QtWidgets.QRadioButton(Form) + self.repeatsRadio.setChecked(True) + self.repeatsRadio.setAutoExclusive(False) + self.repeatsRadio.setObjectName("repeatsRadio") + self.gridLayout.addWidget(self.repeatsRadio, 0, 8, 1, 1) + self.ampMinEdit = QtWidgets.QLineEdit(Form) + self.ampMinEdit.setObjectName("ampMinEdit") + self.gridLayout.addWidget(self.ampMinEdit, 1, 6, 1, 1) + self.lengthRadio = QtWidgets.QRadioButton(Form) + self.lengthRadio.setAutoExclusive(False) + self.lengthRadio.setObjectName("lengthRadio") + self.gridLayout.addWidget(self.lengthRadio, 1, 8, 1, 1) + self.label_8 = QtWidgets.QLabel(Form) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 0, 5, 1, 1) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) + self.shatterHzEdit = QtWidgets.QLineEdit(Form) + self.shatterHzEdit.setObjectName("shatterHzEdit") + self.gridLayout.addWidget(self.shatterHzEdit, 1, 5, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) + self.removeButton = QtWidgets.QToolButton(Form) + self.removeButton.setObjectName("removeButton") + self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) + + self.retranslateUi(Form) + self.repeatsRadio.clicked.connect(self.lengthRadio.toggle) + self.lengthRadio.clicked.connect(self.repeatsRadio.toggle) + self.repeatsRadio.toggled['bool'].connect(self.repeatsEdit.setEnabled) + self.lengthRadio.toggled['bool'].connect(self.lengthEdit.setEnabled) + QtCore.QMetaObject.connectSlotsByName(Form) + + def retranslateUi(self, Form): + _translate = QtCore.QCoreApplication.translate + Form.setWindowTitle(_translate("Form", "Form")) + self.lengthEdit.setText(_translate("Form", "1")) + self.onsetEdit.setText(_translate("Form", "0.1")) + self.label_2.setText(_translate("Form", "Offset")) + self.label.setText(_translate("Form", "Onset")) + self.offsetEdit.setText(_translate("Form", "0.1")) + self.label_7.setText(_translate("Form", "Amp Max (/1)")) + self.label_6.setText(_translate("Form", "Amp Min (/1)")) + self.seedEdit.setText(_translate("Form", "1")) + self.ampMaxEdit.setText(_translate("Form", "0.9")) + self.repeatsEdit.setText(_translate("Form", "5")) + self.frequencyEdit.setText(_translate("Form", "20")) + self.repeatsRadio.setText(_translate("Form", "Repeats")) + self.ampMinEdit.setText(_translate("Form", "0.1")) + self.lengthRadio.setText(_translate("Form", "Length (s)")) + self.label_8.setText(_translate("Form", "Shatter (Hz)")) + self.label_4.setText(_translate("Form", "Frequncy (Hz)")) + self.shatterHzEdit.setText(_translate("Form", "500")) + self.label_5.setText(_translate("Form", "Seed")) + self.removeButton.setText(_translate("Form", "-")) + self.position.setText(_translate("Form", "1")) + diff --git a/UI/plumeValveWidget.py b/UI/plumeValveWidget.py new file mode 100644 index 0000000..33c157a --- /dev/null +++ b/UI/plumeValveWidget.py @@ -0,0 +1,93 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'PlumeValveWidget.ui' +# +# Created by: PyQt5 UI code generator 5.9 +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore, QtGui, QtWidgets + +class Ui_Form(object): + def setupUi(self, Form): + Form.setObjectName("Form") + Form.resize(848, 76) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(Form.sizePolicy().hasHeightForWidth()) + Form.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + Form.setFont(font) + self.gridLayout = QtWidgets.QGridLayout(Form) + self.gridLayout.setObjectName("gridLayout") + self.plumeDataLabel = QtWidgets.QLabel(Form) + self.plumeDataLabel.setObjectName("plumeDataLabel") + self.gridLayout.addWidget(self.plumeDataLabel, 1, 5, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 0, 6, 1, 1) + self.targetMaxEdit = QtWidgets.QLineEdit(Form) + self.targetMaxEdit.setObjectName("targetMaxEdit") + self.gridLayout.addWidget(self.targetMaxEdit, 1, 7, 1, 1) + self.line_2 = QtWidgets.QFrame(Form) + self.line_2.setFrameShape(QtWidgets.QFrame.HLine) + self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) + self.line_2.setObjectName("line_2") + self.gridLayout.addWidget(self.line_2, 2, 2, 1, 6) + self.label_2 = QtWidgets.QLabel(Form) + self.label_2.setObjectName("label_2") + self.gridLayout.addWidget(self.label_2, 0, 3, 1, 1) + self.label_3 = QtWidgets.QLabel(Form) + self.label_3.setObjectName("label_3") + self.gridLayout.addWidget(self.label_3, 0, 7, 1, 1) + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 1, 3, 1, 1) + self.onsetEdit = QtWidgets.QLineEdit(Form) + self.onsetEdit.setObjectName("onsetEdit") + self.gridLayout.addWidget(self.onsetEdit, 1, 2, 1, 1) + self.label = QtWidgets.QLabel(Form) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 2, 1, 1) + self.dataSamplingRateEdit = QtWidgets.QLineEdit(Form) + self.dataSamplingRateEdit.setObjectName("dataSamplingRateEdit") + self.gridLayout.addWidget(self.dataSamplingRateEdit, 1, 6, 1, 1) + self.label_8 = QtWidgets.QLabel(Form) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 0, 4, 1, 1) + self.removeButton = QtWidgets.QToolButton(Form) + self.removeButton.setObjectName("removeButton") + self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) + self.shatterHzEdit = QtWidgets.QLineEdit(Form) + self.shatterHzEdit.setObjectName("shatterHzEdit") + self.gridLayout.addWidget(self.shatterHzEdit, 1, 4, 1, 1) + self.openPlumeDataButton = QtWidgets.QPushButton(Form) + self.openPlumeDataButton.setObjectName("openPlumeDataButton") + self.gridLayout.addWidget(self.openPlumeDataButton, 0, 5, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) + + self.retranslateUi(Form) + QtCore.QMetaObject.connectSlotsByName(Form) + + def retranslateUi(self, Form): + _translate = QtCore.QCoreApplication.translate + Form.setWindowTitle(_translate("Form", "Form")) + self.plumeDataLabel.setText(_translate("Form", "-")) + self.label_5.setText(_translate("Form", "Data Sampling Rate")) + self.targetMaxEdit.setText(_translate("Form", "1.0")) + self.label_2.setText(_translate("Form", "Offset")) + self.label_3.setText(_translate("Form", "Target Max.")) + self.offsetEdit.setText(_translate("Form", "0.1")) + self.onsetEdit.setText(_translate("Form", "0.1")) + self.label.setText(_translate("Form", "Onset")) + self.dataSamplingRateEdit.setText(_translate("Form", "10000")) + self.label_8.setText(_translate("Form", "Shatter (Hz)")) + self.removeButton.setText(_translate("Form", "-")) + self.shatterHzEdit.setText(_translate("Form", "500")) + self.openPlumeDataButton.setText(_translate("Form", "Open Plume Data")) + self.position.setText(_translate("Form", "1")) + diff --git a/UI/simpleValveWidget.py b/UI/simpleValveWidget.py new file mode 100644 index 0000000..21c5fd1 --- /dev/null +++ b/UI/simpleValveWidget.py @@ -0,0 +1,174 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'SimpleValveWidget.ui' +# +# Created by: PyQt5 UI code generator 5.9 +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore, QtGui, QtWidgets + +class Ui_Form(object): + def setupUi(self, Form): + Form.setObjectName("Form") + Form.resize(1421, 113) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Maximum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(Form.sizePolicy().hasHeightForWidth()) + Form.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + Form.setFont(font) + self.gridLayout = QtWidgets.QGridLayout(Form) + self.gridLayout.setObjectName("gridLayout") + self.shatterHzEdit = QtWidgets.QLineEdit(Form) + self.shatterHzEdit.setEnabled(False) + self.shatterHzEdit.setObjectName("shatterHzEdit") + self.gridLayout.addWidget(self.shatterHzEdit, 3, 7, 1, 1) + self.repeatsRadio = QtWidgets.QRadioButton(Form) + self.repeatsRadio.setChecked(True) + self.repeatsRadio.setAutoExclusive(False) + self.repeatsRadio.setObjectName("repeatsRadio") + self.gridLayout.addWidget(self.repeatsRadio, 1, 9, 1, 1) + self.lengthRadio = QtWidgets.QRadioButton(Form) + self.lengthRadio.setAutoExclusive(False) + self.lengthRadio.setObjectName("lengthRadio") + self.gridLayout.addWidget(self.lengthRadio, 3, 9, 1, 1) + self.cleanRadio = QtWidgets.QRadioButton(Form) + self.cleanRadio.setChecked(True) + self.cleanRadio.setAutoExclusive(False) + self.cleanRadio.setObjectName("cleanRadio") + self.gridLayout.addWidget(self.cleanRadio, 1, 6, 1, 1) + self.shatterRadio = QtWidgets.QRadioButton(Form) + self.shatterRadio.setAutoExclusive(False) + self.shatterRadio.setObjectName("shatterRadio") + self.gridLayout.addWidget(self.shatterRadio, 3, 6, 1, 1) + self.label_7 = QtWidgets.QLabel(Form) + self.label_7.setObjectName("label_7") + self.gridLayout.addWidget(self.label_7, 2, 5, 1, 1) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 4, 1, 1) + self.shatterDutyEdit = QtWidgets.QLineEdit(Form) + self.shatterDutyEdit.setEnabled(False) + self.shatterDutyEdit.setObjectName("shatterDutyEdit") + self.gridLayout.addWidget(self.shatterDutyEdit, 3, 8, 1, 1) + self.label_9 = QtWidgets.QLabel(Form) + self.label_9.setObjectName("label_9") + self.gridLayout.addWidget(self.label_9, 2, 8, 1, 1) + self.label_8 = QtWidgets.QLabel(Form) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 2, 7, 1, 1) + self.pulseWidthEdit = QtWidgets.QLineEdit(Form) + self.pulseWidthEdit.setObjectName("pulseWidthEdit") + self.gridLayout.addWidget(self.pulseWidthEdit, 1, 4, 1, 1) + self.repeatsEdit = QtWidgets.QLineEdit(Form) + self.repeatsEdit.setObjectName("repeatsEdit") + self.gridLayout.addWidget(self.repeatsEdit, 1, 10, 1, 1) + self.pulseDutyEdit = QtWidgets.QLineEdit(Form) + self.pulseDutyEdit.setEnabled(False) + self.pulseDutyEdit.setObjectName("pulseDutyEdit") + self.gridLayout.addWidget(self.pulseDutyEdit, 3, 5, 1, 1) + self.pulseDelayEdit = QtWidgets.QLineEdit(Form) + self.pulseDelayEdit.setObjectName("pulseDelayEdit") + self.gridLayout.addWidget(self.pulseDelayEdit, 1, 5, 1, 1) + self.line_2 = QtWidgets.QFrame(Form) + self.line_2.setFrameShape(QtWidgets.QFrame.HLine) + self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) + self.line_2.setObjectName("line_2") + self.gridLayout.addWidget(self.line_2, 4, 0, 1, 11) + self.fromValuesRadio = QtWidgets.QRadioButton(Form) + self.fromValuesRadio.setChecked(True) + self.fromValuesRadio.setAutoExclusive(False) + self.fromValuesRadio.setObjectName("fromValuesRadio") + self.gridLayout.addWidget(self.fromValuesRadio, 1, 3, 1, 1) + self.fromDutyRadio = QtWidgets.QRadioButton(Form) + self.fromDutyRadio.setAutoExclusive(False) + self.fromDutyRadio.setObjectName("fromDutyRadio") + self.gridLayout.addWidget(self.fromDutyRadio, 3, 3, 1, 1) + self.label_6 = QtWidgets.QLabel(Form) + self.label_6.setObjectName("label_6") + self.gridLayout.addWidget(self.label_6, 0, 5, 1, 1) + self.label_2 = QtWidgets.QLabel(Form) + self.label_2.setObjectName("label_2") + self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) + self.lengthEdit = QtWidgets.QLineEdit(Form) + self.lengthEdit.setEnabled(False) + self.lengthEdit.setObjectName("lengthEdit") + self.gridLayout.addWidget(self.lengthEdit, 3, 10, 1, 1) + self.onsetEdit = QtWidgets.QLineEdit(Form) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.onsetEdit.sizePolicy().hasHeightForWidth()) + self.onsetEdit.setSizePolicy(sizePolicy) + self.onsetEdit.setObjectName("onsetEdit") + self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) + self.label = QtWidgets.QLabel(Form) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 1, 1, 1) + self.frequencyEdit = QtWidgets.QLineEdit(Form) + self.frequencyEdit.setEnabled(False) + self.frequencyEdit.setObjectName("frequencyEdit") + self.gridLayout.addWidget(self.frequencyEdit, 3, 4, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 2, 4, 1, 1) + self.removeButton = QtWidgets.QToolButton(Form) + self.removeButton.setObjectName("removeButton") + self.gridLayout.addWidget(self.removeButton, 2, 0, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 2, 1) + + self.retranslateUi(Form) + self.fromValuesRadio.clicked.connect(self.fromDutyRadio.toggle) + self.fromDutyRadio.clicked.connect(self.fromValuesRadio.toggle) + self.cleanRadio.clicked.connect(self.shatterRadio.toggle) + self.shatterRadio.clicked.connect(self.cleanRadio.toggle) + self.repeatsRadio.clicked.connect(self.lengthRadio.toggle) + self.lengthRadio.clicked.connect(self.repeatsRadio.toggle) + self.fromValuesRadio.toggled['bool'].connect(self.pulseWidthEdit.setEnabled) + self.fromValuesRadio.toggled['bool'].connect(self.pulseDelayEdit.setEnabled) + self.fromDutyRadio.toggled['bool'].connect(self.frequencyEdit.setEnabled) + self.fromDutyRadio.toggled['bool'].connect(self.pulseDutyEdit.setEnabled) + self.shatterRadio.toggled['bool'].connect(self.shatterHzEdit.setEnabled) + self.shatterRadio.toggled['bool'].connect(self.shatterDutyEdit.setEnabled) + self.repeatsRadio.toggled['bool'].connect(self.repeatsEdit.setEnabled) + self.lengthRadio.toggled['bool'].connect(self.lengthEdit.setEnabled) + QtCore.QMetaObject.connectSlotsByName(Form) + + def retranslateUi(self, Form): + _translate = QtCore.QCoreApplication.translate + Form.setWindowTitle(_translate("Form", "Form")) + self.shatterHzEdit.setText(_translate("Form", "500")) + self.repeatsRadio.setText(_translate("Form", "Repeats")) + self.lengthRadio.setText(_translate("Form", "Length (s)")) + self.cleanRadio.setText(_translate("Form", "Clean")) + self.shatterRadio.setText(_translate("Form", "Shatter")) + self.label_7.setText(_translate("Form", "Duty (/1)")) + self.label_4.setText(_translate("Form", "Pulse Width (s)")) + self.shatterDutyEdit.setText(_translate("Form", "0.5")) + self.label_9.setText(_translate("Form", "Duty (/1)")) + self.label_8.setText(_translate("Form", "Frequency (Hz)")) + self.pulseWidthEdit.setText(_translate("Form", "0.1")) + self.repeatsEdit.setText(_translate("Form", "5")) + self.pulseDutyEdit.setText(_translate("Form", "0.5")) + self.pulseDelayEdit.setText(_translate("Form", "0.1")) + self.fromValuesRadio.setText(_translate("Form", "From Values")) + self.fromDutyRadio.setText(_translate("Form", "From Duty")) + self.label_6.setText(_translate("Form", "Pulse Delay (s)")) + self.label_2.setText(_translate("Form", "Offset")) + self.offsetEdit.setText(_translate("Form", "0.1")) + self.lengthEdit.setText(_translate("Form", "1")) + self.onsetEdit.setText(_translate("Form", "0.1")) + self.label.setText(_translate("Form", "Onset")) + self.frequencyEdit.setText(_translate("Form", "5")) + self.label_5.setText(_translate("Form", "Frequency (Hz)")) + self.removeButton.setText(_translate("Form", "-")) + self.position.setText(_translate("Form", "1")) + From 5168aa8585c4e4f098e41a7297cd26a17a470658 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 23 Aug 2019 13:32:38 +0100 Subject: [PATCH 45/83] Update loading trialbank to have positions --- Models/Experiment.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Models/Experiment.py b/Models/Experiment.py index fc1572f..888932e 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -81,7 +81,10 @@ def load_arraydata(self, file_conf): try: with open(file_conf, 'rb') as fn: arraydata = pickle.load(fn) - + for i in arraydata: + for index, j in enumerate(i[1]): + if 'position' not in j: + j['position'] = index self.arraydata = arraydata self.layoutChanged.emit() except: From 8374773daa60d0acf16ca42ceae8a138cf742c77 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 23 Aug 2019 13:37:22 +0100 Subject: [PATCH 46/83] testing trialbank loading --- Models/Experiment.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Models/Experiment.py b/Models/Experiment.py index 888932e..7377526 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -85,6 +85,8 @@ def load_arraydata(self, file_conf): for index, j in enumerate(i[1]): if 'position' not in j: j['position'] = index + for i in arraydata[0][1]: + print(i['position']) self.arraydata = arraydata self.layoutChanged.emit() except: From 9bc90bd86a89053c04479494cc494f3b8916847d Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 7 Jan 2020 11:55:49 +0000 Subject: [PATCH 47/83] Create README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..43b6afd --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# PulseBoy +GUI tool for controlling NI pulse trains From 1f3742e5ab8d3fce944edb434e27df743a5a8932 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 7 Jan 2020 11:56:18 +0000 Subject: [PATCH 48/83] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 43b6afd..c4febae 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,4 @@ # PulseBoy GUI tool for controlling NI pulse trains + +Originally forked from RoboDoig/PulseBoy From 842f3dd0d6c102117a58bc47e52f0985e7746b13 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 25 Feb 2020 19:17:04 +0000 Subject: [PATCH 49/83] Add binary pulse shattering --- Designs/binaryValveDesign.py | 89 +++++++++++++++------------ Models/PBWidgets.py | 2 + UI/BinaryValveWidget.ui | 116 +++++++++++++++++++++-------------- UI/binaryValveDesign.py | 89 +++++++++++++++------------ 4 files changed, 174 insertions(+), 122 deletions(-) diff --git a/Designs/binaryValveDesign.py b/Designs/binaryValveDesign.py index dbb65e0..a470d54 100644 --- a/Designs/binaryValveDesign.py +++ b/Designs/binaryValveDesign.py @@ -11,7 +11,7 @@ class Ui_Form(object): def setupUi(self, Form): Form.setObjectName("Form") - Form.resize(848, 76) + Form.resize(905, 113) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) @@ -22,53 +22,63 @@ def setupUi(self, Form): Form.setFont(font) self.gridLayout = QtWidgets.QGridLayout(Form) self.gridLayout.setObjectName("gridLayout") - self.offsetEdit = QtWidgets.QLineEdit(Form) - self.offsetEdit.setObjectName("offsetEdit") - self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) self.label_2 = QtWidgets.QLabel(Form) self.label_2.setObjectName("label_2") - self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.gridLayout.addWidget(self.label_2, 2, 1, 1, 1) + self.binsizeEdit = QtWidgets.QLineEdit(Form) + self.binsizeEdit.setObjectName("binsizeEdit") + self.gridLayout.addWidget(self.binsizeEdit, 3, 3, 1, 1) + self.shatterBox = QtWidgets.QCheckBox(Form) + self.shatterBox.setChecked(True) + self.shatterBox.setObjectName("shatterBox") + self.gridLayout.addWidget(self.shatterBox, 1, 6, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 2, 3, 1, 1) + self.numofbinsEdit = QtWidgets.QLineEdit(Form) + self.numofbinsEdit.setObjectName("numofbinsEdit") + self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) self.valuetobinariseEdit = QtWidgets.QLineEdit(Form) self.valuetobinariseEdit.setObjectName("valuetobinariseEdit") self.gridLayout.addWidget(self.valuetobinariseEdit, 1, 5, 1, 1) - self.label_3 = QtWidgets.QLabel(Form) - self.label_3.setObjectName("label_3") - self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) - self.shatterEdit = QtWidgets.QLineEdit(Form) - self.shatterEdit.setObjectName("shatterEdit") - self.gridLayout.addWidget(self.shatterEdit, 1, 6, 1, 1) self.onsetEdit = QtWidgets.QLineEdit(Form) self.onsetEdit.setObjectName("onsetEdit") self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 3, 1, 1, 1) self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) + self.shatterEdit = QtWidgets.QLineEdit(Form) + self.shatterEdit.setObjectName("shatterEdit") + self.gridLayout.addWidget(self.shatterEdit, 1, 7, 1, 1) + self.label_3 = QtWidgets.QLabel(Form) + self.label_3.setObjectName("label_3") + self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) self.label = QtWidgets.QLabel(Form) self.label.setObjectName("label") self.gridLayout.addWidget(self.label, 0, 1, 1, 1) + self.label_6 = QtWidgets.QLabel(Form) + self.label_6.setObjectName("label_6") + self.gridLayout.addWidget(self.label_6, 0, 7, 1, 1) self.line_2 = QtWidgets.QFrame(Form) self.line_2.setFrameShape(QtWidgets.QFrame.HLine) self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") - self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) - self.label_6 = QtWidgets.QLabel(Form) - self.label_6.setObjectName("label_6") - self.gridLayout.addWidget(self.label_6, 0, 6, 1, 1) - self.binsizeEdit = QtWidgets.QLineEdit(Form) - self.binsizeEdit.setObjectName("binsizeEdit") - self.gridLayout.addWidget(self.binsizeEdit, 1, 4, 1, 1) - self.label_4 = QtWidgets.QLabel(Form) - self.label_4.setObjectName("label_4") - self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) - self.label_5 = QtWidgets.QLabel(Form) - self.label_5.setObjectName("label_5") - self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) - self.numofbinsEdit = QtWidgets.QLineEdit(Form) - self.numofbinsEdit.setObjectName("numofbinsEdit") - self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) - self.position = QtWidgets.QLabel(Form) - self.position.setObjectName("position") - self.gridLayout.addWidget(self.position, 0, 0, 1, 1) + self.gridLayout.addWidget(self.line_2, 4, 1, 1, 7) + self.shatterDutyEdit = QtWidgets.QLineEdit(Form) + self.shatterDutyEdit.setObjectName("shatterDutyEdit") + self.gridLayout.addWidget(self.shatterDutyEdit, 3, 7, 1, 1) + self.label_7 = QtWidgets.QLabel(Form) + self.label_7.setObjectName("label_7") + self.gridLayout.addWidget(self.label_7, 2, 7, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -76,18 +86,21 @@ def setupUi(self, Form): def retranslateUi(self, Form): _translate = QtCore.QCoreApplication.translate Form.setWindowTitle(_translate("Form", "Form")) - self.offsetEdit.setText(_translate("Form", "0.1")) self.label_2.setText(_translate("Form", "Offset")) + self.binsizeEdit.setText(_translate("Form", "0.05")) + self.shatterBox.setText(_translate("Form", "Shatter Pulse")) + self.label_5.setText(_translate("Form", "Bin size")) + self.numofbinsEdit.setText(_translate("Form", "8")) + self.label_4.setText(_translate("Form", "Number of bins")) + self.position.setText(_translate("Form", "1")) self.valuetobinariseEdit.setText(_translate("Form", "2")) - self.label_3.setText(_translate("Form", "Value to binarise")) - self.shatterEdit.setText(_translate("Form", "500")) self.onsetEdit.setText(_translate("Form", "0.1")) + self.offsetEdit.setText(_translate("Form", "0.1")) self.removeButton.setText(_translate("Form", "-")) + self.shatterEdit.setText(_translate("Form", "500")) + self.label_3.setText(_translate("Form", "Value to binarise")) self.label.setText(_translate("Form", "Onset")) self.label_6.setText(_translate("Form", "Shatter (Hz)")) - self.binsizeEdit.setText(_translate("Form", "0.05")) - self.label_4.setText(_translate("Form", "Number of bins")) - self.label_5.setText(_translate("Form", "Bin size")) - self.numofbinsEdit.setText(_translate("Form", "8")) - self.position.setText(_translate("Form", "1")) + self.shatterDutyEdit.setText(_translate("Form", "0.5")) + self.label_7.setText(_translate("Form", "Shatter Duty")) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 6044ede..f616074 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -231,6 +231,8 @@ def get_parameters(self): params['bin_size'] = float(self.binsizeEdit.text()) params['shatter_frequency'] = float(self.shatterEdit.text()) params['position'] = int(self.position.text()) + params['isShatter'] = bool(self.shatterBox.isChecked()) + params['shatter_duty'] = float(self.shatterDutyEdit.text()) return params diff --git a/UI/BinaryValveWidget.ui b/UI/BinaryValveWidget.ui index 0755998..d5898d9 100644 --- a/UI/BinaryValveWidget.ui +++ b/UI/BinaryValveWidget.ui @@ -6,8 +6,8 @@ 0 0 - 848 - 76 + 905 + 113 @@ -25,38 +25,62 @@ Form - - + + - 0.1 + Offset - - + + - Offset + 0.05 - - + + - 2 + Shatter Pulse + + + true - - + + - Value to binarise + Bin size - - + + - 500 + 8 + + + + + + + Number of bins + + + + + + + 1 + + + + + + + 2 @@ -67,66 +91,66 @@ - - + + - - + 0.1 - - + + - Onset + - - - - - Qt::Horizontal + + + + 500 - - + + - Shatter (Hz) + Value to binarise - - + + - 0.05 + Onset - - + + - Number of bins + Shatter (Hz) - - - - Bin size + + + + Qt::Horizontal - - + + - 8 + 0.5 - - + + - 1 + Shatter Duty diff --git a/UI/binaryValveDesign.py b/UI/binaryValveDesign.py index dbb65e0..a470d54 100644 --- a/UI/binaryValveDesign.py +++ b/UI/binaryValveDesign.py @@ -11,7 +11,7 @@ class Ui_Form(object): def setupUi(self, Form): Form.setObjectName("Form") - Form.resize(848, 76) + Form.resize(905, 113) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) @@ -22,53 +22,63 @@ def setupUi(self, Form): Form.setFont(font) self.gridLayout = QtWidgets.QGridLayout(Form) self.gridLayout.setObjectName("gridLayout") - self.offsetEdit = QtWidgets.QLineEdit(Form) - self.offsetEdit.setObjectName("offsetEdit") - self.gridLayout.addWidget(self.offsetEdit, 1, 2, 1, 1) self.label_2 = QtWidgets.QLabel(Form) self.label_2.setObjectName("label_2") - self.gridLayout.addWidget(self.label_2, 0, 2, 1, 1) + self.gridLayout.addWidget(self.label_2, 2, 1, 1, 1) + self.binsizeEdit = QtWidgets.QLineEdit(Form) + self.binsizeEdit.setObjectName("binsizeEdit") + self.gridLayout.addWidget(self.binsizeEdit, 3, 3, 1, 1) + self.shatterBox = QtWidgets.QCheckBox(Form) + self.shatterBox.setChecked(True) + self.shatterBox.setObjectName("shatterBox") + self.gridLayout.addWidget(self.shatterBox, 1, 6, 1, 1) + self.label_5 = QtWidgets.QLabel(Form) + self.label_5.setObjectName("label_5") + self.gridLayout.addWidget(self.label_5, 2, 3, 1, 1) + self.numofbinsEdit = QtWidgets.QLineEdit(Form) + self.numofbinsEdit.setObjectName("numofbinsEdit") + self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) + self.label_4 = QtWidgets.QLabel(Form) + self.label_4.setObjectName("label_4") + self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) + self.position = QtWidgets.QLabel(Form) + self.position.setObjectName("position") + self.gridLayout.addWidget(self.position, 0, 0, 1, 1) self.valuetobinariseEdit = QtWidgets.QLineEdit(Form) self.valuetobinariseEdit.setObjectName("valuetobinariseEdit") self.gridLayout.addWidget(self.valuetobinariseEdit, 1, 5, 1, 1) - self.label_3 = QtWidgets.QLabel(Form) - self.label_3.setObjectName("label_3") - self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) - self.shatterEdit = QtWidgets.QLineEdit(Form) - self.shatterEdit.setObjectName("shatterEdit") - self.gridLayout.addWidget(self.shatterEdit, 1, 6, 1, 1) self.onsetEdit = QtWidgets.QLineEdit(Form) self.onsetEdit.setObjectName("onsetEdit") self.gridLayout.addWidget(self.onsetEdit, 1, 1, 1, 1) + self.offsetEdit = QtWidgets.QLineEdit(Form) + self.offsetEdit.setObjectName("offsetEdit") + self.gridLayout.addWidget(self.offsetEdit, 3, 1, 1, 1) self.removeButton = QtWidgets.QToolButton(Form) self.removeButton.setObjectName("removeButton") self.gridLayout.addWidget(self.removeButton, 1, 0, 1, 1) + self.shatterEdit = QtWidgets.QLineEdit(Form) + self.shatterEdit.setObjectName("shatterEdit") + self.gridLayout.addWidget(self.shatterEdit, 1, 7, 1, 1) + self.label_3 = QtWidgets.QLabel(Form) + self.label_3.setObjectName("label_3") + self.gridLayout.addWidget(self.label_3, 0, 5, 1, 1) self.label = QtWidgets.QLabel(Form) self.label.setObjectName("label") self.gridLayout.addWidget(self.label, 0, 1, 1, 1) + self.label_6 = QtWidgets.QLabel(Form) + self.label_6.setObjectName("label_6") + self.gridLayout.addWidget(self.label_6, 0, 7, 1, 1) self.line_2 = QtWidgets.QFrame(Form) self.line_2.setFrameShape(QtWidgets.QFrame.HLine) self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") - self.gridLayout.addWidget(self.line_2, 2, 1, 1, 6) - self.label_6 = QtWidgets.QLabel(Form) - self.label_6.setObjectName("label_6") - self.gridLayout.addWidget(self.label_6, 0, 6, 1, 1) - self.binsizeEdit = QtWidgets.QLineEdit(Form) - self.binsizeEdit.setObjectName("binsizeEdit") - self.gridLayout.addWidget(self.binsizeEdit, 1, 4, 1, 1) - self.label_4 = QtWidgets.QLabel(Form) - self.label_4.setObjectName("label_4") - self.gridLayout.addWidget(self.label_4, 0, 3, 1, 1) - self.label_5 = QtWidgets.QLabel(Form) - self.label_5.setObjectName("label_5") - self.gridLayout.addWidget(self.label_5, 0, 4, 1, 1) - self.numofbinsEdit = QtWidgets.QLineEdit(Form) - self.numofbinsEdit.setObjectName("numofbinsEdit") - self.gridLayout.addWidget(self.numofbinsEdit, 1, 3, 1, 1) - self.position = QtWidgets.QLabel(Form) - self.position.setObjectName("position") - self.gridLayout.addWidget(self.position, 0, 0, 1, 1) + self.gridLayout.addWidget(self.line_2, 4, 1, 1, 7) + self.shatterDutyEdit = QtWidgets.QLineEdit(Form) + self.shatterDutyEdit.setObjectName("shatterDutyEdit") + self.gridLayout.addWidget(self.shatterDutyEdit, 3, 7, 1, 1) + self.label_7 = QtWidgets.QLabel(Form) + self.label_7.setObjectName("label_7") + self.gridLayout.addWidget(self.label_7, 2, 7, 1, 1) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) @@ -76,18 +86,21 @@ def setupUi(self, Form): def retranslateUi(self, Form): _translate = QtCore.QCoreApplication.translate Form.setWindowTitle(_translate("Form", "Form")) - self.offsetEdit.setText(_translate("Form", "0.1")) self.label_2.setText(_translate("Form", "Offset")) + self.binsizeEdit.setText(_translate("Form", "0.05")) + self.shatterBox.setText(_translate("Form", "Shatter Pulse")) + self.label_5.setText(_translate("Form", "Bin size")) + self.numofbinsEdit.setText(_translate("Form", "8")) + self.label_4.setText(_translate("Form", "Number of bins")) + self.position.setText(_translate("Form", "1")) self.valuetobinariseEdit.setText(_translate("Form", "2")) - self.label_3.setText(_translate("Form", "Value to binarise")) - self.shatterEdit.setText(_translate("Form", "500")) self.onsetEdit.setText(_translate("Form", "0.1")) + self.offsetEdit.setText(_translate("Form", "0.1")) self.removeButton.setText(_translate("Form", "-")) + self.shatterEdit.setText(_translate("Form", "500")) + self.label_3.setText(_translate("Form", "Value to binarise")) self.label.setText(_translate("Form", "Onset")) self.label_6.setText(_translate("Form", "Shatter (Hz)")) - self.binsizeEdit.setText(_translate("Form", "0.05")) - self.label_4.setText(_translate("Form", "Number of bins")) - self.label_5.setText(_translate("Form", "Bin size")) - self.numofbinsEdit.setText(_translate("Form", "8")) - self.position.setText(_translate("Form", "1")) + self.shatterDutyEdit.setText(_translate("Form", "0.5")) + self.label_7.setText(_translate("Form", "Shatter Duty")) From 4ad526509663146c60d44d14f7e0e027d974ea73 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 27 Feb 2020 19:20:05 +0000 Subject: [PATCH 50/83] change to data saving --- Controllers/QueueControl.py | 9 +- Controllers/main.py | 5 +- Designs/mainDesign.py | 266 +++++++++++++--------- Models/Experiment.py | 10 + UI/PulseBoyUI_v2.py | 266 +++++++++++++--------- UI/PulseBoyUI_v2.ui | 441 ++++++++++++++++++++++-------------- 6 files changed, 601 insertions(+), 396 deletions(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 0a01c63..9077312 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -67,9 +67,11 @@ def trial(self): self.analog_data = [] # Save data - save_string = export_params['export_path'] + str(self.experiment.current_trial) + \ - export_params['export_suffix'] + '.mat' - sio.savemat(save_string, {'analog_data': self.analog_data, 'pulses': pulses, 't': t}) + if export_params['save_pulses']: + save_string = export_params['export_path'] + str(self.experiment.current_trial) + \ + export_params['pulse_suffix'] + '.mat' + sio.savemat(save_string, {'analog_data': self.analog_data, 'pulses': pulses, 't': t}) + if self.experiment.total_trials() - self.experiment.current_trial == 1: self.parent.should_run = False @@ -78,6 +80,7 @@ def trial(self): if self.parent.should_run: self.experiment.advance_trial() + print('finished') self.finished.emit() diff --git a/Controllers/main.py b/Controllers/main.py index fdd6fcb..2798a7c 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -233,8 +233,11 @@ def get_global_params(self): def get_export_params(self): params = dict() + params['save_names'] = bool(self.trialNameCheckBox.isChecked()) + params['save_pulses'] = bool(self.pulseCheckBox.isChecked()) params['export_path'] = str(self.exportPathEdit.text()) - params['export_suffix'] = str(self.exportSuffixEdit.text()) + params['pulse_suffix'] = str(self.pulseSuffixEdit.text()) + params['trial_suffix'] = str(self.trialNameSuffixEdit.text()) return params diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 82c2a48..e17ef10 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -16,6 +16,41 @@ def setupUi(self, MainWindow): self.centralwidget.setObjectName("centralwidget") self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) + self.label = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label.setFont(font) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 0, 1, 1) + self.label_8 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_8.setFont(font) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) self.viewWidgetTab.setObjectName("viewWidgetTab") self.pulseTab = QtWidgets.QWidget() @@ -45,15 +80,6 @@ def setupUi(self, MainWindow): self.gridLayout_6.addWidget(self.analogView, 0, 0, 1, 1) self.viewWidgetTab.addTab(self.analogDataTab, "") self.gridLayout.addWidget(self.viewWidgetTab, 3, 2, 1, 1) - self.label_8 = QtWidgets.QLabel(self.centralwidget) - font = QtGui.QFont() - font.setFamily("Lucida Console") - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.label_8.setFont(font) - self.label_8.setObjectName("label_8") - self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) self.trialBankTable = QtWidgets.QTableView(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -68,32 +94,6 @@ def setupUi(self, MainWindow): self.trialBankTable.setObjectName("trialBankTable") self.trialBankTable.horizontalHeader().setStretchLastSection(False) self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) - self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) - self.valveBankScrollArea.setWidgetResizable(True) - self.valveBankScrollArea.setObjectName("valveBankScrollArea") - self.valveBankContents = QtWidgets.QWidget() - self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) - self.valveBankContents.setSizePolicy(sizePolicy) - self.valveBankContents.setObjectName("valveBankContents") - self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) - self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) - self.valveBankLayout.setContentsMargins(0, 0, 0, 0) - self.valveBankLayout.setObjectName("valveBankLayout") - self.valveBankScrollArea.setWidget(self.valveBankContents) - self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) - self.label = QtWidgets.QLabel(self.centralwidget) - font = QtGui.QFont() - font.setFamily("Lucida Console") - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.label.setFont(font) - self.label.setObjectName("label") - self.gridLayout.addWidget(self.label, 0, 0, 1, 1) self.setupTabs = QtWidgets.QTabWidget(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -177,8 +177,42 @@ def setupUi(self, MainWindow): self.experimentSetupTab.setObjectName("experimentSetupTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) self.gridLayout_4.setObjectName("gridLayout_4") - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 8, 1, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 8, 2, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 7, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) + self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveUpButton.setObjectName("moveUpButton") + self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") + self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 9, 1, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 8, 0, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveDownButton.setObjectName("moveDownButton") + self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) + self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 9, 2, 1, 1) + self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.removeTrialButton.setObjectName("removeTrialButton") + self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) @@ -187,6 +221,11 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem2, 1, 0, 1, 1) + self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.runSelectedButton.setObjectName("runSelectedButton") + self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) self.valveTypeCombo.setObjectName("valveTypeCombo") self.valveTypeCombo.addItem("") @@ -195,67 +234,69 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.removeTrialButton.setObjectName("removeTrialButton") - self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) - self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.runSelectedButton.setObjectName("runSelectedButton") - self.gridLayout_4.addWidget(self.runSelectedButton, 7, 0, 1, 1) - self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.moveUpButton.setObjectName("moveUpButton") - self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) - self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueButton.setObjectName("startQueueButton") - self.gridLayout_4.addWidget(self.startQueueButton, 6, 0, 1, 1) - self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addTrialButton.setObjectName("addTrialButton") - self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) - self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.updateTrialButton.setObjectName("updateTrialButton") - self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) - self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.moveDownButton.setObjectName("moveDownButton") - self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) - self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addValveButton.setObjectName("addValveButton") - self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) - self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.stopQueueButton.setObjectName("stopQueueButton") - self.gridLayout_4.addWidget(self.stopQueueButton, 6, 2, 1, 1) - self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) - self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") - self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 7, 2, 1, 1) - self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.pauseQueueButton.setObjectName("pauseQueueButton") - self.gridLayout_4.addWidget(self.pauseQueueButton, 6, 1, 1, 1) - self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") - self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 7, 1, 1, 1) - self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") - self.gridLayout_4.addWidget(self.randomiseTrialsButton, 5, 0, 1, 1) + self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) + self.horizontalLayout = QtWidgets.QHBoxLayout() + self.horizontalLayout.setObjectName("horizontalLayout") + self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) + self.label_10.setObjectName("label_10") + self.horizontalLayout.addWidget(self.label_10) + self.repeatsBox = QtWidgets.QSpinBox(self.experimentSetupTab) + self.repeatsBox.setProperty("value", 1) + self.repeatsBox.setObjectName("repeatsBox") + self.horizontalLayout.addWidget(self.repeatsBox) + self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) + self.checkBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.checkBox.setObjectName("checkBox") + self.gridLayout_4.addWidget(self.checkBox, 7, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) self.gridLayout_7.setObjectName("gridLayout_7") - self.label_13 = QtWidgets.QLabel(self.dataExportTab) - self.label_13.setObjectName("label_13") - self.gridLayout_7.addWidget(self.label_13, 1, 0, 1, 1) - self.label_12 = QtWidgets.QLabel(self.dataExportTab) - self.label_12.setObjectName("label_12") - self.gridLayout_7.addWidget(self.label_12, 0, 0, 1, 1) - self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportPathEdit.setObjectName("exportPathEdit") - self.gridLayout_7.addWidget(self.exportPathEdit, 0, 1, 1, 1) - self.exportSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportSuffixEdit.setObjectName("exportSuffixEdit") - self.gridLayout_7.addWidget(self.exportSuffixEdit, 1, 1, 1, 1) + spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem4, 9, 1, 1, 1) + self.horizontalLayout_4 = QtWidgets.QHBoxLayout() + self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) + self.horizontalLayout_4.setSpacing(6) + self.horizontalLayout_4.setObjectName("horizontalLayout_4") + self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.trialNameCheckBox.setObjectName("trialNameCheckBox") + self.horizontalLayout_4.addWidget(self.trialNameCheckBox) + self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.pulseCheckBox.setObjectName("pulseCheckBox") + self.horizontalLayout_4.addWidget(self.pulseCheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) self.exportPathDirButton.setObjectName("exportPathDirButton") - self.gridLayout_7.addWidget(self.exportPathDirButton, 0, 2, 1, 1) + self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) + self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setText("") + self.exportPathEdit.setObjectName("exportPathEdit") + self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) + self.horizontalLayout_5 = QtWidgets.QHBoxLayout() + self.horizontalLayout_5.setObjectName("horizontalLayout_5") + self.label_14 = QtWidgets.QLabel(self.dataExportTab) + self.label_14.setObjectName("label_14") + self.horizontalLayout_5.addWidget(self.label_14) + self.label_13 = QtWidgets.QLabel(self.dataExportTab) + self.label_13.setObjectName("label_13") + self.horizontalLayout_5.addWidget(self.label_13) + self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) + self.horizontalLayout_6 = QtWidgets.QHBoxLayout() + self.horizontalLayout_6.setObjectName("horizontalLayout_6") + self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") + self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) + self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") + self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) + spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) self.setupTabs.addTab(self.dataExportTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) @@ -281,16 +322,16 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(2) + self.setupTabs.setCurrentIndex(3) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.label.setText(_translate("MainWindow", "Valve Bank")) + self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.label_8.setText(_translate("MainWindow", "Trial Bank")) - self.label.setText(_translate("MainWindow", "Valve Bank")) self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.label_2.setText(_translate("MainWindow", "Digital Out Device")) @@ -311,31 +352,36 @@ def retranslateUi(self, MainWindow): self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) + self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.moveDownButton.setText(_translate("MainWindow", "Move Down")) + self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) - self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) - self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) - self.moveUpButton.setText(_translate("MainWindow", "Move Up")) - self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) - self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) - self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) - self.moveDownButton.setText(_translate("MainWindow", "Move Down")) - self.addValveButton.setText(_translate("MainWindow", "Add Valve")) - self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) - self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) - self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) - self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) - self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.label_10.setText(_translate("MainWindow", "Repeats")) + self.checkBox.setText(_translate("MainWindow", "Shuffle repeats")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) - self.label_13.setText(_translate("MainWindow", "Export Suffix")) - self.label_12.setText(_translate("MainWindow", "Export Path")) - self.exportPathEdit.setText(_translate("MainWindow", "C:/Users/erskina/PycharmProjects/PulseBoy/Data/")) - self.exportSuffixEdit.setText(_translate("MainWindow", "data")) + self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) + self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) self.exportPathDirButton.setText(_translate("MainWindow", "...")) + self.label_12.setText(_translate("MainWindow", "Save path")) + self.label_14.setText(_translate("MainWindow", "Name suffix")) + self.label_13.setText(_translate("MainWindow", "Pulse suffix")) + self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) + self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) diff --git a/Models/Experiment.py b/Models/Experiment.py index 7377526..d6daaaf 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -101,6 +101,16 @@ def save_arraydata(self, file_conf): print("save failed") pass + def save_trial_names(self, file_conf): + try: + with open(file_conf[0] + file_conf[1], 'wb') as fn: + for i in self.arraydata: + fn.write(i) + fn.close() + except: + print('save failed') + pass + def advance_trial(self): self.current_trial += 1 diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 82c2a48..e17ef10 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -16,6 +16,41 @@ def setupUi(self, MainWindow): self.centralwidget.setObjectName("centralwidget") self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) + self.label = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label.setFont(font) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 0, 1, 1) + self.label_8 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_8.setFont(font) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) self.viewWidgetTab.setObjectName("viewWidgetTab") self.pulseTab = QtWidgets.QWidget() @@ -45,15 +80,6 @@ def setupUi(self, MainWindow): self.gridLayout_6.addWidget(self.analogView, 0, 0, 1, 1) self.viewWidgetTab.addTab(self.analogDataTab, "") self.gridLayout.addWidget(self.viewWidgetTab, 3, 2, 1, 1) - self.label_8 = QtWidgets.QLabel(self.centralwidget) - font = QtGui.QFont() - font.setFamily("Lucida Console") - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.label_8.setFont(font) - self.label_8.setObjectName("label_8") - self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) self.trialBankTable = QtWidgets.QTableView(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -68,32 +94,6 @@ def setupUi(self, MainWindow): self.trialBankTable.setObjectName("trialBankTable") self.trialBankTable.horizontalHeader().setStretchLastSection(False) self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) - self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) - self.valveBankScrollArea.setWidgetResizable(True) - self.valveBankScrollArea.setObjectName("valveBankScrollArea") - self.valveBankContents = QtWidgets.QWidget() - self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) - self.valveBankContents.setSizePolicy(sizePolicy) - self.valveBankContents.setObjectName("valveBankContents") - self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) - self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) - self.valveBankLayout.setContentsMargins(0, 0, 0, 0) - self.valveBankLayout.setObjectName("valveBankLayout") - self.valveBankScrollArea.setWidget(self.valveBankContents) - self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) - self.label = QtWidgets.QLabel(self.centralwidget) - font = QtGui.QFont() - font.setFamily("Lucida Console") - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.label.setFont(font) - self.label.setObjectName("label") - self.gridLayout.addWidget(self.label, 0, 0, 1, 1) self.setupTabs = QtWidgets.QTabWidget(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -177,8 +177,42 @@ def setupUi(self, MainWindow): self.experimentSetupTab.setObjectName("experimentSetupTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) self.gridLayout_4.setObjectName("gridLayout_4") - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 8, 1, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 8, 2, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 7, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) + self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveUpButton.setObjectName("moveUpButton") + self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") + self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 9, 1, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 8, 0, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveDownButton.setObjectName("moveDownButton") + self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) + self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 9, 2, 1, 1) + self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.removeTrialButton.setObjectName("removeTrialButton") + self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) @@ -187,6 +221,11 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem2, 1, 0, 1, 1) + self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.runSelectedButton.setObjectName("runSelectedButton") + self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) self.valveTypeCombo.setObjectName("valveTypeCombo") self.valveTypeCombo.addItem("") @@ -195,67 +234,69 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.removeTrialButton.setObjectName("removeTrialButton") - self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) - self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.runSelectedButton.setObjectName("runSelectedButton") - self.gridLayout_4.addWidget(self.runSelectedButton, 7, 0, 1, 1) - self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.moveUpButton.setObjectName("moveUpButton") - self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) - self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueButton.setObjectName("startQueueButton") - self.gridLayout_4.addWidget(self.startQueueButton, 6, 0, 1, 1) - self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addTrialButton.setObjectName("addTrialButton") - self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) - self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.updateTrialButton.setObjectName("updateTrialButton") - self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) - self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.moveDownButton.setObjectName("moveDownButton") - self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) - self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addValveButton.setObjectName("addValveButton") - self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) - self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.stopQueueButton.setObjectName("stopQueueButton") - self.gridLayout_4.addWidget(self.stopQueueButton, 6, 2, 1, 1) - self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) - self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") - self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 7, 2, 1, 1) - self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.pauseQueueButton.setObjectName("pauseQueueButton") - self.gridLayout_4.addWidget(self.pauseQueueButton, 6, 1, 1, 1) - self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") - self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 7, 1, 1, 1) - self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") - self.gridLayout_4.addWidget(self.randomiseTrialsButton, 5, 0, 1, 1) + self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) + self.horizontalLayout = QtWidgets.QHBoxLayout() + self.horizontalLayout.setObjectName("horizontalLayout") + self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) + self.label_10.setObjectName("label_10") + self.horizontalLayout.addWidget(self.label_10) + self.repeatsBox = QtWidgets.QSpinBox(self.experimentSetupTab) + self.repeatsBox.setProperty("value", 1) + self.repeatsBox.setObjectName("repeatsBox") + self.horizontalLayout.addWidget(self.repeatsBox) + self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) + self.checkBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.checkBox.setObjectName("checkBox") + self.gridLayout_4.addWidget(self.checkBox, 7, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) self.gridLayout_7.setObjectName("gridLayout_7") - self.label_13 = QtWidgets.QLabel(self.dataExportTab) - self.label_13.setObjectName("label_13") - self.gridLayout_7.addWidget(self.label_13, 1, 0, 1, 1) - self.label_12 = QtWidgets.QLabel(self.dataExportTab) - self.label_12.setObjectName("label_12") - self.gridLayout_7.addWidget(self.label_12, 0, 0, 1, 1) - self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportPathEdit.setObjectName("exportPathEdit") - self.gridLayout_7.addWidget(self.exportPathEdit, 0, 1, 1, 1) - self.exportSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportSuffixEdit.setObjectName("exportSuffixEdit") - self.gridLayout_7.addWidget(self.exportSuffixEdit, 1, 1, 1, 1) + spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem4, 9, 1, 1, 1) + self.horizontalLayout_4 = QtWidgets.QHBoxLayout() + self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) + self.horizontalLayout_4.setSpacing(6) + self.horizontalLayout_4.setObjectName("horizontalLayout_4") + self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.trialNameCheckBox.setObjectName("trialNameCheckBox") + self.horizontalLayout_4.addWidget(self.trialNameCheckBox) + self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.pulseCheckBox.setObjectName("pulseCheckBox") + self.horizontalLayout_4.addWidget(self.pulseCheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) self.exportPathDirButton.setObjectName("exportPathDirButton") - self.gridLayout_7.addWidget(self.exportPathDirButton, 0, 2, 1, 1) + self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) + self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setText("") + self.exportPathEdit.setObjectName("exportPathEdit") + self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) + self.horizontalLayout_5 = QtWidgets.QHBoxLayout() + self.horizontalLayout_5.setObjectName("horizontalLayout_5") + self.label_14 = QtWidgets.QLabel(self.dataExportTab) + self.label_14.setObjectName("label_14") + self.horizontalLayout_5.addWidget(self.label_14) + self.label_13 = QtWidgets.QLabel(self.dataExportTab) + self.label_13.setObjectName("label_13") + self.horizontalLayout_5.addWidget(self.label_13) + self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) + self.horizontalLayout_6 = QtWidgets.QHBoxLayout() + self.horizontalLayout_6.setObjectName("horizontalLayout_6") + self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") + self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) + self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") + self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) + spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) self.setupTabs.addTab(self.dataExportTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) @@ -281,16 +322,16 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(2) + self.setupTabs.setCurrentIndex(3) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.label.setText(_translate("MainWindow", "Valve Bank")) + self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.label_8.setText(_translate("MainWindow", "Trial Bank")) - self.label.setText(_translate("MainWindow", "Valve Bank")) self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.label_2.setText(_translate("MainWindow", "Digital Out Device")) @@ -311,31 +352,36 @@ def retranslateUi(self, MainWindow): self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) + self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.moveDownButton.setText(_translate("MainWindow", "Move Down")) + self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) - self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) - self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) - self.moveUpButton.setText(_translate("MainWindow", "Move Up")) - self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) - self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) - self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) - self.moveDownButton.setText(_translate("MainWindow", "Move Down")) - self.addValveButton.setText(_translate("MainWindow", "Add Valve")) - self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) - self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) - self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) - self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) - self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.label_10.setText(_translate("MainWindow", "Repeats")) + self.checkBox.setText(_translate("MainWindow", "Shuffle repeats")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) - self.label_13.setText(_translate("MainWindow", "Export Suffix")) - self.label_12.setText(_translate("MainWindow", "Export Path")) - self.exportPathEdit.setText(_translate("MainWindow", "C:/Users/erskina/PycharmProjects/PulseBoy/Data/")) - self.exportSuffixEdit.setText(_translate("MainWindow", "data")) + self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) + self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) self.exportPathDirButton.setText(_translate("MainWindow", "...")) + self.label_12.setText(_translate("MainWindow", "Save path")) + self.label_14.setText(_translate("MainWindow", "Name suffix")) + self.label_13.setText(_translate("MainWindow", "Pulse suffix")) + self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) + self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 6ac0e8c..e46b585 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -15,6 +15,64 @@ + + + + true + + + + + 0 + 0 + 18 + 348 + + + + + 0 + 0 + + + + + QLayout::SetFixedSize + + + + + + + + + + Lucida Console + 12 + 75 + true + + + + Valve Bank + + + + + + + + Lucida Console + 12 + 75 + true + + + + Trial Bank + + + @@ -56,21 +114,6 @@ - - - - - Lucida Console - 12 - 75 - true - - - - Trial Bank - - - @@ -95,49 +138,6 @@ - - - - true - - - - - 0 - 0 - 18 - 348 - - - - - 0 - 0 - - - - - QLayout::SetFixedSize - - - - - - - - - - Lucida Console - 12 - 75 - true - - - - Valve Bank - - - @@ -153,7 +153,7 @@ - 2 + 3 @@ -326,85 +326,38 @@ Experiment - - - - Qt::Vertical - - - - 20 - 40 - - - - - - - - - 0 - 0 - - + + - Trial Name + Add To Trials - - - - - Simple - - - - - Binary - - - - - Anti Plume - - - - - Noise - - - - - Plume - - + + + + Pause Queue + - - + + - Remove Trial + Stop Queue - - - - Qt::Vertical - - - - 20 - 40 - + + + + Randomise trials - + - - + + - Run Selected + Update Trial @@ -415,24 +368,24 @@ - - + + - Start Queue + Start Queue from Selected - - + + - Add To Trials + Start Queue - - + + - Update Trial + Add Valve @@ -443,45 +396,117 @@ - - + + - Add Valve + Wait for trigger - - + + - Stop Queue + Remove Trial - - + + + + + 0 + 0 + + - Wait for trigger + Trial Name - - - - Pause Queue + + + + Qt::Vertical - + + + 20 + 40 + + + - - + + - Start Queue from Selected + Run Selected - - + + + + + Simple + + + + + Binary + + + + + Anti Plume + + + + + Noise + + + + + Plume + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + Repeats + + + + + + + 1 + + + + + + + - Randomise trials + Shuffle repeats @@ -492,40 +517,112 @@ Data - - - - Export Suffix + + + + Qt::Vertical - + + + 20 + 40 + + + - - + + + + 6 + + + QLayout::SetDefaultConstraint + + + + + Save trial names + + + + + + + Save pulses + + + + + + + - Export Path + ... - + - C:/Users/erskina/PycharmProjects/PulseBoy/Data/ + - - + + - data + Save path - - - - ... + + + + + + Name suffix + + + + + + + Pulse suffix + + + + + + + + + + + trial_name + + + + + + + data + + + + + + + + + Qt::Vertical - + + + 20 + 40 + + + From 0ec0499105e7d3f9b92d62495a1d686f6410d7fd Mon Sep 17 00:00:00 2001 From: Tom Date: Thu, 27 Feb 2020 19:20:41 +0000 Subject: [PATCH 51/83] change path --- Controllers/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index fdd6fcb..a25a75d 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -1,6 +1,6 @@ import sys sys.path.append('C:\\Users\\warnert\\Documents\\GitHub') -sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy') +sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy_updated\\PulseBoy') from PyPulse import PulseInterface import numpy as np from PyQt5 import QtWidgets From 01eb596461aa07c2668b015bf1bc85cf25fe37fd Mon Sep 17 00:00:00 2001 From: Tom Date: Thu, 27 Feb 2020 19:48:15 +0000 Subject: [PATCH 52/83] Write trial names to file --- Controllers/QueueControl.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 9077312..993342c 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -76,11 +76,16 @@ def trial(self): if self.experiment.total_trials() - self.experiment.current_trial == 1: self.parent.should_run = False self.experiment.reset_trials() + if export_params['save_names']: + names = [i[-1] for i in self.experiment.arraydata] + f = open(export_params['export_path']+export_params['trial_suffix']+'.txt', 'w') + f.write('\n'.join(names)) + f.close() if self.parent.should_run: self.experiment.advance_trial() - print('finished') + self.finished.emit() From 572436412be9cd83051eb5a3fd44c0e2e393ab3c Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 27 Feb 2020 19:59:59 +0000 Subject: [PATCH 53/83] add intial trialbank repeats --- Controllers/QueueControl.py | 8 +++++++- Controllers/main.py | 5 +++++ Designs/mainDesign.py | 10 +++++----- UI/PulseBoyUI_v2.py | 10 +++++----- UI/PulseBoyUI_v2.ui | 4 ++-- 5 files changed, 24 insertions(+), 13 deletions(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 993342c..d5d535d 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -74,13 +74,18 @@ def trial(self): if self.experiment.total_trials() - self.experiment.current_trial == 1: - self.parent.should_run = False self.experiment.reset_trials() if export_params['save_names']: names = [i[-1] for i in self.experiment.arraydata] f = open(export_params['export_path']+export_params['trial_suffix']+'.txt', 'w') f.write('\n'.join(names)) f.close() + global_params['repeats_done'] += 1 + if global_params['repeats_done'] == global_params['repeats']: + self.parent.should_run = False + else: + if global_params['shuffle_repeats']: + self.experiment.randomise_trials() if self.parent.should_run: self.experiment.advance_trial() @@ -114,6 +119,7 @@ def prepare_thread(self): self.thread.start() def start(self): + params[''] if not self.should_run: self.should_run = True diff --git a/Controllers/main.py b/Controllers/main.py index 6ae9ecd..c3d2944 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -1,6 +1,8 @@ import sys sys.path.append('C:\\Users\\warnert\\Documents\\GitHub') sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy_updated\\PulseBoy') +sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy') + from PyPulse import PulseInterface import numpy as np from PyQt5 import QtWidgets @@ -228,6 +230,9 @@ def get_global_params(self): params = dict() params['global_onset'] = float(self.globalOnsetEdit.text()) params['global_offset'] = float(self.globalOffsetEdit.text()) + params['repeats'] = float(self.repeatsBox.text()) + params['repeats_done'] = 0 + params['shuffle_repeats'] = bool(self.shuffleRepeatsBox.isChecked()) return params diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index e17ef10..1606aaf 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -246,9 +246,9 @@ def setupUi(self, MainWindow): self.repeatsBox.setObjectName("repeatsBox") self.horizontalLayout.addWidget(self.repeatsBox) self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) - self.checkBox = QtWidgets.QCheckBox(self.experimentSetupTab) - self.checkBox.setObjectName("checkBox") - self.gridLayout_4.addWidget(self.checkBox, 7, 2, 1, 1) + self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") + self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -322,7 +322,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(3) + self.setupTabs.setCurrentIndex(2) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -372,7 +372,7 @@ def retranslateUi(self, MainWindow): self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) self.label_10.setText(_translate("MainWindow", "Repeats")) - self.checkBox.setText(_translate("MainWindow", "Shuffle repeats")) + self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index e17ef10..1606aaf 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -246,9 +246,9 @@ def setupUi(self, MainWindow): self.repeatsBox.setObjectName("repeatsBox") self.horizontalLayout.addWidget(self.repeatsBox) self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) - self.checkBox = QtWidgets.QCheckBox(self.experimentSetupTab) - self.checkBox.setObjectName("checkBox") - self.gridLayout_4.addWidget(self.checkBox, 7, 2, 1, 1) + self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") + self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -322,7 +322,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(3) + self.setupTabs.setCurrentIndex(2) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -372,7 +372,7 @@ def retranslateUi(self, MainWindow): self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) self.label_10.setText(_translate("MainWindow", "Repeats")) - self.checkBox.setText(_translate("MainWindow", "Shuffle repeats")) + self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index e46b585..0b9796c 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,7 +153,7 @@ - 3 + 2 @@ -504,7 +504,7 @@ - + Shuffle repeats From a4fc8ec913f44c759ed614e01c696c1190c71342 Mon Sep 17 00:00:00 2001 From: Tom Date: Thu, 27 Feb 2020 20:26:31 +0000 Subject: [PATCH 54/83] Save trial name and time of repeat start --- Controllers/QueueControl.py | 20 +++++++++++++++----- Controllers/main.py | 2 +- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index d5d535d..86cf7bc 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -4,6 +4,7 @@ from PyPulse import PulseInterface import scipy.io as sio import numpy as np +from datetime import datetime class QueueWorker(QtCore.QObject): @@ -77,17 +78,23 @@ def trial(self): self.experiment.reset_trials() if export_params['save_names']: names = [i[-1] for i in self.experiment.arraydata] - f = open(export_params['export_path']+export_params['trial_suffix']+'.txt', 'w') + date = datetime.today().strftime('%Y-%m-%d') + time = datetime.today().strftime('%H:%M:%S') + f = open(export_params['export_path']+date+export_params['trial_suffix']+'.txt', 'a') + f.write(time) + f.write('\n') f.write('\n'.join(names)) + f.write('\n') f.close() - global_params['repeats_done'] += 1 - if global_params['repeats_done'] == global_params['repeats']: + self.parent.repeats_done += 1 + if self.parent.repeats_done == global_params['repeats']: self.parent.should_run = False + self.parent.repeats_done = 0 else: if global_params['shuffle_repeats']: self.experiment.randomise_trials() - if self.parent.should_run: + elif self.parent.should_run: self.experiment.advance_trial() @@ -104,6 +111,7 @@ def __init__(self, experiment, get_global_params, get_hardware_params, get_expor self.get_hardware_params = get_hardware_params self.get_export_params = get_export_params self.prepare_thread() + self.repeats_done = 0 self.should_run = False self.trigger_control = trigger_control @@ -119,7 +127,7 @@ def prepare_thread(self): self.thread.start() def start(self): - params[''] + if not self.should_run: self.should_run = True @@ -133,6 +141,8 @@ def stop(self): self.should_run = False self.experiment.reset_trials() + self.repeats_done = 0 + def run_selected(self, trial): if not self.should_run: diff --git a/Controllers/main.py b/Controllers/main.py index c3d2944..df44c45 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -231,7 +231,7 @@ def get_global_params(self): params['global_onset'] = float(self.globalOnsetEdit.text()) params['global_offset'] = float(self.globalOffsetEdit.text()) params['repeats'] = float(self.repeatsBox.text()) - params['repeats_done'] = 0 + #params['repeats_done'] = 0 params['shuffle_repeats'] = bool(self.shuffleRepeatsBox.isChecked()) return params From 4735a305b5bca37ab32e69231a3ee3cccbefcfd1 Mon Sep 17 00:00:00 2001 From: Tom Date: Thu, 27 Feb 2020 20:31:33 +0000 Subject: [PATCH 55/83] add repeat print --- Controllers/QueueControl.py | 1 + 1 file changed, 1 insertion(+) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 86cf7bc..03ca08b 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -87,6 +87,7 @@ def trial(self): f.write('\n') f.close() self.parent.repeats_done += 1 + print('repeats done ', self.parent.repeats_done) if self.parent.repeats_done == global_params['repeats']: self.parent.should_run = False self.parent.repeats_done = 0 From c62e3b8fb5c996ea891407ebcfd4182b0e4c968b Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 1 Dec 2020 17:39:53 +0000 Subject: [PATCH 56/83] New camera tab *camera not yet implimented --- Controllers/main.py | 6 +- Designs/mainDesign.py | 229 +++++++++++++++++-------- UI/PulseBoyUI_v2.py | 229 +++++++++++++++++-------- UI/PulseBoyUI_v2.ui | 386 ++++++++++++++++++++++++++++++------------ 4 files changed, 596 insertions(+), 254 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index df44c45..5fa87f6 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -8,8 +8,10 @@ from PyQt5 import QtWidgets import Models.Experiment as Experiment from Controllers import QueueControl, QueueControl +from multiprocessing import Queue, Process from Designs import mainDesign from Models import PBWidgets +from vipy import StreamNSave import pickle as pickle import os.path @@ -62,7 +64,7 @@ def __init__(self): self.pauseQueueButton.clicked.connect(self.queue_controller.pause) self.runSelectedButton.clicked.connect(lambda x: self.queue_controller.run_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) self.startQueueFromSelectedButton.clicked.connect(lambda x: self.queue_controller.run_from_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) - + def add_valve(self, v_type='Simple', params=None): position = len(self.valveBankContents.children()) - 1 if v_type == 'Simple': @@ -249,6 +251,8 @@ def get_export_params(self): def set_export_path(self): path = QtWidgets.QFileDialog.getExistingDirectory(self, "Choose Export Path") self.exportPathEdit.setText(path + '/') + + # Back up the reference to the exceptionhook sys._excepthook = sys.excepthook diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 1606aaf..99750b5 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -16,23 +16,6 @@ def setupUi(self, MainWindow): self.centralwidget.setObjectName("centralwidget") self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") - self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) - self.valveBankScrollArea.setWidgetResizable(True) - self.valveBankScrollArea.setObjectName("valveBankScrollArea") - self.valveBankContents = QtWidgets.QWidget() - self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) - self.valveBankContents.setSizePolicy(sizePolicy) - self.valveBankContents.setObjectName("valveBankContents") - self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) - self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) - self.valveBankLayout.setContentsMargins(0, 0, 0, 0) - self.valveBankLayout.setObjectName("valveBankLayout") - self.valveBankScrollArea.setWidget(self.valveBankContents) - self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.label = QtWidgets.QLabel(self.centralwidget) font = QtGui.QFont() font.setFamily("Lucida Console") @@ -51,6 +34,23 @@ def setupUi(self, MainWindow): self.label_8.setFont(font) self.label_8.setObjectName("label_8") self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) self.viewWidgetTab.setObjectName("viewWidgetTab") self.pulseTab = QtWidgets.QWidget() @@ -109,50 +109,50 @@ def setupUi(self, MainWindow): self.hardwareTab.setObjectName("hardwareTab") self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) self.gridLayout_2.setObjectName("gridLayout_2") - self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") - self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) - self.label_9 = QtWidgets.QLabel(self.hardwareTab) - self.label_9.setObjectName("label_9") - self.gridLayout_2.addWidget(self.label_9, 9, 0, 1, 1) self.label_2 = QtWidgets.QLabel(self.hardwareTab) self.label_2.setObjectName("label_2") self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) - self.label_4 = QtWidgets.QLabel(self.hardwareTab) - self.label_4.setObjectName("label_4") - self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) - self.label_3 = QtWidgets.QLabel(self.hardwareTab) - self.label_3.setObjectName("label_3") - self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) self.analogChannelsLabel.setObjectName("analogChannelsLabel") self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) - self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.analogInDevEdit.setObjectName("analogInDevEdit") - self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) self.analogChannelsEdit.setObjectName("analogChannelsEdit") self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) self.label_5 = QtWidgets.QLabel(self.hardwareTab) self.label_5.setObjectName("label_5") self.gridLayout_2.addWidget(self.label_5, 6, 0, 1, 1) + self.label_11 = QtWidgets.QLabel(self.hardwareTab) + self.label_11.setObjectName("label_11") + self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.syncClockEdit.setObjectName("syncClockEdit") + self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.label_4 = QtWidgets.QLabel(self.hardwareTab) + self.label_4.setObjectName("label_4") + self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) self.sampRateEdit.setObjectName("sampRateEdit") self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) - self.label_11 = QtWidgets.QLabel(self.hardwareTab) - self.label_11.setObjectName("label_11") - self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.label_9 = QtWidgets.QLabel(self.hardwareTab) + self.label_9.setObjectName("label_9") + self.gridLayout_2.addWidget(self.label_9, 4, 1, 1, 1) self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) self.triggerInEdit.setObjectName("triggerInEdit") - self.gridLayout_2.addWidget(self.triggerInEdit, 10, 0, 1, 1) - self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.syncClockEdit.setObjectName("syncClockEdit") - self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.gridLayout_2.addWidget(self.triggerInEdit, 5, 1, 1, 1) self.setupTabs.addTab(self.hardwareTab, "") self.globalParametersTab = QtWidgets.QWidget() self.globalParametersTab.setObjectName("globalParametersTab") @@ -254,29 +254,67 @@ def setupUi(self, MainWindow): self.dataExportTab.setObjectName("dataExportTab") self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) self.gridLayout_7.setObjectName("gridLayout_7") + self.horizontalLayout_3 = QtWidgets.QHBoxLayout() + self.horizontalLayout_3.setObjectName("horizontalLayout_3") + self.label_18 = QtWidgets.QLabel(self.dataExportTab) + self.label_18.setObjectName("label_18") + self.horizontalLayout_3.addWidget(self.label_18) + self.label_15 = QtWidgets.QLabel(self.dataExportTab) + self.label_15.setObjectName("label_15") + self.horizontalLayout_3.addWidget(self.label_15) + self.gridLayout_7.addLayout(self.horizontalLayout_3, 10, 1, 1, 1) + self.horizontalLayout_2 = QtWidgets.QHBoxLayout() + self.horizontalLayout_2.setObjectName("horizontalLayout_2") + self.saveTrialStartscheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.saveTrialStartscheckBox.setChecked(True) + self.saveTrialStartscheckBox.setObjectName("saveTrialStartscheckBox") + self.horizontalLayout_2.addWidget(self.saveTrialStartscheckBox) + self.saveCameraVideocheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.saveCameraVideocheckBox.setChecked(True) + self.saveCameraVideocheckBox.setObjectName("saveCameraVideocheckBox") + self.horizontalLayout_2.addWidget(self.saveCameraVideocheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_2, 9, 1, 1, 1) + self.horizontalLayout_7 = QtWidgets.QHBoxLayout() + self.horizontalLayout_7.setObjectName("horizontalLayout_7") + self.trialStartsSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialStartsSuffixEdit.setObjectName("trialStartsSuffixEdit") + self.horizontalLayout_7.addWidget(self.trialStartsSuffixEdit) + self.cameraSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.cameraSuffixEdit.setObjectName("cameraSuffixEdit") + self.horizontalLayout_7.addWidget(self.cameraSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_7, 11, 1, 1, 1) + self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setText("") + self.exportPathEdit.setObjectName("exportPathEdit") + self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) + self.horizontalLayout_6 = QtWidgets.QHBoxLayout() + self.horizontalLayout_6.setObjectName("horizontalLayout_6") + self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") + self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) + self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") + self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem4, 9, 1, 1, 1) + self.gridLayout_7.addItem(spacerItem4, 2, 1, 1, 1) + spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem5, 12, 1, 1, 1) self.horizontalLayout_4 = QtWidgets.QHBoxLayout() self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) self.horizontalLayout_4.setSpacing(6) self.horizontalLayout_4.setObjectName("horizontalLayout_4") self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.trialNameCheckBox.setChecked(True) self.trialNameCheckBox.setObjectName("trialNameCheckBox") self.horizontalLayout_4.addWidget(self.trialNameCheckBox) self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) self.pulseCheckBox.setObjectName("pulseCheckBox") self.horizontalLayout_4.addWidget(self.pulseCheckBox) self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) - self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) - self.exportPathDirButton.setObjectName("exportPathDirButton") - self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) - self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportPathEdit.setText("") - self.exportPathEdit.setObjectName("exportPathEdit") - self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) - self.label_12 = QtWidgets.QLabel(self.dataExportTab) - self.label_12.setObjectName("label_12") - self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) self.horizontalLayout_5 = QtWidgets.QHBoxLayout() self.horizontalLayout_5.setObjectName("horizontalLayout_5") self.label_14 = QtWidgets.QLabel(self.dataExportTab) @@ -286,18 +324,49 @@ def setupUi(self, MainWindow): self.label_13.setObjectName("label_13") self.horizontalLayout_5.addWidget(self.label_13) self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) - self.horizontalLayout_6 = QtWidgets.QHBoxLayout() - self.horizontalLayout_6.setObjectName("horizontalLayout_6") - self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") - self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) - self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") - self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) - self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) - spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) + self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) + self.exportPathDirButton.setObjectName("exportPathDirButton") + self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) self.setupTabs.addTab(self.dataExportTab, "") + self.cameraTab = QtWidgets.QWidget() + self.cameraTab.setObjectName("cameraTab") + self.gridLayout_8 = QtWidgets.QGridLayout(self.cameraTab) + self.gridLayout_8.setObjectName("gridLayout_8") + spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem6, 3, 0, 1, 2) + spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem7, 10, 0, 1, 2) + self.label_19 = QtWidgets.QLabel(self.cameraTab) + self.label_19.setObjectName("label_19") + self.gridLayout_8.addWidget(self.label_19, 5, 1, 1, 1) + self.cameraSaveIconBox = QtWidgets.QCheckBox(self.cameraTab) + self.cameraSaveIconBox.setChecked(True) + self.cameraSaveIconBox.setObjectName("cameraSaveIconBox") + self.gridLayout_8.addWidget(self.cameraSaveIconBox, 7, 0, 1, 1) + self.label_17 = QtWidgets.QLabel(self.cameraTab) + self.label_17.setObjectName("label_17") + self.gridLayout_8.addWidget(self.label_17, 5, 0, 1, 1) + self.cameraSaveIntervalEdit = QtWidgets.QLineEdit(self.cameraTab) + self.cameraSaveIntervalEdit.setObjectName("cameraSaveIntervalEdit") + self.gridLayout_8.addWidget(self.cameraSaveIntervalEdit, 6, 0, 1, 1) + self.numberCamerasEdit = QtWidgets.QLineEdit(self.cameraTab) + self.numberCamerasEdit.setObjectName("numberCamerasEdit") + self.gridLayout_8.addWidget(self.numberCamerasEdit, 6, 1, 1, 1) + self.launchCameraButton = QtWidgets.QPushButton(self.cameraTab) + self.launchCameraButton.setObjectName("launchCameraButton") + self.gridLayout_8.addWidget(self.launchCameraButton, 4, 0, 1, 2) + self.blackAndWhiteBox = QtWidgets.QCheckBox(self.cameraTab) + self.blackAndWhiteBox.setChecked(True) + self.blackAndWhiteBox.setObjectName("blackAndWhiteBox") + self.gridLayout_8.addWidget(self.blackAndWhiteBox, 7, 1, 1, 1) + self.showStreamcheckBox = QtWidgets.QCheckBox(self.cameraTab) + self.showStreamcheckBox.setChecked(True) + self.showStreamcheckBox.setObjectName("showStreamcheckBox") + self.gridLayout_8.addWidget(self.showStreamcheckBox, 8, 1, 1, 1) + self.pushButton = QtWidgets.QPushButton(self.cameraTab) + self.pushButton.setObjectName("pushButton") + self.gridLayout_8.addWidget(self.pushButton, 8, 0, 1, 1) + self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) @@ -332,20 +401,20 @@ def retranslateUi(self, MainWindow): self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) - self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.label_2.setText(_translate("MainWindow", "Digital Out Device")) - self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) - self.label_3.setText(_translate("MainWindow", "Analog Input Device")) self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) - self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) self.analogChannelsEdit.setText(_translate("MainWindow", "1")) self.label_5.setText(_translate("MainWindow", "Sampling Rate")) - self.sampRateEdit.setText(_translate("MainWindow", "20000")) self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) - self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) + self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.sampRateEdit.setText(_translate("MainWindow", "20000")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) self.label_6.setText(_translate("MainWindow", "Onset")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) @@ -374,15 +443,31 @@ def retranslateUi(self, MainWindow): self.label_10.setText(_translate("MainWindow", "Repeats")) self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) + self.label_18.setText(_translate("MainWindow", "Time suffix")) + self.label_15.setText(_translate("MainWindow", "Camera suffix")) + self.saveTrialStartscheckBox.setText(_translate("MainWindow", "Save trial start times")) + self.saveCameraVideocheckBox.setText(_translate("MainWindow", "Save camera video")) + self.trialStartsSuffixEdit.setText(_translate("MainWindow", "trial_starts")) + self.cameraSuffixEdit.setText(_translate("MainWindow", "camera")) + self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) + self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) + self.label_12.setText(_translate("MainWindow", "Save path")) self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) - self.exportPathDirButton.setText(_translate("MainWindow", "...")) - self.label_12.setText(_translate("MainWindow", "Save path")) self.label_14.setText(_translate("MainWindow", "Name suffix")) self.label_13.setText(_translate("MainWindow", "Pulse suffix")) - self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) - self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) + self.exportPathDirButton.setText(_translate("MainWindow", "...")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) + self.label_19.setText(_translate("MainWindow", "Number of cameras")) + self.cameraSaveIconBox.setText(_translate("MainWindow", "Camera save icon")) + self.label_17.setText(_translate("MainWindow", "Camera save interval (s)")) + self.cameraSaveIntervalEdit.setText(_translate("MainWindow", "600")) + self.numberCamerasEdit.setText(_translate("MainWindow", "2")) + self.launchCameraButton.setText(_translate("MainWindow", "Launch camera(s)")) + self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) + self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) + self.pushButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) self.actionLoad.setText(_translate("MainWindow", "Load")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 1606aaf..99750b5 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -16,23 +16,6 @@ def setupUi(self, MainWindow): self.centralwidget.setObjectName("centralwidget") self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") - self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) - self.valveBankScrollArea.setWidgetResizable(True) - self.valveBankScrollArea.setObjectName("valveBankScrollArea") - self.valveBankContents = QtWidgets.QWidget() - self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) - self.valveBankContents.setSizePolicy(sizePolicy) - self.valveBankContents.setObjectName("valveBankContents") - self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) - self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) - self.valveBankLayout.setContentsMargins(0, 0, 0, 0) - self.valveBankLayout.setObjectName("valveBankLayout") - self.valveBankScrollArea.setWidget(self.valveBankContents) - self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.label = QtWidgets.QLabel(self.centralwidget) font = QtGui.QFont() font.setFamily("Lucida Console") @@ -51,6 +34,23 @@ def setupUi(self, MainWindow): self.label_8.setFont(font) self.label_8.setObjectName("label_8") self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) self.viewWidgetTab.setObjectName("viewWidgetTab") self.pulseTab = QtWidgets.QWidget() @@ -109,50 +109,50 @@ def setupUi(self, MainWindow): self.hardwareTab.setObjectName("hardwareTab") self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) self.gridLayout_2.setObjectName("gridLayout_2") - self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") - self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) - self.label_9 = QtWidgets.QLabel(self.hardwareTab) - self.label_9.setObjectName("label_9") - self.gridLayout_2.addWidget(self.label_9, 9, 0, 1, 1) self.label_2 = QtWidgets.QLabel(self.hardwareTab) self.label_2.setObjectName("label_2") self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) - self.label_4 = QtWidgets.QLabel(self.hardwareTab) - self.label_4.setObjectName("label_4") - self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) - self.label_3 = QtWidgets.QLabel(self.hardwareTab) - self.label_3.setObjectName("label_3") - self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) self.analogChannelsLabel.setObjectName("analogChannelsLabel") self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) - self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.analogInDevEdit.setObjectName("analogInDevEdit") - self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) self.analogChannelsEdit.setObjectName("analogChannelsEdit") self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) self.label_5 = QtWidgets.QLabel(self.hardwareTab) self.label_5.setObjectName("label_5") self.gridLayout_2.addWidget(self.label_5, 6, 0, 1, 1) + self.label_11 = QtWidgets.QLabel(self.hardwareTab) + self.label_11.setObjectName("label_11") + self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.syncClockEdit.setObjectName("syncClockEdit") + self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.label_4 = QtWidgets.QLabel(self.hardwareTab) + self.label_4.setObjectName("label_4") + self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) self.sampRateEdit.setObjectName("sampRateEdit") self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) - self.label_11 = QtWidgets.QLabel(self.hardwareTab) - self.label_11.setObjectName("label_11") - self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.label_9 = QtWidgets.QLabel(self.hardwareTab) + self.label_9.setObjectName("label_9") + self.gridLayout_2.addWidget(self.label_9, 4, 1, 1, 1) self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) self.triggerInEdit.setObjectName("triggerInEdit") - self.gridLayout_2.addWidget(self.triggerInEdit, 10, 0, 1, 1) - self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.syncClockEdit.setObjectName("syncClockEdit") - self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.gridLayout_2.addWidget(self.triggerInEdit, 5, 1, 1, 1) self.setupTabs.addTab(self.hardwareTab, "") self.globalParametersTab = QtWidgets.QWidget() self.globalParametersTab.setObjectName("globalParametersTab") @@ -254,29 +254,67 @@ def setupUi(self, MainWindow): self.dataExportTab.setObjectName("dataExportTab") self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) self.gridLayout_7.setObjectName("gridLayout_7") + self.horizontalLayout_3 = QtWidgets.QHBoxLayout() + self.horizontalLayout_3.setObjectName("horizontalLayout_3") + self.label_18 = QtWidgets.QLabel(self.dataExportTab) + self.label_18.setObjectName("label_18") + self.horizontalLayout_3.addWidget(self.label_18) + self.label_15 = QtWidgets.QLabel(self.dataExportTab) + self.label_15.setObjectName("label_15") + self.horizontalLayout_3.addWidget(self.label_15) + self.gridLayout_7.addLayout(self.horizontalLayout_3, 10, 1, 1, 1) + self.horizontalLayout_2 = QtWidgets.QHBoxLayout() + self.horizontalLayout_2.setObjectName("horizontalLayout_2") + self.saveTrialStartscheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.saveTrialStartscheckBox.setChecked(True) + self.saveTrialStartscheckBox.setObjectName("saveTrialStartscheckBox") + self.horizontalLayout_2.addWidget(self.saveTrialStartscheckBox) + self.saveCameraVideocheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.saveCameraVideocheckBox.setChecked(True) + self.saveCameraVideocheckBox.setObjectName("saveCameraVideocheckBox") + self.horizontalLayout_2.addWidget(self.saveCameraVideocheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_2, 9, 1, 1, 1) + self.horizontalLayout_7 = QtWidgets.QHBoxLayout() + self.horizontalLayout_7.setObjectName("horizontalLayout_7") + self.trialStartsSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialStartsSuffixEdit.setObjectName("trialStartsSuffixEdit") + self.horizontalLayout_7.addWidget(self.trialStartsSuffixEdit) + self.cameraSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.cameraSuffixEdit.setObjectName("cameraSuffixEdit") + self.horizontalLayout_7.addWidget(self.cameraSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_7, 11, 1, 1, 1) + self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setText("") + self.exportPathEdit.setObjectName("exportPathEdit") + self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) + self.horizontalLayout_6 = QtWidgets.QHBoxLayout() + self.horizontalLayout_6.setObjectName("horizontalLayout_6") + self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") + self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) + self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") + self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem4, 9, 1, 1, 1) + self.gridLayout_7.addItem(spacerItem4, 2, 1, 1, 1) + spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem5, 12, 1, 1, 1) self.horizontalLayout_4 = QtWidgets.QHBoxLayout() self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) self.horizontalLayout_4.setSpacing(6) self.horizontalLayout_4.setObjectName("horizontalLayout_4") self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.trialNameCheckBox.setChecked(True) self.trialNameCheckBox.setObjectName("trialNameCheckBox") self.horizontalLayout_4.addWidget(self.trialNameCheckBox) self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) self.pulseCheckBox.setObjectName("pulseCheckBox") self.horizontalLayout_4.addWidget(self.pulseCheckBox) self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) - self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) - self.exportPathDirButton.setObjectName("exportPathDirButton") - self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) - self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportPathEdit.setText("") - self.exportPathEdit.setObjectName("exportPathEdit") - self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) - self.label_12 = QtWidgets.QLabel(self.dataExportTab) - self.label_12.setObjectName("label_12") - self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) self.horizontalLayout_5 = QtWidgets.QHBoxLayout() self.horizontalLayout_5.setObjectName("horizontalLayout_5") self.label_14 = QtWidgets.QLabel(self.dataExportTab) @@ -286,18 +324,49 @@ def setupUi(self, MainWindow): self.label_13.setObjectName("label_13") self.horizontalLayout_5.addWidget(self.label_13) self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) - self.horizontalLayout_6 = QtWidgets.QHBoxLayout() - self.horizontalLayout_6.setObjectName("horizontalLayout_6") - self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") - self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) - self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") - self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) - self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) - spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) + self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) + self.exportPathDirButton.setObjectName("exportPathDirButton") + self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) self.setupTabs.addTab(self.dataExportTab, "") + self.cameraTab = QtWidgets.QWidget() + self.cameraTab.setObjectName("cameraTab") + self.gridLayout_8 = QtWidgets.QGridLayout(self.cameraTab) + self.gridLayout_8.setObjectName("gridLayout_8") + spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem6, 3, 0, 1, 2) + spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem7, 10, 0, 1, 2) + self.label_19 = QtWidgets.QLabel(self.cameraTab) + self.label_19.setObjectName("label_19") + self.gridLayout_8.addWidget(self.label_19, 5, 1, 1, 1) + self.cameraSaveIconBox = QtWidgets.QCheckBox(self.cameraTab) + self.cameraSaveIconBox.setChecked(True) + self.cameraSaveIconBox.setObjectName("cameraSaveIconBox") + self.gridLayout_8.addWidget(self.cameraSaveIconBox, 7, 0, 1, 1) + self.label_17 = QtWidgets.QLabel(self.cameraTab) + self.label_17.setObjectName("label_17") + self.gridLayout_8.addWidget(self.label_17, 5, 0, 1, 1) + self.cameraSaveIntervalEdit = QtWidgets.QLineEdit(self.cameraTab) + self.cameraSaveIntervalEdit.setObjectName("cameraSaveIntervalEdit") + self.gridLayout_8.addWidget(self.cameraSaveIntervalEdit, 6, 0, 1, 1) + self.numberCamerasEdit = QtWidgets.QLineEdit(self.cameraTab) + self.numberCamerasEdit.setObjectName("numberCamerasEdit") + self.gridLayout_8.addWidget(self.numberCamerasEdit, 6, 1, 1, 1) + self.launchCameraButton = QtWidgets.QPushButton(self.cameraTab) + self.launchCameraButton.setObjectName("launchCameraButton") + self.gridLayout_8.addWidget(self.launchCameraButton, 4, 0, 1, 2) + self.blackAndWhiteBox = QtWidgets.QCheckBox(self.cameraTab) + self.blackAndWhiteBox.setChecked(True) + self.blackAndWhiteBox.setObjectName("blackAndWhiteBox") + self.gridLayout_8.addWidget(self.blackAndWhiteBox, 7, 1, 1, 1) + self.showStreamcheckBox = QtWidgets.QCheckBox(self.cameraTab) + self.showStreamcheckBox.setChecked(True) + self.showStreamcheckBox.setObjectName("showStreamcheckBox") + self.gridLayout_8.addWidget(self.showStreamcheckBox, 8, 1, 1, 1) + self.pushButton = QtWidgets.QPushButton(self.cameraTab) + self.pushButton.setObjectName("pushButton") + self.gridLayout_8.addWidget(self.pushButton, 8, 0, 1, 1) + self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) @@ -332,20 +401,20 @@ def retranslateUi(self, MainWindow): self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) - self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.label_2.setText(_translate("MainWindow", "Digital Out Device")) - self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) - self.label_3.setText(_translate("MainWindow", "Analog Input Device")) self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) - self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) self.analogChannelsEdit.setText(_translate("MainWindow", "1")) self.label_5.setText(_translate("MainWindow", "Sampling Rate")) - self.sampRateEdit.setText(_translate("MainWindow", "20000")) self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) - self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) + self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.sampRateEdit.setText(_translate("MainWindow", "20000")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) self.label_6.setText(_translate("MainWindow", "Onset")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) @@ -374,15 +443,31 @@ def retranslateUi(self, MainWindow): self.label_10.setText(_translate("MainWindow", "Repeats")) self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) + self.label_18.setText(_translate("MainWindow", "Time suffix")) + self.label_15.setText(_translate("MainWindow", "Camera suffix")) + self.saveTrialStartscheckBox.setText(_translate("MainWindow", "Save trial start times")) + self.saveCameraVideocheckBox.setText(_translate("MainWindow", "Save camera video")) + self.trialStartsSuffixEdit.setText(_translate("MainWindow", "trial_starts")) + self.cameraSuffixEdit.setText(_translate("MainWindow", "camera")) + self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) + self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) + self.label_12.setText(_translate("MainWindow", "Save path")) self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) - self.exportPathDirButton.setText(_translate("MainWindow", "...")) - self.label_12.setText(_translate("MainWindow", "Save path")) self.label_14.setText(_translate("MainWindow", "Name suffix")) self.label_13.setText(_translate("MainWindow", "Pulse suffix")) - self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) - self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) + self.exportPathDirButton.setText(_translate("MainWindow", "...")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) + self.label_19.setText(_translate("MainWindow", "Number of cameras")) + self.cameraSaveIconBox.setText(_translate("MainWindow", "Camera save icon")) + self.label_17.setText(_translate("MainWindow", "Camera save interval (s)")) + self.cameraSaveIntervalEdit.setText(_translate("MainWindow", "600")) + self.numberCamerasEdit.setText(_translate("MainWindow", "2")) + self.launchCameraButton.setText(_translate("MainWindow", "Launch camera(s)")) + self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) + self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) + self.pushButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) self.actionLoad.setText(_translate("MainWindow", "Load")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 0b9796c..5f2c2f0 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -15,34 +15,6 @@ - - - - true - - - - - 0 - 0 - 18 - 348 - - - - - 0 - 0 - - - - - QLayout::SetFixedSize - - - - - @@ -73,6 +45,34 @@ + + + + true + + + + + 0 + 0 + 18 + 348 + + + + + 0 + 0 + + + + + QLayout::SetFixedSize + + + + + @@ -160,20 +160,6 @@ Hardware - - - - 4 - - - - - - - Trigger In Source - - - @@ -181,24 +167,24 @@ - - + + - Digital Channels + dev2/ai4 - - + + - dev2/port0/line0:3 + 4 - - + + - Analog Input Device + dev2/port0/line0:3 @@ -209,13 +195,6 @@ - - - - dev2/ai4 - - - @@ -230,6 +209,27 @@ + + + + Synchronisation Clock + + + + + + + /dev2/ai/SampleClock + + + + + + + Digital Channels + + + @@ -237,6 +237,13 @@ + + + + Analog Input Device + + + @@ -250,27 +257,20 @@ - - + + - Synchronisation Clock + Trigger In Source - + cDAQ1Mod2/ai3 - - - - /dev2/ai/SampleClock - - - @@ -517,7 +517,112 @@ Data + + + + + + Time suffix + + + + + + + Camera suffix + + + + + + + + + + Save trial start times + + + true + + + + + + + Save camera video + + + true + + + + + + + + + + + trial_starts + + + + + + + camera + + + + + + + + + + + + + + + + + + trial_name + + + + + + + data + + + + + + + + + Save path + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + Qt::Vertical @@ -543,6 +648,9 @@ Save trial names + + true + @@ -554,27 +662,6 @@ - - - - ... - - - - - - - - - - - - - - Save path - - - @@ -593,26 +680,35 @@ - - - - - - trial_name - - - - - - - data - - - - + + + + ... + + - - + + + + + Cameras + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + Qt::Vertical @@ -624,6 +720,78 @@ + + + + Number of cameras + + + + + + + Camera save icon + + + true + + + + + + + Camera save interval (s) + + + + + + + 600 + + + + + + + 2 + + + + + + + Launch camera(s) + + + + + + + Black and white + + + true + + + + + + + Show stream + + + true + + + + + + + Close cameras(s) + + + From ea3c2b57bf0cea907606fc6eef5b9cc9ea80dc91 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Wed, 2 Dec 2020 15:12:29 +0000 Subject: [PATCH 57/83] added camera support --- Controllers/main.py | 30 +++++++++++++++++++++++++++--- Designs/mainDesign.py | 8 ++++---- UI/PulseBoyUI_v2.py | 8 ++++---- UI/PulseBoyUI_v2.ui | 2 +- 4 files changed, 36 insertions(+), 12 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index 5fa87f6..5e8a0f6 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -8,7 +8,7 @@ from PyQt5 import QtWidgets import Models.Experiment as Experiment from Controllers import QueueControl, QueueControl -from multiprocessing import Queue, Process +from multiprocessing import Queue, Process, Manager from Designs import mainDesign from Models import PBWidgets from vipy import StreamNSave @@ -64,7 +64,15 @@ def __init__(self): self.pauseQueueButton.clicked.connect(self.queue_controller.pause) self.runSelectedButton.clicked.connect(lambda x: self.queue_controller.run_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) self.startQueueFromSelectedButton.clicked.connect(lambda x: self.queue_controller.run_from_selected(self.trialBankTable.selectionModel().selectedRows()[0].row())) - + + ## Camera code + camera_params = Manager().dict() + self.cameraParams = camera_params + self.launchCameraButton.clicked.connect(self.startStream) + + self.get_camera_params() + self.closeCamerasButton.clicked.connect(self.terminateCameraStream) + def add_valve(self, v_type='Simple', params=None): position = len(self.valveBankContents.children()) - 1 if v_type == 'Simple': @@ -253,7 +261,23 @@ def set_export_path(self): self.exportPathEdit.setText(path + '/') - + def startStream(self): + self.get_camera_params() + + self.cameraProcess = Process(target=StreamNSave.stream_and_save, + args=(self.cameraParams,)) + def terminateCameraStream(self): + self.cameraProcess.terminate() + + def get_camera_params(self): + self.cameraParams['saveStream'] = bool(self.saveCameraVideocheckBox.isChecked()) + self.cameraParams['showStream'] = bool(self.showStreamcheckBox.isChecked()) + self.cameraParams['outDir'] = str(self.exportPathEdit.text()) + self.cameraParams['cams'] = int(self.numberCamerasEdit.text()) + self.cameraParams['camera_suffix'] = str(self.cameraSuffixEdit.text()) + self.cameraParams['inter_stream_interval'] = float(self.cameraSaveIntervalEdit.text()) + self.cameraParams['recording_ind'] = bool(self.cameraSaveIconBox.isChecked()) + # Back up the reference to the exceptionhook sys._excepthook = sys.excepthook diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 99750b5..1c4b3d5 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -363,9 +363,9 @@ def setupUi(self, MainWindow): self.showStreamcheckBox.setChecked(True) self.showStreamcheckBox.setObjectName("showStreamcheckBox") self.gridLayout_8.addWidget(self.showStreamcheckBox, 8, 1, 1, 1) - self.pushButton = QtWidgets.QPushButton(self.cameraTab) - self.pushButton.setObjectName("pushButton") - self.gridLayout_8.addWidget(self.pushButton, 8, 0, 1, 1) + self.closeCamerasButton = QtWidgets.QPushButton(self.cameraTab) + self.closeCamerasButton.setObjectName("closeCamerasButton") + self.gridLayout_8.addWidget(self.closeCamerasButton, 8, 0, 1, 1) self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) @@ -466,7 +466,7 @@ def retranslateUi(self, MainWindow): self.launchCameraButton.setText(_translate("MainWindow", "Launch camera(s)")) self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) - self.pushButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.closeCamerasButton.setText(_translate("MainWindow", "Close cameras(s)")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 99750b5..1c4b3d5 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -363,9 +363,9 @@ def setupUi(self, MainWindow): self.showStreamcheckBox.setChecked(True) self.showStreamcheckBox.setObjectName("showStreamcheckBox") self.gridLayout_8.addWidget(self.showStreamcheckBox, 8, 1, 1, 1) - self.pushButton = QtWidgets.QPushButton(self.cameraTab) - self.pushButton.setObjectName("pushButton") - self.gridLayout_8.addWidget(self.pushButton, 8, 0, 1, 1) + self.closeCamerasButton = QtWidgets.QPushButton(self.cameraTab) + self.closeCamerasButton.setObjectName("closeCamerasButton") + self.gridLayout_8.addWidget(self.closeCamerasButton, 8, 0, 1, 1) self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) @@ -466,7 +466,7 @@ def retranslateUi(self, MainWindow): self.launchCameraButton.setText(_translate("MainWindow", "Launch camera(s)")) self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) - self.pushButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.closeCamerasButton.setText(_translate("MainWindow", "Close cameras(s)")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 5f2c2f0..8ff4d4b 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -786,7 +786,7 @@ - + Close cameras(s) From 29e523070eec9efcf448f89b569ca810f2500450 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Wed, 2 Dec 2020 16:27:36 +0000 Subject: [PATCH 58/83] allows stream to close on its own --- Controllers/main.py | 12 ++++++++---- Designs/mainDesign.py | 4 ++++ UI/PulseBoyUI_v2.py | 6 +++++- UI/PulseBoyUI_v2.ui | 9 ++++++++- 4 files changed, 25 insertions(+), 6 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index 5e8a0f6..e269ef9 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -72,6 +72,7 @@ def __init__(self): self.get_camera_params() self.closeCamerasButton.clicked.connect(self.terminateCameraStream) + self.updateCamerasButton.clicked.connect(self.get_camera_params) def add_valve(self, v_type='Simple', params=None): position = len(self.valveBankContents.children()) - 1 @@ -263,21 +264,24 @@ def set_export_path(self): def startStream(self): self.get_camera_params() - + self.cameraParams['runStream'] = True self.cameraProcess = Process(target=StreamNSave.stream_and_save, args=(self.cameraParams,)) + self.cameraProcess.daemon = True + self.cameraProcess.start() def terminateCameraStream(self): - self.cameraProcess.terminate() + self.cameraParams['runStream'] = False + #self.cameraProcess.terminate() def get_camera_params(self): self.cameraParams['saveStream'] = bool(self.saveCameraVideocheckBox.isChecked()) self.cameraParams['showStream'] = bool(self.showStreamcheckBox.isChecked()) self.cameraParams['outDir'] = str(self.exportPathEdit.text()) self.cameraParams['cams'] = int(self.numberCamerasEdit.text()) - self.cameraParams['camera_suffix'] = str(self.cameraSuffixEdit.text()) + self.cameraParams['cameraSuffix'] = str(self.cameraSuffixEdit.text()) self.cameraParams['inter_stream_interval'] = float(self.cameraSaveIntervalEdit.text()) self.cameraParams['recording_ind'] = bool(self.cameraSaveIconBox.isChecked()) - + # Back up the reference to the exceptionhook sys._excepthook = sys.excepthook diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 1c4b3d5..a9acbfa 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -366,6 +366,9 @@ def setupUi(self, MainWindow): self.closeCamerasButton = QtWidgets.QPushButton(self.cameraTab) self.closeCamerasButton.setObjectName("closeCamerasButton") self.gridLayout_8.addWidget(self.closeCamerasButton, 8, 0, 1, 1) + self.updateCamerasButton = QtWidgets.QPushButton(self.cameraTab) + self.updateCamerasButton.setObjectName("updateCamerasButton") + self.gridLayout_8.addWidget(self.updateCamerasButton, 9, 0, 1, 1) self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) @@ -467,6 +470,7 @@ def retranslateUi(self, MainWindow): self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) self.closeCamerasButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.updateCamerasButton.setText(_translate("MainWindow", "Update camera(s)")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 1c4b3d5..37835b4 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -366,6 +366,9 @@ def setupUi(self, MainWindow): self.closeCamerasButton = QtWidgets.QPushButton(self.cameraTab) self.closeCamerasButton.setObjectName("closeCamerasButton") self.gridLayout_8.addWidget(self.closeCamerasButton, 8, 0, 1, 1) + self.updateCamerasButton = QtWidgets.QPushButton(self.cameraTab) + self.updateCamerasButton.setObjectName("updateCamerasButton") + self.gridLayout_8.addWidget(self.updateCamerasButton, 9, 0, 1, 1) self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) @@ -391,7 +394,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(2) + self.setupTabs.setCurrentIndex(4) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -467,6 +470,7 @@ def retranslateUi(self, MainWindow): self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) self.closeCamerasButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.updateCamerasButton.setText(_translate("MainWindow", "Update camera(s)")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 8ff4d4b..8ea6e25 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,7 +153,7 @@ - 2 + 4 @@ -792,6 +792,13 @@ + + + + Update camera(s) + + + From ccb8804f2aa8e2930000c10835af24677ca32f1b Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Mon, 7 Dec 2020 20:18:05 +0000 Subject: [PATCH 59/83] Remove shatter duty reset --- Models/PBWidgets.py | 1 + 1 file changed, 1 insertion(+) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index f616074..872ecf2 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -244,6 +244,7 @@ def set_parameters(self, params): self.binsizeEdit.setText(str(params['bin_size'])) self.shatterEdit.setText(str(params['shatter_frequency'])) self.position.setText(str(params['position'])) + self.shatterDutyEdit.setText(str(params['shatter_duty'])) From 5ba3f388d2ac8b4b2aeb6f8a640581b11a096c92 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Fri, 19 Feb 2021 14:54:45 +0000 Subject: [PATCH 60/83] Add invert valves box --- Designs/mainDesign.py | 23 +++++++++++++++++------ UI/PulseBoyUI_v2.py | 23 +++++++++++++++++------ UI/PulseBoyUI_v2.ui | 27 ++++++++++++++++++++++----- pulseboi.code-workspace | 19 +++++++++++++++++++ 4 files changed, 75 insertions(+), 17 deletions(-) create mode 100644 pulseboi.code-workspace diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index a9acbfa..48f41f8 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -158,9 +158,12 @@ def setupUi(self, MainWindow): self.globalParametersTab.setObjectName("globalParametersTab") self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) self.gridLayout_3.setObjectName("gridLayout_3") - self.label_6 = QtWidgets.QLabel(self.globalParametersTab) - self.label_6.setObjectName("label_6") - self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.invertBlankcheckBox = QtWidgets.QCheckBox(self.globalParametersTab) + self.invertBlankcheckBox.setObjectName("invertBlankcheckBox") + self.gridLayout_3.addWidget(self.invertBlankcheckBox, 3, 0, 1, 1) + self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.blankValveEdit.setObjectName("blankValveEdit") + self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOnsetEdit.setObjectName("globalOnsetEdit") self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) @@ -171,7 +174,13 @@ def setupUi(self, MainWindow): self.globalOffsetEdit.setObjectName("globalOffsetEdit") self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem1, 2, 0, 1, 1) + self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) + self.label_6 = QtWidgets.QLabel(self.globalParametersTab) + self.label_6.setObjectName("label_6") + self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.label_16 = QtWidgets.QLabel(self.globalParametersTab) + self.label_16.setObjectName("label_16") + self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) self.setupTabs.addTab(self.globalParametersTab, "") self.experimentSetupTab = QtWidgets.QWidget() self.experimentSetupTab.setObjectName("experimentSetupTab") @@ -394,7 +403,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(2) + self.setupTabs.setCurrentIndex(1) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -419,10 +428,12 @@ def retranslateUi(self, MainWindow): self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) - self.label_6.setText(_translate("MainWindow", "Onset")) + self.invertBlankcheckBox.setText(_translate("MainWindow", "Invert blank off state")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) + self.label_6.setText(_translate("MainWindow", "Onset")) + self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 37835b4..48f41f8 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -158,9 +158,12 @@ def setupUi(self, MainWindow): self.globalParametersTab.setObjectName("globalParametersTab") self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) self.gridLayout_3.setObjectName("gridLayout_3") - self.label_6 = QtWidgets.QLabel(self.globalParametersTab) - self.label_6.setObjectName("label_6") - self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.invertBlankcheckBox = QtWidgets.QCheckBox(self.globalParametersTab) + self.invertBlankcheckBox.setObjectName("invertBlankcheckBox") + self.gridLayout_3.addWidget(self.invertBlankcheckBox, 3, 0, 1, 1) + self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.blankValveEdit.setObjectName("blankValveEdit") + self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOnsetEdit.setObjectName("globalOnsetEdit") self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) @@ -171,7 +174,13 @@ def setupUi(self, MainWindow): self.globalOffsetEdit.setObjectName("globalOffsetEdit") self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem1, 2, 0, 1, 1) + self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) + self.label_6 = QtWidgets.QLabel(self.globalParametersTab) + self.label_6.setObjectName("label_6") + self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.label_16 = QtWidgets.QLabel(self.globalParametersTab) + self.label_16.setObjectName("label_16") + self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) self.setupTabs.addTab(self.globalParametersTab, "") self.experimentSetupTab = QtWidgets.QWidget() self.experimentSetupTab.setObjectName("experimentSetupTab") @@ -394,7 +403,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(4) + self.setupTabs.setCurrentIndex(1) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -419,10 +428,12 @@ def retranslateUi(self, MainWindow): self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) - self.label_6.setText(_translate("MainWindow", "Onset")) + self.invertBlankcheckBox.setText(_translate("MainWindow", "Invert blank off state")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) + self.label_6.setText(_translate("MainWindow", "Onset")) + self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 8ea6e25..8dee050 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,7 +153,7 @@ - 4 + 1 @@ -278,13 +278,16 @@ Global Parameters - - + + - Onset + Invert blank off state + + + @@ -306,7 +309,7 @@ - + Qt::Vertical @@ -319,6 +322,20 @@ + + + + Onset + + + + + + + Blank valve indexes (0 indexing) + + + diff --git a/pulseboi.code-workspace b/pulseboi.code-workspace new file mode 100644 index 0000000..bd32c09 --- /dev/null +++ b/pulseboi.code-workspace @@ -0,0 +1,19 @@ +{ + "folders": [ + { + "path": "." + }, + { + "path": "..\\PyPulse" + }, + { + "path": "..\\daqface" + }, + { + "path": "..\\vipy" + } + ], + "settings": { + "python.pythonPath": "c:\\Users\\warnert\\Documents\\WinPython-64bit-3.6.3.0Qt5\\python-3.6.3.amd64\\python.exe" + } +} \ No newline at end of file From 81eb4d6907d63cbad00a7f87c10d569517a1b069 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 19 Feb 2021 14:57:47 +0000 Subject: [PATCH 61/83] Add invert valve rest state --- Controllers/main.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index e269ef9..1826c79 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -150,10 +150,13 @@ def trial_selected(self): selected_trial = 0 trial_params = self.trialBankModel.arraydata[selected_trial][1] - + invert_valves = [] + if self.invertBlankcheckBox.isChecked(): + invert_valves = [int(i) for i in self.blankValveEdit.text().split(',')] + pulses, t = PulseInterface.make_pulse(float(self.sampRateEdit.text()), float(self.globalOnsetEdit.text()), - float(self.globalOffsetEdit.text()), trial_params) + float(self.globalOffsetEdit.text()), trial_params, invert_chan_list=invert_valves) self.graphicsView.plotItem.clear() for p, pulse in enumerate(pulses): @@ -244,6 +247,11 @@ def get_global_params(self): params['repeats'] = float(self.repeatsBox.text()) #params['repeats_done'] = 0 params['shuffle_repeats'] = bool(self.shuffleRepeatsBox.isChecked()) + params['inverted_blank_off_state'] = bool(self.invertBlankcheckBox.isChecked()) + if params['inverted_blank_off_state']: + params['inverted_blank_valves'] = [int(i) for i in self.blankValveEdit.text().split(',')] + else: + params['inverted_blank_valves'] = None return params From ca2464500bdb0f330513b90ce787f888f3d2447e Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 19 Feb 2021 15:48:42 +0000 Subject: [PATCH 62/83] Try and catch in case blank valves empty --- Controllers/main.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index 1826c79..7e70cfb 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -152,7 +152,10 @@ def trial_selected(self): trial_params = self.trialBankModel.arraydata[selected_trial][1] invert_valves = [] if self.invertBlankcheckBox.isChecked(): - invert_valves = [int(i) for i in self.blankValveEdit.text().split(',')] + try: + invert_valves = [int(i) for i in self.blankValveEdit.text().split(',')] + except ValueError: + print('Unable to invert channels, did not understand input "%s' % self.blankValveEdit.text()) pulses, t = PulseInterface.make_pulse(float(self.sampRateEdit.text()), float(self.globalOnsetEdit.text()), From a981bfc0f2d042c72ade794598073813c8885f22 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Fri, 19 Feb 2021 18:36:18 +0000 Subject: [PATCH 63/83] Add inverted channels to queuecontroller --- Controllers/QueueControl.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 03ca08b..6dbf990 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -30,11 +30,13 @@ def trial(self): hardware_params = self.get_hardware_params() global_params = self.get_global_params() export_params = self.get_export_params() - + invert_valves = [] + if global_params['inverted_blank_off_state']: + invert_valves = global_params['inverted_blank_valves'] pulses, t = PulseInterface.make_pulse(hardware_params['samp_rate'], global_params['global_onset'], global_params['global_offset'], - trial_params) + trial_params, invert_chan_list=invert_valves) # in standard configuration we want to run each trial sequentially if not self.parent.trigger_state(): From e2c43ea5860552cf7dcdc0b7b8e38d47ec6f1a36 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Mon, 22 Feb 2021 11:46:34 +0000 Subject: [PATCH 64/83] close valves after trial --- Controllers/QueueControl.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 6dbf990..0d7489c 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -51,6 +51,9 @@ def trial(self): self.trial_daq = daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], len(t) / hardware_params['samp_rate'], pulses) self.trial_daq.DoTask() + close_valves= daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], + len(t) / hardware_params['samp_rate'], np.zeros((len(pulses), 10))) + close_valves.DoTask() self.analog_data = [] # unless the 'wait for trigger' box is checked, in which case we want to wait for our trigger in else: From 0b6b4c1aa77fda317b0704dffd0cbb5c63dd1f7a Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Mon, 22 Feb 2021 14:00:39 +0000 Subject: [PATCH 65/83] init close_valves --- Controllers/main.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Controllers/main.py b/Controllers/main.py index 7e70cfb..9a590ea 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -14,6 +14,7 @@ from vipy import StreamNSave import pickle as pickle import os.path +import daqface.DAQ as daq # noinspection PyBroadException @@ -73,6 +74,8 @@ def __init__(self): self.get_camera_params() self.closeCamerasButton.clicked.connect(self.terminateCameraStream) self.updateCamerasButton.clicked.connect(self.get_camera_params) + self.resetValveButton.clicked.connect(self.reset_all_chans()) + def add_valve(self, v_type='Simple', params=None): position = len(self.valveBankContents.children()) - 1 @@ -93,6 +96,9 @@ def add_valve(self, v_type='Simple', params=None): new_valve.set_parameters(params) self.valveBankContents.layout().addWidget(new_valve) + def reset_all_chans(self): + daq.closeValves(self.get_hardware_params()['digital_dev']) + def add_trial(self): n_valves = 0 all_params = list() @@ -293,6 +299,8 @@ def get_camera_params(self): self.cameraParams['inter_stream_interval'] = float(self.cameraSaveIntervalEdit.text()) self.cameraParams['recording_ind'] = bool(self.cameraSaveIconBox.isChecked()) + def reset_all_valves(): + # Back up the reference to the exceptionhook sys._excepthook = sys.excepthook From 912d1a699b56b55b656806d2ae59c23329fcab4e Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Mon, 22 Feb 2021 14:10:17 +0000 Subject: [PATCH 66/83] add valve close button --- Designs/mainDesign.py | 6 +++++- UI/PulseBoyUI_v2.py | 6 +++++- UI/PulseBoyUI_v2.ui | 9 ++++++++- 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 48f41f8..3569dd7 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -258,6 +258,9 @@ def setupUi(self, MainWindow): self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) + self.closeValvesButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.closeValvesButton.setObjectName("closeValvesButton") + self.gridLayout_4.addWidget(self.closeValvesButton, 0, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -403,7 +406,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(1) + self.setupTabs.setCurrentIndex(0) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -456,6 +459,7 @@ def retranslateUi(self, MainWindow): self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) self.label_10.setText(_translate("MainWindow", "Repeats")) self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) + self.closeValvesButton.setText(_translate("MainWindow", "Close all valves")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_18.setText(_translate("MainWindow", "Time suffix")) self.label_15.setText(_translate("MainWindow", "Camera suffix")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 48f41f8..3569dd7 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -258,6 +258,9 @@ def setupUi(self, MainWindow): self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) + self.closeValvesButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.closeValvesButton.setObjectName("closeValvesButton") + self.gridLayout_4.addWidget(self.closeValvesButton, 0, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -403,7 +406,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(1) + self.setupTabs.setCurrentIndex(0) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -456,6 +459,7 @@ def retranslateUi(self, MainWindow): self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) self.label_10.setText(_translate("MainWindow", "Repeats")) self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) + self.closeValvesButton.setText(_translate("MainWindow", "Close all valves")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_18.setText(_translate("MainWindow", "Time suffix")) self.label_15.setText(_translate("MainWindow", "Camera suffix")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 8dee050..2d7427f 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,7 +153,7 @@ - 1 + 0 @@ -527,6 +527,13 @@ + + + + Close all valves + + + From adc3a6377b542da89731866e6d4704ba5e4673ee Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Mon, 22 Feb 2021 14:14:02 +0000 Subject: [PATCH 67/83] remove additional function --- Controllers/main.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index 9a590ea..528f1c4 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -74,7 +74,7 @@ def __init__(self): self.get_camera_params() self.closeCamerasButton.clicked.connect(self.terminateCameraStream) self.updateCamerasButton.clicked.connect(self.get_camera_params) - self.resetValveButton.clicked.connect(self.reset_all_chans()) + self.closeValveButton.clicked.connect(self.reset_all_chans()) def add_valve(self, v_type='Simple', params=None): @@ -299,7 +299,6 @@ def get_camera_params(self): self.cameraParams['inter_stream_interval'] = float(self.cameraSaveIntervalEdit.text()) self.cameraParams['recording_ind'] = bool(self.cameraSaveIconBox.isChecked()) - def reset_all_valves(): # Back up the reference to the exceptionhook sys._excepthook = sys.excepthook From 404b41405bdc869934b4528712fdad96a9a30247 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 23 Feb 2021 13:12:32 +0000 Subject: [PATCH 68/83] close valve function rename --- Controllers/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index 528f1c4..209fd2d 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -74,7 +74,7 @@ def __init__(self): self.get_camera_params() self.closeCamerasButton.clicked.connect(self.terminateCameraStream) self.updateCamerasButton.clicked.connect(self.get_camera_params) - self.closeValveButton.clicked.connect(self.reset_all_chans()) + self.closeValvesButton.clicked.connect(self.reset_all_chans) def add_valve(self, v_type='Simple', params=None): From b1151ffc47b66332b1643f15d6b86c74b76fc2d1 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Mon, 1 Mar 2021 15:53:12 +0000 Subject: [PATCH 69/83] add shuffle trial parameters --- Designs/mainDesign.py | 52 +++++++++++++++++++++++++++++-------------- UI/PulseBoyUI_v2.py | 52 +++++++++++++++++++++++++++++-------------- UI/PulseBoyUI_v2.ui | 51 +++++++++++++++++++++++++++++++++++++----- 3 files changed, 116 insertions(+), 39 deletions(-) diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 3569dd7..f28308d 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -158,12 +158,26 @@ def setupUi(self, MainWindow): self.globalParametersTab.setObjectName("globalParametersTab") self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) self.gridLayout_3.setObjectName("gridLayout_3") + self.shuffleOffsetlineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleOffsetlineEdit.setObjectName("shuffleOffsetlineEdit") + self.gridLayout_3.addWidget(self.shuffleOffsetlineEdit, 6, 0, 1, 1) + self.label_16 = QtWidgets.QLabel(self.globalParametersTab) + self.label_16.setObjectName("label_16") + self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) + self.shuffleGrouplineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleGrouplineEdit.setObjectName("shuffleGrouplineEdit") + self.gridLayout_3.addWidget(self.shuffleGrouplineEdit, 6, 1, 1, 1) self.invertBlankcheckBox = QtWidgets.QCheckBox(self.globalParametersTab) self.invertBlankcheckBox.setObjectName("invertBlankcheckBox") self.gridLayout_3.addWidget(self.invertBlankcheckBox, 3, 0, 1, 1) + self.label_21 = QtWidgets.QLabel(self.globalParametersTab) + self.label_21.setObjectName("label_21") + self.gridLayout_3.addWidget(self.label_21, 5, 0, 1, 1) self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.blankValveEdit.setObjectName("blankValveEdit") self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) + spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOnsetEdit.setObjectName("globalOnsetEdit") self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) @@ -173,14 +187,14 @@ def setupUi(self, MainWindow): self.globalOffsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOffsetEdit.setObjectName("globalOffsetEdit") self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) - spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem2, 7, 0, 1, 1) self.label_6 = QtWidgets.QLabel(self.globalParametersTab) self.label_6.setObjectName("label_6") self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) - self.label_16 = QtWidgets.QLabel(self.globalParametersTab) - self.label_16.setObjectName("label_16") - self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) + self.label_20 = QtWidgets.QLabel(self.globalParametersTab) + self.label_20.setObjectName("label_20") + self.gridLayout_3.addWidget(self.label_20, 5, 1, 1, 1) self.setupTabs.addTab(self.globalParametersTab, "") self.experimentSetupTab = QtWidgets.QWidget() self.experimentSetupTab.setObjectName("experimentSetupTab") @@ -230,8 +244,8 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 1, 0, 1, 1) + spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) self.runSelectedButton.setObjectName("runSelectedButton") self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) @@ -243,8 +257,8 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) + spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem4, 4, 0, 1, 1) self.horizontalLayout = QtWidgets.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) @@ -311,10 +325,10 @@ def setupUi(self, MainWindow): self.label_12 = QtWidgets.QLabel(self.dataExportTab) self.label_12.setObjectName("label_12") self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) - spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem4, 2, 1, 1, 1) spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem5, 12, 1, 1, 1) + self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) + spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem6, 12, 1, 1, 1) self.horizontalLayout_4 = QtWidgets.QHBoxLayout() self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) self.horizontalLayout_4.setSpacing(6) @@ -344,10 +358,10 @@ def setupUi(self, MainWindow): self.cameraTab.setObjectName("cameraTab") self.gridLayout_8 = QtWidgets.QGridLayout(self.cameraTab) self.gridLayout_8.setObjectName("gridLayout_8") - spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_8.addItem(spacerItem6, 3, 0, 1, 2) spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_8.addItem(spacerItem7, 10, 0, 1, 2) + self.gridLayout_8.addItem(spacerItem7, 3, 0, 1, 2) + spacerItem8 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem8, 10, 0, 1, 2) self.label_19 = QtWidgets.QLabel(self.cameraTab) self.label_19.setObjectName("label_19") self.gridLayout_8.addWidget(self.label_19, 5, 1, 1, 1) @@ -406,7 +420,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(0) + self.setupTabs.setCurrentIndex(1) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -431,12 +445,16 @@ def retranslateUi(self, MainWindow): self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) + self.shuffleOffsetlineEdit.setText(_translate("MainWindow", "0")) + self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) + self.shuffleGrouplineEdit.setText(_translate("MainWindow", "1")) self.invertBlankcheckBox.setText(_translate("MainWindow", "Invert blank off state")) + self.label_21.setText(_translate("MainWindow", "Shuffle offset")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.label_6.setText(_translate("MainWindow", "Onset")) - self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) + self.label_20.setText(_translate("MainWindow", "Shuffle group size")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) diff --git a/UI/PulseBoyUI_v2.py b/UI/PulseBoyUI_v2.py index 3569dd7..f28308d 100644 --- a/UI/PulseBoyUI_v2.py +++ b/UI/PulseBoyUI_v2.py @@ -158,12 +158,26 @@ def setupUi(self, MainWindow): self.globalParametersTab.setObjectName("globalParametersTab") self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) self.gridLayout_3.setObjectName("gridLayout_3") + self.shuffleOffsetlineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleOffsetlineEdit.setObjectName("shuffleOffsetlineEdit") + self.gridLayout_3.addWidget(self.shuffleOffsetlineEdit, 6, 0, 1, 1) + self.label_16 = QtWidgets.QLabel(self.globalParametersTab) + self.label_16.setObjectName("label_16") + self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) + self.shuffleGrouplineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleGrouplineEdit.setObjectName("shuffleGrouplineEdit") + self.gridLayout_3.addWidget(self.shuffleGrouplineEdit, 6, 1, 1, 1) self.invertBlankcheckBox = QtWidgets.QCheckBox(self.globalParametersTab) self.invertBlankcheckBox.setObjectName("invertBlankcheckBox") self.gridLayout_3.addWidget(self.invertBlankcheckBox, 3, 0, 1, 1) + self.label_21 = QtWidgets.QLabel(self.globalParametersTab) + self.label_21.setObjectName("label_21") + self.gridLayout_3.addWidget(self.label_21, 5, 0, 1, 1) self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.blankValveEdit.setObjectName("blankValveEdit") self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) + spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOnsetEdit.setObjectName("globalOnsetEdit") self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) @@ -173,14 +187,14 @@ def setupUi(self, MainWindow): self.globalOffsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOffsetEdit.setObjectName("globalOffsetEdit") self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) - spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem2, 7, 0, 1, 1) self.label_6 = QtWidgets.QLabel(self.globalParametersTab) self.label_6.setObjectName("label_6") self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) - self.label_16 = QtWidgets.QLabel(self.globalParametersTab) - self.label_16.setObjectName("label_16") - self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) + self.label_20 = QtWidgets.QLabel(self.globalParametersTab) + self.label_20.setObjectName("label_20") + self.gridLayout_3.addWidget(self.label_20, 5, 1, 1, 1) self.setupTabs.addTab(self.globalParametersTab, "") self.experimentSetupTab = QtWidgets.QWidget() self.experimentSetupTab.setObjectName("experimentSetupTab") @@ -230,8 +244,8 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 1, 0, 1, 1) + spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) self.runSelectedButton.setObjectName("runSelectedButton") self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) @@ -243,8 +257,8 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) + spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem4, 4, 0, 1, 1) self.horizontalLayout = QtWidgets.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) @@ -311,10 +325,10 @@ def setupUi(self, MainWindow): self.label_12 = QtWidgets.QLabel(self.dataExportTab) self.label_12.setObjectName("label_12") self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) - spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem4, 2, 1, 1, 1) spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem5, 12, 1, 1, 1) + self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) + spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem6, 12, 1, 1, 1) self.horizontalLayout_4 = QtWidgets.QHBoxLayout() self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) self.horizontalLayout_4.setSpacing(6) @@ -344,10 +358,10 @@ def setupUi(self, MainWindow): self.cameraTab.setObjectName("cameraTab") self.gridLayout_8 = QtWidgets.QGridLayout(self.cameraTab) self.gridLayout_8.setObjectName("gridLayout_8") - spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_8.addItem(spacerItem6, 3, 0, 1, 2) spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_8.addItem(spacerItem7, 10, 0, 1, 2) + self.gridLayout_8.addItem(spacerItem7, 3, 0, 1, 2) + spacerItem8 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem8, 10, 0, 1, 2) self.label_19 = QtWidgets.QLabel(self.cameraTab) self.label_19.setObjectName("label_19") self.gridLayout_8.addWidget(self.label_19, 5, 1, 1, 1) @@ -406,7 +420,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(0) + self.setupTabs.setCurrentIndex(1) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -431,12 +445,16 @@ def retranslateUi(self, MainWindow): self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) + self.shuffleOffsetlineEdit.setText(_translate("MainWindow", "0")) + self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) + self.shuffleGrouplineEdit.setText(_translate("MainWindow", "1")) self.invertBlankcheckBox.setText(_translate("MainWindow", "Invert blank off state")) + self.label_21.setText(_translate("MainWindow", "Shuffle offset")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.label_6.setText(_translate("MainWindow", "Onset")) - self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) + self.label_20.setText(_translate("MainWindow", "Shuffle group size")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 2d7427f..bf8a46e 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,7 +153,7 @@ - 0 + 1 @@ -278,6 +278,27 @@ Global Parameters + + + + 0 + + + + + + + Blank valve indexes (0 indexing) + + + + + + + 1 + + + @@ -285,9 +306,29 @@ + + + + Shuffle offset + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + @@ -309,7 +350,7 @@ - + Qt::Vertical @@ -329,10 +370,10 @@ - - + + - Blank valve indexes (0 indexing) + Shuffle group size From 31524b2f80f916abe6fb20642f2c7c2db1827e92 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Mon, 1 Mar 2021 15:54:29 +0000 Subject: [PATCH 70/83] Add shuffle parameter back end --- Controllers/main.py | 10 ++++++++-- Models/Experiment.py | 12 ++++++++++-- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index 528f1c4..b652174 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -11,7 +11,10 @@ from multiprocessing import Queue, Process, Manager from Designs import mainDesign from Models import PBWidgets -from vipy import StreamNSave +try: + from vipulse import StreamNSave +except ImportError: + pass import pickle as pickle import os.path import daqface.DAQ as daq @@ -147,7 +150,8 @@ def move_trial_down(self): self.select_trial(idx + 1) def randomise_trials(self): - self.trialBankModel.randomise_trials() + glob_params = self.get_global_params() + self.trialBankModel.randomise_trials(glob_params) def trial_selected(self): try: @@ -262,6 +266,8 @@ def get_global_params(self): else: params['inverted_blank_valves'] = None + params['shuffle_offset'] = int(self.shuffleOffsetlineEdit.text()) + params['shuffle_group_size'] = int(self.shuffleGrouplineEdit.text()) return params def get_export_params(self): diff --git a/Models/Experiment.py b/Models/Experiment.py index d6daaaf..6d22d3b 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -1,6 +1,8 @@ from PyQt5 import QtCore, QtGui import pickle as pickle import random +import numpy as np +import math default_row = [[0, [], '']] @@ -120,5 +122,11 @@ def reset_trials(self): def total_trials(self): return len(self.arraydata) - def randomise_trials(self): - random.shuffle(self.arraydata) + def randomise_trials(self, global_params): + shuffle_offset = global_params['shuffle_offset'] + shuffle_group_size = global_params['shuffle_group_size'] + out_shuffle = list(self.arraydata[:shuffle_offset]) + shuffle_indexes = np.arange((math.ceil(len(self.arraydata)-shuffle_offset)/shuffle_group_size))*shuffle_group_size+shuffle_offset + for i in shuffle_indexes: + out_shuffle.append(self.arraydata[i]) + self.arraydata = out_shuffle From 9381b3bf8936230f6c6e5c2b18b4603b4974e9b8 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Mon, 1 Mar 2021 16:00:50 +0000 Subject: [PATCH 71/83] shuffle index fix --- Models/Experiment.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Models/Experiment.py b/Models/Experiment.py index 6d22d3b..c86025e 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -127,6 +127,8 @@ def randomise_trials(self, global_params): shuffle_group_size = global_params['shuffle_group_size'] out_shuffle = list(self.arraydata[:shuffle_offset]) shuffle_indexes = np.arange((math.ceil(len(self.arraydata)-shuffle_offset)/shuffle_group_size))*shuffle_group_size+shuffle_offset + random.shuffle(shuffle_indexes) for i in shuffle_indexes: - out_shuffle.append(self.arraydata[i]) + for j in range(shuffle_group_size): + out_shuffle.append(self.arraydata[int(i+j)]) self.arraydata = out_shuffle From c61cdd739d571542599a50a355fe2646e8892107 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Mon, 1 Mar 2021 16:04:52 +0000 Subject: [PATCH 72/83] vipulse warning print --- Controllers/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Controllers/main.py b/Controllers/main.py index 03b6a19..e426409 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -14,7 +14,7 @@ try: from vipulse import StreamNSave except ImportError: - pass + print('No camera!') import pickle as pickle import os.path import daqface.DAQ as daq From dc8b62213904bbb7d96479d21255d0447f114425 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Tue, 2 Mar 2021 11:49:08 +0000 Subject: [PATCH 73/83] add shuffle tick box fix --- Controllers/QueueControl.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 0d7489c..50f2665 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -98,7 +98,7 @@ def trial(self): self.parent.repeats_done = 0 else: if global_params['shuffle_repeats']: - self.experiment.randomise_trials() + self.experiment.randomise_trials(global_params) elif self.parent.should_run: self.experiment.advance_trial() From 91ea134a53c94d31da5b8854e9138eb357cec92e Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Tue, 2 Mar 2021 12:27:02 +0000 Subject: [PATCH 74/83] old binary pulse fix attempt --- Models/PBWidgets.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 872ecf2..677b40e 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -242,9 +242,11 @@ def set_parameters(self, params): self.numofbinsEdit.setText(str(params['num_of_bins'])) self.valuetobinariseEdit.setText(str(params['value_to_binarise'])) self.binsizeEdit.setText(str(params['bin_size'])) - self.shatterEdit.setText(str(params['shatter_frequency'])) self.position.setText(str(params['position'])) - self.shatterDutyEdit.setText(str(params['shatter_duty'])) + if 'shatter_frequency' in params: + self.shatterEdit.setText(str(params['shatter_frequency'])) + if 'shatter_duty' in params: + self.shatterDutyEdit.setText(str(params['shatter_duty'])) From ce750161dd455f751fc15d2e76a06db95e386653 Mon Sep 17 00:00:00 2001 From: warnerwarner Date: Tue, 2 Mar 2021 12:34:18 +0000 Subject: [PATCH 75/83] stop binary being force shattered --- Models/PBWidgets.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Models/PBWidgets.py b/Models/PBWidgets.py index 677b40e..61d2b50 100644 --- a/Models/PBWidgets.py +++ b/Models/PBWidgets.py @@ -247,6 +247,10 @@ def set_parameters(self, params): self.shatterEdit.setText(str(params['shatter_frequency'])) if 'shatter_duty' in params: self.shatterDutyEdit.setText(str(params['shatter_duty'])) + if 'isShatter' in params: + self.shatterBox.setChecked(bool(params['isShatter'])) + else: + self.shatterBox.setChecked(False) From 6fa9151f74684a18f315067fd255d972d05b8ab6 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 6 Apr 2021 17:29:43 +0100 Subject: [PATCH 76/83] increase number of repetitions to 1mil --- .gitignore | 2 + UI/PulseBoyUI_v2.ui | 183 +++++++++--------- UI/mainDesign.py | 449 ++++++++++++++++++++++++++++++-------------- 3 files changed, 404 insertions(+), 230 deletions(-) diff --git a/.gitignore b/.gitignore index 089865a..1d623c3 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,5 @@ Data/ >>>>>>> 73c6c9b7133534e9970e82c3c355c6f2e3fd1194 TestData/020217_right_25_2_export_final.mat TrialBanks/ +Controllers/dist +Controllers/build \ No newline at end of file diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index bf8a46e..25417c5 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,7 +153,7 @@ - 1 + 2 @@ -384,24 +384,10 @@ Experiment - - - - Add To Trials - - - - - - - Pause Queue - - - - - + + - Stop Queue + Close all valves @@ -412,10 +398,10 @@ - - + + - Update Trial + Run Selected @@ -433,6 +419,27 @@ + + + + + + Repeats + + + + + + + 1000000 + + + 1 + + + + + @@ -440,17 +447,17 @@ - - + + - Add Valve + Shuffle repeats - - + + - Move Down + Add Valve @@ -461,46 +468,6 @@ - - - - Remove Trial - - - - - - - - 0 - 0 - - - - Trial Name - - - - - - - Qt::Vertical - - - - 20 - 40 - - - - - - - - Run Selected - - - @@ -543,35 +510,71 @@ - - - - - - Repeats - - - - - - - 1 - - - - + + + + Update Trial + + - - + + - Shuffle repeats + Move Down - - + + + + + 0 + 0 + + - Close all valves + Trial Name + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Remove Trial + + + + + + + Add To Trials + + + + + + + Pause Queue + + + + + + + Stop Queue diff --git a/UI/mainDesign.py b/UI/mainDesign.py index 82c2a48..d645c53 100644 --- a/UI/mainDesign.py +++ b/UI/mainDesign.py @@ -16,6 +16,41 @@ def setupUi(self, MainWindow): self.centralwidget.setObjectName("centralwidget") self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") + self.label = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label.setFont(font) + self.label.setObjectName("label") + self.gridLayout.addWidget(self.label, 0, 0, 1, 1) + self.label_8 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setFamily("Lucida Console") + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_8.setFont(font) + self.label_8.setObjectName("label_8") + self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) self.viewWidgetTab.setObjectName("viewWidgetTab") self.pulseTab = QtWidgets.QWidget() @@ -45,15 +80,6 @@ def setupUi(self, MainWindow): self.gridLayout_6.addWidget(self.analogView, 0, 0, 1, 1) self.viewWidgetTab.addTab(self.analogDataTab, "") self.gridLayout.addWidget(self.viewWidgetTab, 3, 2, 1, 1) - self.label_8 = QtWidgets.QLabel(self.centralwidget) - font = QtGui.QFont() - font.setFamily("Lucida Console") - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.label_8.setFont(font) - self.label_8.setObjectName("label_8") - self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) self.trialBankTable = QtWidgets.QTableView(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -68,32 +94,6 @@ def setupUi(self, MainWindow): self.trialBankTable.setObjectName("trialBankTable") self.trialBankTable.horizontalHeader().setStretchLastSection(False) self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) - self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) - self.valveBankScrollArea.setWidgetResizable(True) - self.valveBankScrollArea.setObjectName("valveBankScrollArea") - self.valveBankContents = QtWidgets.QWidget() - self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) - self.valveBankContents.setSizePolicy(sizePolicy) - self.valveBankContents.setObjectName("valveBankContents") - self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) - self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) - self.valveBankLayout.setContentsMargins(0, 0, 0, 0) - self.valveBankLayout.setObjectName("valveBankLayout") - self.valveBankScrollArea.setWidget(self.valveBankContents) - self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) - self.label = QtWidgets.QLabel(self.centralwidget) - font = QtGui.QFont() - font.setFamily("Lucida Console") - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.label.setFont(font) - self.label.setObjectName("label") - self.gridLayout.addWidget(self.label, 0, 0, 1, 1) self.setupTabs = QtWidgets.QTabWidget(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -109,58 +109,75 @@ def setupUi(self, MainWindow): self.hardwareTab.setObjectName("hardwareTab") self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) self.gridLayout_2.setObjectName("gridLayout_2") - self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") - self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) - self.label_9 = QtWidgets.QLabel(self.hardwareTab) - self.label_9.setObjectName("label_9") - self.gridLayout_2.addWidget(self.label_9, 9, 0, 1, 1) self.label_2 = QtWidgets.QLabel(self.hardwareTab) self.label_2.setObjectName("label_2") self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) - self.label_4 = QtWidgets.QLabel(self.hardwareTab) - self.label_4.setObjectName("label_4") - self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) - self.label_3 = QtWidgets.QLabel(self.hardwareTab) - self.label_3.setObjectName("label_3") - self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) self.analogChannelsLabel.setObjectName("analogChannelsLabel") self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) - self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.analogInDevEdit.setObjectName("analogInDevEdit") - self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) self.analogChannelsEdit.setObjectName("analogChannelsEdit") self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) self.label_5 = QtWidgets.QLabel(self.hardwareTab) self.label_5.setObjectName("label_5") self.gridLayout_2.addWidget(self.label_5, 6, 0, 1, 1) + self.label_11 = QtWidgets.QLabel(self.hardwareTab) + self.label_11.setObjectName("label_11") + self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.syncClockEdit.setObjectName("syncClockEdit") + self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.label_4 = QtWidgets.QLabel(self.hardwareTab) + self.label_4.setObjectName("label_4") + self.gridLayout_2.addWidget(self.label_4, 0, 1, 1, 1) self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) self.sampRateEdit.setObjectName("sampRateEdit") self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) - self.label_11 = QtWidgets.QLabel(self.hardwareTab) - self.label_11.setObjectName("label_11") - self.gridLayout_2.addWidget(self.label_11, 4, 0, 1, 1) + self.label_9 = QtWidgets.QLabel(self.hardwareTab) + self.label_9.setObjectName("label_9") + self.gridLayout_2.addWidget(self.label_9, 4, 1, 1, 1) self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) self.triggerInEdit.setObjectName("triggerInEdit") - self.gridLayout_2.addWidget(self.triggerInEdit, 10, 0, 1, 1) - self.syncClockEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.syncClockEdit.setObjectName("syncClockEdit") - self.gridLayout_2.addWidget(self.syncClockEdit, 5, 0, 1, 1) + self.gridLayout_2.addWidget(self.triggerInEdit, 5, 1, 1, 1) self.setupTabs.addTab(self.hardwareTab, "") self.globalParametersTab = QtWidgets.QWidget() self.globalParametersTab.setObjectName("globalParametersTab") self.gridLayout_3 = QtWidgets.QGridLayout(self.globalParametersTab) self.gridLayout_3.setObjectName("gridLayout_3") - self.label_6 = QtWidgets.QLabel(self.globalParametersTab) - self.label_6.setObjectName("label_6") - self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.shuffleOffsetlineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleOffsetlineEdit.setObjectName("shuffleOffsetlineEdit") + self.gridLayout_3.addWidget(self.shuffleOffsetlineEdit, 6, 0, 1, 1) + self.label_16 = QtWidgets.QLabel(self.globalParametersTab) + self.label_16.setObjectName("label_16") + self.gridLayout_3.addWidget(self.label_16, 2, 1, 1, 1) + self.shuffleGrouplineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleGrouplineEdit.setObjectName("shuffleGrouplineEdit") + self.gridLayout_3.addWidget(self.shuffleGrouplineEdit, 6, 1, 1, 1) + self.invertBlankcheckBox = QtWidgets.QCheckBox(self.globalParametersTab) + self.invertBlankcheckBox.setObjectName("invertBlankcheckBox") + self.gridLayout_3.addWidget(self.invertBlankcheckBox, 3, 0, 1, 1) + self.label_21 = QtWidgets.QLabel(self.globalParametersTab) + self.label_21.setObjectName("label_21") + self.gridLayout_3.addWidget(self.label_21, 5, 0, 1, 1) + self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.blankValveEdit.setObjectName("blankValveEdit") + self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) + spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOnsetEdit.setObjectName("globalOnsetEdit") self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) @@ -170,23 +187,57 @@ def setupUi(self, MainWindow): self.globalOffsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOffsetEdit.setObjectName("globalOffsetEdit") self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) - spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem1, 2, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem2, 7, 0, 1, 1) + self.label_6 = QtWidgets.QLabel(self.globalParametersTab) + self.label_6.setObjectName("label_6") + self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) + self.label_20 = QtWidgets.QLabel(self.globalParametersTab) + self.label_20.setObjectName("label_20") + self.gridLayout_3.addWidget(self.label_20, 5, 1, 1, 1) self.setupTabs.addTab(self.globalParametersTab, "") self.experimentSetupTab = QtWidgets.QWidget() self.experimentSetupTab.setObjectName("experimentSetupTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) self.gridLayout_4.setObjectName("gridLayout_4") - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem2, 4, 0, 1, 1) - self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.trialNameEdit.sizePolicy().hasHeightForWidth()) - self.trialNameEdit.setSizePolicy(sizePolicy) - self.trialNameEdit.setObjectName("trialNameEdit") - self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) + self.closeValvesButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.closeValvesButton.setObjectName("closeValvesButton") + self.gridLayout_4.addWidget(self.closeValvesButton, 0, 2, 1, 1) + self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") + self.gridLayout_4.addWidget(self.randomiseTrialsButton, 7, 0, 1, 1) + self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.runSelectedButton.setObjectName("runSelectedButton") + self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) + self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveUpButton.setObjectName("moveUpButton") + self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) + self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") + self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 9, 1, 1, 1) + self.horizontalLayout = QtWidgets.QHBoxLayout() + self.horizontalLayout.setObjectName("horizontalLayout") + self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) + self.label_10.setObjectName("label_10") + self.horizontalLayout.addWidget(self.label_10) + self.repeatsBox = QtWidgets.QSpinBox(self.experimentSetupTab) + self.repeatsBox.setMaximum(1000000) + self.repeatsBox.setProperty("value", 1) + self.repeatsBox.setObjectName("repeatsBox") + self.horizontalLayout.addWidget(self.repeatsBox) + self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) + self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.startQueueButton.setObjectName("startQueueButton") + self.gridLayout_4.addWidget(self.startQueueButton, 8, 0, 1, 1) + self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") + self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) + self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addValveButton.setObjectName("addValveButton") + self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) + self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") + self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 9, 2, 1, 1) self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) self.valveTypeCombo.setObjectName("valveTypeCombo") self.valveTypeCombo.addItem("") @@ -195,68 +246,157 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.removeTrialButton.setObjectName("removeTrialButton") - self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) - self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.runSelectedButton.setObjectName("runSelectedButton") - self.gridLayout_4.addWidget(self.runSelectedButton, 7, 0, 1, 1) - self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.moveUpButton.setObjectName("moveUpButton") - self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) - self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueButton.setObjectName("startQueueButton") - self.gridLayout_4.addWidget(self.startQueueButton, 6, 0, 1, 1) - self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addTrialButton.setObjectName("addTrialButton") - self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) self.updateTrialButton.setObjectName("updateTrialButton") self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveDownButton.setObjectName("moveDownButton") self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) - self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addValveButton.setObjectName("addValveButton") - self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) - self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.stopQueueButton.setObjectName("stopQueueButton") - self.gridLayout_4.addWidget(self.stopQueueButton, 6, 2, 1, 1) - self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) - self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") - self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 7, 2, 1, 1) + self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialNameEdit.sizePolicy().hasHeightForWidth()) + self.trialNameEdit.setSizePolicy(sizePolicy) + self.trialNameEdit.setObjectName("trialNameEdit") + self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) + spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem4, 1, 0, 1, 1) + self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.removeTrialButton.setObjectName("removeTrialButton") + self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) self.pauseQueueButton.setObjectName("pauseQueueButton") - self.gridLayout_4.addWidget(self.pauseQueueButton, 6, 1, 1, 1) - self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") - self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 7, 1, 1, 1) - self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") - self.gridLayout_4.addWidget(self.randomiseTrialsButton, 5, 0, 1, 1) + self.gridLayout_4.addWidget(self.pauseQueueButton, 8, 1, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 8, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") self.gridLayout_7 = QtWidgets.QGridLayout(self.dataExportTab) self.gridLayout_7.setObjectName("gridLayout_7") - self.label_13 = QtWidgets.QLabel(self.dataExportTab) - self.label_13.setObjectName("label_13") - self.gridLayout_7.addWidget(self.label_13, 1, 0, 1, 1) - self.label_12 = QtWidgets.QLabel(self.dataExportTab) - self.label_12.setObjectName("label_12") - self.gridLayout_7.addWidget(self.label_12, 0, 0, 1, 1) + self.horizontalLayout_3 = QtWidgets.QHBoxLayout() + self.horizontalLayout_3.setObjectName("horizontalLayout_3") + self.label_18 = QtWidgets.QLabel(self.dataExportTab) + self.label_18.setObjectName("label_18") + self.horizontalLayout_3.addWidget(self.label_18) + self.label_15 = QtWidgets.QLabel(self.dataExportTab) + self.label_15.setObjectName("label_15") + self.horizontalLayout_3.addWidget(self.label_15) + self.gridLayout_7.addLayout(self.horizontalLayout_3, 10, 1, 1, 1) + self.horizontalLayout_2 = QtWidgets.QHBoxLayout() + self.horizontalLayout_2.setObjectName("horizontalLayout_2") + self.saveTrialStartscheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.saveTrialStartscheckBox.setChecked(True) + self.saveTrialStartscheckBox.setObjectName("saveTrialStartscheckBox") + self.horizontalLayout_2.addWidget(self.saveTrialStartscheckBox) + self.saveCameraVideocheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.saveCameraVideocheckBox.setChecked(True) + self.saveCameraVideocheckBox.setObjectName("saveCameraVideocheckBox") + self.horizontalLayout_2.addWidget(self.saveCameraVideocheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_2, 9, 1, 1, 1) + self.horizontalLayout_7 = QtWidgets.QHBoxLayout() + self.horizontalLayout_7.setObjectName("horizontalLayout_7") + self.trialStartsSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialStartsSuffixEdit.setObjectName("trialStartsSuffixEdit") + self.horizontalLayout_7.addWidget(self.trialStartsSuffixEdit) + self.cameraSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.cameraSuffixEdit.setObjectName("cameraSuffixEdit") + self.horizontalLayout_7.addWidget(self.cameraSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_7, 11, 1, 1, 1) self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.exportPathEdit.setText("") self.exportPathEdit.setObjectName("exportPathEdit") - self.gridLayout_7.addWidget(self.exportPathEdit, 0, 1, 1, 1) - self.exportSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.exportSuffixEdit.setObjectName("exportSuffixEdit") - self.gridLayout_7.addWidget(self.exportSuffixEdit, 1, 1, 1, 1) + self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) + self.horizontalLayout_6 = QtWidgets.QHBoxLayout() + self.horizontalLayout_6.setObjectName("horizontalLayout_6") + self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") + self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) + self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") + self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) + spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) + spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem6, 12, 1, 1, 1) + self.horizontalLayout_4 = QtWidgets.QHBoxLayout() + self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) + self.horizontalLayout_4.setSpacing(6) + self.horizontalLayout_4.setObjectName("horizontalLayout_4") + self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.trialNameCheckBox.setChecked(True) + self.trialNameCheckBox.setObjectName("trialNameCheckBox") + self.horizontalLayout_4.addWidget(self.trialNameCheckBox) + self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.pulseCheckBox.setObjectName("pulseCheckBox") + self.horizontalLayout_4.addWidget(self.pulseCheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) + self.horizontalLayout_5 = QtWidgets.QHBoxLayout() + self.horizontalLayout_5.setObjectName("horizontalLayout_5") + self.label_14 = QtWidgets.QLabel(self.dataExportTab) + self.label_14.setObjectName("label_14") + self.horizontalLayout_5.addWidget(self.label_14) + self.label_13 = QtWidgets.QLabel(self.dataExportTab) + self.label_13.setObjectName("label_13") + self.horizontalLayout_5.addWidget(self.label_13) + self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) self.exportPathDirButton.setObjectName("exportPathDirButton") - self.gridLayout_7.addWidget(self.exportPathDirButton, 0, 2, 1, 1) + self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) self.setupTabs.addTab(self.dataExportTab, "") + self.cameraTab = QtWidgets.QWidget() + self.cameraTab.setObjectName("cameraTab") + self.gridLayout_8 = QtWidgets.QGridLayout(self.cameraTab) + self.gridLayout_8.setObjectName("gridLayout_8") + spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem7, 3, 0, 1, 2) + spacerItem8 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem8, 10, 0, 1, 2) + self.label_19 = QtWidgets.QLabel(self.cameraTab) + self.label_19.setObjectName("label_19") + self.gridLayout_8.addWidget(self.label_19, 5, 1, 1, 1) + self.cameraSaveIconBox = QtWidgets.QCheckBox(self.cameraTab) + self.cameraSaveIconBox.setChecked(True) + self.cameraSaveIconBox.setObjectName("cameraSaveIconBox") + self.gridLayout_8.addWidget(self.cameraSaveIconBox, 7, 0, 1, 1) + self.label_17 = QtWidgets.QLabel(self.cameraTab) + self.label_17.setObjectName("label_17") + self.gridLayout_8.addWidget(self.label_17, 5, 0, 1, 1) + self.cameraSaveIntervalEdit = QtWidgets.QLineEdit(self.cameraTab) + self.cameraSaveIntervalEdit.setObjectName("cameraSaveIntervalEdit") + self.gridLayout_8.addWidget(self.cameraSaveIntervalEdit, 6, 0, 1, 1) + self.numberCamerasEdit = QtWidgets.QLineEdit(self.cameraTab) + self.numberCamerasEdit.setObjectName("numberCamerasEdit") + self.gridLayout_8.addWidget(self.numberCamerasEdit, 6, 1, 1, 1) + self.launchCameraButton = QtWidgets.QPushButton(self.cameraTab) + self.launchCameraButton.setObjectName("launchCameraButton") + self.gridLayout_8.addWidget(self.launchCameraButton, 4, 0, 1, 2) + self.blackAndWhiteBox = QtWidgets.QCheckBox(self.cameraTab) + self.blackAndWhiteBox.setChecked(True) + self.blackAndWhiteBox.setObjectName("blackAndWhiteBox") + self.gridLayout_8.addWidget(self.blackAndWhiteBox, 7, 1, 1, 1) + self.showStreamcheckBox = QtWidgets.QCheckBox(self.cameraTab) + self.showStreamcheckBox.setChecked(True) + self.showStreamcheckBox.setObjectName("showStreamcheckBox") + self.gridLayout_8.addWidget(self.showStreamcheckBox, 8, 1, 1, 1) + self.closeCamerasButton = QtWidgets.QPushButton(self.cameraTab) + self.closeCamerasButton.setObjectName("closeCamerasButton") + self.gridLayout_8.addWidget(self.closeCamerasButton, 8, 0, 1, 1) + self.updateCamerasButton = QtWidgets.QPushButton(self.cameraTab) + self.updateCamerasButton.setObjectName("updateCamerasButton") + self.gridLayout_8.addWidget(self.updateCamerasButton, 9, 0, 1, 1) + self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) @@ -287,56 +427,85 @@ def setupUi(self, MainWindow): def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.label.setText(_translate("MainWindow", "Valve Bank")) + self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.label_8.setText(_translate("MainWindow", "Trial Bank")) - self.label.setText(_translate("MainWindow", "Valve Bank")) - self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) - self.label_9.setText(_translate("MainWindow", "Trigger In Source")) self.label_2.setText(_translate("MainWindow", "Digital Out Device")) - self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) - self.label_3.setText(_translate("MainWindow", "Analog Input Device")) self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) - self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) self.analogChannelsEdit.setText(_translate("MainWindow", "1")) self.label_5.setText(_translate("MainWindow", "Sampling Rate")) - self.sampRateEdit.setText(_translate("MainWindow", "20000")) self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) - self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) + self.label_4.setText(_translate("MainWindow", "Digital Channels")) + self.sampRateEdit.setText(_translate("MainWindow", "20000")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) - self.label_6.setText(_translate("MainWindow", "Onset")) + self.shuffleOffsetlineEdit.setText(_translate("MainWindow", "0")) + self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) + self.shuffleGrouplineEdit.setText(_translate("MainWindow", "1")) + self.invertBlankcheckBox.setText(_translate("MainWindow", "Invert blank off state")) + self.label_21.setText(_translate("MainWindow", "Shuffle offset")) self.globalOnsetEdit.setText(_translate("MainWindow", "0")) self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) + self.label_6.setText(_translate("MainWindow", "Onset")) + self.label_20.setText(_translate("MainWindow", "Shuffle group size")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) - self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.closeValvesButton.setText(_translate("MainWindow", "Close all valves")) + self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) + self.moveUpButton.setText(_translate("MainWindow", "Move Up")) + self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.label_10.setText(_translate("MainWindow", "Repeats")) + self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) + self.addValveButton.setText(_translate("MainWindow", "Add Valve")) + self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) - self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) - self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) - self.moveUpButton.setText(_translate("MainWindow", "Move Up")) - self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) - self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) self.moveDownButton.setText(_translate("MainWindow", "Move Down")) - self.addValveButton.setText(_translate("MainWindow", "Add Valve")) - self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) - self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) + self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) - self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) - self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) - self.label_13.setText(_translate("MainWindow", "Export Suffix")) - self.label_12.setText(_translate("MainWindow", "Export Path")) - self.exportPathEdit.setText(_translate("MainWindow", "C:/Users/erskina/PycharmProjects/PulseBoy/Data/")) - self.exportSuffixEdit.setText(_translate("MainWindow", "data")) + self.label_18.setText(_translate("MainWindow", "Time suffix")) + self.label_15.setText(_translate("MainWindow", "Camera suffix")) + self.saveTrialStartscheckBox.setText(_translate("MainWindow", "Save trial start times")) + self.saveCameraVideocheckBox.setText(_translate("MainWindow", "Save camera video")) + self.trialStartsSuffixEdit.setText(_translate("MainWindow", "trial_starts")) + self.cameraSuffixEdit.setText(_translate("MainWindow", "camera")) + self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) + self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) + self.label_12.setText(_translate("MainWindow", "Save path")) + self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) + self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) + self.label_14.setText(_translate("MainWindow", "Name suffix")) + self.label_13.setText(_translate("MainWindow", "Pulse suffix")) self.exportPathDirButton.setText(_translate("MainWindow", "...")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) + self.label_19.setText(_translate("MainWindow", "Number of cameras")) + self.cameraSaveIconBox.setText(_translate("MainWindow", "Camera save icon")) + self.label_17.setText(_translate("MainWindow", "Camera save interval (s)")) + self.cameraSaveIntervalEdit.setText(_translate("MainWindow", "600")) + self.numberCamerasEdit.setText(_translate("MainWindow", "2")) + self.launchCameraButton.setText(_translate("MainWindow", "Launch camera(s)")) + self.blackAndWhiteBox.setText(_translate("MainWindow", "Black and white")) + self.showStreamcheckBox.setText(_translate("MainWindow", "Show stream")) + self.closeCamerasButton.setText(_translate("MainWindow", "Close cameras(s)")) + self.updateCamerasButton.setText(_translate("MainWindow", "Update camera(s)")) + self.setupTabs.setTabText(self.setupTabs.indexOf(self.cameraTab), _translate("MainWindow", "Cameras")) self.menuFile.setTitle(_translate("MainWindow", "File")) self.actionSave.setText(_translate("MainWindow", "Save")) self.actionLoad.setText(_translate("MainWindow", "Load")) From aecca2fb03fbb800cd0feb3d56926ecb3bfc4ba5 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 6 Apr 2021 17:30:17 +0100 Subject: [PATCH 77/83] increase reps to 1million --- Designs/mainDesign.py | 121 +++++++++++++++++++++--------------------- 1 file changed, 61 insertions(+), 60 deletions(-) diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index f28308d..d645c53 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -200,55 +200,44 @@ def setupUi(self, MainWindow): self.experimentSetupTab.setObjectName("experimentSetupTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.experimentSetupTab) self.gridLayout_4.setObjectName("gridLayout_4") - self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.addTrialButton.setObjectName("addTrialButton") - self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) - self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.pauseQueueButton.setObjectName("pauseQueueButton") - self.gridLayout_4.addWidget(self.pauseQueueButton, 8, 1, 1, 1) - self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.stopQueueButton.setObjectName("stopQueueButton") - self.gridLayout_4.addWidget(self.stopQueueButton, 8, 2, 1, 1) + self.closeValvesButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.closeValvesButton.setObjectName("closeValvesButton") + self.gridLayout_4.addWidget(self.closeValvesButton, 0, 2, 1, 1) self.randomiseTrialsButton = QtWidgets.QPushButton(self.experimentSetupTab) self.randomiseTrialsButton.setObjectName("randomiseTrialsButton") self.gridLayout_4.addWidget(self.randomiseTrialsButton, 7, 0, 1, 1) - self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.updateTrialButton.setObjectName("updateTrialButton") - self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) + self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.runSelectedButton.setObjectName("runSelectedButton") + self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) self.moveUpButton = QtWidgets.QPushButton(self.experimentSetupTab) self.moveUpButton.setObjectName("moveUpButton") self.gridLayout_4.addWidget(self.moveUpButton, 3, 1, 1, 1) self.startQueueFromSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) self.startQueueFromSelectedButton.setObjectName("startQueueFromSelectedButton") self.gridLayout_4.addWidget(self.startQueueFromSelectedButton, 9, 1, 1, 1) + self.horizontalLayout = QtWidgets.QHBoxLayout() + self.horizontalLayout.setObjectName("horizontalLayout") + self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) + self.label_10.setObjectName("label_10") + self.horizontalLayout.addWidget(self.label_10) + self.repeatsBox = QtWidgets.QSpinBox(self.experimentSetupTab) + self.repeatsBox.setMaximum(1000000) + self.repeatsBox.setProperty("value", 1) + self.repeatsBox.setObjectName("repeatsBox") + self.horizontalLayout.addWidget(self.repeatsBox) + self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) self.startQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) self.startQueueButton.setObjectName("startQueueButton") self.gridLayout_4.addWidget(self.startQueueButton, 8, 0, 1, 1) + self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) + self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") + self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) self.addValveButton = QtWidgets.QPushButton(self.experimentSetupTab) self.addValveButton.setObjectName("addValveButton") self.gridLayout_4.addWidget(self.addValveButton, 0, 0, 1, 1) - self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.moveDownButton.setObjectName("moveDownButton") - self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) self.triggerWaitCheckBox = QtWidgets.QCheckBox(self.experimentSetupTab) self.triggerWaitCheckBox.setObjectName("triggerWaitCheckBox") self.gridLayout_4.addWidget(self.triggerWaitCheckBox, 9, 2, 1, 1) - self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.removeTrialButton.setObjectName("removeTrialButton") - self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) - self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.trialNameEdit.sizePolicy().hasHeightForWidth()) - self.trialNameEdit.setSizePolicy(sizePolicy) - self.trialNameEdit.setObjectName("trialNameEdit") - self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) - spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 1, 0, 1, 1) - self.runSelectedButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.runSelectedButton.setObjectName("runSelectedButton") - self.gridLayout_4.addWidget(self.runSelectedButton, 9, 0, 1, 1) self.valveTypeCombo = QtWidgets.QComboBox(self.experimentSetupTab) self.valveTypeCombo.setObjectName("valveTypeCombo") self.valveTypeCombo.addItem("") @@ -257,24 +246,36 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) + spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) + self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.updateTrialButton.setObjectName("updateTrialButton") + self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) + self.moveDownButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.moveDownButton.setObjectName("moveDownButton") + self.gridLayout_4.addWidget(self.moveDownButton, 3, 2, 1, 1) + self.trialNameEdit = QtWidgets.QLineEdit(self.experimentSetupTab) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialNameEdit.sizePolicy().hasHeightForWidth()) + self.trialNameEdit.setSizePolicy(sizePolicy) + self.trialNameEdit.setObjectName("trialNameEdit") + self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem4, 4, 0, 1, 1) - self.horizontalLayout = QtWidgets.QHBoxLayout() - self.horizontalLayout.setObjectName("horizontalLayout") - self.label_10 = QtWidgets.QLabel(self.experimentSetupTab) - self.label_10.setObjectName("label_10") - self.horizontalLayout.addWidget(self.label_10) - self.repeatsBox = QtWidgets.QSpinBox(self.experimentSetupTab) - self.repeatsBox.setProperty("value", 1) - self.repeatsBox.setObjectName("repeatsBox") - self.horizontalLayout.addWidget(self.repeatsBox) - self.gridLayout_4.addLayout(self.horizontalLayout, 7, 1, 1, 1) - self.shuffleRepeatsBox = QtWidgets.QCheckBox(self.experimentSetupTab) - self.shuffleRepeatsBox.setObjectName("shuffleRepeatsBox") - self.gridLayout_4.addWidget(self.shuffleRepeatsBox, 7, 2, 1, 1) - self.closeValvesButton = QtWidgets.QPushButton(self.experimentSetupTab) - self.closeValvesButton.setObjectName("closeValvesButton") - self.gridLayout_4.addWidget(self.closeValvesButton, 0, 2, 1, 1) + self.gridLayout_4.addItem(spacerItem4, 1, 0, 1, 1) + self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.removeTrialButton.setObjectName("removeTrialButton") + self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) + self.addTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.addTrialButton.setObjectName("addTrialButton") + self.gridLayout_4.addWidget(self.addTrialButton, 2, 0, 1, 1) + self.pauseQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.pauseQueueButton.setObjectName("pauseQueueButton") + self.gridLayout_4.addWidget(self.pauseQueueButton, 8, 1, 1, 1) + self.stopQueueButton = QtWidgets.QPushButton(self.experimentSetupTab) + self.stopQueueButton.setObjectName("stopQueueButton") + self.gridLayout_4.addWidget(self.stopQueueButton, 8, 2, 1, 1) self.setupTabs.addTab(self.experimentSetupTab, "") self.dataExportTab = QtWidgets.QWidget() self.dataExportTab.setObjectName("dataExportTab") @@ -420,7 +421,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(1) + self.setupTabs.setCurrentIndex(2) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -456,28 +457,28 @@ def retranslateUi(self, MainWindow): self.label_6.setText(_translate("MainWindow", "Onset")) self.label_20.setText(_translate("MainWindow", "Shuffle group size")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) - self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) - self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) - self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) + self.closeValvesButton.setText(_translate("MainWindow", "Close all valves")) self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) - self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) + self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) self.moveUpButton.setText(_translate("MainWindow", "Move Up")) self.startQueueFromSelectedButton.setText(_translate("MainWindow", "Start Queue from Selected")) + self.label_10.setText(_translate("MainWindow", "Repeats")) self.startQueueButton.setText(_translate("MainWindow", "Start Queue")) + self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) self.addValveButton.setText(_translate("MainWindow", "Add Valve")) - self.moveDownButton.setText(_translate("MainWindow", "Move Down")) self.triggerWaitCheckBox.setText(_translate("MainWindow", "Wait for trigger")) - self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) - self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) - self.runSelectedButton.setText(_translate("MainWindow", "Run Selected")) self.valveTypeCombo.setItemText(0, _translate("MainWindow", "Simple")) self.valveTypeCombo.setItemText(1, _translate("MainWindow", "Binary")) self.valveTypeCombo.setItemText(2, _translate("MainWindow", "Anti Plume")) self.valveTypeCombo.setItemText(3, _translate("MainWindow", "Noise")) self.valveTypeCombo.setItemText(4, _translate("MainWindow", "Plume")) - self.label_10.setText(_translate("MainWindow", "Repeats")) - self.shuffleRepeatsBox.setText(_translate("MainWindow", "Shuffle repeats")) - self.closeValvesButton.setText(_translate("MainWindow", "Close all valves")) + self.updateTrialButton.setText(_translate("MainWindow", "Update Trial")) + self.moveDownButton.setText(_translate("MainWindow", "Move Down")) + self.trialNameEdit.setText(_translate("MainWindow", "Trial Name")) + self.removeTrialButton.setText(_translate("MainWindow", "Remove Trial")) + self.addTrialButton.setText(_translate("MainWindow", "Add To Trials")) + self.pauseQueueButton.setText(_translate("MainWindow", "Pause Queue")) + self.stopQueueButton.setText(_translate("MainWindow", "Stop Queue")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_18.setText(_translate("MainWindow", "Time suffix")) self.label_15.setText(_translate("MainWindow", "Camera suffix")) From 7c30c9d26bff2f27a123fe4059d03db578f29558 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Wed, 14 Apr 2021 15:34:59 +0100 Subject: [PATCH 78/83] Add carrier flow hardware param --- Designs/mainDesign.py | 58 +++++++++++++++++++------------ UI/PulseBoyUI_v2.ui | 81 +++++++++++++++++++++++++++---------------- UI/mainDesign.py | 58 +++++++++++++++++++------------ 3 files changed, 121 insertions(+), 76 deletions(-) diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index d645c53..8034e8c 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -109,21 +109,21 @@ def setupUi(self, MainWindow): self.hardwareTab.setObjectName("hardwareTab") self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) self.gridLayout_2.setObjectName("gridLayout_2") - self.label_2 = QtWidgets.QLabel(self.hardwareTab) - self.label_2.setObjectName("label_2") - self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) - self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.analogInDevEdit.setObjectName("analogInDevEdit") - self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) - self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") - self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) + self.label_22 = QtWidgets.QLabel(self.hardwareTab) + self.label_22.setObjectName("label_22") + self.gridLayout_2.addWidget(self.label_22, 9, 1, 1, 1) + self.carrierControlBox = QtWidgets.QCheckBox(self.hardwareTab) + self.carrierControlBox.setObjectName("carrierControlBox") + self.gridLayout_2.addWidget(self.carrierControlBox, 10, 0, 1, 1) self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) - self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) - self.analogChannelsLabel.setObjectName("analogChannelsLabel") - self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) self.analogChannelsEdit.setObjectName("analogChannelsEdit") self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) @@ -142,17 +142,26 @@ def setupUi(self, MainWindow): self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) self.sampRateEdit.setObjectName("sampRateEdit") self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) - self.label_3 = QtWidgets.QLabel(self.hardwareTab) - self.label_3.setObjectName("label_3") - self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) - spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) + self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) + self.analogChannelsLabel.setObjectName("analogChannelsLabel") + self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) self.label_9 = QtWidgets.QLabel(self.hardwareTab) self.label_9.setObjectName("label_9") self.gridLayout_2.addWidget(self.label_9, 4, 1, 1, 1) + self.label_2 = QtWidgets.QLabel(self.hardwareTab) + self.label_2.setObjectName("label_2") + self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) self.triggerInEdit.setObjectName("triggerInEdit") self.gridLayout_2.addWidget(self.triggerInEdit, 5, 1, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) + self.carrierDeviceEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.carrierDeviceEdit.setObjectName("carrierDeviceEdit") + self.gridLayout_2.addWidget(self.carrierDeviceEdit, 10, 1, 1, 1) + spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) self.setupTabs.addTab(self.hardwareTab, "") self.globalParametersTab = QtWidgets.QWidget() self.globalParametersTab.setObjectName("globalParametersTab") @@ -421,7 +430,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(2) + self.setupTabs.setCurrentIndex(0) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -431,20 +440,23 @@ def retranslateUi(self, MainWindow): self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.label_2.setText(_translate("MainWindow", "Digital Out Device")) - self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) - self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) + self.label_22.setText(_translate("MainWindow", "Carrier flow out device")) + self.carrierControlBox.setText(_translate("MainWindow", "Control carrier flow")) self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) - self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) self.analogChannelsEdit.setText(_translate("MainWindow", "1")) self.label_5.setText(_translate("MainWindow", "Sampling Rate")) self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) self.label_4.setText(_translate("MainWindow", "Digital Channels")) self.sampRateEdit.setText(_translate("MainWindow", "20000")) - self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.label_2.setText(_translate("MainWindow", "Digital Out Device")) self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.carrierDeviceEdit.setText(_translate("MainWindow", "dev2/port0/line5")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) self.shuffleOffsetlineEdit.setText(_translate("MainWindow", "0")) self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) diff --git a/UI/PulseBoyUI_v2.ui b/UI/PulseBoyUI_v2.ui index 25417c5..9c64997 100644 --- a/UI/PulseBoyUI_v2.ui +++ b/UI/PulseBoyUI_v2.ui @@ -153,45 +153,45 @@ - 2 + 0 Hardware - - + + - Digital Out Device + Carrier flow out device - - + + - dev2/ai4 + Control carrier flow - - + + - 4 + dev2/port0/line0:3 - - + + - dev2/port0/line0:3 + 4 - - + + - Analog Channels + dev2/ai4 @@ -237,6 +237,34 @@ + + + + Analog Channels + + + + + + + Trigger In Source + + + + + + + Digital Out Device + + + + + + + cDAQ1Mod2/ai3 + + + @@ -244,6 +272,13 @@ + + + + dev2/port0/line5 + + + @@ -257,20 +292,6 @@ - - - - Trigger In Source - - - - - - - cDAQ1Mod2/ai3 - - - diff --git a/UI/mainDesign.py b/UI/mainDesign.py index d645c53..8034e8c 100644 --- a/UI/mainDesign.py +++ b/UI/mainDesign.py @@ -109,21 +109,21 @@ def setupUi(self, MainWindow): self.hardwareTab.setObjectName("hardwareTab") self.gridLayout_2 = QtWidgets.QGridLayout(self.hardwareTab) self.gridLayout_2.setObjectName("gridLayout_2") - self.label_2 = QtWidgets.QLabel(self.hardwareTab) - self.label_2.setObjectName("label_2") - self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) - self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.analogInDevEdit.setObjectName("analogInDevEdit") - self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) - self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) - self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") - self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) + self.label_22 = QtWidgets.QLabel(self.hardwareTab) + self.label_22.setObjectName("label_22") + self.gridLayout_2.addWidget(self.label_22, 9, 1, 1, 1) + self.carrierControlBox = QtWidgets.QCheckBox(self.hardwareTab) + self.carrierControlBox.setObjectName("carrierControlBox") + self.gridLayout_2.addWidget(self.carrierControlBox, 10, 0, 1, 1) self.digitalOutDevEdit = QtWidgets.QLineEdit(self.hardwareTab) self.digitalOutDevEdit.setObjectName("digitalOutDevEdit") self.gridLayout_2.addWidget(self.digitalOutDevEdit, 1, 0, 1, 1) - self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) - self.analogChannelsLabel.setObjectName("analogChannelsLabel") - self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) + self.digitalChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.digitalChannelsEdit.setObjectName("digitalChannelsEdit") + self.gridLayout_2.addWidget(self.digitalChannelsEdit, 1, 1, 1, 1) + self.analogInDevEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.analogInDevEdit.setObjectName("analogInDevEdit") + self.gridLayout_2.addWidget(self.analogInDevEdit, 3, 0, 1, 1) self.analogChannelsEdit = QtWidgets.QLineEdit(self.hardwareTab) self.analogChannelsEdit.setObjectName("analogChannelsEdit") self.gridLayout_2.addWidget(self.analogChannelsEdit, 3, 1, 1, 1) @@ -142,17 +142,26 @@ def setupUi(self, MainWindow): self.sampRateEdit = QtWidgets.QLineEdit(self.hardwareTab) self.sampRateEdit.setObjectName("sampRateEdit") self.gridLayout_2.addWidget(self.sampRateEdit, 7, 0, 1, 1) - self.label_3 = QtWidgets.QLabel(self.hardwareTab) - self.label_3.setObjectName("label_3") - self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) - spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) + self.analogChannelsLabel = QtWidgets.QLabel(self.hardwareTab) + self.analogChannelsLabel.setObjectName("analogChannelsLabel") + self.gridLayout_2.addWidget(self.analogChannelsLabel, 2, 1, 1, 1) self.label_9 = QtWidgets.QLabel(self.hardwareTab) self.label_9.setObjectName("label_9") self.gridLayout_2.addWidget(self.label_9, 4, 1, 1, 1) + self.label_2 = QtWidgets.QLabel(self.hardwareTab) + self.label_2.setObjectName("label_2") + self.gridLayout_2.addWidget(self.label_2, 0, 0, 1, 1) self.triggerInEdit = QtWidgets.QLineEdit(self.hardwareTab) self.triggerInEdit.setObjectName("triggerInEdit") self.gridLayout_2.addWidget(self.triggerInEdit, 5, 1, 1, 1) + self.label_3 = QtWidgets.QLabel(self.hardwareTab) + self.label_3.setObjectName("label_3") + self.gridLayout_2.addWidget(self.label_3, 2, 0, 1, 1) + self.carrierDeviceEdit = QtWidgets.QLineEdit(self.hardwareTab) + self.carrierDeviceEdit.setObjectName("carrierDeviceEdit") + self.gridLayout_2.addWidget(self.carrierDeviceEdit, 10, 1, 1, 1) + spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_2.addItem(spacerItem, 8, 0, 1, 1) self.setupTabs.addTab(self.hardwareTab, "") self.globalParametersTab = QtWidgets.QWidget() self.globalParametersTab.setObjectName("globalParametersTab") @@ -421,7 +430,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(2) + self.setupTabs.setCurrentIndex(0) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -431,20 +440,23 @@ def retranslateUi(self, MainWindow): self.label_8.setText(_translate("MainWindow", "Trial Bank")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.pulseTab), _translate("MainWindow", "Pulses")) self.viewWidgetTab.setTabText(self.viewWidgetTab.indexOf(self.analogDataTab), _translate("MainWindow", "Analog Data")) - self.label_2.setText(_translate("MainWindow", "Digital Out Device")) - self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) - self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) + self.label_22.setText(_translate("MainWindow", "Carrier flow out device")) + self.carrierControlBox.setText(_translate("MainWindow", "Control carrier flow")) self.digitalOutDevEdit.setText(_translate("MainWindow", "dev2/port0/line0:3")) - self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) + self.digitalChannelsEdit.setText(_translate("MainWindow", "4")) + self.analogInDevEdit.setText(_translate("MainWindow", "dev2/ai4")) self.analogChannelsEdit.setText(_translate("MainWindow", "1")) self.label_5.setText(_translate("MainWindow", "Sampling Rate")) self.label_11.setText(_translate("MainWindow", "Synchronisation Clock")) self.syncClockEdit.setText(_translate("MainWindow", "/dev2/ai/SampleClock")) self.label_4.setText(_translate("MainWindow", "Digital Channels")) self.sampRateEdit.setText(_translate("MainWindow", "20000")) - self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.analogChannelsLabel.setText(_translate("MainWindow", "Analog Channels")) self.label_9.setText(_translate("MainWindow", "Trigger In Source")) + self.label_2.setText(_translate("MainWindow", "Digital Out Device")) self.triggerInEdit.setText(_translate("MainWindow", "cDAQ1Mod2/ai3")) + self.label_3.setText(_translate("MainWindow", "Analog Input Device")) + self.carrierDeviceEdit.setText(_translate("MainWindow", "dev2/port0/line5")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.hardwareTab), _translate("MainWindow", "Hardware")) self.shuffleOffsetlineEdit.setText(_translate("MainWindow", "0")) self.label_16.setText(_translate("MainWindow", "Blank valve indexes (0 indexing)")) From 07cd01399f7c6febd4742a8f7c3b81887fd56fb5 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Mon, 3 May 2021 14:18:07 +0100 Subject: [PATCH 79/83] carrier flow edits --- Controllers/QueueControl.py | 14 ++++++++++---- Controllers/main.py | 2 ++ Designs/mainDesign.py | 6 +++--- 3 files changed, 15 insertions(+), 7 deletions(-) diff --git a/Controllers/QueueControl.py b/Controllers/QueueControl.py index 50f2665..eefeef2 100644 --- a/Controllers/QueueControl.py +++ b/Controllers/QueueControl.py @@ -38,6 +38,11 @@ def trial(self): global_params['global_offset'], trial_params, invert_chan_list=invert_valves) + if hardware_params['control_carrier']: + while len(pulses) < hardware_params['digital_channels']: + pulses = np.append(pulses, np.zeros((1, pulses.shape[1])), axis=0) + carrier_control = np.append(np.ones(pulses.shape[1]-0), np.zeros(0)) + pulses = np.append(pulses, carrier_control[np.newaxis], axis=0) # in standard configuration we want to run each trial sequentially if not self.parent.trigger_state(): if hardware_params['analog_channels'] > 0: @@ -51,9 +56,9 @@ def trial(self): self.trial_daq = daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], len(t) / hardware_params['samp_rate'], pulses) self.trial_daq.DoTask() - close_valves= daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], - len(t) / hardware_params['samp_rate'], np.zeros((len(pulses), 10))) - close_valves.DoTask() + # close_valves= daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], + # len(t) / hardware_params['samp_rate'], np.zeros((len(pulses), 10))) + # close_valves.DoTask() self.analog_data = [] # unless the 'wait for trigger' box is checked, in which case we want to wait for our trigger in else: @@ -68,7 +73,8 @@ def trial(self): self.analog_data = self.trial_daq.DoTask() else: - self.trial_daq= daq.DoTriggeredCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], len(t) / hardware_params['samp_rate'], pulses, hardware_params['trigger_source']) + self.trial_daq= daq.DoTriggeredCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], len(t) / hardware_params['samp_rate'], + pulses, hardware_params['trigger_source']) self.trial_daq.DoTask() self.analog_data = [] diff --git a/Controllers/main.py b/Controllers/main.py index e426409..30658f5 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -250,6 +250,8 @@ def get_hardware_params(self): params['sync_clock'] = self.syncClockEdit.text() params['samp_rate'] = float(self.sampRateEdit.text()) params['trigger_source'] = self.triggerInEdit.text() + params['control_carrier'] = self.carrierControlBox.isChecked() +# params['carrier_chan'] = int(self.carrierDeviceEdit.text()) return params diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 8034e8c..99a9411 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -302,11 +302,11 @@ def setupUi(self, MainWindow): self.horizontalLayout_2 = QtWidgets.QHBoxLayout() self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.saveTrialStartscheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.saveTrialStartscheckBox.setChecked(True) + self.saveTrialStartscheckBox.setChecked(False) self.saveTrialStartscheckBox.setObjectName("saveTrialStartscheckBox") self.horizontalLayout_2.addWidget(self.saveTrialStartscheckBox) self.saveCameraVideocheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.saveCameraVideocheckBox.setChecked(True) + self.saveCameraVideocheckBox.setChecked(False) self.saveCameraVideocheckBox.setObjectName("saveCameraVideocheckBox") self.horizontalLayout_2.addWidget(self.saveCameraVideocheckBox) self.gridLayout_7.addLayout(self.horizontalLayout_2, 9, 1, 1, 1) @@ -344,7 +344,7 @@ def setupUi(self, MainWindow): self.horizontalLayout_4.setSpacing(6) self.horizontalLayout_4.setObjectName("horizontalLayout_4") self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.trialNameCheckBox.setChecked(True) + self.trialNameCheckBox.setChecked(False) self.trialNameCheckBox.setObjectName("trialNameCheckBox") self.horizontalLayout_4.addWidget(self.trialNameCheckBox) self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) From efb252a790aff672611b031bbb709a03a9d33bc4 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 17 Feb 2022 19:28:45 +0000 Subject: [PATCH 80/83] back offset --- Controllers/main.py | 25 +++++ Designs/mainDesign.py | 222 +++++++++++++++++++++++------------------- Models/Experiment.py | 11 ++- 3 files changed, 158 insertions(+), 100 deletions(-) diff --git a/Controllers/main.py b/Controllers/main.py index 30658f5..9607c1d 100644 --- a/Controllers/main.py +++ b/Controllers/main.py @@ -79,6 +79,9 @@ def __init__(self): self.updateCamerasButton.clicked.connect(self.get_camera_params) self.closeValvesButton.clicked.connect(self.reset_all_chans) + ## Saving pulses + self.savePulseButton.clicked.connect(self.save_all_pulses) + def add_valve(self, v_type='Simple', params=None): position = len(self.valveBankContents.children()) - 1 @@ -270,6 +273,7 @@ def get_global_params(self): params['shuffle_offset'] = int(self.shuffleOffsetlineEdit.text()) params['shuffle_group_size'] = int(self.shuffleGrouplineEdit.text()) + params['shuffle_back_offset'] = int(self.shuffleBackOffsetlineEdit.text()) return params def get_export_params(self): @@ -307,6 +311,27 @@ def get_camera_params(self): self.cameraParams['inter_stream_interval'] = float(self.cameraSaveIntervalEdit.text()) self.cameraParams['recording_ind'] = bool(self.cameraSaveIconBox.isChecked()) + def save_all_pulses(self): + global_params = self.get_global_params() + hardware_params = self.get_hardware_params() + export_params = self.get_export_params() + invert_valves = [] + all_pulses = {} + for trial_params in self.trialBankModel.arraydata: + pulses, t = PulseInterface.make_pulse(hardware_params['samp_rate'], + global_params['global_onset'], + global_params['global_offset'], + trial_params[1]) + save_string = export_params['export_path'] + trial_params[-1] + '_'+export_params['pulse_suffix'] + '.npy' + np.save(save_string, pulses) + all_pulses[trial_params[-1]] = pulses + save_string = export_params['export_path'] + export_params['pulse_suffix'] + '.pkl' + #pickle.dump(all_pulses, open(save_string, 'wb'), protocol=pickle.HIGHEST_PROTOCOL) + + + + + # Back up the reference to the exceptionhook sys._excepthook = sys.excepthook diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 99a9411..095a8c0 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -16,6 +16,23 @@ def setupUi(self, MainWindow): self.centralwidget.setObjectName("centralwidget") self.gridLayout = QtWidgets.QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") + self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) + self.valveBankScrollArea.setWidgetResizable(True) + self.valveBankScrollArea.setObjectName("valveBankScrollArea") + self.valveBankContents = QtWidgets.QWidget() + self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) + self.valveBankContents.setSizePolicy(sizePolicy) + self.valveBankContents.setObjectName("valveBankContents") + self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) + self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) + self.valveBankLayout.setContentsMargins(0, 0, 0, 0) + self.valveBankLayout.setObjectName("valveBankLayout") + self.valveBankScrollArea.setWidget(self.valveBankContents) + self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.label = QtWidgets.QLabel(self.centralwidget) font = QtGui.QFont() font.setFamily("Lucida Console") @@ -34,23 +51,6 @@ def setupUi(self, MainWindow): self.label_8.setFont(font) self.label_8.setObjectName("label_8") self.gridLayout.addWidget(self.label_8, 2, 0, 1, 1) - self.valveBankScrollArea = QtWidgets.QScrollArea(self.centralwidget) - self.valveBankScrollArea.setWidgetResizable(True) - self.valveBankScrollArea.setObjectName("valveBankScrollArea") - self.valveBankContents = QtWidgets.QWidget() - self.valveBankContents.setGeometry(QtCore.QRect(0, 0, 18, 348)) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Minimum) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.valveBankContents.sizePolicy().hasHeightForWidth()) - self.valveBankContents.setSizePolicy(sizePolicy) - self.valveBankContents.setObjectName("valveBankContents") - self.valveBankLayout = QtWidgets.QVBoxLayout(self.valveBankContents) - self.valveBankLayout.setSizeConstraint(QtWidgets.QLayout.SetFixedSize) - self.valveBankLayout.setContentsMargins(0, 0, 0, 0) - self.valveBankLayout.setObjectName("valveBankLayout") - self.valveBankScrollArea.setWidget(self.valveBankContents) - self.gridLayout.addWidget(self.valveBankScrollArea, 1, 0, 1, 1) self.viewWidgetTab = QtWidgets.QTabWidget(self.centralwidget) self.viewWidgetTab.setObjectName("viewWidgetTab") self.pulseTab = QtWidgets.QWidget() @@ -80,20 +80,6 @@ def setupUi(self, MainWindow): self.gridLayout_6.addWidget(self.analogView, 0, 0, 1, 1) self.viewWidgetTab.addTab(self.analogDataTab, "") self.gridLayout.addWidget(self.viewWidgetTab, 3, 2, 1, 1) - self.trialBankTable = QtWidgets.QTableView(self.centralwidget) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.trialBankTable.sizePolicy().hasHeightForWidth()) - self.trialBankTable.setSizePolicy(sizePolicy) - font = QtGui.QFont() - font.setFamily("Lucida Console") - self.trialBankTable.setFont(font) - self.trialBankTable.setContextMenuPolicy(QtCore.Qt.DefaultContextMenu) - self.trialBankTable.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows) - self.trialBankTable.setObjectName("trialBankTable") - self.trialBankTable.horizontalHeader().setStretchLastSection(False) - self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) self.setupTabs = QtWidgets.QTabWidget(self.centralwidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) @@ -182,28 +168,36 @@ def setupUi(self, MainWindow): self.label_21 = QtWidgets.QLabel(self.globalParametersTab) self.label_21.setObjectName("label_21") self.gridLayout_3.addWidget(self.label_21, 5, 0, 1, 1) - self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) - self.blankValveEdit.setObjectName("blankValveEdit") - self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) - spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem1, 4, 0, 1, 1) - self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) - self.globalOnsetEdit.setObjectName("globalOnsetEdit") - self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) self.label_7 = QtWidgets.QLabel(self.globalParametersTab) self.label_7.setObjectName("label_7") self.gridLayout_3.addWidget(self.label_7, 0, 1, 1, 1) self.globalOffsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) self.globalOffsetEdit.setObjectName("globalOffsetEdit") self.gridLayout_3.addWidget(self.globalOffsetEdit, 1, 1, 1, 1) - spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_3.addItem(spacerItem2, 7, 0, 1, 1) + spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem1, 9, 0, 1, 1) self.label_6 = QtWidgets.QLabel(self.globalParametersTab) self.label_6.setObjectName("label_6") self.gridLayout_3.addWidget(self.label_6, 0, 0, 1, 1) self.label_20 = QtWidgets.QLabel(self.globalParametersTab) self.label_20.setObjectName("label_20") self.gridLayout_3.addWidget(self.label_20, 5, 1, 1, 1) + self.blankValveEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.blankValveEdit.setObjectName("blankValveEdit") + self.gridLayout_3.addWidget(self.blankValveEdit, 3, 1, 1, 1) + self.globalOnsetEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.globalOnsetEdit.setObjectName("globalOnsetEdit") + self.gridLayout_3.addWidget(self.globalOnsetEdit, 1, 0, 1, 1) + spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_3.addItem(spacerItem2, 4, 0, 1, 1) + self.label_23 = QtWidgets.QLabel(self.globalParametersTab) + self.label_23.setObjectName("label_23") + self.gridLayout_3.addWidget(self.label_23, 7, 0, 1, 1) + self.shuffleBackOffsetlineEdit = QtWidgets.QLineEdit(self.globalParametersTab) + self.shuffleBackOffsetlineEdit.setObjectName("shuffleBackOffsetlineEdit") + self.gridLayout_3.addWidget(self.shuffleBackOffsetlineEdit, 8, 0, 1, 1) + spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) + self.gridLayout_3.addItem(spacerItem3, 8, 1, 1, 1) self.setupTabs.addTab(self.globalParametersTab, "") self.experimentSetupTab = QtWidgets.QWidget() self.experimentSetupTab.setObjectName("experimentSetupTab") @@ -255,8 +249,8 @@ def setupUi(self, MainWindow): self.valveTypeCombo.addItem("") self.valveTypeCombo.addItem("") self.gridLayout_4.addWidget(self.valveTypeCombo, 0, 1, 1, 1) - spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem3, 4, 0, 1, 1) + spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem4, 4, 0, 1, 1) self.updateTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) self.updateTrialButton.setObjectName("updateTrialButton") self.gridLayout_4.addWidget(self.updateTrialButton, 2, 1, 1, 1) @@ -271,8 +265,8 @@ def setupUi(self, MainWindow): self.trialNameEdit.setSizePolicy(sizePolicy) self.trialNameEdit.setObjectName("trialNameEdit") self.gridLayout_4.addWidget(self.trialNameEdit, 3, 0, 1, 1) - spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_4.addItem(spacerItem4, 1, 0, 1, 1) + spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_4.addItem(spacerItem5, 1, 0, 1, 1) self.removeTrialButton = QtWidgets.QPushButton(self.experimentSetupTab) self.removeTrialButton.setObjectName("removeTrialButton") self.gridLayout_4.addWidget(self.removeTrialButton, 2, 2, 1, 1) @@ -299,17 +293,52 @@ def setupUi(self, MainWindow): self.label_15.setObjectName("label_15") self.horizontalLayout_3.addWidget(self.label_15) self.gridLayout_7.addLayout(self.horizontalLayout_3, 10, 1, 1, 1) + spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem6, 2, 1, 1, 1) + self.horizontalLayout_6 = QtWidgets.QHBoxLayout() + self.horizontalLayout_6.setObjectName("horizontalLayout_6") + self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") + self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) + self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) + self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") + self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) + self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) self.horizontalLayout_2 = QtWidgets.QHBoxLayout() self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.saveTrialStartscheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.saveTrialStartscheckBox.setChecked(False) + self.saveTrialStartscheckBox.setChecked(True) self.saveTrialStartscheckBox.setObjectName("saveTrialStartscheckBox") self.horizontalLayout_2.addWidget(self.saveTrialStartscheckBox) self.saveCameraVideocheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.saveCameraVideocheckBox.setChecked(False) + self.saveCameraVideocheckBox.setChecked(True) self.saveCameraVideocheckBox.setObjectName("saveCameraVideocheckBox") self.horizontalLayout_2.addWidget(self.saveCameraVideocheckBox) self.gridLayout_7.addLayout(self.horizontalLayout_2, 9, 1, 1, 1) + self.horizontalLayout_5 = QtWidgets.QHBoxLayout() + self.horizontalLayout_5.setObjectName("horizontalLayout_5") + self.label_14 = QtWidgets.QLabel(self.dataExportTab) + self.label_14.setObjectName("label_14") + self.horizontalLayout_5.addWidget(self.label_14) + self.label_13 = QtWidgets.QLabel(self.dataExportTab) + self.label_13.setObjectName("label_13") + self.horizontalLayout_5.addWidget(self.label_13) + self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) + self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) + self.exportPathDirButton.setObjectName("exportPathDirButton") + self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) + self.horizontalLayout_4 = QtWidgets.QHBoxLayout() + self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) + self.horizontalLayout_4.setSpacing(6) + self.horizontalLayout_4.setObjectName("horizontalLayout_4") + self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.trialNameCheckBox.setChecked(True) + self.trialNameCheckBox.setObjectName("trialNameCheckBox") + self.horizontalLayout_4.addWidget(self.trialNameCheckBox) + self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) + self.pulseCheckBox.setObjectName("pulseCheckBox") + self.horizontalLayout_4.addWidget(self.pulseCheckBox) + self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) self.horizontalLayout_7 = QtWidgets.QHBoxLayout() self.horizontalLayout_7.setObjectName("horizontalLayout_7") self.trialStartsSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) @@ -319,59 +348,27 @@ def setupUi(self, MainWindow): self.cameraSuffixEdit.setObjectName("cameraSuffixEdit") self.horizontalLayout_7.addWidget(self.cameraSuffixEdit) self.gridLayout_7.addLayout(self.horizontalLayout_7, 11, 1, 1, 1) + spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_7.addItem(spacerItem7, 13, 1, 1, 1) + self.label_12 = QtWidgets.QLabel(self.dataExportTab) + self.label_12.setObjectName("label_12") + self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) self.exportPathEdit = QtWidgets.QLineEdit(self.dataExportTab) self.exportPathEdit.setText("") self.exportPathEdit.setObjectName("exportPathEdit") self.gridLayout_7.addWidget(self.exportPathEdit, 3, 1, 1, 1) - self.horizontalLayout_6 = QtWidgets.QHBoxLayout() - self.horizontalLayout_6.setObjectName("horizontalLayout_6") - self.trialNameSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.trialNameSuffixEdit.setObjectName("trialNameSuffixEdit") - self.horizontalLayout_6.addWidget(self.trialNameSuffixEdit) - self.pulseSuffixEdit = QtWidgets.QLineEdit(self.dataExportTab) - self.pulseSuffixEdit.setObjectName("pulseSuffixEdit") - self.horizontalLayout_6.addWidget(self.pulseSuffixEdit) - self.gridLayout_7.addLayout(self.horizontalLayout_6, 8, 1, 1, 1) - self.label_12 = QtWidgets.QLabel(self.dataExportTab) - self.label_12.setObjectName("label_12") - self.gridLayout_7.addWidget(self.label_12, 3, 0, 1, 1) - spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem5, 2, 1, 1, 1) - spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_7.addItem(spacerItem6, 12, 1, 1, 1) - self.horizontalLayout_4 = QtWidgets.QHBoxLayout() - self.horizontalLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint) - self.horizontalLayout_4.setSpacing(6) - self.horizontalLayout_4.setObjectName("horizontalLayout_4") - self.trialNameCheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.trialNameCheckBox.setChecked(False) - self.trialNameCheckBox.setObjectName("trialNameCheckBox") - self.horizontalLayout_4.addWidget(self.trialNameCheckBox) - self.pulseCheckBox = QtWidgets.QCheckBox(self.dataExportTab) - self.pulseCheckBox.setObjectName("pulseCheckBox") - self.horizontalLayout_4.addWidget(self.pulseCheckBox) - self.gridLayout_7.addLayout(self.horizontalLayout_4, 5, 1, 1, 1) - self.horizontalLayout_5 = QtWidgets.QHBoxLayout() - self.horizontalLayout_5.setObjectName("horizontalLayout_5") - self.label_14 = QtWidgets.QLabel(self.dataExportTab) - self.label_14.setObjectName("label_14") - self.horizontalLayout_5.addWidget(self.label_14) - self.label_13 = QtWidgets.QLabel(self.dataExportTab) - self.label_13.setObjectName("label_13") - self.horizontalLayout_5.addWidget(self.label_13) - self.gridLayout_7.addLayout(self.horizontalLayout_5, 7, 1, 1, 1) - self.exportPathDirButton = QtWidgets.QPushButton(self.dataExportTab) - self.exportPathDirButton.setObjectName("exportPathDirButton") - self.gridLayout_7.addWidget(self.exportPathDirButton, 3, 2, 1, 1) + self.savePulseButton = QtWidgets.QPushButton(self.dataExportTab) + self.savePulseButton.setObjectName("savePulseButton") + self.gridLayout_7.addWidget(self.savePulseButton, 12, 1, 1, 1) self.setupTabs.addTab(self.dataExportTab, "") self.cameraTab = QtWidgets.QWidget() self.cameraTab.setObjectName("cameraTab") self.gridLayout_8 = QtWidgets.QGridLayout(self.cameraTab) self.gridLayout_8.setObjectName("gridLayout_8") - spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_8.addItem(spacerItem7, 3, 0, 1, 2) spacerItem8 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) - self.gridLayout_8.addItem(spacerItem8, 10, 0, 1, 2) + self.gridLayout_8.addItem(spacerItem8, 3, 0, 1, 2) + spacerItem9 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + self.gridLayout_8.addItem(spacerItem9, 10, 0, 1, 2) self.label_19 = QtWidgets.QLabel(self.cameraTab) self.label_19.setObjectName("label_19") self.gridLayout_8.addWidget(self.label_19, 5, 1, 1, 1) @@ -407,6 +404,20 @@ def setupUi(self, MainWindow): self.gridLayout_8.addWidget(self.updateCamerasButton, 9, 0, 1, 1) self.setupTabs.addTab(self.cameraTab, "") self.gridLayout.addWidget(self.setupTabs, 1, 2, 1, 1) + self.trialBankTable = QtWidgets.QTableView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.trialBankTable.sizePolicy().hasHeightForWidth()) + self.trialBankTable.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setFamily("Lucida Console") + self.trialBankTable.setFont(font) + self.trialBankTable.setContextMenuPolicy(QtCore.Qt.DefaultContextMenu) + self.trialBankTable.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows) + self.trialBankTable.setObjectName("trialBankTable") + self.trialBankTable.horizontalHeader().setStretchLastSection(False) + self.gridLayout.addWidget(self.trialBankTable, 3, 0, 1, 1) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 1229, 21)) @@ -430,7 +441,7 @@ def setupUi(self, MainWindow): self.retranslateUi(MainWindow) self.viewWidgetTab.setCurrentIndex(0) - self.setupTabs.setCurrentIndex(0) + self.setupTabs.setCurrentIndex(1) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): @@ -463,11 +474,13 @@ def retranslateUi(self, MainWindow): self.shuffleGrouplineEdit.setText(_translate("MainWindow", "1")) self.invertBlankcheckBox.setText(_translate("MainWindow", "Invert blank off state")) self.label_21.setText(_translate("MainWindow", "Shuffle offset")) - self.globalOnsetEdit.setText(_translate("MainWindow", "0")) self.label_7.setText(_translate("MainWindow", "Offset")) self.globalOffsetEdit.setText(_translate("MainWindow", "0")) self.label_6.setText(_translate("MainWindow", "Onset")) self.label_20.setText(_translate("MainWindow", "Shuffle group size")) + self.globalOnsetEdit.setText(_translate("MainWindow", "0")) + self.label_23.setText(_translate("MainWindow", "Shuffle back-offset")) + self.shuffleBackOffsetlineEdit.setText(_translate("MainWindow", "0")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.globalParametersTab), _translate("MainWindow", "Global Parameters")) self.closeValvesButton.setText(_translate("MainWindow", "Close all valves")) self.randomiseTrialsButton.setText(_translate("MainWindow", "Randomise trials")) @@ -494,18 +507,19 @@ def retranslateUi(self, MainWindow): self.setupTabs.setTabText(self.setupTabs.indexOf(self.experimentSetupTab), _translate("MainWindow", "Experiment")) self.label_18.setText(_translate("MainWindow", "Time suffix")) self.label_15.setText(_translate("MainWindow", "Camera suffix")) - self.saveTrialStartscheckBox.setText(_translate("MainWindow", "Save trial start times")) - self.saveCameraVideocheckBox.setText(_translate("MainWindow", "Save camera video")) - self.trialStartsSuffixEdit.setText(_translate("MainWindow", "trial_starts")) - self.cameraSuffixEdit.setText(_translate("MainWindow", "camera")) self.trialNameSuffixEdit.setText(_translate("MainWindow", "trial_name")) self.pulseSuffixEdit.setText(_translate("MainWindow", "data")) - self.label_12.setText(_translate("MainWindow", "Save path")) - self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) - self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) + self.saveTrialStartscheckBox.setText(_translate("MainWindow", "Save trial start times")) + self.saveCameraVideocheckBox.setText(_translate("MainWindow", "Save camera video")) self.label_14.setText(_translate("MainWindow", "Name suffix")) self.label_13.setText(_translate("MainWindow", "Pulse suffix")) self.exportPathDirButton.setText(_translate("MainWindow", "...")) + self.trialNameCheckBox.setText(_translate("MainWindow", "Save trial names")) + self.pulseCheckBox.setText(_translate("MainWindow", "Save pulses")) + self.trialStartsSuffixEdit.setText(_translate("MainWindow", "trial_starts")) + self.cameraSuffixEdit.setText(_translate("MainWindow", "camera")) + self.label_12.setText(_translate("MainWindow", "Save path")) + self.savePulseButton.setText(_translate("MainWindow", "Save all pulses")) self.setupTabs.setTabText(self.setupTabs.indexOf(self.dataExportTab), _translate("MainWindow", "Data")) self.label_19.setText(_translate("MainWindow", "Number of cameras")) self.cameraSaveIconBox.setText(_translate("MainWindow", "Camera save icon")) @@ -524,3 +538,13 @@ def retranslateUi(self, MainWindow): self.actionSave_Configuration.setText(_translate("MainWindow", "Save Configuration")) from pyqtgraph import PlotWidget + +if __name__ == "__main__": + import sys + app = QtWidgets.QApplication(sys.argv) + MainWindow = QtWidgets.QMainWindow() + ui = Ui_MainWindow() + ui.setupUi(MainWindow) + MainWindow.show() + sys.exit(app.exec_()) + diff --git a/Models/Experiment.py b/Models/Experiment.py index c86025e..82013bd 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -39,6 +39,7 @@ def append_row(self, row): if self.arraydata[0] == default_row.copy()[0]: self.arraydata[0] = row else: + self.arraydata = list(self.arraydata) self.arraydata.append(row) self.layoutChanged.emit() @@ -124,11 +125,19 @@ def total_trials(self): def randomise_trials(self, global_params): shuffle_offset = global_params['shuffle_offset'] + shuffle_back_offset = global_params['shuffle_back_offset'] shuffle_group_size = global_params['shuffle_group_size'] out_shuffle = list(self.arraydata[:shuffle_offset]) - shuffle_indexes = np.arange((math.ceil(len(self.arraydata)-shuffle_offset)/shuffle_group_size))*shuffle_group_size+shuffle_offset + out_shuffle_back = [] + if shuffle_back_offset > 0: + out_shuffle_back = list(self.arraydata[-shuffle_back_offset:]) + + print(len(out_shuffle_back), shuffle_back_offset) + shuffle_indexes = np.arange((math.ceil(len(self.arraydata)-shuffle_offset-shuffle_back_offset)/shuffle_group_size))*shuffle_group_size+shuffle_offset+shuffle_back_offset random.shuffle(shuffle_indexes) for i in shuffle_indexes: for j in range(shuffle_group_size): out_shuffle.append(self.arraydata[int(i+j)]) + if shuffle_back_offset > 0: + out_shuffle += out_shuffle_back self.arraydata = out_shuffle From 9fd890fee48303f1a69f43ba95d391a98bb49fb9 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 17 Feb 2022 19:40:41 +0000 Subject: [PATCH 81/83] main design back offset --- Designs/mainDesign.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Designs/mainDesign.py b/Designs/mainDesign.py index 095a8c0..f4ebf47 100644 --- a/Designs/mainDesign.py +++ b/Designs/mainDesign.py @@ -538,7 +538,7 @@ def retranslateUi(self, MainWindow): self.actionSave_Configuration.setText(_translate("MainWindow", "Save Configuration")) from pyqtgraph import PlotWidget - +import sys if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) From 4620ab1d0619ed9d20f0d8bdbb56a78020b2d7fa Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Thu, 17 Feb 2022 20:10:16 +0000 Subject: [PATCH 82/83] end trig fix --- Models/Experiment.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Models/Experiment.py b/Models/Experiment.py index 82013bd..3680cbc 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -133,7 +133,7 @@ def randomise_trials(self, global_params): out_shuffle_back = list(self.arraydata[-shuffle_back_offset:]) print(len(out_shuffle_back), shuffle_back_offset) - shuffle_indexes = np.arange((math.ceil(len(self.arraydata)-shuffle_offset-shuffle_back_offset)/shuffle_group_size))*shuffle_group_size+shuffle_offset+shuffle_back_offset + shuffle_indexes = np.arange((math.ceil(len(self.arraydata)-shuffle_offset-shuffle_back_offset)/shuffle_group_size))*shuffle_group_size+shuffle_offset random.shuffle(shuffle_indexes) for i in shuffle_indexes: for j in range(shuffle_group_size): From 5ae5cda9143478a6d0a1d6cc66bdc8cd88d93f39 Mon Sep 17 00:00:00 2001 From: Tom Warner Date: Tue, 8 Mar 2022 15:24:05 +0000 Subject: [PATCH 83/83] shuffle back offset fix 1 --- Models/Experiment.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Models/Experiment.py b/Models/Experiment.py index 3680cbc..9196c51 100644 --- a/Models/Experiment.py +++ b/Models/Experiment.py @@ -127,6 +127,9 @@ def randomise_trials(self, global_params): shuffle_offset = global_params['shuffle_offset'] shuffle_back_offset = global_params['shuffle_back_offset'] shuffle_group_size = global_params['shuffle_group_size'] + if shuffle_offset + shuffle_back_offset > len(self.arraydata): + shuffle_offset = math.ceil(len(self.arraydata)/2) + shuffle_back_offset = math.floor(len(self.arraydata)/2) out_shuffle = list(self.arraydata[:shuffle_offset]) out_shuffle_back = [] if shuffle_back_offset > 0: