def updateData(self, values11, values21, offset, segment_size=101): # Update the data from (i*101) to (i+1)*101 logger.debug( "Calculating data and inserting in existing data at offset %d", offset) for i in range(len(values11)): re, im = values11[i] re21, im21 = values21[i] freq = self.data11[offset * segment_size + i].freq rawData11 = Datapoint(freq, re, im) rawData21 = Datapoint(freq, re21, im21) # TODO: Use applyCalibration instead if self.app.calibration.isCalculated: re, im = self.app.calibration.correct11(re, im, freq) if self.app.calibration.isValid2Port(): re21, im21 = self.app.calibration.correct21( re21, im21, freq) self.data11[offset * segment_size + i] = Datapoint(freq, re, im) self.data21[offset * segment_size + i] = Datapoint( freq, re21, im21) self.rawData11[offset * segment_size + i] = rawData11 self.rawData21[offset * segment_size + i] = rawData21 logger.debug("Saving data to application (%d and %d points)", len(self.data11), len(self.data21)) self.app.saveData(self.data11, self.data21) logger.debug("Sending \"updated\" signal") self.signals.updated.emit()
def updateData(self, frequencies, values11, values21, index): # Update the data from (i*101) to (i+1)*101 logger.debug( "Calculating data and inserting in existing data at index %d", index) offset = self.sweep.points * index v11 = values11[:] v21 = values21[:] raw_data11 = [] raw_data21 = [] for freq in frequencies: real11, imag11 = v11.pop(0) real21, imag21 = v21.pop(0) raw_data11.append(Datapoint(freq, real11, imag11)) raw_data21.append(Datapoint(freq, real21, imag21)) data11, data21 = self.applyCalibration(raw_data11, raw_data21) logger.debug("update Freqs: %s, Offset: %s", len(frequencies), offset) for i in range(len(frequencies)): self.data11[offset + i] = data11[i] self.data21[offset + i] = data21[i] self.rawData11[offset + i] = raw_data11[i] self.rawData21[offset + i] = raw_data21[i] logger.debug("Saving data to application (%d and %d points)", len(self.data11), len(self.data21)) self.app.saveData(self.data11, self.data21) logger.debug('Sending "updated" signal') # self.signals.updated.emit() self.updated = 1
def applyCalibration(self, raw_data11: List[Datapoint], raw_data21: List[Datapoint]) ->\ (List[Datapoint], List[Datapoint]): if self.offsetDelay != 0: tmp = [] for d in raw_data11: tmp.append(Calibration.correctDelay11(d, self.offsetDelay)) raw_data11 = tmp tmp = [] for d in raw_data21: tmp.append(Calibration.correctDelay21(d, self.offsetDelay)) raw_data21 = tmp if not self.app.calibration.isCalculated: return raw_data11, raw_data21 data11: List[Datapoint] = [] data21: List[Datapoint] = [] if self.app.calibration.isValid1Port(): for d in raw_data11: re, im = self.app.calibration.correct11(d.re, d.im, d.freq) data11.append(Datapoint(d.freq, re, im)) else: data11 = raw_data11 if self.app.calibration.isValid2Port(): for d in raw_data21: re, im = self.app.calibration.correct21(d.re, d.im, d.freq) data21.append(Datapoint(d.freq, re, im)) else: data21 = raw_data21 return data11, data21
def init_data(self): self.data11 = [] self.data21 = [] self.rawData11 = [] self.rawData21 = [] for freq in self.sweep.get_frequencies(): self.data11.append(Datapoint(freq, 0.0, 0.0)) self.data21.append(Datapoint(freq, 0.0, 0.0)) self.rawData11.append(Datapoint(freq, 0.0, 0.0)) self.rawData21.append(Datapoint(freq, 0.0, 0.0)) logger.debug("Init data length: %s", len(self.data11))
def test_cor_att_data(self): dp1 = [ Datapoint(100000, 0.1091, 0.3118), Datapoint(100001, 0.1091, 0.3124), Datapoint(100002, 0.1091, 0.3130), ] dp2 = corr_att_data(dp1, 10) self.assertEqual(dp2[0].gain - dp1[0].gain, 10) self.assertEqual(len(dp1), len(dp2)) # ignore negative attenuation dp3 = corr_att_data(dp1, -10) self.assertEqual(dp1, dp3)
def _append_line_data(self, freq: int, data: list): data_list = iter(self.sdata) vals = iter(data) for v in vals: if self.opts.format == "ri": next(data_list).append(Datapoint(freq, float(v), float(next(vals)))) if self.opts.format == "ma": z = cmath.rect(float(v), math.radians(float(next(vals)))) next(data_list).append(Datapoint(freq, z.real, z.imag)) if self.opts.format == "db": z = cmath.rect(math.exp(float(v) / 20), math.radians(float(next(vals)))) next(data_list).append(Datapoint(freq, z.real, z.imag))
def correct21(self, dp: Datapoint): i = self.interp try: s21 = (dp.z - i["e30"](dp.freq)) / i["e10e32"](dp.freq) return Datapoint(dp.freq, s21.real, s21.imag) except ValueError: # TODO: implement warn message in gui logger.info("Data outside calibration") nearest = sorted(self.dataset.frequencies(), key=lambda k: abs(dp.freq - k))[0] ds = self.dataset.get(nearest) s21 = (dp.z - ds["e30"]) / ds["e10e32"] return Datapoint(dp.freq, s21.real, s21.imag)
def exportFile(self, filename: str, data: List[List[Datapoint]]): ts = Touchstone(filename) i = 0 ts.sdata[0] = data[0] ts.sdata[1] = data[1] for dp in data[0]: ts.sdata[2].append(Datapoint(dp.freq, 0, 0)) ts.sdata[3].append(Datapoint(dp.freq, 0, 0)) try: ts.save(4) except IOError as e: logger.exception("Error during file export: %s", e) return
def test_setter(self): ts = Touchstone("") dp_list = [Datapoint(1, 0.0, 0.0), Datapoint(3, 1.0, 1.0)] ts.s11data = dp_list[:] ts.s21data = dp_list[:] ts.s12data = dp_list[:] ts.s22data = dp_list[:] self.assertEqual(ts.s11data, dp_list) self.assertEqual(ts.s21data, dp_list) self.assertEqual(ts.s12data, dp_list) self.assertEqual(ts.s22data, dp_list) self.assertEqual(ts.min_freq(), 1) self.assertEqual(ts.max_freq(), 3) ts.gen_interpolation() self.assertEqual(ts.s_freq("11", 2), Datapoint(2, 0.5, 0.5))
def test_save(self): ts = Touchstone("./test/data/valid.s2p") self.assertEqual(ts.saves(), "# HZ S RI R 50\n") ts.load() lines = ts.saves().splitlines() self.assertEqual(len(lines), 1021) self.assertEqual(lines[0], "# HZ S RI R 50") self.assertEqual(lines[1], '500000 -0.333238 0.000180018') self.assertEqual(lines[-1], '900000000 -0.127646 0.31969') lines = ts.saves(4).splitlines() self.assertEqual(len(lines), 1021) self.assertEqual(lines[0], "# HZ S RI R 50") self.assertEqual( lines[1], '500000 -0.333238 0.000180018 0.67478 -8.1951e-07' ' 0.67529 -8.20129e-07 -0.333238 0.000308078') self.assertEqual( lines[-1], '900000000 -0.127646 0.31969 0.596287 -0.503453' ' 0.599076 -0.50197 -0.122713 0.326965') ts.filename = "./test/data/output.s2p" ts.save(4) os.remove(ts.filename) ts.filename = "" self.assertRaises(FileNotFoundError, ts.save) ts.s11data[0] = Datapoint(100, 0.1, 0.1) self.assertRaisesRegex(LookupError, "Frequencies of sdata not correlated", ts.saves, 4)
def correct11(self, dp: Datapoint): i = self.interp try: s11 = (dp.z - i["e00"](dp.freq)) / ( (dp.z * i["e11"](dp.freq)) - i["delta_e"](dp.freq)) return Datapoint(dp.freq, s11.real, s11.imag) except ValueError: # TODO: implement warn message in gui logger.info("Data outside calibration") nearest = sorted(self.dataset.frequencies(), key=lambda k: abs(dp.freq - k))[0] ds = self.dataset.get(nearest) s11 = (dp.z - ds["e00"]) / ( (dp.z * ds["e11"]) - ds["delta_e"]) return Datapoint(dp.freq, s11.real, s11.imag)
def test_load(self): ts = Touchstone("./test/data/valid.s1p") ts.load() self.assertEqual(str(ts.opts), "# HZ S RI R 50") self.assertEqual(len(ts.s11data), 1010) self.assertEqual(len(ts.s21data), 0) self.assertEqual(ts.r, 50) ts = Touchstone("./test/data/valid.s2p") ts.load() ts.gen_interpolation() self.assertEqual(str(ts.opts), "# HZ S RI R 50") self.assertEqual(len(ts.s11data), 1020) self.assertEqual(len(ts.s21data), 1020) self.assertEqual(len(ts.s12data), 1020) self.assertEqual(len(ts.s22data), 1020) self.assertIn("! Vector Network Analyzer VNA R2", ts.comments) self.assertEqual(ts.min_freq(), 500000) self.assertEqual(ts.max_freq(), 900000000) self.assertEqual(ts.s_freq("11", 1), Datapoint(1, -3.33238E-001, 1.80018E-004)) self.assertEqual( ts.s_freq("11", 750000), Datapoint(750000, -0.3331754099382822, 0.00032433255669243524)) ts = Touchstone("./test/data/ma.s2p") ts.load() self.assertEqual(str(ts.opts), "# MHZ S MA R 50") ts = Touchstone("./test/data/db.s2p") ts.load() self.assertEqual(str(ts.opts), "# HZ S DB R 50") ts = Touchstone("./test/data/broken_pair.s2p") with self.assertLogs(level=logging.ERROR) as cm: ts.load() self.assertRegex(cm.output[0], "Data values aren't pairs") ts = Touchstone("./test/data/missing_pair.s2p") with self.assertLogs(level=logging.ERROR) as cm: ts.load() self.assertRegex(cm.output[0], "Inconsistent number") ts = Touchstone("./test/data/nonexistent.s2p") with self.assertLogs(level=logging.ERROR) as cm: ts.load() self.assertRegex(cm.output[0], "No such file or directory")
def saveData(self, frequencies, values11, values21): rawData11 = [] rawData21 = [] logger.debug("Calculating data including corrections") for i in range(len(values11)): re, im = values11[i] re21, im21 = values21[i] freq = frequencies[i] rawData11 += [Datapoint(freq, re, im)] rawData21 += [Datapoint(freq, re21, im21)] self.data11, self.data21 = self.applyCalibration(rawData11, rawData21) self.rawData11 = rawData11 self.rawData21 = rawData21 logger.debug("Saving data to application (%d and %d points)", len(self.data11), len(self.data21)) self.app.saveData(self.data11, self.data21) logger.debug("Sending \"updated\" signal") self.signals.updated.emit()
def drawBands(self, qp, fstart, fstop): qp.setBrush(self.bands.color) qp.setPen(QtGui.QColor(128, 128, 128, 0)) # Don't outline the bands for _, start, end in self.bands.bands: try: start = int(start) end = int(end) except ValueError: continue # don't draw if either band not in chart or completely in band if start < fstart < fstop < end or end < fstart or start > fstop: continue x_start = max(self.leftMargin + 1, self.getXPosition(Datapoint(start, 0, 0))) x_stop = min(self.leftMargin + self.chartWidth, self.getXPosition(Datapoint(end, 0, 0))) qp.drawRect(x_start, self.topMargin, x_stop - x_start, self.chartHeight)
def updateData(self, values11, values21, offset, segment_size=101): # Update the data from (i*101) to (i+1)*101 logger.debug("Calculating data and inserting in existing data at offset %d", offset) for i, val11 in enumerate(values11): re, im = val11 re21, im21 = values21[i] freq = self.data11[offset * segment_size + i].freq raw_data11 = Datapoint(freq, re, im) raw_data21 = Datapoint(freq, re21, im21) data11, data21 = self.applyCalibration([raw_data11], [raw_data21]) self.data11[offset * segment_size + i] = data11[0] self.data21[offset * segment_size + i] = data21[0] self.rawData11[offset * segment_size + i] = raw_data11 self.rawData21[offset * segment_size + i] = raw_data21 logger.debug("Saving data to application (%d and %d points)", len(self.data11), len(self.data21)) self.app.saveData(self.data11, self.data21) logger.debug("Sending \"updated\" signal") self.signals.updated.emit()
def exportFile(self, nr_params: int = 1): if len(self.app.data.s11) == 0: QtWidgets.QMessageBox.warning(self, "No data to save", "There is no data to save.") return if nr_params > 2 and len(self.app.data.s21) == 0: QtWidgets.QMessageBox.warning(self, "No S21 data to save", "There is no S21 data to save.") return filedialog = QtWidgets.QFileDialog(self) if nr_params == 1: filedialog.setDefaultSuffix("s1p") filedialog.setNameFilter( "Touchstone 1-Port Files (*.s1p);;All files (*.*)") else: filedialog.setDefaultSuffix("s2p") filedialog.setNameFilter( "Touchstone 2-Port Files (*.s2p);;All files (*.*)") filedialog.setAcceptMode(QtWidgets.QFileDialog.AcceptSave) selected = filedialog.exec() if not selected: return filename = filedialog.selectedFiles()[0] if filename == "": logger.debug("No file name selected.") return ts = Touchstone(filename) ts.sdata[0] = self.app.data.s11 if nr_params > 1: ts.sdata[1] = self.app.data.s21 for dp in self.app.data.s11: ts.sdata[2].append(Datapoint(dp.freq, 0, 0)) ts.sdata[3].append(Datapoint(dp.freq, 0, 0)) try: ts.save(nr_params) except IOError as e: logger.exception("Error during file export: %s", e) return
def setUp(self): self.dp = Datapoint(100000, 0.1091, 0.3118) self.dp0 = Datapoint(100000, 0, 0) self.dp50 = Datapoint(100000, 1, 0) self.dp75 = Datapoint(100000, 0.2, 0) self.dp_im50 = Datapoint(100000, 0, 1) self.dp_ill = Datapoint(100000, 1.1, 0)
def saveData(self, frequencies, values11, values21): logger.debug("Freqs: %d, values11: %d, values21: %d", len(frequencies), len(values11), len(values21)) v11 = values11[:] v21 = values21[:] raw_data11 = [] raw_data21 = [] logger.debug("Calculating data including corrections") for freq in frequencies: real11, imag11 = v11.pop(0) real21, imag21 = v21.pop(0) raw_data11.append(Datapoint(freq, real11, imag11)) raw_data21.append(Datapoint(freq, real21, imag21)) self.rawData11 = raw_data11 self.rawData21 = raw_data21 self.data11, self.data21 = self.applyCalibration( raw_data11, raw_data21) logger.debug("Saving data to application (%d and %d points)", len(self.data11), len(self.data21)) self.app.saveData(self.data11, self.data21) logger.debug("Sending \"updated\" signal") self.signals.updated.emit()
def applyCalibration(self, raw_data11: List[Datapoint], raw_data21: List[Datapoint]) ->\ (List[Datapoint], List[Datapoint]): if not self.app.calibration.isCalculated: return raw_data11, raw_data21 data11: List[Datapoint] = [] data21: List[Datapoint] = [] if self.app.calibration.isValid1Port(): logger.debug("Applying S11 calibration.") for d in raw_data11: re, im = self.app.calibration.correct11(d.re, d.im, d.freq) data11.append(Datapoint(d.freq, re, im)) else: data11 = raw_data11 if self.app.calibration.isValid2Port(): logger.debug("Applying S21 calibration.") for d in raw_data21: re, im = self.app.calibration.correct21(d.re, d.im, d.freq) data21.append(Datapoint(d.freq, re, im)) else: data21 = raw_data21 return data11, data21
def drawBands(self, qp, fstart, fstop): qp.setBrush(self.bands.color) qp.setPen(QtGui.QColor(128, 128, 128, 0)) # Don't outline the bands for (_, start, end) in self.bands.bands: if fstart < start < fstop and fstart < end < fstop: # The band is entirely within the chart x_start = self.getXPosition(Datapoint(start, 0, 0)) x_end = self.getXPosition(Datapoint(end, 0, 0)) qp.drawRect(x_start, self.topMargin, x_end - x_start, self.chartHeight) elif fstart < start < fstop: # Only the start of the band is within the chart x_start = self.getXPosition(Datapoint(start, 0, 0)) qp.drawRect(x_start, self.topMargin, self.leftMargin + self.chartWidth - x_start, self.chartHeight) elif fstart < end < fstop: # Only the end of the band is within the chart x_end = self.getXPosition(Datapoint(end, 0, 0)) qp.drawRect(self.leftMargin + 1, self.topMargin, x_end - (self.leftMargin + 1), self.chartHeight) elif start < fstart < fstop < end: # All the chart is in a band, we won't show it(?) pass
def test_groupDelay(self): dpoints = [ Datapoint(100000, 0.1091, 0.3118), Datapoint(100001, 0.1091, 0.3124), Datapoint(100002, 0.1091, 0.3130), ] dpoints0 = [ Datapoint(100000, 0.1091, 0.3124), Datapoint(100000, 0.1091, 0.3124), Datapoint(100000, 0.1091, 0.3124), ] self.assertAlmostEqual(groupDelay(dpoints, 1), -9.514e-5) self.assertEqual(groupDelay(dpoints0, 1), 0.0)
def load(self, filename): self.source = os.path.basename(filename) self.dataset = CalDataSet() self.notes = [] parsed_header = False with open(filename) as calfile: for i, line in enumerate(calfile): line = line.strip() if line.startswith("!"): note = line[2:] self.notes.append(note) continue if line.startswith("#"): if not parsed_header: # Check that this is a valid header if line == ( "# Hz ShortR ShortI OpenR OpenI LoadR LoadI" " ThroughR ThroughI IsolationR IsolationI"): parsed_header = True continue if not parsed_header: logger.warning( "Warning: Read line without having read header: %s", line) continue m = RXP_CAL_LINE.search(line) if not m: logger.warning("Illegal data in cal file. Line %i", i) cal = m.groupdict() if cal["throughr"]: nr_cals = 5 else: nr_cals = 3 for name in Calibration.CAL_NAMES[:nr_cals]: self.dataset.insert( name, Datapoint(int(cal["freq"]), float(cal[f"{name}r"]), float(cal[f"{name}i"])))
def setUp(self): self.dp = Datapoint(100000, 0.1091, 0.3118) self.dp0 = Datapoint(100000, 0, 0) self.dp50 = Datapoint(100000, 1, 0)
class MarkerSettingsWindow(QtWidgets.QWidget): exampleData11 = [ Datapoint(123000000, 0.89, -0.11), Datapoint(123500000, 0.9, -0.1), Datapoint(124000000, 0.91, -0.95) ] exampleData21 = [ Datapoint(123000000, -0.25, 0.49), Datapoint(123456000, -0.3, 0.5), Datapoint(124000000, -0.2, 0.5) ] def __init__(self, app: QtWidgets.QWidget): super().__init__() self.app = app self.setWindowTitle("Marker settings") self.setWindowIcon(self.app.icon) QtWidgets.QShortcut(QtCore.Qt.Key_Escape, self, self.cancelButtonClick) self.exampleMarker = Marker("Example marker") layout = QtWidgets.QVBoxLayout() self.setLayout(layout) settings_group_box = QtWidgets.QGroupBox("Settings") settings_group_box_layout = QtWidgets.QFormLayout(settings_group_box) self.checkboxColouredMarker = QtWidgets.QCheckBox( "Colored marker name") self.checkboxColouredMarker.setChecked( self.app.settings.value("ColoredMarkerNames", True, bool)) self.checkboxColouredMarker.stateChanged.connect(self.updateMarker) settings_group_box_layout.addRow(self.checkboxColouredMarker) fields_group_box = QtWidgets.QGroupBox("Displayed data") fields_group_box_layout = QtWidgets.QFormLayout(fields_group_box) self.savedFieldSelection = self.app.settings.value( "MarkerFields", defaultValue=default_label_ids()) if self.savedFieldSelection == "": self.savedFieldSelection = [] self.currentFieldSelection = self.savedFieldSelection[:] self.active_labels_view = QtWidgets.QListView() self.update_displayed_data_form() fields_group_box_layout.addRow(self.active_labels_view) layout.addWidget(settings_group_box) layout.addWidget(fields_group_box) layout.addWidget(self.exampleMarker.getGroupBox()) btn_layout = QtWidgets.QHBoxLayout() layout.addLayout(btn_layout) btn_ok = QtWidgets.QPushButton("OK") btn_apply = QtWidgets.QPushButton("Apply") btn_default = QtWidgets.QPushButton("Defaults") btn_cancel = QtWidgets.QPushButton("Cancel") btn_ok.clicked.connect(self.okButtonClick) btn_apply.clicked.connect(self.applyButtonClick) btn_default.clicked.connect(self.defaultButtonClick) btn_cancel.clicked.connect(self.cancelButtonClick) btn_layout.addWidget(btn_ok) btn_layout.addWidget(btn_apply) btn_layout.addWidget(btn_default) btn_layout.addWidget(btn_cancel) self.updateMarker() for m in self.app.markers: m.setFieldSelection(self.currentFieldSelection) m.setColoredText(self.checkboxColouredMarker.isChecked()) def updateMarker(self): self.exampleMarker.setFrequency(123456000) self.exampleMarker.setColoredText( self.checkboxColouredMarker.isChecked()) self.exampleMarker.setFieldSelection(self.currentFieldSelection) self.exampleMarker.findLocation(self.exampleData11) self.exampleMarker.resetLabels() self.exampleMarker.updateLabels(self.exampleData11, self.exampleData21) def updateField(self, field: QtGui.QStandardItem): if field.checkState() == QtCore.Qt.Checked: if not field.data() in self.currentFieldSelection: self.currentFieldSelection = [] for i in range(self.model.rowCount()): field = self.model.item(i, 0) if field.checkState() == QtCore.Qt.Checked: self.currentFieldSelection.append(field.data()) else: if field.data() in self.currentFieldSelection: self.currentFieldSelection.remove(field.data()) self.updateMarker() def applyButtonClick(self): self.savedFieldSelection = self.currentFieldSelection[:] self.app.settings.setValue("MarkerFields", self.savedFieldSelection) self.app.settings.setValue("ColoredMarkerNames", self.checkboxColouredMarker.isChecked()) for m in self.app.markers: m.setFieldSelection(self.savedFieldSelection) m.setColoredText(self.checkboxColouredMarker.isChecked()) def okButtonClick(self): self.applyButtonClick() self.close() def cancelButtonClick(self): self.currentFieldSelection = self.savedFieldSelection[:] self.update_displayed_data_form() self.updateMarker() self.close() def defaultButtonClick(self): self.currentFieldSelection = default_label_ids() self.update_displayed_data_form() self.updateMarker() def update_displayed_data_form(self): self.model = QtGui.QStandardItemModel() for label in TYPES: item = QtGui.QStandardItem(label.description) item.setData(label.label_id) item.setCheckable(True) item.setEditable(False) if label.label_id in self.currentFieldSelection: item.setCheckState(QtCore.Qt.Checked) self.model.appendRow(item) self.active_labels_view.setModel(self.model) self.model.itemChanged.connect(self.updateField)
def correct_delay(d: Datapoint, delay: float, reflect: bool = False): mult = 2 if reflect else 1 corr_data = d.z * cmath.exp( complex(0, 1) * 2 * math.pi * d.freq * delay * -1 * mult) return Datapoint(d.freq, corr_data.real, corr_data.imag)
def s_freq(self, name: str, freq: int) -> Datapoint: return Datapoint(freq, float(self._interp[name]["real"](freq)), float(self._interp[name]["imag"](freq)))
def correct11(self, dp: Datapoint): i = self.interp s11 = (dp.z - i["e00"](dp.freq)) / ( (dp.z * i["e11"](dp.freq)) - i["delta_e"](dp.freq)) return Datapoint(dp.freq, s11.real, s11.imag)
def correct21(self, dp: Datapoint): i = self.interp s21 = (dp.z - i["e30"](dp.freq)) / i["e10e32"](dp.freq) return Datapoint(dp.freq, s21.real, s21.imag)
def correct21(self, dp: Datapoint, dp11: Datapoint): i = self.interp s21 = (dp.z - i["e30"](dp.freq)) / i["e10e32"](dp.freq) s21 = s21 * (i["e10e01"](dp.freq) / (i["e11"](dp.freq) * dp11.z - i["delta_e"](dp.freq))) return Datapoint(dp.freq, s21.real, s21.imag)
def main(): my_test = MyTest() logger.info("loading calibration") my_test.set_calibration("calibrations/24_25_includedKit_blueCable.cal") logger.info("connecting to device") my_test.connect_device() logger.info("read averaged sweep") averaged_read = my_test.readAveragedSegment(2400000, 2500000, 3, 0) logger.debug("\nthe frequencies(" + str(len(averaged_read[0])) + "): " + str(averaged_read[0])) logger.debug("\ns11 data(" + str(len(averaged_read[1])) + "): " + str(averaged_read[1])) logger.debug("\ns21 data(" + str(len(averaged_read[2])) + "): " + str(averaged_read[2])) logger.info("applying calibration") #build data points out of the read s11_raw = [] s21_raw = [] for i in range(len(averaged_read[0])): s11_dp = Datapoint( freq = averaged_read[0][i],\ re = averaged_read[1][i][0],\ im = averaged_read[1][i][1] ) s11_raw.append(s11_dp) s21_dp = Datapoint( freq = averaged_read[0][i],\ re = averaged_read[2][i][0],\ im = averaged_read[2][i][1] ) s21_raw.append(s21_dp) def printdatapoints(datapoints: List[Datapoint]): for dp in datapoints: print(dp) print("s11_raw:") printdatapoints(s11_raw) print("s21_raw:") printdatapoints(s21_raw) my_test.exportFile("touchstoneTest.csv", [s11_raw, s21_raw]) calibrated_read__ = my_test.apply_calibration(s11_raw, s21_raw) calibrated_read = [] for i in range(3): calibrated_read.append([]) for i in range(len(calibrated_read__[0])): calibrated_read[0].append(calibrated_read__[0][i].freq) calibrated_read[1].append( [calibrated_read__[0][i].re, calibrated_read__[0][i].im]) calibrated_read[2].append( [calibrated_read__[1][i].re, calibrated_read__[1][i].im]) logger.debug("\nthe calibrated read: " + str(calibrated_read)) logger.info("displaying data") plot_magnitude(averaged_read[0], convert_2d_float_1d_complex(averaged_read[1]), "uncalibrated s11") plot_magnitude(averaged_read[0], convert_2d_float_1d_complex(averaged_read[2]), "uncalibrated s21") plot_magnitude(calibrated_read[0], convert_2d_float_1d_complex(calibrated_read[1]), "calibrated s11") plot_magnitude(calibrated_read[0], convert_2d_float_1d_complex(calibrated_read[2]), "calibrated s21") plt.show() #save touchstone files for further data processing and visualization logger.info("disconnecting device") my_test.disconnect_device()