From 190ca4ded523aa1c90df82859b30de66f7008278 Mon Sep 17 00:00:00 2001 From: Luke Date: Tue, 17 Jul 2018 18:33:39 -0700 Subject: [PATCH] Inital comit. Basic transfer function and tank impedance plotting --- pySmithPlot/.gitignore | 92 ++ pySmithPlot/README.md | 73 + pySmithPlot/setup.py | 19 + pySmithPlot/smithplot/__init__.py | 12 + pySmithPlot/smithplot/smithaxes.py | 1544 +++++++++++++++++++ pySmithPlot/smithplot/smithhelper.py | 60 + pySmithPlot/testbenches/.gitignore | 2 + pySmithPlot/testbenches/data/s11.csv | 1002 ++++++++++++ pySmithPlot/testbenches/data/s22.csv | 1002 ++++++++++++ pySmithPlot/testbenches/smith_full_test.py | 265 ++++ pySmithPlot/testbenches/smith_short_test.py | 37 + tankPlot.py | 113 ++ 12 files changed, 4221 insertions(+) create mode 100644 pySmithPlot/.gitignore create mode 100755 pySmithPlot/README.md create mode 100755 pySmithPlot/setup.py create mode 100644 pySmithPlot/smithplot/__init__.py create mode 100644 pySmithPlot/smithplot/smithaxes.py create mode 100644 pySmithPlot/smithplot/smithhelper.py create mode 100644 pySmithPlot/testbenches/.gitignore create mode 100755 pySmithPlot/testbenches/data/s11.csv create mode 100755 pySmithPlot/testbenches/data/s22.csv create mode 100755 pySmithPlot/testbenches/smith_full_test.py create mode 100755 pySmithPlot/testbenches/smith_short_test.py create mode 100644 tankPlot.py diff --git a/pySmithPlot/.gitignore b/pySmithPlot/.gitignore new file mode 100644 index 0000000..00f2f1c --- /dev/null +++ b/pySmithPlot/.gitignore @@ -0,0 +1,92 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*,cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# IPython Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# dotenv +.env + +# virtualenv +venv/ +ENV/ + +# Spyder project settings +.spyderproject + +# Rope project settings +.ropeproject + +# Pycharm project settings +.idea diff --git a/pySmithPlot/README.md b/pySmithPlot/README.md new file mode 100755 index 0000000..fd86dbd --- /dev/null +++ b/pySmithPlot/README.md @@ -0,0 +1,73 @@ +pySmithPlot +=========== + +## New Release of Version 0.2 + +After 2 years of getting dusty **pySmithPlot** now got some new features and bug fixes. Here is a short changelog: + +- **Support for Python 3** +- improved grid generation algorithm +- plot() now also handles also single numbers and purely real data +- plot() can now interpolate lines between points or generate an equidistant spacing +- changed handling of input data and renormalization; now the actual datatype (S,Z,Y-Parameter) can be specified when calling plot() +- changed behaviour for normalization and placement of the label +- added some parameter checks +- removed default `matplotlib` settings +- renamed some parameters to improve consistency +- fixed issues with Unicode symbols +- fixed issues with grid generation +- fixed issues with axis label display and placement + +There are still some plans for the future and they hopefully don't take another two years: + +- [ ] support for Admittance Charts +- [ ] support for `contour()` plots +- [ ] zoom and 'cut out' function +- [ ] special handling of other `matplotlib.patch` objects like arrows +- [ ] ... + +## Features + +**pySmithPlot** is a matplotlib extension providing a projection class for creating high quality Smith Charts with Python. The generated plots blend seamless into matplotlib's style and support almost the full range of customization options. + +This Library allows the fully automatic generation of Smith Charts with various customizable parameters and well selected default values. It also provides the following modifications and extensions: + +- circle shaped drawing area with labels placed around +- plot() accepts real and complex numbers as well as numpy.ndarray's +- lines can be automatically interpolated to improve the optical appearance +- data ranges can be interpolated to an equidistant spacing +- start/end markers of lines can be modified and rotate tangential +- gridlines are 3-point arcs to improve space efficiency of exported plots +- 'fancy' option for adaptive grid generation +- own tick locators for nice axis labels + +For making a Smith Chart plot, it is sufficient to `import smithplot` and create a new subplot with projection set to 'smith'. (Requires matplotlib version 1.2) + +A short example can be found in the `testbenches` directory and started with: + + python3 smith_short_test.py + +For more details and documentation, take a look into `smithplot/smithaxes.py`. + +`testbenches/smith_full_test.py` runs various testbenches and gives a comparison for almost all parameters. These are the generated sample plots: + +![Grid Styles](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_grid_styles.png) +[Grid Styles - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_grid_styles.pdf) + +![Fancy Threshold](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_fancy_grid.png) +[Fancy Threshold - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_fancy_grid.pdf) + +![Grid Locators](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_grid_locators.png) +[Grid Locators - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_grid_locators.pdf) + +![Marker Modification](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_markers.png) +[Marker Modification - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_markers.pdf) + +![Interpolation](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_interpolation.png) +[Interpolation - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_interpolation.pdf) + +![Normalize](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_normalize.png) +[Normalize - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_normalize.pdf) + +![Miscellaneous](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_miscellaneous.png) +[Miscellaneous - PDF](https://github.com/vMeijin/pySmithPlot/wiki/images/examples/sample_miscellaneous.pdf) diff --git a/pySmithPlot/setup.py b/pySmithPlot/setup.py new file mode 100755 index 0000000..599f1f2 --- /dev/null +++ b/pySmithPlot/setup.py @@ -0,0 +1,19 @@ +import os + +from setuptools import setup + + +def read(fname): + return open(os.path.join(os.path.dirname(__file__), fname)).read() + + +setup(name="pysmithplot", + version="0.2.0", + packages=["smithplot"], + description="An extension for Matplotlib providing a projection class to generate high quality Smith Chart plots.", + long_description=read('README.md'), + author="Paul Staerke", + author_email="paul.staerke@gmail.com", + license="BSD", + url="https://github.com/vMeijin/pySmithPlot", + install_requires=["matplotlib >= 1.2.0", "numpy", "scipy"]) diff --git a/pySmithPlot/smithplot/__init__.py b/pySmithPlot/smithplot/__init__.py new file mode 100644 index 0000000..85871b6 --- /dev/null +++ b/pySmithPlot/smithplot/__init__.py @@ -0,0 +1,12 @@ +# -*- coding: utf-8 -*- +import matplotlib +from matplotlib.projections import register_projection + +from .smithaxes import SmithAxes + +# check version requierment +if matplotlib.__version__ < '1.2': + raise ImportError("pySmithPlot requires at least matplotlib version 1.2") + +# add smith projection to available projections +register_projection(SmithAxes) diff --git a/pySmithPlot/smithplot/smithaxes.py b/pySmithPlot/smithplot/smithaxes.py new file mode 100644 index 0000000..2ed8cbb --- /dev/null +++ b/pySmithPlot/smithplot/smithaxes.py @@ -0,0 +1,1544 @@ +# -*- coding: utf-8 -*- +# last edit: 11.04.2018 +''' +Library for plotting fully automatic a Smith Chart with various customizable +parameters and well selected default values. It also provides the following +modifications and features: + + - circle shaped drawing area with labels placed around + - :meth:`plot` accepts single real and complex numbers and numpy.ndarray's + - plotted lines can be interpolated + - start/end markers of lines can be modified and rotate tangential + - gridlines are 3-point arcs to improve space efficiency of exported plots + - 'fancy' option for adaptive grid generation + - own tick locators for nice axis labels + +For making a Smith Chart plot it is sufficient to import :mod:`smithplot` and +create a new subplot with projection set to 'smith'. Parameters can be set +either with keyword arguments or :meth:`update_Params`. + +Example: + + # creating a new plot and modify parameters afterwards + import smithplot + from smithplot import SmithAxes + from matplotlib import pyplot as pp + ax = pp.subplot('111', projection='smith') + SmithAxes.update_scParams(ax, reset=True, grid_major_enable=False) + ## or in short form direct + #ax = pp.subplot('111', projection='smith', grid_major_enable=False) + pp.plot([25, 50 + 50j, 100 - 50j], datatype=SmithAxes.Z_PARAMETER) + pp.show() + +Note: Supplying parameters to :meth:`subplot` may not always work as +expected, because subplot uses an index for the axes with a key created +of all given parameters. This does not work always, especially if the +parameters are array-like types (e.g. numpy.ndarray). +''' + +from collections import Iterable +from numbers import Number +from types import MethodType, FunctionType + +import matplotlib as mp +import numpy as np +from matplotlib.axes import Axes +from matplotlib.axis import XAxis +from matplotlib.cbook import simple_linear_interpolation as linear_interpolation +from matplotlib.legend_handler import HandlerLine2D +from matplotlib.lines import Line2D +from matplotlib.markers import MarkerStyle +from matplotlib.patches import Circle, Arc +from matplotlib.path import Path +from matplotlib.spines import Spine +from matplotlib.ticker import Formatter, AutoMinorLocator, Locator +from matplotlib.transforms import Affine2D, BboxTransformTo, Transform +from scipy.interpolate import fitpack + +from . import smithhelper +from .smithhelper import EPSILON, TWO_PI, ang_to_c, z_to_xy + + +class SmithAxes(Axes): + ''' + The :class:`SmithAxes` provides an implementation of :class:`matplotlib.axes.Axes` + for drawing a full automatic Smith Chart it also provides own implementations for + + - :class:`matplotlib.transforms.Transform` + -> :class:`MoebiusTransform` + -> :class:`InvertedMoebiusTransform` + -> :class:`PolarTranslate` + - :class:`matplotlib.ticker.Locator` + -> :class:`RealMaxNLocator` + -> :class:`ImagMaxNLocator` + -> :class:`SmithAutoMinorLocator` + - :class:`matplotlib.ticker.Formatter` + -> :class:`RealFormatter` + -> :class:`ImagFormatter` + ''' + + name = 'smith' + + # data types + S_PARAMETER = "S" + Z_PARAMETER = "Z" + Y_PARAMETER = "Y" + _datatypes = [S_PARAMETER, Z_PARAMETER, Y_PARAMETER] + + # constants used for indicating values near infinity, which are all transformed into one point + _inf = smithhelper.INF + _near_inf = 0.9 * smithhelper.INF + _ax_lim_x = 2 * _inf # prevents missing labels in special cases + _ax_lim_y = 2 * _inf # prevents missing labels in special cases + + # default parameter, see update_scParams for description + scDefaultParams = {"plot.zorder": 4, + "plot.marker.hack": True, + "plot.marker.rotate": True, + "plot.marker.start": "s", + "plot.marker.default": "o", + "plot.marker.end": "^", + "plot.default.interpolation": 5, + "plot.default.datatype": S_PARAMETER, + "grid.zorder": 1, + "grid.locator.precision": 2, + "grid.major.enable": True, + "grid.major.linestyle": '-', + "grid.major.linewidth": 1, + "grid.major.color": "0.2", + "grid.major.xmaxn": 10, + "grid.major.ymaxn": 16, + "grid.major.fancy": True, + "grid.major.fancy.threshold": (100, 50), + "grid.minor.enable": True, + "grid.minor.capstyle": "round", + "grid.minor.dashes": [0.2, 2], + "grid.minor.linewidth": 0.75, + "grid.minor.color": "0.4", + "grid.minor.xauto": 4, + "grid.minor.yauto": 4, + "grid.minor.fancy": True, + "grid.minor.fancy.dividers": [0, 1, 2, 3, 5, 10, 20], + "grid.minor.fancy.threshold": 35, + "axes.xlabel.rotation": 90, + "axes.xlabel.fancybox": {"boxstyle": "round,pad=0.2,rounding_size=0.2", + "facecolor": 'w', + "edgecolor": "w", + "mutation_aspect": 0.75, + "alpha": 1}, + "axes.ylabel.correction": (-1, 0, 0), + "axes.radius": 0.44, + "axes.impedance": 50, + "axes.normalize": True, + "axes.normalize.label": True, + "symbol.infinity": "∞ ", # BUG: symbol gets cut off without end-space + "symbol.infinity.correction": 8, + "symbol.ohm": "Ω"} + + @staticmethod + def update_scParams(sc_dict=None, instance=None, filter_dict=False, reset=True, **kwargs): + ''' + Method for updating the parameters of a SmithAxes instance. If no instance + is given, the changes are global, but affect only instances created + afterwards. Parameter can be passed as dictionary or keyword arguments. + If passed as keyword, the seperator '.' must be replaced with '_'. + + Note: Parameter changes are not always immediate (e.g. changes to the + grid). It is not recommended to modify parameter after adding anything to + the plot. For a reset call :meth:`cla`. + + Example: + update_scParams({grid.major: True}) + update_scParams(grid_major=True) + + Valid parameters with default values and description: + + plot.zorder: 5 + Zorder of plotted lines. + Accepts: integer + + plot.marker.hack: True + Enables the replacement of start and endmarkers. + Accepts: boolean + Note: Uses ugly code injection and may causes unexpected behavior. + + plot.marker.rotate: True + Rotates the endmarker in the direction of its line. + Accepts: boolean + Note: needs plot.marker.hack=True + + plot.marker.start: 's', + Marker for the first point of a line, if it has more than 1 point. + Accepts: None or see matplotlib.markers.MarkerStyle() + Note: needs plot.marker.hack=True + + plot.marker.default: 'o' + Marker used for linepoints. + Accepts: None or see matplotlib.markers.MarkerStyle() + + plot.marker.end: '^', + Marker for the last point of a line, if it has more than 1 point. + Accepts: None or see matplotlib.markers.MarkerStyle() + Note: needs plot.marker.hack=True + + plot.default.interpolation: 5 + Default number of interpolated steps between two points of a + line, if interpolation is used. + Accepts: integer + + plot.default.datatype: SmithAxes.S_PARAMETER + Default datatype for plots. + Accepts: SmithAxes.[S_PARAMETER,Z_PARAMETER,Y_PARAMETER] + + grid.zorder : 1 + Zorder of the gridlines. + Accepts: integer + Note: may not work as expected + + grid.locator.precision: 2 + Sets the number of significant decimals per decade for the + Real and Imag MaxNLocators. Example with precision 2: + 1.12 -> 1.1, 22.5 -> 22, 135 -> 130, ... + Accepts: integer + Note: value is an orientation, several exceptions are implemented + + grid.major.enable: True + Enables the major grid. + Accepts: boolean + + grid.major.linestyle: 'solid' + Major gridline style. + Accepts: see matplotlib.patches.Patch.set_linestyle() + + grid.major.linewidth: 1 + Major gridline width. + Accepts: float + + grid.major.color: '0.2' + Major gridline color. + Accepts: matplotlib color + + grid.major.xmaxn: 10 + Maximum number of spacing steps for the real axis. + Accepts: integer + + grid.major.ymaxn: 16 + Maximum number of spacing steps for the imaginary axis. + Accepts: integer + + grid.major.fancy: True + Draws a fancy major grid instead of the standard one. + Accepts: boolean + + grid.major.fancy.threshold: (100, 50) + Minimum distance times 1000 between two gridlines relative to + total plot size 2x2. Either tuple for individual real and + imaginary distances or single value for both. + Accepts: (float, float) or float + + grid.minor.enable: True + Enables the minor grid. + Accepts: boolean + + grid.minor.capstyle: 'round' + Minor dashes capstyle + Accepts: 'round', 'butt', 'miter', 'projecting' + + grid.minor.dashes: (0.2, 2) + Minor gridline dash style. + Accepts: tuple + + grid.minor.linewidth: 0.75 + Minor gridline width. + Accepts: float + + grid.minor.color: 0.4 + Minor gridline color. + Accepts: matplotlib color + + grid.minor.xauto: 4 + Maximum number of spacing steps for the real axis. + Accepts: integer + + grid.minor.yauto: 4 + Maximum number of spacing steps for the imaginary axis. + Accepts: integer + + grid.minor.fancy: True + Draws a fancy minor grid instead the standard one. + Accepts: boolean + + grid.minor.fancy.dividers: [1, 2, 3, 5, 10, 20] + Divisions for the fancy minor grid, which are selected by + comparing the distance of gridlines with the threshold value. + Accepts: list of integers + + grid.minor.fancy.threshold: 25 + Minimum distance for using the next bigger divider. Value times + 1000 relative to total plot size 2. + Accepts: float + + axes.xlabel.rotation: 90 + Rotation of the real axis labels in degree. + Accepts: float + + axes.xlabel.fancybox: {"boxstyle": "round4,pad=0.3,rounding_size=0.2", + "facecolor": 'w', + "edgecolor": "w", + "mutation_aspect": 0.75, + "alpha": 1}, + FancyBboxPatch parameters for the x-label background box. + Accepts: dictionary with rectprops + + axes.ylabel.correction: (-1, 0, 0) + Correction in x, y, and radial direction for the labels of the imaginary axis. + Usually needs to be adapted when fontsize changes 'font.size'. + Accepts: (float, float, float) + + axes.radius: 0.44 + Radius of the plotting area. Usually needs to be adapted to + the size of the figure. + Accepts: float + + axes.impedance: 50 + Defines the reference impedance for normalisation. + Accepts: float + + axes.normalize: True + If True, the Smith Chart is normalized to the reference impedance. + Accepts: boolean + + axes.normalize.label: True + If 'axes.normalize' and True, a textbox with 'Z_0: ... Ohm' is put in + the lower left corner. + Accepts: boolean + + symbol.infinity: "∞ " + Symbol string for infinity. + Accepts: string + + Note: Without the trailing space the label might get cut off. + + symbol.infinity.correction: 8 + Correction of size for the infinity symbol, because normal symbol + seems smaller than other letters. + Accepts: float + + symbol.ohm "Ω" + Symbol string for the resistance unit (usually a large Omega). + Accepts: string + + Note: The keywords are processed after the dictionary and override + possible double entries. + ''' + scParams = SmithAxes.scDefaultParams if instance is None else instance.scParams + + if sc_dict is not None: + for key, value in sc_dict.items(): + if key in scParams: + scParams[key] = value + else: + raise KeyError("key '%s' is not in scParams" % key) + + remaining = kwargs.copy() + for key in kwargs: + key_dot = key.replace("_", ".") + if key_dot in scParams: + scParams[key_dot] = remaining.pop(key) + + if not filter_dict and len(remaining) > 0: + raise KeyError("Following keys are invalid SmithAxes parameters: '%s'" % ",".join(remaining.keys())) + + if reset and instance is not None: + instance.cla() + + if filter_dict: + return remaining + + def __init__(self, *args, **kwargs): + ''' + Builds a new :class:`SmithAxes` instance. For futher details see: + + :meth:`update_scParams` + :class:`matplotlib.axes.Axes` + ''' + # define new class attributes + self._majorarcs = None + self._minorarcs = None + self._impedance = None + self._normalize = None + self._current_zorder = None + self.scParams = self.scDefaultParams.copy() + + # seperate Axes parameter + Axes.__init__(self, *args, **SmithAxes.update_scParams(instance=self, filter_dict=True, reset=False, **kwargs)) + self.set_aspect(1, adjustable='box', anchor='C') + + # remove all ticks + self.tick_params(axis="both", which="both", bottom=False, top=False, left=False, right=False) + + def _get_key(self, key): + ''' + Get a key from the local parameter dictionary or from global + matplotlib rcParams. + + Keyword arguments: + + *key*: + Key to get from scParams or matplotlib.rcParams + Accepts: string + + Returns: + + *value*: + Value got from scParams or rcParams with key + ''' + if key in self.scParams: + return self.scParams[key] + elif key in mp.rcParams: + return mp.rcParams[key] + else: + raise KeyError("%s is not a valid key" % key) + + def _init_axis(self): + self.xaxis = mp.axis.XAxis(self) + self.yaxis = mp.axis.YAxis(self) + self._update_transScale() + + def cla(self): + self._majorarcs = [] + self._minorarcs = [] + + # deactivate grid function when calling base class + tgrid = self.grid + + def dummy(*args, **kwargs): + pass + + self.grid = dummy + # Don't forget to call the base class + Axes.cla(self) + self.grid = tgrid + + self._normbox = None + self._impedance = self._get_key("axes.impedance") + self._normalize = self._get_key("axes.normalize") + self._current_zorder = self._get_key("plot.zorder") + + self.xaxis.set_major_locator(self.RealMaxNLocator(self, self._get_key("grid.major.xmaxn"))) + self.yaxis.set_major_locator(self.ImagMaxNLocator(self, self._get_key("grid.major.ymaxn"))) + + self.xaxis.set_minor_locator(self.SmithAutoMinorLocator(self._get_key("grid.minor.xauto"))) + self.yaxis.set_minor_locator(self.SmithAutoMinorLocator(self._get_key("grid.minor.yauto"))) + + self.xaxis.set_ticks_position('none') + self.yaxis.set_ticks_position('none') + + Axes.set_xlim(self, 0, self._ax_lim_x) + Axes.set_ylim(self, -self._ax_lim_y, self._ax_lim_y) + + for label in self.get_xticklabels(): + label.set_verticalalignment("center") + label.set_horizontalalignment('center') + label.set_rotation_mode("anchor") + label.set_rotation(self._get_key("axes.xlabel.rotation")) + label.set_bbox(self._get_key("axes.xlabel.fancybox")) + self.add_artist(label) # if not readded, labels are drawn behind grid + + for tick, loc in zip(self.yaxis.get_major_ticks(), + self.yaxis.get_majorticklocs()): + # workaround for fixing to small infinity symbol + if abs(loc) > self._near_inf: + tick.label.set_size(tick.label.get_size() + + self._get_key("symbol.infinity.correction")) + + tick.label.set_verticalalignment('center') + + x = np.real(self._moebius_z(loc * 1j)) + if x < -0.1: + tick.label.set_horizontalalignment('right') + elif x > 0.1: + tick.label.set_horizontalalignment('left') + else: + tick.label.set_horizontalalignment('center') + + self.yaxis.set_major_formatter(self.ImagFormatter(self)) + self.xaxis.set_major_formatter(self.RealFormatter(self)) + + if self._get_key("axes.normalize") and self._get_key("axes.normalize.label"): + x, y = z_to_xy(self._moebius_inv_z(-1 - 1j)) + box = self.text(x, y, "Z$_\mathrm{0}$ = %d$\,$%s" % (self._impedance, self._get_key("symbol.ohm")), ha="left", va="bottom") + + px = self._get_key("ytick.major.pad") + py = px + 0.5 * box.get_size() + box.set_transform(self._yaxis_correction + Affine2D().translate(-px, -py)) + + for grid in ['major', "minor"]: + self.grid(b=self._get_key("grid.%s.enable" % grid), which=grid) + + def _set_lim_and_transforms(self): + r = self._get_key("axes.radius") + self.transProjection = self.MoebiusTransform(self) # data space -> moebius space + self.transAffine = Affine2D().scale(r, r).translate(0.5, 0.5) # moebius space -> axes space + self.transDataToAxes = self.transProjection + self.transAffine + self.transAxes = BboxTransformTo(self.bbox) # axes space -> drawing space + self.transMoebius = self.transAffine + self.transAxes + self.transData = self.transProjection + self.transMoebius + + self._xaxis_pretransform = Affine2D().scale(1, 2 * self._ax_lim_y).translate(0, -self._ax_lim_y) + self._xaxis_transform = self._xaxis_pretransform + self.transData + self._xaxis_text1_transform = Affine2D().scale(1.0, 0.0) + self.transData + + self._yaxis_stretch = Affine2D().scale(self._ax_lim_x, 1.0) + self._yaxis_correction = self.transData + Affine2D().translate(*self._get_key("axes.ylabel.correction")[:2]) + self._yaxis_transform = self._yaxis_stretch + self.transData + self._yaxis_text1_transform = self._yaxis_stretch + self._yaxis_correction + + def get_xaxis_transform(self, which='grid'): + assert which in ['tick1', 'tick2', 'grid'] + return self._xaxis_transform + + def get_xaxis_text1_transform(self, pixelPad): + return self._xaxis_text1_transform, 'center', 'center' + + def get_yaxis_transform(self, which='grid'): + assert which in ['tick1', 'tick2', 'grid'] + return self._yaxis_transform + + def get_yaxis_text1_transform(self, pixelPad): + if hasattr(self, 'yaxis') and len(self.yaxis.majorTicks) > 0: + font_size = self.yaxis.majorTicks[0].label.get_size() + else: + font_size = self._get_key("font.size") + + offset = self._get_key("axes.ylabel.correction")[2] + return self._yaxis_text1_transform + self.PolarTranslate(self, pad=pixelPad + offset, font_size=font_size), 'center', 'center' + + def _gen_axes_patch(self): + return Circle((0.5, 0.5), self._get_key("axes.radius") + 0.015) + + def _gen_axes_spines(self, locations=None, offset=0.0, units='inches'): + return {SmithAxes.name: Spine.circular_spine(self, (0.5, 0.5), self._get_key("axes.radius"))} + + def set_xscale(self, *args, **kwargs): + if args[0] != 'linear': + raise NotImplementedError() + Axes.set_xscale(self, *args, **kwargs) + + def set_yscale(self, *args, **kwargs): + if args[0] != 'linear': + raise NotImplementedError() + Axes.set_yscale(self, *args, **kwargs) + + def set_xlim(self, *args, **kwargs): + '''xlim is immutable and always set to (0, infinity)''' + Axes.set_xlim(self, 0, self._ax_lim_x) + + def set_ylim(self, *args, **kwargs): + '''ylim is immutable and always set to (-infinity, infinity)''' + Axes.set_ylim(self, -self._ax_lim_y, self._ax_lim_y) + + def format_coord(self, re, im): + sgn = "+" if im > 0 else "-" + return "%.5f %s %.5fj" % (re, sgn, abs(im)) if re > 0 else "" + + def get_data_ratio(self): + return 1.0 + + # disable panning and zoom in matplotlib figure viewer + def can_zoom(self): + return False + + def start_pan(self, x, y, button): + pass + + def end_pan(self): + pass + + def drag_pan(self, button, key, x, y): + pass + + def _moebius_z(self, *args, normalize=None): + ''' + Basic transformation. + + Arguments: + + *z*: + Complex number or numpy.ndarray with dtype=complex + + *x, y*: + Float numbers or numpy.ndarray's with dtype not complex + + *normalize*: + If True, the values are normalized to self._impedance. + If None, self._normalize determines behaviour. + Accepts: boolean or None + + Returns: + + *w*: + Performs w = (z - k) / (z + k) with k = 'axes.scale' + Type: Complex number or numpy.ndarray with dtype=complex + ''' + normalize = self._normalize if normalize is None else normalize + norm = 1 if normalize else self._impedance + return smithhelper.moebius_z(*args, norm=norm) + + def _moebius_inv_z(self, *args, normalize=None): + ''' + Basic inverse transformation. + + Arguments: + + *z*: + Complex number or numpy.ndarray with dtype=complex + + *x, y*: + Float numbers or numpy.ndarray's with dtype not complex + + *normalize*: + If True, the values are normalized to self._impedance. + If None, self._normalize determines behaviour. + Accepts: boolean or None + + Returns: + + *w*: + Performs w = k * (1 - z) / (1 + z) with k = 'axes.scale' + Type: Complex number or numpy.ndarray with dtype=complex + ''' + normalize = self._normalize if normalize is None else normalize + norm = 1 if normalize else self._impedance + return smithhelper.moebius_inv_z(*args, norm=norm) + + def real_interp1d(self, x, steps): + ''' + Interpolates the given vector as real numbers in the way, that they + are evenly spaced after a transformation with imaginary part 0. + + Keyword Arguments + + *x*: + Real values to interpolate. + Accepts: 1D iterable (e.g. list or numpy.ndarray) + + *steps*: + Number of steps between two points. + Accepts: integer + ''' + return self._moebius_inv_z(linear_interpolation(self._moebius_z(np.array(x)), steps)) + + def imag_interp1d(self, y, steps): + ''' + Interpolates the given vector as imaginary numbers in the way, that + they are evenly spaced after a transformation with real part 0. + + Keyword Arguments + + *y*: + Imaginary values to interpolate. + Accepts: 1D iterable (e.g. list or numpy.ndarray) + + *steps*: + Number of steps between two points. + Accepts: integer + ''' + angs = np.angle(self._moebius_z(np.array(y) * 1j)) % TWO_PI + i_angs = linear_interpolation(angs, steps) + return np.imag(self._moebius_inv_z(ang_to_c(i_angs))) + + def legend(self, *args, **kwargs): + this_axes = self + + class SmithHandlerLine2D(HandlerLine2D): + def create_artists(self, legend, orig_handle, + xdescent, ydescent, width, height, fontsize, + trans): + legline, legline_marker = HandlerLine2D.create_artists(self, legend, orig_handle, xdescent, ydescent, + width, height, fontsize, trans) + + if hasattr(orig_handle, "_markerhacked"): + this_axes._hack_linedraw(legline_marker, True) + return legline, legline_marker + + return Axes.legend(self, *args, handler_map={Line2D: SmithHandlerLine2D()}, **kwargs) + + def plot(self, *args, **kwargs): + ''' + Plot the given data into the Smith Chart. Behavior similar to basic + :meth:`matplotlib.axes.Axes.plot`, but with some extensions: + + - Additional support for real and complex data. Complex values must be + either of type 'complex' or a numpy.ndarray with dtype=complex. + - If 'zorder' is not provided, the current default value is used. + - If 'marker' is not providet, the default value is used. + - Extra keywords are added. + + Extra keyword arguments: + + *datatype*: + Specifies the input data format. Must be either 'S', 'Z' or 'Y'. + Accepts: SmithAxes.[S_PARAMETER,Z_PARAMETER,Y_PARAMETER] + Default: 'plot.default.datatype' + + *markerhack*: + If set, activates the manipulation of start and end markern + of the created line. + Accepts: boolean + Default: 'plot.marker.hack' + + *rotate_marker*: + If *markerhack* is active, rotates the endmarker in direction + of the corresponding path. + Accepts: boolean + Default: 'plot.rotatemarker' + + *interpolate*: + If 'value' >0 the given data is interpolated linearly by 'value' + steps in SmithAxes cooardinate space. 'markevery', if specified, + will be modified accordingly. If 'True' the 'plot.default_intperpolation' + value is used. + Accepts: boolean or integer + Default: False + + *equipoints*: + If 'value' >0 the given data is interpolated linearly by equidistant + steps in SmithAxes cooardinate space. Cannot be used with 'interpolate' + enabled. + Accepts: boolean + Default: False + + + + See :meth:`matplotlib.axes.Axes.plot` for mor details + ''' + # split input into real and imaginary part if complex + new_args = () + for arg in args: + # check if argument is a string or already an ndarray + # if not, try to convert to an ndarray + if not (isinstance(arg, str) or isinstance(arg, np.ndarray)): + try: + if isinstance(arg, Iterable): + arg = np.array(arg) + elif isinstance(arg, Number): + arg = np.array([arg]) + except TypeError: + pass + + # if (converted) arg is an ndarray of complex type, split it + if isinstance(arg, np.ndarray) and arg.dtype in [np.complex, np.complex128]: + new_args += z_to_xy(arg) + else: + new_args += (arg,) + + # ensure newer plots are above older ones + if 'zorder' not in kwargs: + kwargs['zorder'] = self._current_zorder + self._current_zorder += 0.001 + + # extract or load non-matplotlib keyword arguments from parameters + kwargs.setdefault("marker", self._get_key("plot.marker.default")) + interpolate = kwargs.pop("interpolate", False) + equipoints = kwargs.pop("equipoints", False) + datatype = kwargs.pop("datatype", self._get_key("plot.default.datatype")) + markerhack = kwargs.pop("markerhack", self._get_key("plot.marker.hack")) + rotate_marker = kwargs.pop("rotate_marker", self._get_key("plot.marker.rotate")) + + if datatype not in self._datatypes: + raise ValueError("'datatype' must be either '%s'" % ",".join(self._datatypes)) + + if interpolate is not False: + if equipoints > 0: + raise ValueError("Interpolation is not available with equidistant markers") + + if interpolate is True: + interpolate = self._get_key("plot.default.interpolation") + elif interpolate < 0: + raise ValueError("Interpolation is only for positive values possible!") + + if "markevery" in kwargs: + mark = kwargs["markevery"] + if isinstance(mark, Iterable): + mark = np.asarray(mark) * (interpolate + 1) + else: + mark *= interpolate + 1 + kwargs["markevery"] = mark + + lines = Axes.plot(self, *new_args, **kwargs) + for line in lines: + cdata = smithhelper.xy_to_z(line.get_data()) + + if datatype == SmithAxes.S_PARAMETER: + z = self._moebius_inv_z(cdata) + elif datatype == SmithAxes.Y_PARAMETER: + z = 1 / cdata + elif datatype == SmithAxes.Z_PARAMETER: + z = cdata + else: + raise ValueError("'datatype' must be '%s', '%s' or '%s'" % (SmithAxes.S_PARAMETER, SmithAxes.Z_PARAMETER, SmithAxes.Y_PARAMETER)) + + if self._normalize and datatype != SmithAxes.S_PARAMETER: + z /= self._impedance + + line.set_data(z_to_xy(z)) + + if interpolate or equipoints: + z = self._moebius_z(*line.get_data()) + if len(z) > 1: + spline, t0 = fitpack.splprep(z_to_xy(z), s=0) + ilen = (interpolate + 1) * (len(t0) - 1) + 1 + if equipoints == 1: + t = np.linspace(0, 1, ilen) + elif equipoints > 1: + t = np.linspace(0, 1, equipoints) + else: + t = np.zeros(ilen) + t[0], t[1:] = t0[0], np.concatenate([np.linspace(i0, i1, interpolate + 2)[1:] for i0, i1 in zip(t0[:-1], t0[1:])]) + + z = self._moebius_inv_z(*fitpack.splev(t, spline)) + line.set_data(z_to_xy(z)) + + if markerhack: + self._hack_linedraw(line, rotate_marker) + + return lines + + def grid(self, + b=None, + which='major', + fancy=None, + dividers=None, + threshold=None, + **kwargs): + ''' + Complete rewritten grid function. Gridlines are replaced with Arcs, + which reduces the amount of points to store and increases speed. The + grid consist of a minor and major part, which can be drawn either as + standard with lines from axis to axis, or fancy with dynamic spacing + and length adaption. + + Keyword arguments: + + *b*: + Enables or disables the selected grid. + Accepts: boolean + + *which*: + The grid to be drawn. + Accepts: ['major', 'minor', 'both'] + + *axis*: + The axis to be drawn. x=real and y=imaginary + Accepts: ['x', 'y', 'both'] + Note: if fancy is set, only 'both' is valid + + *fancy*: + If set to 'True', draws the grid on the fancy way. + Accepts: boolean + + *dividers*: + Adaptive divisions for the minor fancy grid. + Accepts: array with integers + Note: has no effect on major and non-fancy grid + + *threshold*: + Threshold for dynamic adaption of spacing and line length. Can + be specified for both axis together or each seperatly. + Accepts: float or (float, float) + + **kwargs*: + Keyword arguments passed to the gridline creator. + Note: Gridlines are :class:`matplotlib.patches.Patch` and does + not accept all arguments :class:`matplotlib.lines.Line2D` + accepts. + ''' + assert which in ["both", "major", "minor"] + assert fancy in [None, False, True] + + def get_kwargs(grid): + kw = kwargs.copy() + kw.setdefault('zorder', self._get_key("grid.zorder")) + kw.setdefault("alpha", self._get_key("grid.alpha")) + + for key in ["linestyle", "linewidth", "color"]: + if grid == "minor" and key == "linestyle": + if "linestyle" not in kw: + kw.setdefault("dash_capstyle", self._get_key("grid.minor.capstyle")) + kw.setdefault("dashes", self._get_key("grid.minor.dashes")) + else: + kw.setdefault(key, self._get_key("grid.%s.%s" % (grid, key))) + + return kw + + def check_fancy(yticks): + # checks if the imaginary axis is symetric + len_y = (len(yticks) - 1) // 2 + if not (len(yticks) % 2 == 1 and (yticks[len_y:] + yticks[len_y::-1] < EPSILON).all()): + raise ValueError( + "fancy minor grid is only supported for zero-symetric imaginary grid - e.g. ImagMaxNLocator") + return yticks[len_y:] + + def split_threshold(threshold): + if isinstance(threshold, tuple): + thr_x, thr_y = threshold + else: + thr_x = thr_y = threshold + + assert thr_x > 0 and thr_y > 0 + + return thr_x / 1000, thr_y / 1000 + + def add_arc(ps, p0, p1, grid, type): + assert grid in ["major", "minor"] + assert type in ["real", "imag"] + assert p0 != p1 + arcs = self._majorarcs if grid == "major" else self._minorarcs + if grid == "minor": + param["zorder"] -= 1e-9 + arcs.append((type, (ps, p0, p1), self._add_gridline(ps, p0, p1, type, **param))) + + def draw_nonfancy(grid): + if grid == "major": + xticks = self.xaxis.get_majorticklocs() + yticks = self.yaxis.get_majorticklocs() + else: + xticks = self.xaxis.get_minorticklocs() + yticks = self.yaxis.get_minorticklocs() + + xticks = np.round(xticks, 7) + yticks = np.round(yticks, 7) + + for xs in xticks: + if xs < self._near_inf: + add_arc(xs, -self._near_inf, self._inf, grid, "real") + + for ys in yticks: + if abs(ys) < self._near_inf: + add_arc(ys, 0, self._inf, grid, "imag") + + # set fancy parameters + if fancy is None: + fancy_major = self._get_key("grid.major.fancy") + fancy_minor = self._get_key("grid.minor.fancy") + else: + fancy_major = fancy_minor = fancy + + # check parameters + if "axis" in kwargs and kwargs["axis"] != "both": + raise ValueError("Only 'both' is a supported value for 'axis'") + + # plot major grid + if which in ['both', 'major']: + for _, _, arc in self._majorarcs: + arc.remove() + self._majorarcs = [] + + if b: + param = get_kwargs('major') + if fancy_major: + xticks = np.sort(self.xaxis.get_majorticklocs()) + yticks = np.sort(self.yaxis.get_majorticklocs()) + assert len(xticks) > 0 and len(yticks) > 0 + yticks = check_fancy(yticks) + + if threshold is None: + threshold = self._get_key("grid.major.fancy.threshold") + + thr_x, thr_y = split_threshold(threshold) + + # draw the 0 line + add_arc(yticks[0], 0, self._inf, "major", "imag") + + tmp_yticks = yticks.copy() + for xs in xticks: + k = 1 + while k < len(tmp_yticks): + y0, y1 = tmp_yticks[k - 1:k + 1] + if abs(self._moebius_z(xs, y0) - self._moebius_z(xs, y1)) < thr_x: + add_arc(y1, 0, xs, "major", "imag") + add_arc(-y1, 0, xs, "major", "imag") + tmp_yticks = np.delete(tmp_yticks, k) + else: + k += 1 + + for i in range(1, len(yticks)): + y0, y1 = yticks[i - 1:i + 1] + k = 1 + while k < len(xticks): + x0, x1 = xticks[k - 1:k + 1] + if abs(self._moebius_z(x0, y1) - self._moebius_z(x1, y1)) < thr_y: + add_arc(x1, -y0, y0, "major", "real") + xticks = np.delete(xticks, k) + else: + k += 1 + else: + draw_nonfancy("major") + + # plot minor grid + if which in ['both', 'minor']: + # remove the old grid + for _, _, arc in self._minorarcs: + arc.remove() + self._minorarcs = [] + + if b: + param = get_kwargs("minor") + + if fancy_minor: + # 1. Step: get x/y grid data + xticks = np.sort(self.xaxis.get_majorticklocs()) + yticks = np.sort(self.yaxis.get_majorticklocs()) + assert len(xticks) > 0 and len(yticks) > 0 + yticks = check_fancy(yticks) + + if dividers is None: + dividers = self._get_key("grid.minor.fancy.dividers") + assert len(dividers) > 0 + dividers = np.sort(dividers) + + if threshold is None: + threshold = self._get_key("grid.minor.fancy.threshold") + + thr_x, thr_y = split_threshold(threshold) + len_x, len_y = len(xticks) - 1, len(yticks) - 1 + + # 2. Step: calculate optimal gridspacing for each quadrant + d_mat = np.ones((len_x, len_y, 2)) + + # TODO: optimize spacing algorithm + for i in range(len_x): + for k in range(len_y): + x0, x1 = xticks[i:i + 2] + y0, y1 = yticks[k:k + 2] + + xm = self.real_interp1d([x0, x1], 2)[1] + ym = self.imag_interp1d([y0, y1], 2)[1] + + x_div = y_div = dividers[0] + + for div in dividers[1:]: + if abs(self._moebius_z(x1 - (x1 - x0) / div, ym) - self._moebius_z(x1, ym)) > thr_x: + x_div = div + else: + break + + for div in dividers[1:]: + if abs(self._moebius_z(xm, y1) - self._moebius_z(xm, y1 - (y1 - y0) / div)) > thr_y: + y_div = div + else: + break + + d_mat[i, k] = [x_div, y_div] + + # 3. Steps: optimize spacing + # ensure the x-spacing declines towards infinity + d_mat[:-1, 0, 0] = list(map(np.max, zip(d_mat[:-1, 0, 0], d_mat[1:, 0, 0]))) + + # find the values which are near (0, 0.5) on the plot + idx = np.searchsorted(xticks, self._moebius_inv_z(0)) + 1 + idy = np.searchsorted(yticks, self._moebius_inv_z(1j).imag) + + # extend the values around the center towards the border + if idx > idy: + for d in range(idy): + delta = idx - idy + d + d_mat[delta, :d + 1] = d_mat[:delta, d] = d_mat[delta, 0] + else: + for d in range(idx): + delta = idy - idx + d + d_mat[:d + 1, delta] = d_mat[d, :delta] = d_mat[d, 0] + + # 4. Step: gather and optimize the lines + x_lines, y_lines = [], [] + + for i in range(len_x): + x0, x1 = xticks[i:i + 2] + + for k in range(len_y): + y0, y1 = yticks[k:k + 2] + + x_div, y_div = d_mat[i, k] + + for xs in np.linspace(x0, x1, x_div + 1)[1:]: + x_lines.append([xs, y0, y1]) + x_lines.append([xs, -y1, -y0]) + + for ys in np.linspace(y0, y1, y_div + 1)[1:]: + y_lines.append([ys, x0, x1]) + y_lines.append([-ys, x0, x1]) + + # round values to prevent float inaccuarcy + x_lines = np.round(np.array(x_lines), 7) + y_lines = np.round(np.array(y_lines), 7) + + # remove lines which overlap with the major grid + for tp, lines in [("real", x_lines), ("imag", y_lines)]: + for i in range(len(lines)): + ps, p0, p1 = lines[i] + if p0 > p1: + p0, p1 = p1, p0 + + for tq, (qs, q0, q1), _ in self._majorarcs: + if tp == tq and abs(ps - qs) < EPSILON and p1 > q0 and p0 < q1: + lines[i, :] = np.nan + break + + lines = lines[~np.isnan(lines[:, 0])] + lines = lines[np.lexsort(lines[:, 1::-1].transpose())] + + ps, p0, p1 = lines[0] + for qs, q0, q1 in lines[1:]: + if ps != qs or p1 != q0: + add_arc(ps, p0, p1, "minor", tp) + ps, p0, p1 = qs, q0, q1 + else: + p1 = q1 + + else: + draw_nonfancy("minor") + + def _hack_linedraw(self, line, rotate_marker=None): + ''' + Modifies the draw method of a :class:`matplotlib.lines.Line2D` object + to draw different stard and end marker. + + Keyword arguments: + + *line*: + Line to be modified + Accepts: Line2D + + *rotate_marker*: + If set, the end marker will be rotated in direction of their + corresponding path. + Accepts: boolean + ''' + assert isinstance(line, Line2D) + + def new_draw(self_line, renderer): + def new_draw_markers(self_renderer, gc, marker_path, marker_trans, path, trans, rgbFace=None): + # get the drawn path for determining the rotation angle + line_vertices = self_line._get_transformed_path().get_fully_transformed_path().vertices + vertices = path.vertices + + if len(vertices) == 1: + line_set = [[default_marker, vertices]] + else: + if rotate_marker: + dx, dy = np.array(line_vertices[-1]) - np.array(line_vertices[-2]) + end_rot = MarkerStyle(end.get_marker()) + end_rot._transform += Affine2D().rotate(np.arctan2(dy, dx) - np.pi / 2) + else: + end_rot = end + + if len(vertices) == 2: + line_set = [[start, vertices[0:1]], [end_rot, vertices[1:2]]] + else: + line_set = [[start, vertices[0:1]], [default_marker, vertices[1:-1]], [end_rot, vertices[-1:]]] + + for marker, points in line_set: + transform = marker.get_transform() + Affine2D().scale(self_line._markersize) + old_draw_markers(gc, marker.get_path(), transform, Path(points), trans, rgbFace) + + old_draw_markers = renderer.draw_markers + renderer.draw_markers = MethodType(new_draw_markers, renderer) + old_draw(renderer) + renderer.draw_markers = old_draw_markers + + default_marker = line._marker + # check if marker is set and visible + if default_marker: + start = MarkerStyle(self._get_key("plot.marker.start")) + if start.get_marker() is None: + start = default_marker + + end = MarkerStyle(self._get_key("plot.marker.end")) + if end.get_marker() is None: + end = default_marker + + if rotate_marker is None: + rotate_marker = self._get_key("plot.marker.rotate") + + old_draw = line.draw + line.draw = MethodType(new_draw, line) + line._markerhacked = True + + def _add_gridline(self, ps, p0, p1, type, **kwargs): + ''' + Add a gridline for a real axis circle. + + Keyword arguments: + + *ps*: + Axis value + Accepts: float + + *p0*: + Start point + Accepts: float + + *p1*: + End Point + Accepts: float + + **kwargs*: + Keywords passed to the arc creator + ''' + assert type in ["real", "imag"] + + if type == "real": + assert ps >= 0 + + line = Line2D(2 * [ps], [p0, p1], **kwargs) + line.get_path()._interpolation_steps = "x_gridline" + else: + assert 0 <= p0 < p1 + + line = Line2D([p0, p1], 2 * [ps], **kwargs) + + if abs(ps) > EPSILON: + line.get_path()._interpolation_steps = "y_gridline" + + return self.add_artist(line) + + class MoebiusTransform(Transform): + ''' + Class for transforming points and paths to Smith Chart data space. + ''' + input_dims = 2 + output_dims = 2 + is_separable = False + + def __init__(self, axes): + assert isinstance(axes, SmithAxes) + Transform.__init__(self) + self._axes = axes + + def transform_non_affine(self, data): + def _moebius_xy(_xy): + return z_to_xy(self._axes._moebius_z(*_xy)) + + if isinstance(data[0], Iterable): + return list(map(_moebius_xy, data)) + else: + return _moebius_xy(data) + + def transform_path_non_affine(self, path): + vertices = path.vertices + codes = path.codes + + linetype = path._interpolation_steps + if linetype in ["x_gridline", "y_gridline"]: + assert len(vertices) == 2 + + x, y = np.array(list(zip(*vertices))) + z = self._axes._moebius_z(x, y) + + if linetype == "x_gridline": + assert x[0] == x[1] + zm = 0.5 * (1 + self._axes._moebius_z(x[0])) + else: + assert y[0] == y[1] + scale = 1j * (1 if self._axes._normalize else self._axes._impedance) + zm = 1 + scale / y[0] + + d = 2 * abs(zm - 1) + ang0, ang1 = np.angle(z - zm, deg=True) % 360 + + reverse = ang0 > ang1 + if reverse: + ang0, ang1 = ang1, ang0 + + arc = Arc(z_to_xy(zm), d, d, theta1=ang0, theta2=ang1, transform=self._axes.transMoebius) + arc._path = Path.arc(ang0, ang1) # fix for Matplotlib 2.1+ + arc_path = arc.get_patch_transform().transform_path(arc.get_path()) + + if reverse: + new_vertices = arc_path.vertices[::-1] + else: + new_vertices = arc_path.vertices + + new_codes = arc_path.codes + elif linetype == 1: + new_vertices = self.transform_non_affine(vertices) + new_codes = codes + else: + raise NotImplementedError("Value for 'path_interpolation' cannot be interpreted.") + + return Path(new_vertices, new_codes) + + def inverted(self): + return SmithAxes.InvertedMoebiusTransform(self._axes) + + class InvertedMoebiusTransform(Transform): + ''' + Inverse transformation for points and paths in Smith Chart data space. + ''' + input_dims = 2 + output_dims = 2 + is_separable = False + + def __init__(self, axes): + assert isinstance(axes, SmithAxes) + Transform.__init__(self) + self._axes = axes + + def transform_non_affine(self, data): + def _moebius_inv_xy(_xy): + return z_to_xy(self._axes._moebius_inv_z(*_xy)) + + return list(map(_moebius_inv_xy, data)) + + def inverted(self): + return SmithAxes.MoebiusTransform(self._axes) + + class PolarTranslate(Transform): + ''' + Transformation for translating points away from the center by a given + padding. + + Keyword arguments: + + *axes*: + Parent :class:`SmithAxes` + Accepts: SmithAxes instance + + *pad*: + Distance to translate away from center for x and y values. + + *font_size*: + y values are shiftet 0.5 * font_size further away. + ''' + input_dims = 2 + output_dims = 2 + is_separable = False + + def __init__(self, axes, pad, font_size): + Transform.__init__(self, shorthand_name=None) + self.axes = axes + self.pad = pad + self.font_size = font_size + + def transform_non_affine(self, xy): + def _translate(_xy): + x, y = _xy + ang = np.angle(complex(x - x0, y - y0)) + return x + np.cos(ang) * self.pad, y + np.sin(ang) * (self.pad + 0.5 * self.font_size) + + x0, y0 = self.axes.transAxes.transform([0.5, 0.5]) + if isinstance(xy[0], Iterable): + return list(map(_translate, xy)) + else: + return _translate(xy) + + class RealMaxNLocator(Locator): + ''' + Locator for the real axis of a SmithAxes. Creates a nicely rounded + spacing with maximum n values. The transformed center value is + always included. + + Keyword arguments: + + *axes*: + Parent SmithAxes + Accepts: SmithAxes instance + + *n*: + Maximum number of divisions + Accepts: integer + + *precision*: + Maximum number of significant decimals + Accepts: integer + ''' + + def __init__(self, axes, n, precision=None): + assert isinstance(axes, SmithAxes) + assert n > 0 + + Locator.__init__(self) + self.steps = n + if precision is None: + self.precision = axes._get_key("grid.locator.precision") + else: + self.precision = precision + assert self.precision > 0 + + self.ticks = None + self.axes = axes + + def __call__(self): + if self.ticks is None: + self.ticks = self.tick_values(0, self.axes._inf) + return self.ticks + + def nice_round(self, num, down=True): + # normalize to 'precision' decimals befor comma + exp = np.ceil(np.log10(np.abs(num) + EPSILON)) + if exp < 1: # fix for leading 0 + exp += 1 + norm = 10 ** -(exp - self.precision) + + num_normed = num * norm + # increase precision by 0.5, if normed value is smaller than 1/3 + # of its decade range + if num_normed < 3.3: + norm *= 2 + # decrease precision by 1, if normed value is bigger than 1/2 + elif num_normed > 50: + norm /= 10 + + # select rounding function + if not 1 < num_normed % 10 < 9: + # round to nearest value, if last digit is 1 or 9 + if abs(num_normed % 10 - 1) < EPSILON: + num -= 0.5 / norm + f_round = np.round + else: + f_round = np.floor if down else np.ceil + + return f_round(np.round(num * norm, 1)) / norm + + def tick_values(self, vmin, vmax): + tmin, tmax = self.transform(vmin), self.transform(vmax) + mean = self.transform(self.nice_round(self.invert(0.5 * (tmin + tmax)))) + + result = [tmin, tmax, mean] + d0 = abs(tmin - tmax) / (self.steps + 1) + # calculate values above and below mean, adapt delta + for sgn, side, end in [[1, False, tmax], [-1, True, tmin]]: + d, d0 = d0, None + last = mean + while True: + new = last + d * sgn + if self.out_of_range(new) or abs(end - new) < d / 2: + break + + # round new value to the next nice display value + new = self.transform(self.nice_round(self.invert(new), side)) + d = abs(new - last) + if d0 is None: + d0 = d + + last = new + result.append(last) + + return np.sort(self.invert(np.array(result))) + + def out_of_range(self, x): + return abs(x) > 1 + + def transform(self, x): + return self.axes._moebius_z(x) + + def invert(self, x): + return self.axes._moebius_inv_z(x) + + class ImagMaxNLocator(RealMaxNLocator): + def __init__(self, axes, n, precision=None): + SmithAxes.RealMaxNLocator.__init__(self, axes, n // 2, precision) + + def __call__(self): + if self.ticks is None: + tmp = self.tick_values(0, self.axes._inf) + self.ticks = np.concatenate((-tmp[:0:-1], tmp)) + return self.ticks + + def out_of_range(self, x): + return not 0 <= x <= np.pi + + def transform(self, x): + return np.pi - np.angle(self.axes._moebius_z(x * 1j)) + + def invert(self, x): + return np.imag(-self.axes._moebius_inv_z(ang_to_c(np.pi + np.array(x)))) + + class SmithAutoMinorLocator(AutoMinorLocator): + ''' + AutoLocator for SmithAxes. Returns linear spaced intermediate ticks + depending on the major tickvalues. + + Keyword arguments: + + *n*: + Number of intermediate ticks + Accepts: positive integer + ''' + + def __init__(self, n=4): + assert isinstance(n, int) and n > 0 + AutoMinorLocator.__init__(self, n=n) + self._ticks = None + + def __call__(self): + if self._ticks is None: + locs = self.axis.get_majorticklocs() + self._ticks = np.concatenate( + [np.linspace(p0, p1, self.ndivs + 1)[1:-1] for (p0, p1) in zip(locs[:-1], locs[1:])]) + return self._ticks + + class RealFormatter(Formatter): + ''' + Formatter for the real axis of a SmithAxes. Prints the numbers as + float and removes trailing zeros and commata. Special returns: + '' for 0. + + Keyword arguments: + + *axes*: + Parent axes + Accepts: SmithAxes instance + ''' + + def __init__(self, axes, *args, **kwargs): + assert isinstance(axes, SmithAxes) + Formatter.__init__(self, *args, **kwargs) + self._axes = axes + + def __call__(self, x, pos=None): + if x < EPSILON or x > self._axes._near_inf: + return "" + else: + return ('%f' % x).rstrip('0').rstrip('.') + + class ImagFormatter(RealFormatter): + ''' + Formatter for the imaginary axis of a SmithAxes. Prints the numbers + as float and removes trailing zeros and commata. Special returns: + - '' for minus infinity + - 'symbol.infinity' from scParams for plus infinity + - '0' for value near zero (prevents -0) + + Keyword arguments: + + *axes*: + Parent axes + Accepts: SmithAxes instance + ''' + + def __call__(self, x, pos=None): + if x < -self._axes._near_inf: + return "" + elif x > self._axes._near_inf: + return self._axes._get_key("symbol.infinity") # utf8 infinity symbol + elif abs(x) < EPSILON: + return "0" + else: + return ("%f" % x).rstrip('0').rstrip('.') + "j" + + # update docstrings for all methode not set + for key, value in locals().copy().items(): + if isinstance(value, FunctionType): + if value.__doc__ is None and hasattr(Axes, key): + value.__doc__ = getattr(Axes, key).__doc__ + + +__author__ = "Paul Staerke" +__copyright__ = "Copyright 2018, Paul Staerke" +__license__ = "BSD" +__version__ = "0.3" +__maintainer__ = "Paul Staerke" +__email__ = "paul.staerke@gmail.com" +__status__ = "Prototype" diff --git a/pySmithPlot/smithplot/smithhelper.py b/pySmithPlot/smithplot/smithhelper.py new file mode 100644 index 0000000..cba2199 --- /dev/null +++ b/pySmithPlot/smithplot/smithhelper.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +# last edit: 11.04.2018 + +from collections import Iterable + +import numpy as np + +INF = 1e9 +EPSILON = 1e-7 +TWO_PI = 2 * np.pi + + +def xy_to_z(*xy): + if len(xy) == 1: + z = xy[0] + if isinstance(z, Iterable): + z = np.array(z) + if len(z.shape) == 2: + z = z[0] + 1j * z[1] + elif len(z.shape) > 2: + raise ValueError("Something went wrong!") + elif len(xy) == 2: + x, y = xy + if isinstance(x, Iterable): + if isinstance(y, Iterable) and len(x) == len(y): + z = np.array(x) + 1j * np.array(y) + else: + raise ValueError("x and y vectors dont match in type and/or size") + else: + z = x + 1j * y + else: + raise ValueError("Arguments are not valid - specify either complex number/vector z or real and imaginary number/vector x, y") + + return z + + +def z_to_xy(z): + return z.real, z.imag + + +def moebius_z(*args, norm): + z = xy_to_z(*args) + return 1 - 2 * norm / (z + norm) + + +def moebius_inv_z(*args, norm): + z = xy_to_z(*args) + return norm * (1 + z) / (1 - z) + + +def ang_to_c(ang, radius=1): + return radius * (np.cos(ang) + np.sin(ang) * 1j) + + +def lambda_to_rad(lmb): + return lmb * 4 * np.pi + + +def rad_to_lambda(rad): + return rad * 0.25 / np.pi diff --git a/pySmithPlot/testbenches/.gitignore b/pySmithPlot/testbenches/.gitignore new file mode 100644 index 0000000..de364bd --- /dev/null +++ b/pySmithPlot/testbenches/.gitignore @@ -0,0 +1,2 @@ +export.pdf + diff --git a/pySmithPlot/testbenches/data/s11.csv b/pySmithPlot/testbenches/data/s11.csv new file mode 100755 index 0000000..b0f3162 --- /dev/null +++ b/pySmithPlot/testbenches/data/s11.csv @@ -0,0 +1,1002 @@ +s11 X,s11 YRe,s11 YReImag +1000000,0.9999964469545679,-0.001884948887464419 +5999000,0.9998721489437459,-0.01130640128891323 +10998000,0.9995704213777186,-0.02072182633702082 +15997000,0.9990915861140683,-0.03012621253920016 +20996000,0.9984361533346766,-0.03951456800912641 +25995000,0.997604820188507,-0.0488819292828005 +30994000,0.9965984689415746,-0.05822337002897187 +35993000,0.9954181646432516,-0.06753400962199926 +40992000,0.9940651523203938,-0.0768090215461007 +45991000,0.9925408537130198,-0.08604364160100456 +50990000,0.9908468635674323,-0.09523317588025783 +55989000,0.9889849455046664,-0.1043730084948589 +60988000,0.9869570274840647,-0.1134586090164487 +65987000,0.9847651968834794,-0.1224855396160056 +70986000,0.9824116952191906,-0.1314494618758183 +75985000,0.979898912530023,-0.1403461432544592 +80984000,0.9772293814513637,-0.1491714631865103 +85983000,0.9744057710058132,-0.1579214188009033 +90982000,0.9714308801380582,-0.166592130243898 +95981000,0.9683076310222063,-0.1751798455949247 +100980000,0.9650390621702809,-0.1836809453657338 +105979000,0.9616283213708658,-0.1920919465755193 +110978000,0.9580786584869714,-0.2004095063968901 +115977000,0.9543934181421017,-0.2086304253697343 +120976000,0.9505760323232522,-0.2167516501821521 +125975000,0.9466300129291247,-0.2247702760196973 +130974000,0.9425589442912696,-0.2326835484861576 +135973000,0.9383664756951311,-0.240488865101008 +140972000,0.9340563139271012,-0.2481837763804754 +145971000,0.9296322158727035,-0.2557659865108503 +150970000,0.9250979811899129,-0.2632333536242631 +155969000,0.9204574450804364,-0.2705838896886015 +160968000,0.9157144711804726,-0.2778157600245763 +165967000,0.9108729445911286,-0.2849272824641412 +170966000,0.9059367650672454,-0.2919169261655432 +175965000,0.9009098403819276,-0.2987833101012006 +180964000,0.8957960798825766,-0.3055252012354113 +185963000,0.8905993882527117,-0.312141512409546 +190962000,0.8853236594923397,-0.3186312999529162 +195961000,0.8799727711281213,-0.3249937610379039 +200960000,0.8745505786630541,-0.3312282307982181 +205959000,0.8690609102739331,-0.3373341792293009 +210958000,0.8635075617633816,-0.3433112078899473 +215957000,0.8578942917718275,-0.3491590464241474 +220956000,0.852224817253449,-0.3548775489219821 +225955000,0.846502809218793,-0.3604666901381654 +230954000,0.8407318887455131,-0.3659265615864667 +235953000,0.8349156232574877,-0.3712573675278388 +240952000,0.8290575230714654,-0.3764594208695803 +245951000,0.8231610382093153,-0.3815331389923114 +250950000,0.8172295554729949,-0.3864790395209312 +255949000,0.8112663957784521,-0.3912977360550749 +260948000,0.8052748117438124,-0.3959899338738885 +265947000,0.7992579855265056,-0.4005564256292178 +270946000,0.7932190269032482,-0.4049980870405503 +275945000,0.7871609715862409,-0.4093158726042809 +280944000,0.7810867797683774,-0.4135108113290824 +285943000,0.7749993348898119,-0.4175840025083785 +290942000,0.76890144261784,-0.4215366115401119 +295941000,0.762795830031709,-0.425369865803216 +300940000,0.7566851450037251,-0.4290850505994203 +305939000,0.7505719557678014,-0.4326835051682338 +310938000,0.7444587506664533,-0.4361666187822148 +315937000,0.7383479380671434,-0.4395358269288809 +320936000,0.732241846438846,-0.4427926075849103 +325935000,0.7261427245796694,-0.445938477587591 +330934000,0.7200527419864549,-0.4489749891078054 +335933000,0.7139739893573172,-0.451903726228211 +340932000,0.7079084792182204,-0.4547263016296628 +345931000,0.7018581466648366,-0.4574443533883479 +350930000,0.6958248502110913,-0.4600595418855628 +355929000,0.6898103727360143,-0.4625735468315386 +360928000,0.6838164225207282,-0.4649880644042546 +365927000,0.6778446343676556,-0.46730480450371 +370926000,0.6718965707942695,-0.469525488121723 +375925000,0.6659737232939962,-0.471651844826929 +380924000,0.6600775136571488,-0.4736856103642987 +385923000,0.6542092953450669,-0.4756285243681627 +390922000,0.6483703549109265,-0.4774823281874453 +395921000,0.6425619134609932,-0.4792487628215238 +400920000,0.6367851281503796,-0.4809295669649054 +405919000,0.6310410937076854,-0.4825264751586792 +410918000,0.6253308439831922,-0.4840412160465348 +415917000,0.6196553535155795,-0.4854755107329369 +420916000,0.6140155391124387,-0.4868310712409382 +425915000,0.6084122614401333,-0.488109599066963 +430914000,0.6028463266188571,-0.4893127838297985 +435913000,0.5973184878190074,-0.4904423020109488 +440912000,0.5918294468552643,-0.4914998157834369 +445911000,0.5863798557750333,-0.4924869719260865 +450910000,0.580970318438162,-0.4934054008202856 +455909000,0.5756013920850842,-0.4942567155262013 +460908000,0.5702735888907791,-0.495042510935424 +465907000,0.5649873775021734,-0.4957643629969961 +470906000,0.5597431845568099,-0.4964238280138221 +475905000,0.5545413961808316,-0.497022442006453 +480904000,0.5493823594645244,-0.4975617201412914 +485903000,0.5442663839138322,-0.4980431562202861 +490902000,0.5391937428764677,-0.4984682222292436 +495901000,0.5341646749413775,-0.4988383679419268 +500900000,0.5291793853105029,-0.4991550205771759 +505899000,0.5242380471419159,-0.4994195845063432 +510898000,0.5193408028635513,-0.4996334410084038 +515897000,0.5144877654568905,-0.4997979480701714 +520896000,0.5096790197100729,-0.4999144402291198 +525895000,0.5049146234400326,-0.4999842284563873 +530894000,0.5001946086833453,-0.5000086000776182 +535893000,0.4955189828556019,-0.4999888187293673 +540892000,0.4908877298791776,-0.4999261243488775 +545891000,0.4863008112793881,-0.4998217331951172 +550890000,0.4817581672490687,-0.4996768378990399 +555889000,0.4772597176817137,-0.4994926075411166 +560888000,0.4728053631733484,-0.4992701877542506 +565887000,0.4683949859933916,-0.4990107008502866 +570886000,0.4640284510248018,-0.498715245968384 +575885000,0.4597056066738605,-0.4983848992436006 +580884000,0.4554262857499844,-0.4980207139941205 +585883000,0.4511903063159901,-0.4976237209256144 +590882000,0.446997472509284,-0.4971949283513098 +595881000,0.4428475753344745,-0.4967353224263958 +600880000,0.4387403934279184,-0.4962458673954792 +605879000,0.4346756937947571,-0.4957275058518547 +610878000,0.4306532325189998,-0.4951811590074248 +615877000,0.4266727554472372,-0.4946077269721626 +620876000,0.4227339988465815,-0.4940080890420799 +625875000,0.4188366900374327,-0.493383103994699 +630874000,0.4149805480016897,-0.492733610391114 +635873000,0.4111652839670219,-0.492060426883746 +640872000,0.4073906019678293,-0.4913643525289777 +645871000,0.4036561993835097,-0.4906461671038862 +650870000,0.3999617674546645,-0.4899066314263406 +655869000,0.3963069917778665,-0.4891464876777864 +660868000,0.3926915527796064,-0.4883664597280717 +665867000,0.3891151261700447,-0.4875672534617178 +670866000,0.3855773833771707,-0.4867495571050773 +675865000,0.3820779919619814,-0.4859140415538524 +680864000,0.3786166160152808,-0.4850613607005 +685863000,0.3751929165366756,-0.4841921517610605 +690862000,0.3718065517963709,-0.4833070356010036 +695861000,0.3684571776803165,-0.4824066170597008 +700860000,0.3651444480192814,-0.4814914852731673 +705859000,0.3618680149023934,-0.4805622139947495 +710858000,0.3586275289756982,-0.4796193619134532 +715857000,0.3554226397262519,-0.4786634729696385 +720856000,0.3522529957522786,-0.4776950766678288 +725855000,0.3491182450198826,-0.4767146883864041 +730854000,0.3460180351068176,-0.4757228096839718 +735853000,0.3429520134337936,-0.4747199286022267 +740852000,0.3399198274837825,-0.4737065199651286 +745851000,0.3369211250097839,-0.4726830456742533 +750850000,0.3339555542314936,-0.4716499550001731 +755849000,0.3310227640213008,-0.4706076848697585 +760848000,0.3281224040800399,-0.4695566601492881 +765847000,0.3252541251028982,-0.4684972939232854 +770846000,0.3224175789358714,-0.4674299877689988 +775845000,0.3196124187231595,-0.4663551320264638 +780844000,0.3168382990458563,-0.4652731060640946 +785843000,0.3140948760523088,-0.4641842785397614 +790842000,0.3113818075804831,-0.4630890076573172 +795841000,0.3086987532726715,-0.4619876414185597 +800840000,0.306045374682874,-0.4608805178706018 +805839000,0.3034213353771578,-0.4597679653486527 +810838000,0.3008263010273056,-0.4586503027142054 +815837000,0.2982599394980401,-0.4575278395886373 +820836000,0.2957219209281112,-0.456400876582241 +825835000,0.2932119178055141,-0.4552697055186998 +830834000,0.2907296050371031,-0.4541346096550318 +835833000,0.2882746600128543,-0.4529958638970387 +840832000,0.2858467626650236,-0.4518537350102856 +845831000,0.2834455955224247,-0.450708481826651 +850830000,0.2810708437600693,-0.4495603554464906 +855829000,0.2787221952443728,-0.4484095994364584 +860828000,0.2763993405741425,-0.4472564500230305 +865827000,0.2741019731175467,-0.446101136281788 +870826000,0.2718297890452592,-0.4449438803225021 +875825000,0.2695824873599681,-0.4437848974700874 +880824000,0.2673597699224206,-0.4426243964414722 +885823000,0.2651613414741825,-0.4414625795184448 +890822000,0.2629869096572728,-0.4402996427165439 +895821000,0.2608361850308349,-0.4391357759500413 +900820000,0.2587088810849938,-0.4379711631930909 +905819000,0.2566047142520449,-0.4368059826371007 +910818000,0.254523403915115,-0.4356404068443915 +915817000,0.2524646724144304,-0.434474602898212 +920816000,0.2504282450513164,-0.4333087325491677 +925815000,0.2484138500900581,-0.4321429523581346 +930814000,0.2464212187577299,-0.4309774138357204 +935813000,0.2444500852421183,-0.4298122635783372 +940812000,0.2425001866878356,-0.4286476434009562 +945811000,0.2405712631907349,-0.4274836904666005 +950810000,0.2386630577907192,-0.4263205374126518 +955809000,0.2367753164630468,-0.4251583124740236 +960808000,0.2349077881082138,-0.4239971396032775 +965807000,0.2330602245405073,-0.4228371385877354 +970806000,0.23123238047531,-0.4216784251636567 +975805000,0.2294240135152321,-0.4205211111275408 +980804000,0.2276348841351483,-0.4193653044446209 +985803000,0.2258647556662141,-0.4182111093546013 +990802000,0.224113394278924,-0.4170586264747089 +995801000,0.2223805689652796,-0.4159079529001122 +1000800000,0.2206660515201333,-0.4147591823017702 +1005799000,0.2189696165217627,-0.4136124050217657 +1010798000,0.2172910413117315,-0.4124677081661837 +1015797000,0.2156301059740979,-0.4113251756955909 +1020796000,0.2139865933140133,-0.4101848885131696 +1025795000,0.2123602888357636,-0.4090469245505634 +1030794000,0.2107509807203038,-0.407911358851487 +1035793000,0.2091584598023233,-0.4067782636531518 +1040792000,0.2075825195468881,-0.4056477084655646 +1045791000,0.2060229560256985,-0.4045197601487419 +1050790000,0.2044795678930027,-0.4033944829878973 +1055789000,0.2029521563611982,-0.4022719387666476 +1060788000,0.2014405251761593,-0.4011521868382869 +1065787000,0.1999444805923214,-0.400035284195175 +1070786000,0.1984638313475524,-0.398921285536288 +1075785000,0.1969983886378415,-0.3978102433329725 +1080784000,0.1955479660918351,-0.396702207892958 +1085783000,0.1941123797452391,-0.3955972274226538 +1090782000,0.1926914480151241,-0.3944953480877931 +1095781000,0.191284991674141,-0.3933966140724486 +1100780000,0.1898928338246879,-0.3923010676364733 +1105779000,0.1885147998730339,-0.3912087491713965 +1110778000,0.1871507175034248,-0.3901196972548236 +1115777000,0.1858004166521954,-0.3890339487033686 +1120776000,0.1844637294818949,-0.3879515386241632 +1125775000,0.1831404903554497,-0.3868725004649762 +1130774000,0.1818305358103804,-0.385796866062982 +1135773000,0.1805337045330788,-0.3847246656922041 +1140772000,0.1792498373331695,-0.383655928109682 +1145771000,0.1779787771179602,-0.3825906806003813 +1150770000,0.1767203688670005,-0.3815289490208859 +1155769000,0.1754744596067521,-0.3804707578419077 +1160768000,0.1742408983853898,-0.3794161301896315 +1165767000,0.1730195362477369,-0.3783650878859415 +1170766000,0.171810226210346,-0.377317651487549 +1175765000,0.1706128232367363,-0.3762738403240499 +1180764000,0.1694271842127903,-0.375233672534945 +1185763000,0.1682531679223247,-0.3741971651056493 +1190762000,0.1670906350228325,-0.3731643339025101 +1195761000,0.1659394480214129,-0.3721351937068723 +1200760000,0.1647994712508878,-0.3711097582482043 +1205759000,0.1636705708461146,-0.370088040236317 +1210758000,0.1625526147204945,-0.3690700513926956 +1215757000,0.1614454725426897,-0.3680558024809724 +1220756000,0.1603490157135437,-0.3670453033365558 +1225755000,0.1592631173432171,-0.3660385628954492 +1230754000,0.1581876522285364,-0.3650355892222685 +1235753000,0.1571224968305618,-0.3640363895374898 +1240752000,0.156067529252373,-0.3630409702439447 +1245751000,0.1550226292170831,-0.3620493369525792 +1250750000,0.1539876780460725,-0.3610614945075027 +1255749000,0.1529625586374537,-0.3600774470103421 +1260748000,0.1519471554447609,-0.3590971978439192 +1265747000,0.1509413544558731,-0.3581207496952729 +1270746000,0.1499450431721663,-0.3571481045780392 +1275745000,0.1489581105878954,-0.3561792638542116 +1280744000,0.1479804471698118,-0.3552142282552924 +1285743000,0.1470119448370113,-0.3542529979028596 +1290742000,0.1460524969410151,-0.3532955723285541 +1295741000,0.1451019982460851,-0.3523419504935149 +1300740000,0.1441603449097693,-0.3513921308072663 +1305739000,0.1432274344636832,-0.350446111146081 +1310738000,0.1423031657945206,-0.3495038888708257 +1315737000,0.1413874391252941,-0.3485654608443091 +1320736000,0.140480155996813,-0.3476308234481428 +1325735000,0.1395812192493839,-0.3466999725991277 +1330734000,0.1386905330047445,-0.3457729037651808 +1335733000,0.1378080026482236,-0.3448496119808144 +1340732000,0.1369335348111285,-0.3439300918621775 +1345731000,0.1360670373533583,-0.3430143376216759 +1350730000,0.1352084193462406,-0.3421023430821758 +1355729000,0.1343575910555916,-0.3411941016908109 +1360728000,0.1335144639249972,-0.3402896065323944 +1365727000,0.1326789505593147,-0.3393888503424538 +1370726000,0.1318509647083901,-0.3384918255198956 +1375725000,0.1310304212509958,-0.3375985241393106 +1380724000,0.1302172361789806,-0.3367089379629275 +1385723000,0.1294113265816321,-0.3358230584522302 +1390722000,0.1286126106302528,-0.33494087677924 +1395721000,0.1278210075629409,-0.3340623838374793 +1400720000,0.1270364376695849,-0.333187570252619 +1405719000,0.1262588222770584,-0.3323164263928237 +1410718000,0.1254880837346193,-0.3314489423787998 +1415717000,0.1247241453995127,-0.3305851080935536 +1420716000,0.1239669316227707,-0.3297249131918721 +1425715000,0.1232163677352096,-0.3288683471095299 +1430714000,0.1224723800336258,-0.3280153990722269 +1435713000,0.12173489576718,-0.3271660581042755 +1440712000,0.1210038431239751,-0.3263203130370287 +1445711000,0.120279151217823,-0.3254781525170714 +1450710000,0.1195607500751987,-0.324639565014167 +1455709000,0.1188485706223774,-0.323804538828979 +1460708000,0.1181425446727555,-0.3229730621005644 +1465707000,0.1174426049143518,-0.3221451228136488 +1470706000,0.1167486848974857,-0.3213207088056904 +1475705000,0.116060719022635,-0.3204998077737365 +1480704000,0.1153786425284629,-0.3196824072810764 +1485703000,0.1147023914800223,-0.3188684947637041 +1490702000,0.1140319027571235,-0.3180580575365844 +1495701000,0.1133671140428758,-0.3172510827997385 +1500700000,0.1127079638123909,-0.3164475576441476 +1505699000,0.1120543913216492,-0.3156474690574814 +1510698000,0.1114063365965308,-0.3148508039296561 +1515697000,0.1107637404220028,-0.3140575490582292 +1520696000,0.1101265443314641,-0.3132676911536286 +1525695000,0.1094946905962459,-0.3124812168442296 +1530694000,0.1088681222152654,-0.3116981126812751 +1535693000,0.1082467829048295,-0.310918365143653 +1540692000,0.107630617088587,-0.3101419606425246 +1545691000,0.1070195698876315,-0.3093688855258133 +1550690000,0.1064135871107434,-0.308599126082561 +1555689000,0.1058126152447774,-0.3078326685471462 +1560688000,0.1052166014451938,-0.3070694991033788 +1565687000,0.1046254935267257,-0.3063096038884632 +1570686000,0.1040392399541803,-0.3055529689968463 +1575685000,0.1034577898333831,-0.3047995804839405 +1580684000,0.1028810929022494,-0.304049424369736 +1585683000,0.1023090995219869,-0.3033024866422993 +1590682000,0.1017417606684337,-0.3025587532611594 +1595681000,0.101179027923517,-0.3018182101605947 +1600680000,0.1006208534668402,-0.301080843252811 +1605679000,0.1000671900673975,-0.3003466384310202 +1610678000,0.09951799107540338,-0.2996155815724252 +1615677000,0.09897321041425067,-0.2988876585411027 +1620676000,0.09843280257258247,-0.2981628551908021 +1625675000,0.09789672259648063,-0.297441157367648 +1630674000,0.09736492608177238,-0.2967225509127585 +1635673000,0.09683736916644925,-0.2960070216647797 +1640672000,0.09631400852319749,-0.2952945554623354 +1645671000,0.09579480135204088,-0.2945851381463948 +1650670000,0.09527970537308694,-0.2938787555625699 +1655669000,0.09476867881938755,-0.2931753935633284 +1660668000,0.09426168042990013,-0.2924750380101377 +1665667000,0.09375866944255429,-0.2917776747755364 +1670666000,0.09325960558741908,-0.2910832897451354 +1675665000,0.09276444907997505,-0.2903918688195512 +1680664000,0.09227316061448154,-0.2897033979162755 +1685663000,0.09178570135744479,-0.2890178629714779 +1690662000,0.09130203294117889,-0.2883352499417469 +1695661000,0.09082211745746727,-0.2876555448057742 +1700660000,0.09034591745131215,-0.286978733565973 +1705659000,0.08987339591477883,-0.2863048022500459 +1710658000,0.08940451628093027,-0.2856337369124957 +1715657000,0.08893924241785323,-0.2849655236360769 +1720656000,0.08847753862276519,-0.2843001485332035 +1725655000,0.08801936961621815,-0.2836375977472983 +1730654000,0.08756470053638066,-0.2829778574540966 +1735653000,0.08711349693340509,-0.2823209138629013 +1740652000,0.08666572476387979,-0.2816667532177884 +1745651000,0.08622135038536038,-0.2810153617987718 +1750650000,0.08578034055098382,-0.2803667259229192 +1755649000,0.08534266240415933,-0.2797208319454281 +1760648000,0.08490828347333768,-0.2790776662606576 +1765647000,0.08447717166685842,-0.2784372153031235 +1770646000,0.08404929526787086,-0.2777994655484489 +1775645000,0.08362462292933071,-0.2771644035142808 +1780644000,0.08320312366906957,-0.2765320157611666 +1785643000,0.08278476686493685,-0.2759022888933963 +1790642000,0.08236952225001026,-0.2752752095598088 +1795641000,0.08195735990788089,-0.2746507644545649 +1800640000,0.08154825026800272,-0.2740289403178852 +1805639000,0.08114216410111208,-0.2734097239367572 +1810638000,0.0807390725147128,-0.2727931021456131 +1815637000,0.08033894694862975,-0.2721790618269722 +1820636000,0.0799417591706213,-0.2715675899120595 +1825635000,0.0795474812720649,-0.2709586733813907 +1830634000,0.07915608566369281,-0.2703522992653341 +1835633000,0.07876754507140182,-0.2697484546446414 +1840632000,0.07838183253211617,-0.2691471266509543 +1845631000,0.07799892138971409,-0.2685483024672864 +1850630000,0.07761878529100952,-0.2679519693284785 +1855629000,0.07724139818179698,-0.2673581145216309 +1860628000,0.07686673430294944,-0.2667667253865131 +1865627000,0.07649476818657508,-0.2661777893159487 +1870626000,0.07612547465222663,-0.2655912937561825 +1875625000,0.07575882880316809,-0.2650072262072212 +1880624000,0.07539480602269522,-0.2644255742231582 +1885623000,0.07503338197050646,-0.2638463254124739 +1890622000,0.07467453257912782,-0.2632694674383205 +1895621000,0.07431823405038807,-0.2626949880187877 +1900620000,0.07396446285194713,-0.2621228749271449 +1905619000,0.07361319571386948,-0.2615531159920736 +1910618000,0.07326440962525127,-0.2609856990978765 +1915617000,0.0729180818308921,-0.2604206121846727 +1920616000,0.07257418982801789,-0.2598578432485754 +1925615000,0.07223271136304565,-0.2592973803418562 +1930614000,0.07189362442839964,-0.2587392115730918 +1935613000,0.07155690725936847,-0.2581833251072962 +1940612000,0.07122253833101033,-0.2576297091660411 +1945611000,0.07089049635509959,-0.2570783520275585 +1950610000,0.07056076027711811,-0.2565292420268345 +1955609000,0.0702333092732883,-0.2559823675556856 +1960608000,0.06990812274764946,-0.255437717062827 +1965607000,0.06958518032917538,-0.254895279053924 +1970606000,0.06926446186892754,-0.2543550420916354 +1975605000,0.06894594743725979,-0.2538169947956443 +1980604000,0.06862961732105055,-0.2532811258426767 +1985603000,0.06831545202097944,-0.2527474239665113 +1990602000,0.06800343224884431,-0.2522158779579765 +1995601000,0.06769353892490981,-0.251686476664942 +2000600000,0.06738575317529971,-0.2511592089922948 +2005599000,0.06708005632942093,-0.2506340639019094 +2010598000,0.06677642991742561,-0.25011103041261 +2015597000,0.06647485566770928,-0.2495900976001197 +2020596000,0.06617531550444133,-0.2490712545970058 +2025595000,0.06587779154513518,-0.2485544905926143 +2030594000,0.06558226609824414,-0.2480397948329964 +2035593000,0.06528872166079802,-0.2475271566208304 +2040592000,0.06499714091607123,-0.24701656531533 +2045591000,0.06470750673127923,-0.2465080103321546 +2050590000,0.06441980215530996,-0.2460014811433029 +2055589000,0.06413401041648803,-0.2454969672770082 +2060588000,0.06385011492036741,-0.2449944583176207 +2065587000,0.06356809924755402,-0.2444939439054894 +2070586000,0.06328794715156039,-0.2439954137368341 +2075585000,0.06300964255669039,-0.2434988575636113 +2080584000,0.0627331695559501,-0.2430042651933798 +2085583000,0.0624585124089887,-0.2425116264891543 +2090582000,0.06218565554006927,-0.242020931369259 +2095581000,0.06191458353606638,-0.241532169807173 +2100580000,0.06164528114448786,-0.2410453318313724 +2105579000,0.06137773327153173,-0.2405604075251678 +2110578000,0.06111192498015727,-0.2400773870265395 +2115577000,0.06084784148819722,-0.2395962605279617 +2120576000,0.0605854681664808,-0.2391170182762328 +2125575000,0.06032479053699724,-0.2386396505722914 +2130574000,0.06006579427106784,-0.2381641477710364 +2135573000,0.05980846518755789,-0.2376905002811409 +2140572000,0.05955278925110541,-0.23721869856486 +2145571000,0.05929875257037032,-0.2367487331378415 +2150570000,0.0590463413963187,-0.2362805945689254 +2155569000,0.05879554212051685,-0.2358142734799485 +2160568000,0.05854634127345859,-0.2353497605455412 +2165567000,0.0582987255229106,-0.2348870464929217 +2170566000,0.05805268167227862,-0.23442612210169 +2175565000,0.05780819665899939,-0.2339669782036189 +2180564000,0.05756525755295305,-0.2335096056824389 +2185563000,0.05732385155489306,-0.2330539954736275 +2190562000,0.05708396599490273,-0.2326001385641896 +2195561000,0.0568455883308685,-0.2321480259924412 +2200560000,0.05660870614697555,-0.2316976488477876 +2205559000,0.05637330715222055,-0.2312489982705019 +2210558000,0.05613937917894951,-0.2308020654515009 +2215557000,0.05590691018140914,-0.2303568416321189 +2220556000,0.05567588823432112,-0.2299133181038809 +2225555000,0.05544630153147478,-0.2294714862082751 +2230554000,0.05521813838433554,-0.2290313373365207 +2235553000,0.05499138722067776,-0.2285928629293387 +2240552000,0.05476603658322743,-0.2281560544767189 +2245551000,0.05454207512833054,-0.2277209035176866 +2250550000,0.05431949162463345,-0.227287401640068 +2255549000,0.0540982749517851,-0.2268555404802537 +2260548000,0.05387841409915151,-0.2264253117229638 +2265547000,0.05365989816454975,-0.225996707101011 +2270546000,0.05344271635299869,-0.2255697183950612 +2275545000,0.05322685797548665,-0.2251443374333963 +2280544000,0.05301231244775173,-0.2247205560916748 +2285543000,0.0527990692890814,-0.2242983662926911 +2290542000,0.05258711812112726,-0.2238777600061378 +2295541000,0.0523764486667333,-0.2234587292483622 +2300540000,0.05216705074878214,-0.2230412660821263 +2305539000,0.05195891428905108,-0.2226253626163683 +2310538000,0.05175202930709211,-0.2222110110059564 +2315537000,0.05154638591911653,-0.221798203451451 +2320536000,0.0513419743368988,-0.2213869321988612 +2325535000,0.05113878486669443,-0.2209771895394026 +2330534000,0.05093680790817312,-0.2205689678092562 +2335533000,0.0507360339533609,-0.2201622593893257 +2340532000,0.05053645358559944,-0.2197570567049964 +2345531000,0.05033805747851883,-0.2193533522258929 +2350530000,0.05014083639502198,-0.2189511384656359 +2355529000,0.04994478118628365,-0.2185504079816037 +2360528000,0.04974988279075943,-0.2181511533746873 +2365527000,0.04955613223320832,-0.2177533672890529 +2370526000,0.04936352062373461,-0.2173570424118973 +2375525000,0.04917203915682755,-0.21696217147321 +2380524000,0.04898167911042783,-0.2165687472455318 +2385523000,0.04879243184499549,-0.2161767625437154 +2390522000,0.0486042888025966,-0.215786210224686 +2395521000,0.04841724150599735,-0.2153970831872019 +2400520000,0.04823128155777079,-0.2150093743716153 +2405519000,0.04804640063941412,-0.2146230767596363 +2410518000,0.04786259051047925,-0.2142381833740931 +2415517000,0.04767984300771277,-0.2138546872786967 +2420516000,0.04749815004420399,-0.2134725815778032 +2425515000,0.04731750360855069,-0.2130918594161796 +2430514000,0.04713789576402716,-0.2127125139787671 +2435513000,0.04695931864776925,-0.2123345384904461 +2440512000,0.04678176446996529,-0.2119579262158051 +2445511000,0.04660522551305846,-0.2115826704589046 +2450510000,0.04642969413096054,-0.211208764563046 +2455509000,0.04625516274827346,-0.2108362019105395 +2460508000,0.04608162385951942,-0.210464975922474 +2465507000,0.04590907002838596,-0.2100950800584849 +2470506000,0.04573749388697301,-0.2097265078165259 +2475505000,0.04556688813505527,-0.2093592527326421 +2480504000,0.04539724553935165,-0.2089933083807377 +2485503000,0.04522855893279942,-0.2086286683723531 +2490502000,0.0450608212138468,-0.2082653263564373 +2495501000,0.04489402534574416,-0.2079032760191225 +2500500000,0.04472816435585125,-0.2075425110834987 +2505499000,0.04456323133494888,-0.2071830253093927 +2510498000,0.04439921943656033,-0.2068248124931428 +2515497000,0.04423612187628079,-0.2064678664673788 +2520496000,0.04407393193111653,-0.2061121811007997 +2525495000,0.04391264293882724,-0.2057577502979559 +2530494000,0.04375224829728475,-0.205404567999028 +2535493000,0.04359274146382996,-0.2050526281796103 +2540492000,0.04343411595464497,-0.2047019248504925 +2545491000,0.04327636534413037,-0.2043524520574456 +2550490000,0.04311948326428783,-0.2040042038810038 +2555489000,0.04296346340411206,-0.2036571744362546 +2560488000,0.04280829950899334,-0.2033113578726211 +2565487000,0.04265398538011822,-0.2029667483736529 +2570486000,0.04250051487389128,-0.2026233401568138 +2575485000,0.04234788190134742,-0.2022811274732725 +2580484000,0.04219608042758449,-0.2019401046076919 +2585483000,0.04204510447119714,-0.2016002658780229 +2590482000,0.04189494810371719,-0.2012616056352961 +2595481000,0.04174560544906125,-0.2009241182634167 +2600480000,0.04159707068298624,-0.2005877981789587 +2605479000,0.04144933803255046,-0.2002526398309608 +2610478000,0.04130240177557964,-0.1999186377007248 +2615477000,0.04115625624014174,-0.199585786301612 +2620476000,0.04101089580402695,-0.1992540801788446 +2625475000,0.04086631489423231,-0.1989235139093034 +2630474000,0.0407225079864566,-0.1985940821013299 +2635473000,0.04057946960459713,-0.1982657793945309 +2640472000,0.04043719432025195,-0.1979386004595784 +2645471000,0.04029567675223311,-0.1976125399980163 +2650470000,0.04015491156607931,-0.1972875927420658 +2655469000,0.04001489347358023,-0.1969637534544309 +2660468000,0.03987561723230137,-0.1966410169281066 +2665467000,0.03973707764511669,-0.1963193779861882 +2670466000,0.0395992695597478,-0.1959988314816807 +2675465000,0.03946218786830591,-0.1956793722973092 +2680464000,0.03932582750684244,-0.1953609953453311 +2685463000,0.03919018345489955,-0.1950436955673491 +2690462000,0.03905525073507476,-0.1947274679341255 +2695461000,0.03892102441257883,-0.1944123074453967 +2700460000,0.03878749959480876,-0.1940982091296905 +2705459000,0.03865467143092371,-0.1937851680441415 +2710458000,0.03852253511141845,-0.1934731792743112 +2715457000,0.03839108586771345,-0.1931622379340062 +2720456000,0.03826031897174054,-0.1928523391650986 +2725455000,0.03813022973553704,-0.192543478137349 +2730454000,0.03800081351084383,-0.1922356500482265 +2735453000,0.03787206568870882,-0.1919288501227341 +2740452000,0.03774398169909343,-0.1916230736132338 +2745451000,0.03761655701048716,-0.1913183157992693 +2750450000,0.03748978712951812,-0.1910145719873963 +2755449000,0.03736366760058152,-0.1907118375110081 +2760448000,0.0372381940054578,-0.1904101077301651 +2765447000,0.03711336196294646,-0.1901093780314241 +2770446000,0.03698916712849787,-0.1898096438276697 +2775445000,0.03686560519384963,-0.1895109005579465 +2780444000,0.03674267188667169,-0.1892131436872906 +2785443000,0.0366203629702091,-0.1889163687065662 +2790442000,0.03649867424293252,-0.1886205711322973 +2795441000,0.03637760153819469,-0.1883257465065061 +2800440000,0.03625714072388408,-0.1880318903965488 +2805439000,0.03613728770208868,-0.1877389983949556 +2810438000,0.03601803840876183,-0.1874470661192661 +2815437000,0.03589938881338983,-0.1871560892118726 +2820436000,0.03578133491866597,-0.186866063339861 +2825435000,0.03566387276016592,-0.1865769841948507 +2830434000,0.03554699840602771,-0.186288847492839 +2835433000,0.0354307079566385,-0.1860016489740461 +2840432000,0.03531499754431788,-0.1857153844027576 +2845431000,0.03519986333301017,-0.1854300495671735 +2850430000,0.03508530151797795,-0.1851456402792537 +2855429000,0.03497130832550122,-0.1848621523745648 +2860428000,0.03485788001257673,-0.1845795817121307 +2865427000,0.03474501286662068,-0.1842979241742836 +2870426000,0.0346327032051823,-0.1840171756665117 +2875425000,0.03452094737564604,-0.1837373321173139 +2880424000,0.03440974175495137,-0.1834583894780502 +2885423000,0.03429908274930882,-0.1831803437227986 +2890422000,0.03418896679391814,-0.1829031908482069 +2895421000,0.03407939035269347,-0.1826269268733487 +2900420000,0.03397034991798886,-0.1823515478395827 +2905419000,0.03386184201032694,-0.1820770498104061 +2910418000,0.033753863178132,-0.181803428871317 +2915417000,0.03364640999746582,-0.1815306811296705 +2920416000,0.03353947907176336,-0.1812588027145411 +2925415000,0.03343306703157523,-0.1809877897765836 +2930414000,0.03332717053431122,-0.1807176384878943 +2935413000,0.0332217862639872,-0.1804483450418753 +2940412000,0.03311691093097324,-0.1801799056530972 +2945411000,0.03301254127174524,-0.1799123165571645 +2950410000,0.03290867404864284,-0.1796455740105814 +2955409000,0.0328053060496214,-0.1793796742906188 +2960408000,0.03270243408801643,-0.1791146136951806 +2965407000,0.03260005500230401,-0.178850388542673 +2970406000,0.03249816565586583,-0.1785869951718745 +2975405000,0.03239676293675786,-0.1783244299418033 +2980404000,0.03229584375747896,-0.1780626892315908 +2985403000,0.03219540505474439,-0.1778017694403532 +2990402000,0.03209544378926021,-0.1775416669870633 +2995401000,0.03199595694550061,-0.1772823783104242 +3000400000,0.0318969415314887,-0.1770238998687436 +3005399000,0.03179839457857692,-0.1767662281398104 +3010398000,0.03170031314123256,-0.1765093596207686 +3015397000,0.03160269429682439,-0.1762532908279951 +3020396000,0.03150553514541166,-0.1759980182969784 +3025395000,0.03140883280953322,-0.1757435385821966 +3030394000,0.03131258443400498,-0.1754898482569948 +3035393000,0.0312167871857123,-0.1752369439134687 +3040392000,0.03112143825340774,-0.1749848221623429 +3045391000,0.03102653484751383,-0.1747334796328531 +3050390000,0.0309320741999215,-0.1744829129726302 +3055389000,0.0308380535637951,-0.1742331188475823 +3060388000,0.03074447021338211,-0.1739840939417782 +3065387000,0.03065132144381399,-0.1737358349573343 +3070386000,0.03055860457092519,-0.1734883386142994 +3075385000,0.03046631693105728,-0.1732416016505402 +3080384000,0.03037445588087784,-0.1729956208216298 +3085383000,0.03028301879719542,-0.1727503929007359 +3090382000,0.03019200307677705,-0.1725059146785078 +3095381000,0.03010140613616819,-0.1722621829629678 +3100380000,0.03001122541151524,-0.1720191945794009 +3105379000,0.02992145835838755,-0.1717769463702452 +3110378000,0.02983210245160439,-0.171535435194985 +3115377000,0.02974315518506154,-0.1712946579300417 +3120376000,0.02965461407156011,-0.1710546114686678 +3125375000,0.02956647664263756,-0.1708152927208412 +3130374000,0.02947874044840026,-0.170576698613159 +3135373000,0.02939140305735743,-0.170338826088734 +3140372000,0.02930446205625747,-0.1701016721070901 +3145371000,0.02921791504992521,-0.169865233644058 +3150370000,0.02913175966110115,-0.1696295076916761 +3155369000,0.02904599353028381,-0.1693944912580841 +3160368000,0.02896061431556984,-0.1691601813674259 +3165367000,0.02887561969249908,-0.1689265750597473 +3170366000,0.02879100735390216,-0.1686936693908964 +3175365000,0.02870677500974517,-0.1684614614324247 +3180364000,0.02862292038698122,-0.168229948271488 +3185363000,0.02853944122939711,-0.167999127010751 +3190362000,0.02845633529746983,-0.1677689947682875 +3195361000,0.02837360036821601,-0.1675395486774862 +3200360000,0.02829123423504942,-0.1673107858869531 +3205359000,0.0282092347076357,-0.1670827035604181 +3210358000,0.02812759961175249,-0.1668552988766389 +3215357000,0.02804632678914509,-0.1666285690293096 +3220356000,0.02796541409739173,-0.1664025112269651 +3225355000,0.02788485940975982,-0.1661771226928899 +3230354000,0.02780466061507592,-0.1659524006650269 +3235353000,0.02772481561758644,-0.1657283423958835 +3240352000,0.0276453223368236,-0.1655049451524451 +3245351000,0.02756617870747657,-0.1652822062160806 +3250350000,0.02748738267925521,-0.1650601228824566 +3255349000,0.02740893221676499,-0.1648386924614471 +3260348000,0.02733082529937558,-0.1646179122770457 +3265347000,0.02725305992109495,-0.1643977796672765 +3270346000,0.02717563409044144,-0.1641782919841115 +3275345000,0.02709854583032301,-0.1639594465933777 +3280344000,0.02702179317790843,-0.1637412408746774 +3285343000,0.02694537418451004,-0.1635236722213002 +3290342000,0.02686928691545898,-0.1633067380401372 +3295341000,0.02679352944998636,-0.1630904357516006 +3300340000,0.02671809988110607,-0.1628747627895371 +3305339000,0.02664299631549572,-0.1626597166011455 +3310338000,0.02656821687338029,-0.1624452946468963 +3315337000,0.02649375968841738,-0.1622314944004481 +3320336000,0.02641962290758237,-0.1620183133485666 +3325335000,0.02634580469105741,-0.1618057489910444 +3330334000,0.02627230321211727,-0.1615937988406216 +3335333000,0.02619911665701835,-0.1613824604229045 +3340332000,0.02612624322489321,-0.1611717312762879 +3345331000,0.02605368112763551,-0.1609616089518767 +3350330000,0.02598142858979791,-0.1607520910134069 +3355329000,0.02590948384848168,-0.1605431750371696 +3360328000,0.02583784515323417,-0.1603348586119337 +3365327000,0.02576651076594283,-0.1601271393388687 +3370326000,0.02569547896073177,-0.1599200148314686 +3375325000,0.02562474802385917,-0.1597134827154807 +3380324000,0.02555431625361715,-0.1595075406288238 +3385323000,0.02548418196022961,-0.1593021862215205 +3390322000,0.025414343465753,-0.1590974171556193 +3395321000,0.02534479910397947,-0.1588932311051239 +3400320000,0.0252755472203372,-0.1586896257559171 +3405319000,0.02520658617179339,-0.1584865988056932 +3410318000,0.0251379143267616,-0.1582841479638832 +3415317000,0.02506953006500345,-0.1580822709515823 +3420316000,0.02500143177753733,-0.1578809655014818 +3425315000,0.02493361786654358,-0.1576802293577995 +3430314000,0.02486608674527213,-0.1574800602762047 +3435313000,0.02479883683795459,-0.1572804560237552 +3440312000,0.02473186657970849,-0.1570814143788244 +3445311000,0.02466517441645233,-0.1568829331310339 +3450310000,0.02459875880481466,-0.1566850100811856 +3455309000,0.02453261821204711,-0.1564876430411943 +3460308000,0.02446675111593644,-0.1562908298340201 +3465307000,0.02440115600472037,-0.1560945682936026 +3470306000,0.0243358313769988,-0.1558988562647942 +3475305000,0.02427077574165204,-0.1557036916032954 +3480304000,0.02420598761775739,-0.1555090721755876 +3485303000,0.02414146553450425,-0.1553149958588691 +3490302000,0.02407720803111113,-0.1551214605409932 +3495301000,0.0240132136567488,-0.1549284641203994 +3500300000,0.02394948097045413,-0.1547360045060542 +3505299000,0.02388600854105394,-0.1545440796173878 +3510298000,0.02382279494708461,-0.1543526873842264 +3515297000,0.02375983877671195,-0.1541618257467371 +3520296000,0.02369713862765765,-0.153971492655361 +3525295000,0.0236346931071183,-0.1537816860707549 +3530294000,0.02357250083169005,-0.153592403963727 +3535293000,0.0235105604272956,-0.1534036443151791 +3540292000,0.02344887052910694,-0.1532154051160474 +3545291000,0.02338742978147024,-0.1530276843672379 +3550290000,0.02332623683783619,-0.1528404800795718 +3555289000,0.02326529036068292,-0.1526537902737265 +3560288000,0.02320458902144673,-0.152467612980172 +3565287000,0.02314413150044969,-0.152281946239119 +3570286000,0.02308391648682995,-0.1520967881004581 +3575285000,0.02302394267846841,-0.1519121366237003 +3580284000,0.02296420878192418,-0.1517279898779254 +3585283000,0.02290471351236079,-0.1515443459417212 +3590282000,0.02284545559348117,-0.1513612029031282 +3595281000,0.02278643375745992,-0.1511785588595843 +3600280000,0.02272764674487382,-0.1509964119178692 +3605279000,0.02266909330463829,-0.1508147601940494 +3610278000,0.02261077219394036,-0.1506336018134232 +3615277000,0.02255268217817297,-0.1504529349104652 +3620276000,0.02249482203087316,-0.1502727576287754 +3625275000,0.02243719053365334,-0.1500930681210227 +3630274000,0.02237978647614303,-0.1499138645488924 +3635273000,0.02232260865592117,-0.1497351450830333 +3640272000,0.02226565587845863,-0.149556907903007 +3645271000,0.02220892695705334,-0.1493791511972311 +3650270000,0.02215242071277013,-0.1492018731629327 +3655269000,0.02209613597437965,-0.1490250720060933 +3660268000,0.02204007157829913,-0.1488487459413992 +3665267000,0.0219842263685337,-0.1486728931921897 +3670266000,0.02192859919661294,-0.1484975119904071 +3675265000,0.02187318892154022,-0.1483226005765462 +3680264000,0.0218179944097272,-0.1481481571996059 +3685263000,0.02176301453494123,-0.1479741801170381 +3690262000,0.02170824817824535,-0.1478006675946976 +3695261000,0.02165369422794527,-0.1476276179067971 +3700260000,0.02159935157953097,-0.1474550293358548 +3705259000,0.0215452191356218,-0.1472829001726473 +3710258000,0.02149129580591169,-0.1471112287161629 +3715257000,0.02143758050711631,-0.1469400132735534 +3720256000,0.02138407216291749,-0.1467692521600852 +3725255000,0.02133076970390957,-0.1465989436990956 +3730254000,0.02127767206754694,-0.1464290862219439 +3735253000,0.02122477819809254,-0.1462596780679641 +3740252000,0.02117208704656504,-0.1460907175844232 +3745251000,0.02111959757068638,-0.1459222031264698 +3750250000,0.02106730873483298,-0.1457541330570942 +3755249000,0.02101521950998286,-0.1455865057470783 +3760248000,0.02096332887366636,-0.1454193195749544 +3765247000,0.02091163580991728,-0.1452525729269594 +3770246000,0.02086013930922115,-0.1450862641969911 +3775245000,0.02080883836846881,-0.1449203917865624 +3780244000,0.02075773199090758,-0.14475495410476 +3785243000,0.02070681918609107,-0.1445899495682006 +3790242000,0.02065609896983434,-0.1444253766009868 +3795241000,0.02060557036416588,-0.1442612336346643 +3800240000,0.0205552323972793,-0.1440975191081812 +3805239000,0.02050508410348906,-0.143934231467843 +3810238000,0.02045512452318321,-0.1437713691672743 +3815237000,0.02040535270277744,-0.1436089306673732 +3820236000,0.0203557676946724,-0.1434469144362717 +3825235000,0.02030636855720669,-0.1432853189492963 +3830234000,0.02025715435461284,-0.1431241426889237 +3835233000,0.0202081241569716,-0.1429633841447427 +3840232000,0.02015927704017373,-0.1428030418134133 +3845231000,0.02011061208587006,-0.1426431141986257 +3850230000,0.02006212838143284,-0.1424835998110618 +3855229000,0.02001382501991311,-0.1423244971683553 +3860228000,0.01996570109999563,-0.1421658047950513 +3865227000,0.01991775572596088,-0.1420075212225684 +3870226000,0.0198699880076405,-0.1418496449891611 +3875225000,0.0198223970603788,-0.1416921746398778 +3880224000,0.01977498200498951,-0.1415351087265262 +3885223000,0.01972774196771665,-0.1413784458076319 +3890222000,0.0196806760801953,-0.1412221844484044 +3895221000,0.01963378347941136,-0.1410663232206957 +3900220000,0.0195870633076618,-0.1409108607029661 +3905219000,0.01954051471251494,-0.1407557954802454 +3910218000,0.01949413684677381,-0.1406011261440968 +3915217000,0.01944792886843616,-0.1404468512925797 +3920216000,0.01940188994065672,-0.1402929695302134 +3925215000,0.01935601923171082,-0.140139479467943 +3930214000,0.01931031591495591,-0.1399863797230994 +3935213000,0.01926477916879143,-0.1398336689193677 +3940212000,0.01921940817662993,-0.1396813456867509 +3945211000,0.01917420212685306,-0.1395294086615318 +3950210000,0.01912916021277811,-0.1393778564862421 +3955209000,0.01908428163262421,-0.1392266878096255 +3960208000,0.0190395655894724,-0.1390759012866025 +3965207000,0.01899501129123493,-0.1389254955782388 +3970206000,0.01895061795061803,-0.1387754693517081 +3975205000,0.01890638478508588,-0.1386258212802602 +3980204000,0.01886231101683045,-0.1384765500431867 +3985203000,0.01881839587273282,-0.1383276543257889 +3990202000,0.01877463858433259,-0.1381791328193423 +3995201000,0.01873103838779411,-0.1380309842210647 +4000200000,0.01868759452387003,-0.1378832072340833 +4005199000,0.01864430623787294,-0.1377358005674038 +4010198000,0.01860117277963935,-0.1375887629358749 +4015197000,0.01855819340349951,-0.1374420930601588 +4020196000,0.01851536736824388,-0.1372957896666975 +4025195000,0.01847269393709139,-0.1371498514876825 +4030194000,0.01843017237765765,-0.137004277261021 +4035193000,0.01838780196192524,-0.1368590657303085 +4040192000,0.01834558196621128,-0.1367142156447944 +4045191000,0.01830351167113586,-0.1365697257593492 +4050190000,0.01826159036159369,-0.1364255948344405 +4055189000,0.01821981732672162,-0.1362818216360962 +4060188000,0.01817819185986913,-0.136138404935876 +4065187000,0.01813671325857014,-0.1359953435108421 +4070186000,0.0180953808245119,-0.1358526361435297 +4075185000,0.0180541938635046,-0.1357102816219136 +4080184000,0.01801315168545536,-0.1355682787393832 +4085183000,0.01797225360433696,-0.1354266262947111 +4090182000,0.01793149893815849,-0.1352853230920219 +4095181000,0.01789088700894093,-0.1351443679407668 +4100180000,0.01785041714268409,-0.1350037596556928 +4105179000,0.01781008866934286,-0.1348634970568127 +4110178000,0.01776990092279696,-0.1347235789693798 +4115177000,0.01772985324082255,-0.1345840042238568 +4120176000,0.01768994496507026,-0.1344447716558893 +4125175000,0.01765017544103165,-0.1343058801062763 +4130174000,0.01761054401801521,-0.1341673284209454 +4135173000,0.01757105004912152,-0.1340291154509204 +4140172000,0.01753169289121437,-0.1338912400522981 +4145171000,0.01749247190489478,-0.1337537010862195 +4150170000,0.01745338645447791,-0.1336164974188415 +4155169000,0.01741443590796199,-0.1334796279213129 +4160168000,0.01737561963700807,-0.1333430914697442 +4165167000,0.01733693701691186,-0.1332068869451841 +4170166000,0.01729838742657908,-0.1330710132335907 +4175165000,0.01725997024850079,-0.1329354692258057 +4180164000,0.01722168486872944,-0.1328002538175304 +4185163000,0.01718353067685152,-0.132665365909296 +4190162000,0.01714550706596696,-0.1325308044064413 +4195161000,0.01710761343266309,-0.1323965682190852 +4200160000,0.01706984917698984,-0.1322626562621031 +4205159000,0.01703221370243768,-0.1321290674550968 +4210158000,0.01699470641591305,-0.1319958007223762 +4215157000,0.01695732672771522,-0.1318628549929297 +4220156000,0.0169200740515143,-0.131730229200399 +4225155000,0.01688294780432509,-0.1315979222830583 +4230154000,0.01684594740648815,-0.131465933183786 +4235153000,0.01680907228164275,-0.1313342608500416 +4240152000,0.01677232185670996,-0.1312029042338423 +4245151000,0.01673569556186583,-0.1310718622917384 +4250150000,0.01669919283051979,-0.1309411339847877 +4255149000,0.0166628130992954,-0.1308107182785343 +4260148000,0.01662655580800609,-0.1306806141429835 +4265147000,0.01659042039963388,-0.1305508205525783 +4270146000,0.01655440632030913,-0.1304213364861774 +4275145000,0.01651851301928842,-0.1302921609270294 +4280144000,0.01648273994893268,-0.1301632928627523 +4285143000,0.01644708656468929,-0.1300347312853095 +4290142000,0.0164115523250663,-0.1299064751909868 +4295141000,0.01637613669161708,-0.1297785235803704 +4300140000,0.01634083912891704,-0.129650875458323 +4305139000,0.01630565910454229,-0.1295235298339636 +4310138000,0.01627059608905346,-0.1293964857206438 +4315137000,0.01623564955597168,-0.1292697421359254 +4320136000,0.01620081898176062,-0.1291432981015593 +4325135000,0.01616610384580741,-0.1290171526434638 +4330134000,0.01613150363040172,-0.1288913047917025 +4335133000,0.01609701782071649,-0.1287657535804621 +4340132000,0.01606264590479078,-0.1286404980480319 +4345131000,0.01602838737350876,-0.1285155372367825 +4350130000,0.01599424172058006,-0.1283908701931435 +4355129000,0.01596020844252344,-0.128266495967585 +4360128000,0.01592628703864629,-0.1281424136145929 +4365127000,0.01589247701102825,-0.1280186221926505 +4370126000,0.01585877786449874,-0.1278951207642195 +4375125000,0.01582518910662456,-0.1277719083957146 +4380124000,0.01579171024768544,-0.1276489841574882 +4385123000,0.01575834080066207,-0.1275263471238064 +4390122000,0.01572508028121544,-0.1274039963728306 +4395121000,0.01569192820766796,-0.1272819309865973 +4400120000,0.01565888410098926,-0.1271601500509986 +4405119000,0.01562594748477464,-0.1270386526557601 +4410118000,0.01559311788523265,-0.1269174378944236 +4415117000,0.01556039483116334,-0.1267965048643283 +4420116000,0.01552777785394577,-0.1266758526665873 +4425115000,0.0154952664875172,-0.1265554804060724 +4430114000,0.01546286026835797,-0.1264353871913933 +4435113000,0.0154305587354755,-0.126315572134877 +4440112000,0.01539836143038809,-0.1261960343525524 +4445111000,0.01536626789710605,-0.1260767729641267 +4450110000,0.01533427768211815,-0.1259577870929713 +4455109000,0.01530239033437431,-0.1258390758661011 +4460108000,0.01527060540527025,-0.125720638414154 +4465107000,0.01523892244863112,-0.1256024738713757 +4470106000,0.01520734102069543,-0.1254845813756003 +4475105000,0.01517586068009957,-0.1253669600682318 +4480104000,0.01514448098786469,-0.1252496090942238 +4485103000,0.01511320150737738,-0.1251325276020671 +4490102000,0.01508202180437612,-0.125015714743766 +4495101000,0.01505094144693797,-0.1248991696748233 +4500100000,0.01501996000546124,-0.1247828915542237 +4505099000,0.01498907705264907,-0.1246668795444128 +4510098000,0.01495829216349942,-0.1245511328112829 +4515097000,0.01492760491528689,-0.124435650524154 +4520096000,0.01489701488754802,-0.1243204318557568 +4525095000,0.01486652166206959,-0.1242054759822141 +4530094000,0.01483612482286989,-0.1240907820830281 +4535093000,0.01480582395618901,-0.123976349341059 +4540092000,0.01477561865046995,-0.123862176942509 +4545091000,0.01474550849635081,-0.1237482640769073 +4550090000,0.01471549308664377,-0.123634609937092 +4555089000,0.01468557201632659,-0.1235212137191942 +4560088000,0.01465574488252597,-0.1234080746226202 +4565087000,0.0146260112845058,-0.123295191850037 +4570086000,0.01459637082365139,-0.1231825646073557 +4575085000,0.01456682310345858,-0.1230701921037125 +4580084000,0.01453736772951819,-0.1229580735514576 +4585083000,0.01450800430950316,-0.1228462081661356 +4590082000,0.01447873245315745,-0.1227345951664689 +4595081000,0.01444955177228002,-0.1226232337743454 +4600080000,0.01442046188071466,-0.1225121232148008 +4605079000,0.01439146239433375,-0.1224012627160013 +4610078000,0.01436255293102939,-0.1222906515092308 +4615077000,0.01433373311069719,-0.122180288828876 +4620076000,0.01430500255522738,-0.1220701739124069 +4625075000,0.01427636088848683,-0.1219603060003651 +4630074000,0.01424780773631462,-0.1218506843363488 +4635073000,0.01421934272650072,-0.1217413081669944 +4640072000,0.0141909654887804,-0.1216321767419652 +4645071000,0.0141626756548201,-0.1215232893139352 +4650070000,0.01413447285820379,-0.121414645138573 +4655069000,0.01410635673442373,-0.1213062434745282 +4660068000,0.01407832692086686,-0.1211980835834169 +4665067000,0.01405038305680217,-0.1210901647298077 +4670066000,0.01402252478337207,-0.1209824861812046 +4675065000,0.01399475174357767,-0.120875047208035 +4680064000,0.01396706358226929,-0.1207678470836361 +4685063000,0.0139394599461331,-0.1206608850842372 +4690062000,0.01391194048368183,-0.1205541604889487 +4695061000,0.01388450484524251,-0.1204476725797474 +4700060000,0.0138571526829443,-0.1203414206414611 +4705059000,0.01382988365070892,-0.1202354039617559 +4710058000,0.01380269740423978,-0.1201296218311229 +4715057000,0.01377559360100866,-0.1200240735428625 +4720056000,0.01374857190024792,-0.1199187583930723 +4725055000,0.01372163196293696,-0.1198136756806334 +4730054000,0.01369477345179382,-0.1197088247071972 +4735053000,0.01366799603126134,-0.1196042047771684 +4740052000,0.01364129936750169,-0.1194998151976986 +4745051000,0.0136146831283801,-0.1193956552786664 +4750050000,0.01358814698345845,-0.1192917243326663 +4755049000,0.01356169060398371,-0.1191880216749976 +4760048000,0.01353531366287752,-0.1190845466236505 +4765047000,0.01350901583472441,-0.1189812984992885 +4770046000,0.01348279679576514,-0.1188782766252429 +4775045000,0.01345665622388448,-0.1187754803274965 +4780044000,0.01343059379859968,-0.1186729089346674 +4785043000,0.01340460920105624,-0.1185705617780026 +4790042000,0.01337870211400971,-0.1184684381913617 +4795041000,0.01335287222182302,-0.1183665375112041 +4800040000,0.01332711921045338,-0.1182648590765787 +4805039000,0.01330144276744383,-0.1181634022291091 +4810038000,0.01327584258191195,-0.1180621663129831 +4815037000,0.01325031834454315,-0.11796115067494 +4820036000,0.01322486974757831,-0.1178603546642569 +4825035000,0.01319949648480678,-0.1177597776327387 +4830034000,0.01317419825155475,-0.1176594189347055 +4835033000,0.0131489747446798,-0.1175592779269779 +4840032000,0.0131238256625561,-0.1174593539688711 +4845031000,0.01309875070507016,-0.1173596464221758 +4850030000,0.01307374957360974,-0.1172601546511513 +4855029000,0.0130488219710545,-0.1171608780225133 +4860028000,0.01302396760177027,-0.1170618159054191 +4865027000,0.01299918617159279,-0.1169629676714605 +4870026000,0.01297447738782886,-0.1168643326946492 +4875025000,0.01294984095923835,-0.116765910351404 +4880024000,0.01292527659603215,-0.1166677000205446 +4885023000,0.01290078400986006,-0.116569701083275 +4890022000,0.01287636291380334,-0.1164719129231765 +4895021000,0.01285201302236638,-0.1163743349261908 +4900020000,0.01282773405146664,-0.1162769664806163 +4905019000,0.01280352571843024,-0.1161798069770903 +4910018000,0.01277938774197684,-0.1160828558085815 +4915017000,0.01275531984222011,-0.1159861123703789 +4920016000,0.01273132174065039,-0.1158895760600797 +4925015000,0.01270739316013425,-0.1157932462775787 +4930014000,0.01268353382490228,-0.1156971224250584 +4935013000,0.01265974346054044,-0.1156012039069775 +4940012000,0.0126360217939856,-0.1155054901300603 +4945011000,0.012612368553514,-0.1154099805032864 +4950010000,0.01258878346873638,-0.1153146744378788 +4955009000,0.01256526627058774,-0.1152195713472972 +4960008000,0.01254181669131915,-0.1151246706472217 +4965007000,0.01251843446449419,-0.1150299717555475 +4970006000,0.0124951193249756,-0.1149354740923732 +4975005000,0.01247187100892355,-0.1148411770799876 +4980004000,0.01244868925378206,-0.1147470801428644 +4985003000,0.01242557379827702,-0.1146531827076484 +4990002000,0.0124025243824033,-0.1145594842031471 +4995001000,0.01237954074742298,-0.1144659840603185 +5000000000,0.01235662263585402,-0.1143726817122664 diff --git a/pySmithPlot/testbenches/data/s22.csv b/pySmithPlot/testbenches/data/s22.csv new file mode 100755 index 0000000..cada0a3 --- /dev/null +++ b/pySmithPlot/testbenches/data/s22.csv @@ -0,0 +1,1002 @@ +s22 X,s22 YRe,s22 YReImag +1000000,0.9999981769681279,-0.00125665541576428 +5999000,0.999933854812499,-0.007538245865437181 +10998000,0.9997776588170357,-0.01381769298531715 +15997000,0.9995296733223507,-0.02009322530837201 +20996000,0.9991900193516541,-0.02636306844254754 +25995000,0.9987588623334955,-0.03262545201153604 +30994000,0.9982364120350349,-0.03887861141014889 +35993000,0.997622922331483,-0.04512078924547974 +40992000,0.9969186909128376,-0.05135023671980962 +45991000,0.9961240589379943,-0.05756521498823767 +50990000,0.9952394106386067,-0.06376399649658318 +55989000,0.9942651728739509,-0.06994486629966427 +60988000,0.9932018146378552,-0.07610612335865714 +65987000,0.9920498465188035,-0.08224608181583211 +70986000,0.9908098201143736,-0.08836307224485378 +75985000,0.9894823274012541,-0.09445544287482797 +80984000,0.9880680000621782,-0.1005215607863201 +85983000,0.9865675087711874,-0.1065598130776274 +90982000,0.9849815624387055,-0.1125686079996608 +95981000,0.9833109074179924,-0.1185463760578727 +100980000,0.9815563266746119,-0.1244915710797473 +105979000,0.9797186389205803,-0.1304026712464634 +110978000,0.9777986977149722,-0.1362781800874265 +115977000,0.975797390532773,-0.1421166274364664 +120976000,0.9737156378038152,-0.1479165703485885 +125975000,0.9715543919236842,-0.1536765939762675 +130974000,0.9693146362385348,-0.1593953124043726 +135973000,0.9669973840057302,-0.1650713694429124 +140972000,0.9646036773323123,-0.1707034393768906 +145971000,0.9621345860932469,-0.176290227672662 +150970000,0.9595912068314931,-0.1818304716402857 +155969000,0.9569746616418593,-0.1873229410514664 +160968000,0.9542860970406661,-0.1927664387127814 +165967000,0.9515266828232241,-0.1981598009939824 +170966000,0.9486976109110978,-0.2035018983112704 +175965000,0.9458000941911371,-0.208791635565522 +180964000,0.9428353653482366,-0.2140279525355572 +185963000,0.9398046756937277,-0.2192098242266159 +190962000,0.9367092939913328,-0.2243362611743073 +195961000,0.9335505052825068,-0.2294063097043797 +200960000,0.9303296097130211,-0.2344190521487455 +205959000,0.9270479213625498,-0.2393736070182697 +210958000,0.9237067670790333,-0.2442691291329166 +215957000,0.9203074853194226,-0.2491048097099098 +220956000,0.9168514249985507,-0.2538798764106482 +225955000,0.9133399443476247,-0.2585935933471701 +230954000,0.9097744097838838,-0.2632452610490246 +235953000,0.9061561947929151,-0.2678342163914808 +240952000,0.9024866788249517,-0.2723598324860313 +245951000,0.8987672462065917,-0.276821518534233 +250950000,0.8949992850691098,-0.2812187196459394 +255949000,0.8911841862946182,-0.2855509166230461 +260948000,0.8873233424811939,-0.2898176257098941 +265947000,0.883418146928044,-0.2940183983115184 +270946000,0.8794699926416942,-0.2981528206809547 +275945000,0.8754802713641434,-0.3022205135768408 +280944000,0.871450372623811,-0.3062211318925768 +285943000,0.8673816828101293,-0.3101543642583272 +290942000,0.8632755842723676,-0.3140199326171412 +295941000,0.8591334544435321,-0.3178175917765253 +300940000,0.854956664989756,-0.3215471289367535 +305939000,0.8507465809857095,-0.3252083631972269 +310938000,0.8465045601166379,-0.3288011450422331 +315937000,0.8422319519071879,-0.3323253558073698 +320936000,0.8379300969775227,-0.3357809071279738 +325935000,0.8336003263268483,-0.3391677403708279 +330934000,0.8292439606447113,-0.342485826050457 +335933000,0.8248623096500369,-0.3457351632312553 +340932000,0.8204566714581052,-0.3489157789167145 +345931000,0.8160283319754211,-0.3520277274269755 +350930000,0.8115785643225841,-0.3550710897659413 +355929000,0.8071086282849502,-0.3580459729791166 +360928000,0.8026197697909567,-0.360952509503322 +365927000,0.7981132204181438,-0.3637908565094847 +370926000,0.793590196926399,-0.3665611952395356 +375925000,0.7890519008183452,-0.3692637303385394 +380924000,0.7844995179265748,-0.3718986891831083 +385923000,0.7799342180272921,-0.3744663212070732 +390922000,0.7753571544801627,-0.376966897225454 +395921000,0.770769463893775,-0.3794007087575998 +400920000,0.7661722658165047,-0.3817680673504968 +405919000,0.7615666624522381,-0.3840693039030758 +410918000,0.7569537384003748,-0.3863047679923431 +415917000,0.7523345604198277,-0.3884748272022009 +420916000,0.7477101772162524,-0.3905798664556525 +425915000,0.7430816192522083,-0.3926202873512057 +430914000,0.7384498985795107,-0.394596507504108 +435913000,0.7338160086932817,-0.3965089598931087 +440912000,0.729180924407105,-0.3983580922133607 +445911000,0.7245456017486396,-0.4001443662360457 +450910000,0.7199109778752522,-0.4018682571753299 +455909000,0.7152779710087231,-0.4035302530630513 +460908000,0.7106474803888319,-0.4051308541317845 +465907000,0.7060203862448358,-0.4066705722066 +470906000,0.7013975497843501,-0.4081499301059778 +475905000,0.6967798131990635,-0.4095694610523052 +480904000,0.6921679996866068,-0.4109297080922784 +485903000,0.6875629134877914,-0.4122312235274711 +490902000,0.6829653399390065,-0.4134745683555445 +495901000,0.67837604553848,-0.4146603117220691 +500900000,0.6737957780266211,-0.415789030383561 +505899000,0.6692252664790688,-0.416861308181606 +510898000,0.6646652214122393,-0.4178777355284289 +515897000,0.6601163349008163,-0.4188389089040904 +520896000,0.6555792807062824,-0.4197454303652909 +525895000,0.6510547144162391,-0.4205979070660579 +530894000,0.6465432735937702,-0.4213969507903065 +535893000,0.6420455779362022,-0.4221431774963011 +540892000,0.6375622294430208,-0.4228372068732217 +545891000,0.6330938125919767,-0.4234796619096249 +550890000,0.628640894523405,-0.4240711684741186 +555889000,0.6242040252313827,-0.4246123549077412 +560888000,0.6197837377624076,-0.4251038516286995 +565887000,0.6153805484200194,-0.4255462907487916 +570886000,0.6109949569752779,-0.4259403057016716 +575885000,0.6066274468830719,-0.4262865308831479 +580884000,0.6022784855030359,-0.4265856013029696 +585883000,0.5979485243251599,-0.4268381522482932 +590882000,0.5936379991995433,-0.4270448189586638 +595881000,0.5893473305698211,-0.427206236312329 +600880000,0.5850769237098472,-0.4273230385237483 +605879000,0.5808271689635287,-0.427395858852326 +610878000,0.5765984419869961,-0.4274253293219295 +615877000,0.5723911039930898,-0.427412080451249 +620876000,0.5682055019976471,-0.4273567409947029 +625875000,0.5640419690675942,-0.4272599376939736 +630874000,0.5599008245697785,-0.4271222950394308 +635873000,0.555782374421268,-0.4269444350420167 +640872000,0.551686911339978,-0.4267269770147727 +645871000,0.5476147150956405,-0.4264705373640288 +650870000,0.5435660527610844,-0.4261757293902345 +655869000,0.5395411789632607,-0.4258431630979894 +660868000,0.5355403361337852,-0.4254734450150748 +665867000,0.531563754758978,-0.4250671780204451 +670866000,0.5276116536292683,-0.4246249611810421 +675865000,0.5236842400871182,-0.4241473895967023 +680864000,0.5197817102740652,-0.4236350542535888 +685863000,0.5159042493763542,-0.4230885418856654 +690862000,0.5120520318688448,-0.4225084348438735 +695861000,0.5082252217571575,-0.4218953109729071 +700860000,0.504423972818359,-0.4212497434957754 +705859000,0.5006484288389002,-0.420572300904944 +710858000,0.4968987238510412,-0.4198635468610453 +715857000,0.4931749823668048,-0.4191240400982258 +720856000,0.4894773196091537,-0.4183543343357306 +725855000,0.4858058417413491,-0.4175549781965235 +730854000,0.4821606460931793,-0.4167265151316078 +735853000,0.4785418213845736,-0.4158694833504001 +740852000,0.4749494479468785,-0.4149844157573525 +745851000,0.4713835979404994,-0.414071839893402 +750850000,0.4678443355703497,-0.4131322778835628 +755849000,0.4643317172981676,-0.4121662463896149 +760848000,0.4608457920512639,-0.4111742565672856 +765847000,0.4573866014289281,-0.4101568140290822 +770846000,0.4539541799053997,-0.4091144188114968 +775845000,0.4505485550294457,-0.4080475653464967 +780844000,0.4471697476211305,-0.406956742437783 +785843000,0.4438177719651253,-0.4058424332409845 +790842000,0.4404926360008774,-0.4047051152479918 +795841000,0.4371943415094404,-0.4035452602750689 +800840000,0.4339228842971503,-0.4023633344548311 +805839000,0.4306782543757859,-0.4011597982314902 +810838000,0.4274604361397765,-0.3999351063599275 +815837000,0.4242694085398619,-0.3986897079077178 +820836000,0.4211051452535453,-0.3974240462603759 +825835000,0.4179676148520763,-0.3961385591293556 +830834000,0.4148567809647958,-0.3948336785636973 +835833000,0.4117726024393189,-0.3935098309632683 +840832000,0.4087150334991623,-0.3921674370954622 +845831000,0.4056840238978314,-0.3908069121139866 +850830000,0.4026795190697521,-0.389428665580053 +855829000,0.3997014602781475,-0.3880331014859983 +860828000,0.3967497847595183,-0.3866206182807017 +865827000,0.3938244258650874,-0.3851916088971397 +870826000,0.3909253131993773,-0.3837464607822064 +875825000,0.3880523727551477,-0.3822855559275273 +880824000,0.3852055270459767,-0.3808092709029544 +885823000,0.3823846952351926,-0.3793179768907759 +890822000,0.3795897932623553,-0.3778120397221811 +895821000,0.3768207339663052,-0.3762918199144403 +900820000,0.3740774272058476,-0.3747576727102322 +905819000,0.3713597799768911,-0.3732099481171837 +910818000,0.3686676965275753,-0.3716489909498534 +915817000,0.366001078469788,-0.3700751408715232 +920816000,0.3633598248884562,-0.3684887324378123 +925815000,0.3607438324480401,-0.3668900951411371 +930814000,0.3581529954961995,-0.3652795534557396 +935813000,0.3555872061649796,-0.3636574268837978 +940812000,0.3530463544692948,-0.3620240300020472 +945811000,0.3505303284029624,-0.3603796725092496 +950810000,0.3480390140322311,-0.3587246592742742 +955809000,0.3455722955867089,-0.3570592903844549 +960808000,0.3431300555482886,-0.3553838611952169 +965807000,0.3407121747369117,-0.3536986623787037 +970806000,0.3383185323949556,-0.3520039799745341 +975805000,0.3359490062686308,-0.3503000954396185 +980804000,0.3336034726873538,-0.3485872856986548 +985803000,0.3312818066411476,-0.3468658231953385 +990802000,0.3289838818554105,-0.3451359759428514 +995801000,0.3267095708639898,-0.3433980075753266 +1000800000,0.3244587450800782,-0.3416521773992643 +1005799000,0.322231274864808,-0.3398987404444522 +1010798000,0.3200270295944301,-0.3381379475161491 +1015797000,0.3178458777247704,-0.3363700452456596 +1020796000,0.315687686854623,-0.33459527614266 +1025795000,0.3135523237864499,-0.3328138786457485 +1030794000,0.3114396545860474,-0.3310260871745831 +1035793000,0.3093495446397538,-0.3292321321804939 +1040792000,0.3072818587102992,-0.327432240197791 +1045791000,0.3052364609908795,-0.3256266338947755 +1050790000,0.3032132151575571,-0.3238155321245775 +1055789000,0.3012119844198684,-0.3219991499753894 +1060788000,0.2992326315700518,-0.3201776988209993 +1065787000,0.2972750190306552,-0.3183513863709028 +1070786000,0.2953390089005818,-0.3165204167200799 +1075785000,0.2934244629997773,-0.3146849903987896 +1080784000,0.2915312429120871,-0.3128453044211127 +1085783000,0.2896592100273399,-0.3110015523347818 +1090782000,0.2878082255814298,-0.3091539242691251 +1095781000,0.2859781506954608,-0.3073026069837023 +1100780000,0.2841688464133205,-0.3054477839158894 +1105779000,0.2823801737382752,-0.3035896352289661 +1110778000,0.2806119936677982,-0.3017283378583148 +1115777000,0.2788641672279872,-0.2998640655595609 +1120776000,0.2771365555057763,-0.2979969889533481 +1125775000,0.2754290196810065,-0.29612727557268 +1130774000,0.2737414210566331,-0.2942550899076578 +1135773000,0.2720736210881607,-0.2923805934507441 +1140772000,0.2704254814120035,-0.29050394474162 +1145771000,0.2687968638727782,-0.2886252994114663 +1150770000,0.2671876305494598,-0.286744810226446 +1155769000,0.2655976437806646,-0.2848626271310497 +1160768000,0.2640267661891493,-0.2829788972916128 +1165767000,0.2624748607049849,-0.2810937651380362 +1170766000,0.260941790588094,-0.279207372405945 +1175765000,0.2594274194498956,-0.27731985817839 +1180764000,0.2579316112740488,-0.275431358926915 +1185763000,0.2564542304362658,-0.2735420085517834 +1190762000,0.254995141723493,-0.2716519384224321 +1195761000,0.2535542103521595,-0.2697612774168706 +1200760000,0.2521313019857352,-0.2678701519609231 +1205759000,0.2507262827515293,-0.2659786860669117 +1210758000,0.249339019256787,-0.2640870013720117 +1215757000,0.2479693786039392,-0.2621952171754348 +1220756000,0.2466172284054977,-0.2603034504766191 +1225755000,0.245282436797815,-0.2584118160108416 +1230754000,0.2439648724546946,-0.256520426286519 +1235753000,0.2426644046000761,-0.2546293916208008 +1240752000,0.2413809030200964,-0.2527388201744333 +1245751000,0.2401142380747661,-0.2508488179872256 +1250750000,0.238864280708915,-0.2489594890122486 +1255749000,0.2376309024626304,-0.2470709351497565 +1260748000,0.2364139754812067,-0.2451832562809826 +1265747000,0.2352133725244594,-0.2432965503007223 +1270746000,0.234028966975671,-0.2414109131503301 +1275745000,0.2328606328499263,-0.2395264388494861 +1280744000,0.2317082448021137,-0.2376432195283809 +1285743000,0.2305716781342986,-0.2357613454583844 +1290742000,0.229450808802816,-0.2338809050833244 +1295741000,0.2283455134247856,-0.2320019850493247 +1300740000,0.2272556692843337,-0.2301246702350635 +1305739000,0.2261811543383794,-0.2282490437813594 +1310738000,0.2251218472219751,-0.2263751871199582 +1315737000,0.2240776272533103,-0.2245031800021595 +1320736000,0.2230483744383687,-0.2226331005271434 +1325735000,0.2220339694751792,-0.2207650251694942 +1330734000,0.2210342937578238,-0.2188990288071134 +1335733000,0.2200492293799601,-0.217035184747394 +1340732000,0.219078659138191,-0.2151735647544724 +1345731000,0.2181224665350017,-0.2133142390748698 +1350730000,0.2171805357814709,-0.2114572764635075 +1355729000,0.2162527517996713,-0.2096027442091011 +1360728000,0.2153390002247562,-0.2077507081587053 +1365727000,0.2144391674068598,-0.2059012327428251 +1370726000,0.2135531404126665,-0.2040543809993562 +1375725000,0.2126808070267368,-0.2022102145971253 +1380724000,0.2118220557526587,-0.2003687938600144 +1385723000,0.2109767758138683,-0.198530177789317 +1390722000,0.2101448571543245,-0.1966944240868451 +1395721000,0.2093261904389396,-0.194861589177332 +1400720000,0.2085206670537942,-0.1930317282303134 +1405719000,0.2077281791061509,-0.1912048951816482 +1410718000,0.2069486194242987,-0.1893811427548355 +1415717000,0.2061818815571927,-0.187560522482329 +1420716000,0.2054278597739219,-0.1857430847261135 +1425715000,0.2046864490629827,-0.1839288786971047 +1430714000,0.2039575451314373,-0.1821179524767969 +1435713000,0.2032410444038553,-0.1803103530349407 +1440712000,0.2025368440211495,-0.1785061262506617 +1445711000,0.2018448418392322,-0.1767053169304143 +1450710000,0.2011649364275498,-0.1749079688269098 +1455709000,0.2004970270674773,-0.173114124657647 +1460708000,0.1998410137505855,-0.1713238261226707 +1465707000,0.1991967971767672,-0.1695371139231824 +1470706000,0.1985642787522843,-0.1677540277777995 +1475705000,0.1979433605876491,-0.1659746064409891 +1480704000,0.197333945495435,-0.1641988877194261 +1485703000,0.1967359369879789,-0.1624269084884114 +1490702000,0.1961492392749642,-0.160658704708646 +1495701000,0.1955737572609226,-0.1588943114424101 +1500700000,0.1950093965426463,-0.1571337628690437 +1505699000,0.1944560634065144,-0.1553770923006352 +1510698000,0.1939136648257129,-0.1536243321977203 +1515697000,0.1933821084574274,-0.1518755141836353 +1520696000,0.1928613026399131,-0.1501306690597594 +1525695000,0.1923511563895057,-0.1483898268200365 +1530694000,0.1918515793975459,-0.1466530166656613 +1535693000,0.1913624820273396,-0.1449202670180482 +1540692000,0.1908837753108961,-0.1431916055338366 +1545691000,0.1904153709457364,-0.1414670591178919 +1550690000,0.189957181291593,-0.1397466539368142 +1555689000,0.1895091193670724,-0.1380304154320904 +1560688000,0.1890710988462876,-0.1363183683327423 +1565687000,0.1886430340553407,-0.1346105366688759 +1570686000,0.1882248399689816,-0.1329069437828392 +1575685000,0.1878164322069489,-0.1312076123428345 +1580684000,0.1874177270304955,-0.129512564354198 +1585683000,0.1870286413388147,-0.127821821171171 +1590682000,0.186649092665321,-0.1261354035093449 +1595681000,0.1862789991741429,-0.1244533314559061 +1600680000,0.1859182796562409,-0.1227756244825003 +1605679000,0.1855668535258668,-0.1211023014549487 +1610678000,0.185224640816855,-0.1194333806440502 +1615677000,0.1848915621786547,-0.1177688797377749 +1620676000,0.1845675388727659,-0.1161088158502588 +1625675000,0.1842524927688409,-0.1144532055329144 +1630674000,0.1839463463409161,-0.1128020647842503 +1635673000,0.1836490226635643,-0.1111554090600547 +1640672000,0.1833604454081075,-0.1095132532828889 +1645671000,0.1830805388386711,-0.1078756118522942 +1650670000,0.1828092278083977,-0.1062424986538467 +1655669000,0.1825464377555817,-0.1046139270684629 +1660668000,0.1822920946997633,-0.1029899099817389 +1665667000,0.1820461252379102,-0.1013704597926252 +1670666000,0.1818084565404356,-0.0997555884227771 +1675665000,0.1815790163473241,-0.0981453073251637 +1680664000,0.18135773296445,-0.09653962749158122 +1685663000,0.1811445352593297,-0.09493855946284711 +1690662000,0.1809393526575387,-0.09334211333551216 +1695661000,0.1807421151387356,-0.09175029877044164 +1700660000,0.1805527532326918,-0.09016312500118755 +1705659000,0.1803711980154847,-0.08858060084144523 +1710658000,0.1801973811056909,-0.08700273469248465 +1715657000,0.1800312346603798,-0.08542953455130768 +1720656000,0.1798726913713404,-0.08386100801767306 +1725655000,0.1797216844612348,-0.08229716230141104 +1730654000,0.1795781476796503,-0.08073800422997217 +1735653000,0.1794420152994236,-0.07918354025485318 +1740652000,0.1793132221126701,-0.07763377645910026 +1745651000,0.1791917034270596,-0.07608871856374698 +1750650000,0.1790773950620006,-0.07454837193457177 +1755649000,0.1789702333447734,-0.07301274158894053 +1760648000,0.1788701551068035,-0.07148183220207056 +1765647000,0.1787770976799679,-0.06995564811311102 +1770646000,0.1786909988927314,-0.06843419333180897 +1775645000,0.17861179706645,-0.06691747154446706 +1780644000,0.1785394310116397,-0.06540548612001917 +1785643000,0.1784738400242967,-0.06389824011584259 +1790642000,0.1784149638821135,-0.06239573628389806 +1795641000,0.1783627428410546,-0.06089797707559132 +1800640000,0.1783171176313432,-0.05940496464860996 +1805639000,0.1782780294540651,-0.05791670087159965 +1810638000,0.1782454199775283,-0.05643318732967167 +1815637000,0.1782192313335356,-0.0549544253301179 +1820636000,0.1781994061139143,-0.0534804159072862 +1825635000,0.178185887366836,-0.05201115982807594 +1830634000,0.1781786185934402,-0.05054665759645982 +1835633000,0.1781775437441819,-0.04908690945884555 +1840632000,0.1781826072151527,-0.04763191540946121 +1845631000,0.1781937538451346,-0.04618167519352582 +1850630000,0.1782109289113678,-0.04473618831423543 +1855629000,0.1782340781268947,-0.0432954540350644 +1860628000,0.1782631476363827,-0.04185947138650242 +1865627000,0.17829808401328,-0.04042823916888342 +1870626000,0.1783388342561794,-0.03900175595752248 +1875625000,0.1783853457854383,-0.03758002010705908 +1880624000,0.1784375664399647,-0.03616302975534527 +1885623000,0.1784954444737192,-0.03475078282810564 +1890622000,0.1785589285524996,-0.03334327704277982 +1895621000,0.1786279677507665,-0.03194050991229165 +1900620000,0.1787025115481706,-0.03054247874957369 +1905619000,0.1787825098264599,-0.02914918067107188 +1910618000,0.1788679128661685,-0.02776061260082731 +1915617000,0.1789586713435294,-0.02637677127395133 +1920616000,0.1790547363271926,-0.02499765324061272 +1925615000,0.1791560592751582,-0.02362325486945913 +1930614000,0.179262592031707,-0.02225357235103647 +1935613000,0.1793742868239863,-0.02088860170206679 +1940612000,0.1794910962593341,-0.01952833876788922 +1945611000,0.179612973321728,-0.01817277922702722 +1950610000,0.1797398713694629,-0.01682191859281023 +1955609000,0.1798717441313167,-0.01547575221858924 +1960608000,0.1800085457041565,-0.01413427529952688 +1965607000,0.1801502305496241,-0.01279748287656272 +1970606000,0.1802967534914224,-0.01146536983896787 +1975605000,0.1804480697121027,-0.01013793092804964 +1980604000,0.1806041347504799,-0.008815160739420768 +1985603000,0.1807649044985558,-0.007497053726383385 +1990602000,0.1809303351984528,-0.006183604203273844 +1995601000,0.1811003834401741,-0.004874806346991072 +2000600000,0.1812750061581436,-0.003570654201198344 +2005599000,0.1814541606287494,-0.002271141678338857 +2010598000,0.1816378044674998,-0.0009762625624822264 +2015597000,0.1818258956262393,0.0003139894879474525 +2020596000,0.1820183923903318,0.001599620937382227 +2025595000,0.1822152533762533,0.002880638371180169 +2030594000,0.1824164375284851,0.004157048492223012 +2035593000,0.1826219041172625,0.005428858119298461 +2040592000,0.182831612735477,0.006696074183741576 +2045591000,0.1830455232965005,0.007958703727943099 +2050590000,0.1832635960311311,0.009216753902092893 +2055589000,0.1834857914856189,0.01047023196307132 +2060588000,0.1837120705181625,0.01171914527031706 +2065587000,0.1839423942974749,0.01296350128576488 +2070586000,0.1841767242994627,0.01420330757006663 +2075585000,0.1844150223048688,0.01543857178073672 +2080584000,0.1846572503970532,0.01666930167050286 +2085583000,0.1849033709593741,0.01789550508492214 +2090582000,0.1851533466727362,0.01911718996028988 +2095581000,0.1854071405130631,0.02033436432143688 +2100580000,0.1856647157491773,0.02154703628024592 +2105579000,0.1859260359399333,0.02275521403281775 +2110578000,0.1861910649327032,0.02395890585907973 +2115577000,0.1864597668600998,0.02515812011920399 +2120576000,0.186732106138241,0.02635286525280861 +2125575000,0.1870080474641165,0.02754314977654465 +2130574000,0.1872875558135787,0.0287289822827811 +2135573000,0.1875705964389593,0.02991037143763249 +2140572000,0.1878571348666702,0.03108732597895562 +2145571000,0.1881471368954273,0.03225985471542163 +2150570000,0.1884405685934258,0.03342796652377483 +2155569000,0.18873739629677,0.03459167034824503 +2160568000,0.1890375866066609,0.03575097519783738 +2165567000,0.1893411063879733,0.03690589014596119 +2170566000,0.1896479227663956,0.03805642432765479 +2175565000,0.1899580031268664,0.03920258693895819 +2180564000,0.1902713151112805,0.04034438723507239 +2185563000,0.1905878266162453,0.04148183452860508 +2190562000,0.1909075057912912,0.04261493818855303 +2195561000,0.1912303210367119,0.04374370763866514 +2200560000,0.1915562410013816,0.04486815235579188 +2205559000,0.1918852345812303,0.04598828186925216 +2210558000,0.1922172709166254,0.04710410575848245 +2215557000,0.192552319390831,0.0482156336523703 +2220556000,0.1928903496277792,0.04932287522751594 +2225555000,0.1932313314905474,0.05042584020757758 +2230554000,0.1935752350787994,0.05152453836101669 +2235553000,0.1939220307275615,0.05261897950088557 +2240552000,0.194271689004647,0.05370917348255988 +2245551000,0.1946241807095579,0.0547951302036892 +2250550000,0.194979476871004,0.05587685960207193 +2255549000,0.1953375487451512,0.05695437165461702 +2260548000,0.1956983678140658,0.05802767637659569 +2265547000,0.1960619057836295,0.0590967838201018 +2270546000,0.1964281345820813,0.06016170407342758 +2275545000,0.19679702635785,0.0612224472593999 +2280544000,0.197168553477957,0.06227902353455275 +2285543000,0.1975426885261906,0.06333144308795274 +2290542000,0.1979194043017976,0.06437971614076446 +2295541000,0.1982986738171273,0.06542385294431741 +2300540000,0.1986804702962208,0.06646386377952038 +2305539000,0.1990647671732031,0.06749975895598267 +2310538000,0.1994515380906412,0.06853154881108324 +2315537000,0.1998407568975535,0.06955924370855401 +2320536000,0.2002323976480913,0.07058285403799981 +2325535000,0.2006264345999731,0.07160239021404528 +2330534000,0.2010228422122691,0.07261786267463291 +2335533000,0.2014215951447953,0.07362928188145464 +2340532000,0.2018226682554041,0.07463665831758669 +2345531000,0.202226036599485,0.07564000248804745 +2350530000,0.2026316754273081,0.07663932491750984 +2355529000,0.2030395601836295,0.07763463615097217 +2360528000,0.2034496665050858,0.07862594675154691 +2365527000,0.2038619702196884,0.07961326730096117 +2370526000,0.2042764473441891,0.08059660839732373 +2375525000,0.2046930740835275,0.0815759806555489 +2380524000,0.2051118268292271,0.08255139470642435 +2385523000,0.2055326821571628,0.08352286119490446 +2390522000,0.2059556168271304,0.08449039078065416 +2395521000,0.2063806077807646,0.08545399413652063 +2400520000,0.2068076321401002,0.08641368194781325 +2405519000,0.207236667206586,0.08736946491212988 +2410518000,0.20766769045929,0.088321353738191 +2415517000,0.2081006795535103,0.08926935914516912 +2420516000,0.208535612319676,0.09021349186235605 +2425515000,0.2089724667619755,0.09115376262851031 +2430514000,0.2094112210564516,0.09209018219055226 +2435513000,0.209851853550133,0.09302276130350572 +2440512000,0.2102943427596646,0.09395151072983081 +2445511000,0.2107386673701488,0.0948764412390007 +2450510000,0.2111848062333104,0.0957975636062873 +2455509000,0.2116327383663856,0.09671488861239771 +2460508000,0.2120824429512989,0.09762842704342392 +2465507000,0.2125338993329613,0.09853818968978419 +2470506000,0.212987087017545,0.0994441873451417 +2475505000,0.2134419856725338,0.1003464308073375 +2480504000,0.2138985751240257,0.101244930876201 +2485503000,0.2143568353564562,0.1021396983541011 +2490502000,0.2148167465111654,0.1030307440451834 +2495501000,0.2152782888847882,0.1039180787544155 +2500500000,0.2157414429286977,0.1048017132877983 +2505499000,0.2162061892472389,0.1056816584512334 +2510498000,0.2166725085967032,0.1065579250502121 +2515497000,0.2171403818845068,0.1074305238897155 +2520496000,0.2176097901673086,0.1082994657729616 +2525495000,0.2180807146508787,0.1091647615020432 +2530494000,0.2185531366878539,0.1100264218762931 +2535493000,0.2190270377775339,0.1108844576928172 +2540492000,0.2195023995637777,0.1117388797450323 +2545491000,0.2199792038350035,0.1125896988233999 +2550490000,0.2204574325220152,0.1134369257138782 +2555489000,0.2209370676978319,0.1142805711984787 +2560488000,0.2214180915763646,0.1151206460545914 +2565487000,0.2219004865103811,0.1159571610536134 +2570486000,0.2223842349919776,0.1167901269621254 +2575485000,0.222869319650119,0.1176195545400683 +2580484000,0.223355723251025,0.1184454545418287 +2585483000,0.2238434286953561,0.1192678377140639 +2590482000,0.2243324190188725,0.1200867147970429 +2595481000,0.2248226773904105,0.1209020965232739 +2600480000,0.2253141871111104,0.1217139936174003 +2605479000,0.2258069316136437,0.1225224167960735 +2610478000,0.2263008944607205,0.1233273767671337 +2615477000,0.2267960593444789,0.1241288842296341 +2620476000,0.2272924100856952,0.1249269498737062 +2625475000,0.2277899306319771,0.1257215843794179 +2630474000,0.2282886050579882,0.1265127984176109 +2635473000,0.2287884175632058,0.1273006026483477 +2640472000,0.2292893524720776,0.1280850077216636 +2645471000,0.2297913942321816,0.1288660242764118 +2650470000,0.2302945274142034,0.1296436629408264 +2655469000,0.230798736710218,0.130417934331483 +2660468000,0.2313040069329828,0.1311888490532171 +2665467000,0.2318103230153541,0.131956417699147 +2670466000,0.232317670009057,0.1327206508500891 +2675465000,0.2328260330840126,0.1334815590744966 +2680464000,0.2333353975269576,0.1342391529277458 +2685463000,0.2338457487410783,0.1349934429523481 +2690462000,0.2343570722452069,0.1357444396777465 +2695461000,0.2348693536722726,0.1364921536194626 +2700460000,0.2353825787694448,0.1372365952797401 +2705459000,0.2358967333961999,0.1379777751463422 +2710458000,0.2364118035244134,0.1387157036931489 +2715457000,0.2369277752365802,0.1394503913790923 +2720456000,0.2374446347259629,0.1401818486487918 +2725455000,0.2379623682952585,0.1409100859318812 +2730454000,0.2384809623555115,0.1416351136425611 +2735453000,0.2390004034258084,0.142356942179817 +2740452000,0.2395206781326604,0.1430755819273737 +2745451000,0.2400417732079614,0.1437910432524202 +2750450000,0.2405636754900065,0.1445033365069495 +2755449000,0.2410863719207541,0.1452124720259125 +2760448000,0.2416098495469152,0.1459184601285862 +2765447000,0.2421340955179159,0.1466213111173335 +2770446000,0.2426590970854297,0.1473210352776561 +2775445000,0.2431848416028772,0.1480176428782317 +2780444000,0.2437113165244345,0.1487111441705393 +2785443000,0.2442385094043653,0.1494015493887458 +2790442000,0.2447664078963943,0.1500888687496276 +2795441000,0.2452949997523584,0.1507731124519066 +2800440000,0.2458242728224198,0.1514542906768454 +2805439000,0.2463542150538367,0.1521324135876817 +2810438000,0.2468848144899678,0.1528074913292404 +2815437000,0.2474160592699992,0.1534795340281398 +2820436000,0.2479479376283589,0.1541485517927246 +2825435000,0.2484804378933165,0.1548145547123724 +2830434000,0.2490135484872227,0.1554775528580787 +2835433000,0.2495472579248628,0.1561375562815669 +2840432000,0.2500815548132982,0.1567945750155635 +2845431000,0.2506164278513709,0.1574486190737987 +2850430000,0.2511518658286511,0.1580996984505799 +2855429000,0.251687857624626,0.1587478231205564 +2860428000,0.2522243922085488,0.1593930030389801 +2865427000,0.2527614586386862,0.1600352481415075 +2870426000,0.2532990460609008,0.160674568343504 +2875425000,0.253837143709535,0.1613109735410683 +2880424000,0.2543757409048295,0.1619444736094715 +2885423000,0.2549148270536057,0.1625750784040295 +2890422000,0.2554543916488303,0.1632027977601267 +2895421000,0.2559944242678807,0.1638276414922985 +2900420000,0.2565349145726428,0.1644496193946526 +2905419000,0.2570758523088323,0.1650687412407193 +2910418000,0.2576172273054984,0.1656850167834344 +2915417000,0.258159029473628,0.1662984557544724 +2920416000,0.2587012488064186,0.1669090678647864 +2925415000,0.2592438753788204,0.167516862804601 +2930414000,0.2597868993456198,0.1681218502423958 +2935413000,0.2603303109426858,0.1687240398261 +2940412000,0.260874100484747,0.1693234411818617 +2945411000,0.2614182583660047,0.1699200639147949 +2950410000,0.2619627750582427,0.170513917607983 +2955409000,0.2625076411120115,0.1711050118236165 +2960408000,0.2630528471544442,0.1716933561017942 +2965407000,0.2635983838895886,0.1722789599610668 +2970406000,0.2641442420978324,0.1728618328983457 +2975405000,0.2646904126343816,0.1734419843881787 +2980404000,0.2652368864302099,0.1740194238836906 +2985403000,0.2657836544904801,0.1745941608158204 +2990402000,0.2663307078940611,0.1751662045932936 +2995401000,0.2668780377935778,0.1757355646029505 +3000400000,0.2674256354142359,0.1763022502092571 +3005399000,0.2679734920534431,0.1768662707543427 +3010398000,0.2685215990810299,0.1774276355584316 +3015397000,0.2690699479373224,0.1779863539188657 +3020396000,0.2696185301333234,0.1785424351105062 +3025395000,0.2701673372515145,0.1790958883865328 +3030394000,0.2707163609422796,0.1796467229764078 +3035393000,0.2712655929265326,0.1801949480878456 +3040392000,0.2718150249934388,0.1807405729056256 +3045391000,0.2723646490004317,0.1812836065918673 +3050390000,0.2729144568725634,0.1818240582858932 +3055389000,0.2734644406022135,0.1823619371043111 +3060388000,0.2740145922482362,0.1828972521407385 +3065387000,0.2745649039361044,0.1834300124661572 +3070386000,0.2751153678567888,0.1839602271284742 +3075385000,0.2756659762665552,0.1844879051526521 +3080384000,0.2762167214866424,0.1850130555407666 +3085383000,0.276767595902528,0.1855356872718125 +3090382000,0.2773185919634045,0.1860558093016275 +3095381000,0.2778697021820149,0.1865734305630497 +3100380000,0.2784209191340354,0.187088559965787 +3105379000,0.2789722354579491,0.1876012063965855 +3110378000,0.2795236438537307,0.1881113787186834 +3115377000,0.2800751370828352,0.1886190857720509 +3120376000,0.2806267079688285,0.1891243363739995 +3125375000,0.28117834939497,0.1896271393179915 +3130374000,0.2817300543051375,0.1901275033744194 +3135373000,0.2822818157031513,0.190625437290445 +3140372000,0.2828336266521074,0.1911209497898433 +3145371000,0.2833854802739375,0.1916140495729756 +3150370000,0.2839373697492709,0.1921047453169394 +3155369000,0.2844892883168433,0.1925930456754516 +3160368000,0.2850412292727789,0.1930789592786731 +3165367000,0.2855931859710847,0.1935624947336968 +3170366000,0.2861451518219909,0.1940436606238452 +3175365000,0.2866971202926147,0.1945224655092523 +3180364000,0.2872490849055993,0.1949989179263259 +3185363000,0.2878010392398971,0.1954730263883968 +3190362000,0.2883529769288986,0.1959447993848958 +3195361000,0.2889048916616686,0.1964142453822461 +3200360000,0.2894567771809538,0.1968813728229858 +3205359000,0.2900086272842348,0.1973461901265428 +3210358000,0.2905604358217557,0.1978087056883827 +3215357000,0.2911121966980159,0.1982689278810106 +3220356000,0.291663903869249,0.1987268650528303 +3225355000,0.2922155513455187,0.1991825255294563 +3230354000,0.2927671331880475,0.1996359176124997 +3235353000,0.2933186435098849,0.2000870495801189 +3240352000,0.2938700764754807,0.200535929687002 +3245351000,0.2944214263007729,0.2009825661645975 +3250350000,0.2949726872515936,0.2014269672204803 +3255349000,0.2955238536446165,0.2018691410390413 +3260348000,0.2960749198460946,0.2023090957810209 +3265347000,0.2966258802715396,0.2027468395835469 +3270346000,0.2971767293865406,0.2031823805607293 +3275345000,0.2977274617044061,0.2036157268026525 +3280344000,0.2982780717876756,0.204046886376334 +3285343000,0.2988285542466245,0.2044758673251466 +3290342000,0.2993789037394767,0.2049026776691147 +3295341000,0.2999291149719463,0.2053273254048649 +3300340000,0.3004791826966868,0.2057498185055333 +3305339000,0.3010291017126492,0.2061701649206396 +3310338000,0.3015788668661317,0.2065883725767603 +3315337000,0.3021284730484803,0.2070044493766054 +3320336000,0.3026779151980616,0.2074184032001321 +3325335000,0.3032271882972821,0.2078302419032913 +3330334000,0.3037762873741867,0.2082399733189694 +3335333000,0.3043252075020961,0.2086476052569798 +3340332000,0.3048739437974646,0.2090531455032194 +3345331000,0.3054224914222488,0.2094566018209608 +3350330000,0.3059708455809216,0.2098579819496121 +3355329000,0.3065190015227619,0.2102572936059547 +3360328000,0.3070669545391611,0.2106545444830559 +3365327000,0.3076146999645448,0.2110497422508608 +3370326000,0.308162233176196,0.2114428945562772 +3375325000,0.3087095495934999,0.2118340090229871 +3380324000,0.3092566446771383,0.2122230932512449 +3385323000,0.3098035139307393,0.2126101548187828 +3390322000,0.31035015289798,0.2129952012796593 +3395321000,0.3108965571640883,0.2133782401650986 +3400320000,0.3114427223548633,0.2137592789832113 +3405319000,0.3119886441367334,0.2141383252191626 +3410318000,0.3125343182160398,0.2145153863350243 +3415317000,0.3130797403391143,0.2148904697699572 +3420316000,0.3136249062915359,0.2152635829400356 +3425315000,0.314169811898654,0.2156347332386331 +3430314000,0.3147144530242936,0.2160039280360106 +3435313000,0.3152588255711919,0.2163711746796488 +3440312000,0.3158029254806269,0.2167364804942442 +3445311000,0.316346748731954,0.2170998527816539 +3450310000,0.3168902913420288,0.2174612988208028 +3455309000,0.3174335493659259,0.217820825868129 +3460308000,0.3179765188953321,0.2181784411570541 +3465307000,0.318519196059466,0.2185341518985159 +3470306000,0.3190615770239749,0.2188879652806476 +3475305000,0.3196036579916837,0.2192398884692298 +3480304000,0.3201454352008966,0.2195899286071334 +3485303000,0.3206869049259973,0.2199380928147082 +3490302000,0.3212280634778721,0.2202843881900937 +3495301000,0.3217689072014553,0.220628821808362 +3500300000,0.3223094324782927,0.220971400722687 +3505299000,0.32284963572412,0.2213121319635124 +3510298000,0.3233895133891123,0.2216510225387939 +3515297000,0.3239290619590163,0.2219880794345643 +3520296000,0.324468277952259,0.2223233096139499 +3525295000,0.3250071579225349,0.2226567200182998 +3530294000,0.3255456984565819,0.2229883175664626 +3535293000,0.3260838961744719,0.2233181091550292 +3540292000,0.3266217477295705,0.2236461016584404 +3545291000,0.3271592498086535,0.2239723019291715 +3550290000,0.3276963991304613,0.2242967167973036 +3555289000,0.3282331924469406,0.2246193530711242 +3560288000,0.3287696265417481,0.2249402175366912 +3565287000,0.3293056982310456,0.2252593169582536 +3570286000,0.329841404362055,0.2255766580778498 +3575285000,0.3303767418143868,0.2258922476159096 +3580284000,0.3309117074980581,0.2262060922706598 +3585283000,0.3314462983551352,0.2265181987188436 +3590282000,0.3319805113577854,0.226828573615138 +3595281000,0.3325143435090814,0.2271372235925619 +3600280000,0.3330477918427255,0.2274441552625006 +3605279000,0.3335808534223705,0.2277493752145819 +3610278000,0.3341135253411676,0.2280528900166398 +3615277000,0.3346458047231875,0.228354706215329 +3620276000,0.3351776887207829,0.2286548303353208 +3625275000,0.3357091745164371,0.2289532688800637 +3630274000,0.3362402593214062,0.2292500283314263 +3635273000,0.336770940375934,0.2295451151498953 +3640272000,0.3373012149489041,0.2298385357745648 +3645271000,0.3378310803374283,0.2301302966231109 +3650270000,0.3383605338672169,0.2304204040920352 +3655269000,0.3388895728919721,0.2307088645565707 +3660268000,0.339418194793081,0.2309956843706863 +3665267000,0.3399463969795073,0.2312808698671756 +3670266000,0.3404741768882502,0.2315644273579029 +3675265000,0.3410015319825299,0.2318463631333336 +3680264000,0.341528459753327,0.2321266834631358 +3685263000,0.3420549577182714,0.232405394595935 +3690262000,0.3425810234217381,0.2326825027594452 +3695261000,0.3431066544342076,0.232958014160381 +3700260000,0.3436318483525422,0.2332319349846519 +3705259000,0.3441566028000682,0.2335042713974875 +3710258000,0.3446809154253294,0.2337750295431527 +3715257000,0.3452047839030286,0.2340442155453548 +3720256000,0.3457282059327367,0.2343118355069458 +3725255000,0.3462511792401928,0.2345778955104142 +3730254000,0.346773701575489,0.2348424016174521 +3735253000,0.3472957707140925,0.2351053598693505 +3740252000,0.347817384455684,0.2353667762867649 +3745251000,0.3483385406252897,0.2356266568701475 +3750250000,0.3488592370713617,0.2358850075992791 +3755249000,0.3493794716675513,0.2361418344338953 +3760248000,0.3498992423103429,0.2363971433130878 +3765247000,0.3504185469209626,0.2366509401559612 +3770246000,0.3509373834439351,0.2369032308613212 +3775245000,0.3514557498476263,0.237154021307913 +3780244000,0.3519736441231049,0.2374033173542065 +3785243000,0.3524910642849495,0.2376511248387155 +3790242000,0.3530080083706852,0.2378974495799374 +3795241000,0.3535244744404133,0.2381422973763452 +3800240000,0.3540404605771397,0.2383856740065737 +3805239000,0.3545559648860228,0.2386275852293077 +3810238000,0.3550709854946508,0.2388680367834504 +3815237000,0.3555855205530842,0.2391070343882245 +3820236000,0.356099568232543,0.2393445837429195 +3825235000,0.3566131267267441,0.2395806905273357 +3830234000,0.3571261942503208,0.2398153604014568 +3835233000,0.3576387690402907,0.2400485990059342 +3840232000,0.3581508493542545,0.2402804119616941 +3845231000,0.3586624334711872,0.2405108048702481 +3850230000,0.3591735196909451,0.2407397833136405 +3855229000,0.3596841063343874,0.2409673528545825 +3860228000,0.3601941917432248,0.2411935190364969 +3865227000,0.3607037742789763,0.2414182873833335 +3870226000,0.3612128523239648,0.2416416633999222 +3875225000,0.3617214242809375,0.2418636525719645 +3880224000,0.3622294885722379,0.2420842603658979 +3885223000,0.3627370436408603,0.2423034922292606 +3890222000,0.3632440879486756,0.2425213535903368 +3895221000,0.3637506199773251,0.242737849858455 +3900220000,0.3642566382283741,0.2429529864241191 +3905219000,0.3647621412224686,0.2431667686588907 +3910218000,0.3652671274992154,0.2433792019154269 +3915217000,0.3657715956175747,0.2435902915276862 +3920216000,0.3662755441553722,0.2438000428108714 +3925215000,0.3667789717086494,0.2440084610613756 +3930214000,0.3672818768922768,0.2442155515570064 +3935213000,0.3677842583403652,0.2444213195571559 +3940212000,0.3682861147043195,0.2446257703024399 +3945211000,0.3687874446540216,0.244828909015048 +3950210000,0.3692882468775827,0.2450307408987754 +3955209000,0.3697885200806064,0.2452312711389289 +3960208000,0.3702882629870925,0.2454305049026156 +3965207000,0.3707874743383159,0.2456284473385654 +3970206000,0.371286152892665,0.2458251035771853 +3975205000,0.3717842974267849,0.2460204787308817 +3980204000,0.3722819067334546,0.2462145778936865 +3985203000,0.3727789796238257,0.2464074061418018 +3990202000,0.3732755149245384,0.2465989685330789 +3995201000,0.3737715114801909,0.2467892701076124 +4000200000,0.3742669681520387,0.2469783158875382 +4005199000,0.3747618838171818,0.2471661108769481 +4010198000,0.3752562573698424,0.2473526600622346 +4015197000,0.3757500877202526,0.2475379684119193 +4020196000,0.3762433737948598,0.2477220408767934 +4025195000,0.3767361145364181,0.2479048823900008 +4030194000,0.3772283089034005,0.2480864978669925 +4035193000,0.37771995587019,0.2482668922056418 +4040192000,0.3782110544268704,0.2484460702862765 +4045191000,0.3787016035792754,0.2486240369717652 +4050190000,0.3791916023481943,0.2488007971074379 +4055189000,0.3796810497704046,0.2489763555213485 +4060188000,0.3801699448977718,0.2491507170241815 +4065187000,0.3806582867966553,0.2493238864092143 +4070186000,0.3811460745494362,0.2494958684526746 +4075185000,0.3816333072524816,0.2496666679134265 +4080184000,0.3821199840173524,0.2498362895332724 +4085183000,0.3826061039700812,0.2500047380368934 +4090182000,0.3830916662515733,0.2501720181319822 +4095181000,0.383576670016613,0.2503381345091414 +4100180000,0.3840611144349666,0.2505030918421532 +4105179000,0.3845449986899392,0.2506668947877863 +4110178000,0.3850283219792874,0.2508295479860298 +4115177000,0.3855110835149054,0.250991056060107 +4120176000,0.3859932825217454,0.2511514236163566 +4125175000,0.3864749182395906,0.2513106552446008 +4130174000,0.3869559899212136,0.2514687555179155 +4135173000,0.3874364968334481,0.2516257289928526 +4140172000,0.3879164382558855,0.2517815802093147 +4145171000,0.3883958134819334,0.2519363136907828 +4150170000,0.3888746218176773,0.2520899339442039 +4155169000,0.3893528625833873,0.252242445460294 +4160168000,0.3898305351115881,0.2523938527133022 +4165167000,0.3903076387476316,0.2525441601611619 +4170166000,0.3907841728498502,0.2526933722455814 +4175165000,0.3912601367896513,0.2528414933921266 +4180164000,0.3917355299503942,0.2529885280101101 +4185163000,0.3922103517289981,0.2531344804928984 +4190162000,0.3926846015333967,0.2532793552175953 +4195161000,0.3931582787850156,0.2534231565454764 +4200160000,0.3936313829168625,0.2535658888217681 +4205159000,0.3941039133744071,0.253707556375839 +4210158000,0.3945758696151809,0.2538481635212066 +4215157000,0.3950472511079648,0.2539877145554813 +4220156000,0.3955180573341277,0.2541262137606249 +4225155000,0.3959882877869831,0.2542636654029101 +4230154000,0.3964579419703509,0.2544000737327963 +4235153000,0.3969270194010517,0.2545354429853226 +4240152000,0.3973955196060615,0.2546697773797871 +4245151000,0.3978634421247416,0.2548030811201095 +4250150000,0.3983307865069692,0.254935358394639 +4255149000,0.3987975523144809,0.2550666133763902 +4260148000,0.3992637391193716,0.2551968502229199 +4265147000,0.3997293465054528,0.2553260730765388 +4270146000,0.4001943740673091,0.2554542860642776 +4275145000,0.4006588214100122,0.2555814932978861 +4280144000,0.4011226881493566,0.2557076988739369 +4285143000,0.4015859739124903,0.2558329068739622 +4290142000,0.4020486783362196,0.2559571213642921 +4295141000,0.4025108010686074,0.2560803463963173 +4300140000,0.4029723417679634,0.2562025860064254 +4305139000,0.4034333001024584,0.2563238442160045 +4310138000,0.4038936757507463,0.2564441250315893 +4315137000,0.404353468402211,0.2565634324449259 +4320136000,0.4048126777549725,0.2566817704328223 +4325135000,0.4052713035185462,0.2567991429574879 +4330134000,0.4057293454119286,0.2569155539663857 +4335133000,0.4061868031633116,0.2570310073922544 +4340132000,0.4066436765114108,0.2571455071533124 +4345131000,0.4070999652039244,0.2572590571531368 +4350130000,0.407555668998854,0.257371661280876 +4355129000,0.4080107876633761,0.2574833234111742 +4360128000,0.4084653209737215,0.2575940474042155 +4365127000,0.4089192687160874,0.257703837105872 +4370126000,0.4093726306857912,0.2578126963476791 +4375125000,0.4098254066869353,0.257920628946849 +4380124000,0.4102775965333438,0.2580276387064187 +4385123000,0.4107292000474445,0.2581337294151936 +4390122000,0.4111802170607906,0.2582389048478597 +4395121000,0.4116306474138705,0.2583431687650085 +4400120000,0.4120804909556062,0.2584465249131477 +4405119000,0.4125297475445822,0.2585489770248632 +4410118000,0.4129784170471897,0.2586505288187136 +4415117000,0.4134264993389321,0.258751183999383 +4420116000,0.4138739943031988,0.2588509462576459 +4425115000,0.4143209018324769,0.258949819270506 +4430114000,0.4147672218275771,0.2590478067011906 +4435113000,0.4152129541973437,0.2591449121991705 +4440112000,0.4156580988588459,0.2592411394002424 +4445111000,0.4161026557377181,0.2593364919265918 +4450110000,0.4165466247676231,0.2594309733868077 +4455109000,0.4169900058897502,0.2595245873758863 +4460108000,0.4174327990538502,0.259617337475382 +4465107000,0.4178750042171446,0.2597092272533482 +4470106000,0.4183166213450438,0.2598002602644575 +4475105000,0.4187576504110855,0.2598904400500364 +4480104000,0.4191980913950175,0.2599797701379957 +4485103000,0.4196379442862355,0.260068254043095 +4490102000,0.420077209079764,0.2601558952667384 +4495101000,0.4205158857796283,0.2602426972972395 +4500100000,0.4209539743964872,0.2603286636097114 +4505099000,0.4213914749491847,0.2604137976662236 +4510098000,0.4218283874628328,0.2604981029157159 +4515097000,0.4222647119700913,0.2605815827941514 +4520096000,0.4227004485117931,0.2606642407245642 +4525095000,0.4231355971342639,0.2607460801169847 +4530094000,0.4235701578921274,0.2608271043686305 +4535093000,0.4240041308466382,0.2609073168638553 +4540092000,0.4244375160662037,0.2609867209742373 +4545091000,0.4248703136255814,0.261065320058577 +4550090000,0.4253025236070169,0.261143117463001 +4555089000,0.4257341460989243,0.2612201165209432 +4560088000,0.4261651811968981,0.2612963205532431 +4565087000,0.4265956290026842,0.261371732868142 +4570086000,0.4270254896252079,0.2614463567613713 +4575085000,0.4274547631793899,0.261520195516152 +4580084000,0.4278834497870123,0.2615932524032679 +4585083000,0.4283115495761234,0.2616655306810974 +4590082000,0.4287390626809053,0.2617370335956469 +4595081000,0.4291659892424387,0.2618077643806223 +4600080000,0.4295923294073054,0.2618777262574266 +4605079000,0.430018083328964,0.261946922435251 +4610078000,0.4304432511664016,0.2620153561110757 +4615077000,0.4308678330853435,0.2620830304697436 +4620076000,0.4312918292567536,0.2621499486839711 +4625075000,0.4317152398585842,0.2622161139144344 +4630074000,0.4321380650734745,0.2622815293097486 +4635073000,0.4325603050910258,0.2623461980065775 +4640072000,0.4329819601061951,0.2624101231296261 +4645071000,0.4334030303195147,0.2624733077916968 +4650070000,0.4338235159375692,0.2625357550937394 +4655069000,0.4342434171723175,0.2625974681248781 +4660068000,0.4346627342414575,0.2626584499624643 +4665067000,0.4350814673687022,0.2627187036721217 +4670066000,0.4354996167822385,0.2627782323077585 +4675065000,0.435917182716645,0.2628370389116435 +4680064000,0.4363341654112094,0.2628951265144254 +4685063000,0.4367505651114669,0.2629524981351852 +4690062000,0.4371663820670886,0.2630091567814626 +4695061000,0.437581616533957,0.2630651054493137 +4700060000,0.4379962687729231,0.263120347123337 +4705059000,0.438410339049742,0.2631748847767202 +4710058000,0.4388238276354548,0.2632287213712785 +4715057000,0.4392367348062192,0.2632818598574964 +4720056000,0.439649060843081,0.2633343031745667 +4725055000,0.4400608060321343,0.2633860542504317 +4730054000,0.4404719706644389,0.2634371160018144 +4735053000,0.4408825550358291,0.26348749133427 +4740052000,0.4412925594470865,0.2635371831422187 +4745051000,0.4417019842035739,0.2635861943089865 +4750050000,0.4421108296157623,0.263634527706846 +4755049000,0.4425190959983087,0.2636821861970531 +4760048000,0.4429267836710193,0.2637291726298823 +4765047000,0.4433338929581105,0.2637754898446752 +4770046000,0.4437404241884286,0.2638211406698743 +4775045000,0.444146377694894,0.2638661279230602 +4780044000,0.4445517538158572,0.2639104544109847 +4785043000,0.4449565528928883,0.2639541229296342 +4790042000,0.445360775272917,0.2639971362642299 +4795041000,0.4457644213072762,0.2640394971892913 +4800040000,0.4461674913502673,0.2640812084686887 +4805039000,0.4465699857619847,0.2641222728556333 +4810038000,0.4469719049063361,0.2641626930927586 +4815037000,0.447373249151007,0.2642024719121417 +4820036000,0.4477740188681594,0.2642416120353414 +4825035000,0.4481742144336647,0.2642801161734437 +4830034000,0.448573836228265,0.2643179870270755 +4835033000,0.4489728846356269,0.2643552272864835 +4840032000,0.4493713600447871,0.2643918396315166 +4845031000,0.449769262847135,0.2644278267317299 +4850030000,0.4501665934390473,0.2644631912463644 +4855029000,0.4505633522207422,0.2644979358243938 +4860028000,0.4509595395956263,0.2645320631045983 +4865027000,0.4513551559713518,0.2645655757155671 +4870026000,0.4517502017589266,0.2645984762757476 +4875025000,0.4521446773740923,0.2646307673934532 +4880024000,0.4525385832350504,0.2646624516669543 +4885023000,0.4529319197643218,0.2646935316844684 +4890022000,0.4533246873875856,0.2647240100242348 +4895021000,0.4537168865345336,0.2647538892545027 +4900020000,0.4541085176382624,0.264783171933602 +4905019000,0.454499581134715,0.264811860609998 +4910018000,0.4548900774648672,0.264839957822235 +4915017000,0.4552800070711078,0.2648674660991198 +4920016000,0.4556693704010519,0.2648943879595943 +4925015000,0.4560581679043338,0.2649207259129129 +4930014000,0.4564464000343256,0.264946482458599 +4935013000,0.4568340672481612,0.2649716600864673 +4940012000,0.4572211700054418,0.264996261276733 +4945011000,0.4576077087694219,0.2650202884999828 +4950010000,0.4579936840066621,0.2650437442172169 +4955009000,0.4583790961860135,0.2650666308799493 +4960008000,0.4587639457808639,0.2650889509301084 +4965007000,0.459148233266478,0.2651107068002248 +4970006000,0.4595319591217841,0.2651319009133536 +4975005000,0.4599151238283212,0.2651525356831834 +4980004000,0.4602977278709335,0.2651726135140046 +4985003000,0.4606797717372968,0.2651921368007913 +4990002000,0.4610612559179215,0.2652111079292265 +4995001000,0.4614421809063378,0.2652295292757206 +5000000000,0.4618225471985202,0.2652474032074784 \ No newline at end of file diff --git a/pySmithPlot/testbenches/smith_full_test.py b/pySmithPlot/testbenches/smith_full_test.py new file mode 100755 index 0000000..f10b4ce --- /dev/null +++ b/pySmithPlot/testbenches/smith_full_test.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 + +import os +import shutil +import sys +import time +from multiprocessing.pool import Pool +from types import FunctionType + +import numpy as np +from matplotlib import rcParams, pyplot as pp + +sys.path.append("..") +from smithplot.smithaxes import SmithAxes +from smithplot import smithhelper + +rcParams.update({"legend.numpoints": 3, + "axes.axisbelow": True}) + +# sample data +steps = 40 +data = np.loadtxt("data/s11.csv", delimiter=",", skiprows=1)[::steps] +sp_data = data[:, 1] + data[:, 2] * 1j + +data = np.loadtxt("data/s22.csv", delimiter=",", skiprows=1)[::steps] +z_data = 50 * (data[:, 1] + data[:, 2] * 1j) + +# default params +SmithAxes.update_scParams({"plot.marker.hack": False, + "plot.marker.rotate": False, + "grid.minor.enable": False, + "grid.minor.fancy": False}) + +FT = [False, True] +figsize = 6 +ExportFormats = ["pdf", "png"] + + +def plot_example(testbench, title, scale=50, **kwargs): + print("Testbench '%s' : %s" % (testbench, title.replace("\n", ""))) + kwargs.setdefault("markevery", 1) + pp.plot(smithhelper.moebius_inv_z(sp_data, norm=50), datatype="Z", **kwargs) + pp.plot(z_data, datatype="Z", **kwargs) + pp.plot(100, datatype="Z", **kwargs) + pp.plot(25 + 25j, datatype="Z", **kwargs) + pp.title(title) + + +def savefig(testbench): + for ext in ExportFormats: + pp.savefig("%s/sample_%s.%s" % (build_path, testbench.lower().replace(" ", "_"), ext), format=ext) + + +def tb_grid_styles(): + tb = "Grid Styles" + fig = pp.figure(figsize=(3 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + i = 0 + for major_fancy in FT: + for minor in FT: + for minor_fancy in FT: + if minor or not minor_fancy: + i += 1 + pp.subplot(2, 3, i, projection="smith", + grid_major_fancy=major_fancy, + grid_minor_enable=minor, + grid_minor_fancy=minor_fancy) + + major_str = "fancy" if major_fancy else "standard" + minor_str = "off" if not minor else "fancy" if minor_fancy else "standard" + + plot_example(tb, "Major: %s - Minor: %s" % (major_str, minor_str)) + + savefig(tb) + + +def tb_fancy_grids(): + tb = "Fancy Grid" + fig = pp.figure(figsize=(3 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + i = 0 + for threshold in [(50, 50), (100, 50), (125, 100)]: + i += 1 + pp.subplot(2, 3, i, projection="smith", + grid_major_fancy_threshold=threshold) + plot_example(tb, "Major Threshold=(%d, %d)" % threshold) + + for threshold in [15, 30, 60]: + i += 1 + pp.subplot(2, 3, i, projection="smith", + grid_minor_fancy=True, + grid_minor_enable=True, + grid_minor_fancy_threshold=threshold) + plot_example(tb, "Minor Threshold=%d" % threshold) + + savefig(tb) + + +def tb_grid_locators(): + tb = "Grid Locators" + fig = pp.figure(figsize=(4 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + i = 0 + for num in [5, 8, 14, 20]: + i += 1 + pp.subplot(2, 4, i, projection="smith", + grid_major_xmaxn=num) + plot_example(tb, "Max real steps: %d" % num) + + for num in [6, 14, 25, 50]: + i += 1 + pp.subplot(2, 4, i, projection="smith", + grid_major_ymaxn=num) + plot_example(tb, "Max imaginary steps: %d" % num) + + savefig(tb) + + +def tb_normalize(): + tb = "Normalize" + fig = pp.figure(figsize=(3 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + i = 0 + for normalize in FT: + for impedance in [10, 50, 200]: + i += 1 + pp.subplot(2, 3, i, projection="smith", + axes_impedance=impedance, + axes_normalize=normalize) + plot_example(tb, "Impedance: %d Ω — Normalize: %s" % (impedance, normalize)) + + savefig(tb) + + +def tb_markers(): + tb = "Markers" + VStartMarker = np.array([[0, 0], [0.5, 0.5], [0, -0.5], [-0.5, 0.5], [0, 0]]) + XEndMarker = np.array([[0, 0], [0.5, 0.5], [0.25, 0], [0.5, -0.5], [0, 0], [-0.5, -0.5], [-0.25, 0], [-0.5, 0.5], [0, 0]]) + + fig = pp.figure(figsize=(4 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + i = 0 + for hackline, startmarker, endmarker, rotate_marker in [[False, None, None, False], + [True, "s", "^", False], + [True, "s", None, False], + [True, VStartMarker, XEndMarker, False], + [True, "s", "^", True], + [True, None, "^", False]]: + i += 1 + ax = pp.subplot(2, 3, i, projection="smith", + plot_marker_hack=hackline, + plot_marker_rotate=rotate_marker) + SmithAxes.update_scParams(instance=ax, plot_marker_start=startmarker, + plot_marker_end=endmarker) + + def ptype(x): + if isinstance(x, np.ndarray): + return "custom" + elif x is True: + return "on" + elif x is False: + return "off" + elif x is None: + return None + else: + return "'%s'" % x + + plot_example(tb, "HackLines: %s - StartMarker: %s\nEndMarker: %s - Rotate: %s" % tuple(map(ptype, [hackline, startmarker, endmarker, rotate_marker])), markersize=10) + + savefig(tb) + + +def tb_interpolation(): + tb = "Interpolation" + fig = pp.figure(figsize=(3 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + i = 0 + for interpolation, equipoints in [[False, False], + [10, False], + [False, 10], + [False, 50]]: + i += 1 + pp.subplot(2, 2, i, projection="smith") + plot_example(tb, "Interpolation: %s — Equipoints: %s" % ("False" if interpolation is False else interpolation, + "False" if equipoints is False else equipoints), interpolate=interpolation, equipoints=equipoints) + + savefig(tb) + + +def tb_misc(): + tb = "Miscellaneous" + fig = pp.figure(figsize=(3 * figsize, 2 * figsize)) + fig.set_tight_layout(True) + + pp.subplot(2, 3, 1, projection="smith", + plot_marker_hack=True) + plot_example(tb, "Legend") + pp.legend(["S11", "S22", "Polyline", "Z \u2192 0.125l/\u03BB"]) + + divs = [1, 3, 7] + pp.subplot(2, 3, 2, projection="smith", + grid_minor_enable=True, + grid_minor_fancy=True, + grid_minor_fancy_dividers=divs) + plot_example(tb, "Minor fancy dividers=%s" % divs) + + pp.subplot(2, 3, 3, projection="smith", + axes_radius=0.3) + plot_example(tb, "Axes radius: 0.25") + + pp.subplot(2, 3, 4, projection="smith", + symbol_infinity="Inf", + symbol_infinity_correction=0, + symbol_ohm="Ohm") + plot_example(tb, "Infinity symbol: 'Inf' — Ohm symbol: Ohm") + + pp.subplot(2, 3, 5, projection="smith", + grid_locator_precision=4) + plot_example(tb, "Grid Locator Precision: 4") + + pp.subplot(2, 3, 6, projection="smith", + axes_xlabel_rotation=0) + plot_example(tb, "Axes X Label Rotation: 0") + + savefig(tb) + + +build_all = True +build_path = "./build" + +if __name__ == '__main__': + # clear and create path + if os.path.exists(build_path): + shutil.rmtree(build_path) + time.sleep(0.5) + os.makedirs(build_path) + + if build_all: + print("Start parallel testbenches...") + p = Pool() + r = [] + for key, func in locals().copy().items(): + if isinstance(func, FunctionType) and "tb_" in key: + r += [p.apply_async(func, {})] + + for proc in r: + proc.get() + else: + pass + # tb_grid_styles() + # tb_fancy_grids() + # tb_grid_locators() + # tb_normalize() + tb_markers() + # tb_interpolation() + # tb_misc() + pp.show() + + print("build finished") diff --git a/pySmithPlot/testbenches/smith_short_test.py b/pySmithPlot/testbenches/smith_short_test.py new file mode 100755 index 0000000..3e43953 --- /dev/null +++ b/pySmithPlot/testbenches/smith_short_test.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 + +import sys + +import numpy as np +from matplotlib import rcParams, pyplot as pp + +rcParams.update({"legend.numpoints": 3}) + +sys.path.append("..") +from smithplot import SmithAxes + +# sample data +data = np.loadtxt("data/s11.csv", delimiter=",", skiprows=1)[::100] +val1 = data[:, 1] + data[:, 2] * 1j + +data = np.loadtxt("data/s22.csv", delimiter=",", skiprows=1)[::100] +val2 = data[:, 1] + data[:, 2] * 1j + +# plot data +pp.figure(figsize=(6, 6)) + +ax = pp.subplot(1, 1, 1, projection='smith') +pp.plot([10, 100], markevery=1) + + +pp.plot(200 + 100j, datatype=SmithAxes.Z_PARAMETER) +pp.plot(50 * val1, label="default", datatype=SmithAxes.Z_PARAMETER) +pp.plot(50 * val2, markevery=1, label="interpolate=3", interpolate=3, datatype=SmithAxes.Z_PARAMETER) +pp.plot(val1, markevery=1, label="equipoints=22", equipoints=22, datatype=SmithAxes.S_PARAMETER) +pp.plot(val2, markevery=3, label="equipoints=22, \nmarkevery=3", equipoints=22, datatype=SmithAxes.S_PARAMETER) + +leg = pp.legend(loc="lower right", fontsize=12) +pp.title("Matplotlib Smith Chart Projection") + +pp.savefig("export.pdf", format="pdf", bbox_inches="tight") +pp.show() diff --git a/tankPlot.py b/tankPlot.py new file mode 100644 index 0000000..1605a1d --- /dev/null +++ b/tankPlot.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 + +import numpy as np +from matplotlib import rcParams, pyplot as pp + +rcParams['figure.figsize'] = [10,7] +default_window_position='+20+80' + +import sys +sys.path.append("./pySmithPlot") +import smithplot +from smithplot import SmithAxes +################################################################################ +# Operating Enviornment +##### +f0 = 28 +bw0 = 6.5 # assumed tuning range (GHz) +bw_plt = 0.5 # Plotting range (GHz) +fbw = bw0/f0 # fractional bandwidth + +frequency_sweep_steps = 101 +gamma_sweep_steps = 11 + +gamma = 1 - np.power(f0 / (f0 + bw0/2),2) +gamma_limit_ratio = 0.99 # how close gamma can get to theoretical extreme + +# Configuration Of Hardware +##### +q1_L = 10 +q1_C = 10 +l1 = 100e-3 # nH +gm1 = 25e-3 # S + +# Compute frequency sweep +##### +w0 = f0*2*np.pi +fbw_plt = bw_plt/f0 +delta = np.linspace(-fbw_plt/2,fbw_plt/2,frequency_sweep_steps) +w = w0*(1+delta) +f = f0*(1+delta) +jw = 1j*w + +################## +# Compute system +##### +c1 = 1/(w0*w0*l1) +g1_L = 1 / (q1_L*w0*l1) +g1_C = w0 * c1 / q1_C +g1 = g1_L + g1_C + +# Verify gamma is valid +##### +gamma_max = g1 * np.sqrt(l1/c1) +if gamma > (gamma_limit_ratio * gamma_max): + print("==> WARN: Gamma to large, reset to %.3f (was %.3f) <==" % \ + (gamma_max_cap*gamma_max, gamma)) + gamma = gamma_max_cap*gamma_max + +gamma_swp = np.linspace(-gamma,gamma,gamma_sweep_steps); +# compute correction factor for g1 that will produce common gain at f0 +g1_swp = np.sqrt( g1*g1 - (gamma_swp*gamma_swp) * c1/l1 ) +# and compute how much of a negative gm this requres, and it's relative +# proportion to the gm of the assumed main amplifier gm. +g1_boost = (g1_swp - g1) +g1_ratio = -g1_boost / gm1 + +c1_swp = c1 * (1 + gamma_swp) + +## Report System Descrption +print(' L1 = %.3fpH, C1 = %.3ffF' % (1e3*l1, 1e6*c1)) +print(' Rp = %.3f Ohm' % (1/g1)) +print(' Max G1 boost %.2fmS (%.1f%% of gm1)' % \ + (1e3*np.max(np.abs(g1_boost)), 100*np.max(g1_ratio))) + +def db(volt_tf): + return 20*np.log10(np.abs(volt_tf)) +def ang(volt_tf): + return 180/np.pi*np.angle(volt_tf) + +#y_tank=np.zeros((len(delta),len(gamma_swp))) +h1 = pp.figure() +mgr = pp.get_current_fig_manager() +ax1 = h.add_subplot(2,2,(1,3), projection='smith') +ax3 = h.add_subplot(2,2,2) +ax4 = h.add_subplot(2,2,4) +for itune,gamma_tune in enumerate(gamma_swp): + c1_tune = c1_swp[itune] + g1_tune = g1_swp[itune] + K = np.sqrt(c1/l1)/g1_tune + y_tank = g1_tune + jw*c1_tune + 1/(jw * l1) + #print(1/np.mean(np.abs(y_tank))) + ax1.plot(y_tank, datatype=SmithAxes.Y_PARAMETER, marker="None") + tf = gm1 / g1_tune * \ + 1j*(1+delta) / \ + ( 1j*(1+delta) + K*(1 - (1+gamma_tune)*np.power(1+delta,2)) ) + ax3.plot(f,db(tf)) + ax4.plot(f,ang(tf)) + +################################################################################ +ax1.set_title('Tank Impedance') + +ax3.set_title('TF Gain') +ax3.set_ylabel('Gain (dB)') +ax4.set_title('TF Phase') +ax3.set_ylabel('Phase (deg)') +for ax_T in [ax3, ax4]: + ax_T.grid() + ax_T.set_xlabel('Freq (GHz)') + ax_T.set_xlim(( np.min(f), np.max(f) )) + +h.tight_layout() +mgr.window.geometry(default_window_position) +h.show()