diff --git a/docs/source/examples/positionswitch.rst b/docs/source/examples/positionswitch.rst index 3950b3bf..c2e5c2ab 100644 --- a/docs/source/examples/positionswitch.rst +++ b/docs/source/examples/positionswitch.rst @@ -168,7 +168,8 @@ The :meth:`~dysh.spectra.spectrum.Spectrum.plot` command allows changing of axis :alt: The spectrum plot zoomed in along both axes to frame a central emission line. .. WARNING:: - At this point, `dysh` does not handle Doppler corrections. So the frequency and velocity information will be wrong for observations requesting a reference frame other than Topocentric. + At this point, `dysh` does not handle Doppler corrections. + So the frequency and velocity information will be offset for observations requesting a reference frame other than Topocentric. Removing a baseline diff --git a/docs/source/for_beta_testers/beta_testing.rst b/docs/source/for_beta_testers/beta_testing.rst index b48737db..afe6d27f 100644 --- a/docs/source/for_beta_testers/beta_testing.rst +++ b/docs/source/for_beta_testers/beta_testing.rst @@ -2,14 +2,40 @@ Instructions for Beta Testers ***************************** -Instructions +For beta testing we ask that your provide feedback in the form of: + +* Reporting issues. For example, if something does not work or the results are not accurate. +* Making suggestions. For example, requesting new features. +* Letting us know what you think. + +If you are interested in beta testing `dysh`, please contact Pedro Salas (psalas@nrao.edu) to be added to the beta testers list. Thanks for your interest! + Providing feedback ================== -If you encounter a problem with `dysh`, would like to request a new feature or enhancement or would like to leave feedback, please do so using `GitHub issues `_. There are some basic instructions of how to do this :ref:`here `. +If you encounter a problem with `dysh`, would like to request a new feature or enhancement or would like to leave feedback, please do so using `GitHub issues `_. There are some basic instructions of how to do this :ref:`here `. This requires `creating a free account `_ on GitHub if you do not have one. + +If you prefer not to create a GitHub account, please provide your feedback to the `dysh-beta mailing list `_, or send an email to dysh-beta@googlegroups.com. Additionally, we will provide a `form for collecting feedback `_. + +When providing feedback, please provide + +* `Python` version +* `dysh` version +* operating system + +If reporting an issue please also provide + +* the input data (either as a link or a location inside the GBO computing environment) +* a minimum working example to reproduce the error +* outputs (for example, error messages or figures) +* any additional information that might help us reproduce and understand the problem + Example feedback ---------------- -Give and example of how to provide useful feedback when facing an issue. +Here are examples of feedback on GitHub + +* reporting an issue, `Issue #88 `_ +* requesting a modification, `Issue #78, `_ diff --git a/docs/source/for_beta_testers/index.rst b/docs/source/for_beta_testers/index.rst index d9d8181c..adb484db 100644 --- a/docs/source/for_beta_testers/index.rst +++ b/docs/source/for_beta_testers/index.rst @@ -2,7 +2,7 @@ For Beta Testers **************** -Here's some info that developers might find useful +Here's some info that beta testers might find useful .. toctree:: :maxdepth: 2 diff --git a/docs/source/for_developers/index.rst b/docs/source/for_developers/index.rst index d93d7102..200de308 100644 --- a/docs/source/for_developers/index.rst +++ b/docs/source/for_developers/index.rst @@ -8,6 +8,7 @@ Here's some info that developers might find useful :maxdepth: 2 contributing + install doc_standards github_integrations git_workflows diff --git a/docs/source/for_developers/install.rst b/docs/source/for_developers/install.rst new file mode 100644 index 00000000..a835d6a5 --- /dev/null +++ b/docs/source/for_developers/install.rst @@ -0,0 +1,60 @@ +*************************** +Installation for Developers +*************************** + +Here are the steps to install ``dysh`` if you want to develop code. + +We use `hatch `_ to manage the build environment. +The usual caveats apply how you set up your python development environment. + +#. Clone the repo and install hatch. + + .. code-block:: bash + + $ git clone git@github.com:GreenBankObservatory/dysh.git + $ cd dysh + $ pip install hatch + +#. Create and activate a virtual environment with hatch and install the packages required for development. + The virtual environment will be created the first time; subsequent invoking ``hatch shell`` will simply load the created environment. + + .. code-block:: bash + + $ hatch shell + (dysh) $ pip install -r requirements_dev.txt + +#. Build and install the package + + .. code-block:: bash + + (dysh) $ hatch build + (dysh) $ pip install -e . + +#. You can exit this environment (which effectively had started a new shell). + + .. code-block:: bash + + (dysh) $ exit + $ + +#. Each time when you come back in this directory without being in this virtual environment, you'll need to load the virtual environment. + + .. code-block:: bash + + $ hatch shell + +Notice you can *only* do that from within the original install directory tree. + +Additional Installation Options +------------------------------- + +.. include:: install_developer.rst + +Testing +======= +We use `pytest` for unit and integration testing. +From the top-level dysh directory, run: + +.. code-block:: bash + + $ pytest diff --git a/docs/source/getting_started/install_developer.md b/docs/source/for_developers/install_developer.rst similarity index 76% rename from docs/source/getting_started/install_developer.md rename to docs/source/for_developers/install_developer.rst index ef7279b2..71cc02c6 100644 --- a/docs/source/getting_started/install_developer.md +++ b/docs/source/for_developers/install_developer.rst @@ -1,18 +1,21 @@ -# Developer Install -The dysh README suggests a route to install **dysh** using -**hatch**. As suggested also, there are several ways how you can -install **dysh** for development. We give a few practical examples, all -based on having "dyshN" directories in my ~/GBT directory. It is imperative -that a developer install takes place in a shielded environment, generally -using a virtual environment. We list a few, but if you found another approach, -please share. +The previous instructions (and the ``dysh`` README) suggest a route to install ``dysh`` using `hatch`. +However, there are several ways how you can install ``dysh`` for development. +We give a few practical examples, all based on having "dyshN" directories in a ~/GBT directory. +It is imperative that a developer install takes place in a shielded environment, generally using a virtual environment. -## dysh1: native Python +We list a few, but if you found another approach, please share. + +.. _dysh1: + +dysh1: native Python +^^^^^^^^^^^^^^^^^^^^ Here is an example using native python on a vanilla Ubuntu system (python version 3.11 may be different). You will need initial admin privilages for this. +.. code:: bash + # first ensure your native python has at least a way to run pip and allow a venv sudo apt install python3 python3-pip ipython3 python3.11-venv jupyter-core @@ -28,6 +31,8 @@ You will need initial admin privilages for this. After this dysh can be installed in a virtual environment controlled by hatch +.. code:: bash + mkdir ~/GBT/dysh1 cd ~/GBT/dysh1 git clone https://github.com/GreenBankObservatory/dysh @@ -45,34 +50,41 @@ After this dysh can be installed in a virtual environment controlled by hatch Any time development is needed: +.. code:: bash + source $HOME/venv/dysh1/bin/activate cd ~/GBT/dysh1/dysh hatch shell and as always, verify it's there: +.. code:: bash + python -c 'import dysh; print(dysh.__version__)' echo "git BRANCH: $(git branch --show-current) HEAD: $(git rev-list --count HEAD)" and when done, exit the hatch sub-shell - exit - -this will still return to the native virtual environment, so one more exit is needed to kill this shell +.. code:: bash exit +this will still return to the native virtual environment, so one more exit is needed to kill this shell +.. code:: bash + exit +.. _dysh2: - - -## dysh2: anaconda3 python +dysh2: anaconda3 python +^^^^^^^^^^^^^^^^^^^^^^^ Here is an example using an anaconda3 python, no virtual environments, no hatch, no nothing. Simple and self-contained, but with an anaconda3 to maintain. +.. code:: bash + mkdir ~/GBT/dysh2 cd ~/GBT/dysh2 @@ -85,28 +97,34 @@ Simple and self-contained, but with an anaconda3 to maintain. pip install -r docs/requirements.txt pip install -e . - any time development is needed: +.. code:: bash + source ~/GBT/dysh2/python_start.sh and verify +.. code:: bash + python -c 'import dysh; print(dysh.__version__)' echo "git BRANCH: $(git branch --show-current) HEAD: $(git rev-list --count HEAD)" and when done, exit will terminate the shell - exit - - +.. code:: bash + exit +.. _dysh3: -## dysh3: anaconda3 python with virtual environment +dysh3: anaconda3 python with virtual environment +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Here is an example using an anaconda3 python, but now using hatch +.. code:: bash + mkdir ~/GBT/dysh3 cd ~/GBT/dysh3 @@ -116,7 +134,9 @@ Here is an example using an anaconda3 python, but now using hatch pip install hatch After this dysh can be installed in a virtual environment controlled by hatch, -pretty much following what we did in *dysh1*: +pretty much following what we did in :ref:`dysh1`: + +.. code:: bash git clone https://github.com/GreenBankObservatory/dysh cd dysh @@ -130,37 +150,46 @@ pretty much following what we did in *dysh1*: and verify +.. code:: bash + python -c 'import dysh; print(dysh.__version__)' echo "git BRANCH: $(git branch --show-current) HEAD: $(git rev-list --count HEAD)" and when done, exit will terminate the shell +.. code:: bash + exit Any time development is needed: +.. code:: bash + source $HOME/GBT/dysh3/python_start.sh cd ~/GBT/dysh3/dysh hatch shell - - - -## Sample workflows +Sample workflows +---------------- Minor issue: with hatch, if you're not in the code tree (much like git) you don't know where your code tree is. Do we need peter's "rc" files. Do we need a module file? -### Simple dysh commands +Simple ``dysh`` Commands +^^^^^^^^^^^^^^^^^^^^^^^^ +.. code:: bash python -c 'import dysh; print(dysh.__version__)' python -c 'import dysh; print(dysh.__file__)' -### Building Documentation +Building Documentation +^^^^^^^^^^^^^^^^^^^^^^ + +.. code:: bash cd dysh/docs make html diff --git a/docs/source/getting_started/index.rst b/docs/source/getting_started/index.rst index bec888ae..3309e996 100644 --- a/docs/source/getting_started/index.rst +++ b/docs/source/getting_started/index.rst @@ -5,7 +5,7 @@ Getting Started Here's how you get started .. toctree:: - :maxdepth: 2 + :maxdepth: 2 - install - install_developer + install + tutorials/index diff --git a/docs/source/getting_started/install.rst b/docs/source/getting_started/install.rst index f1d2ba3b..f7357a81 100644 --- a/docs/source/getting_started/install.rst +++ b/docs/source/getting_started/install.rst @@ -32,64 +32,5 @@ To install from github without creating a separate virtual environment: $ cd dysh $ pip install -e . -If you wish to install using a virtual environment, which we strongly recommend if you plan to contribute to the code, see `Development`_. - -Development -=========== - -Here are the steps if you want to develop code for ``dysh``. - -Installation ------------- - -We use `hatch `_ to manage the build environment. -The usual caveats apply how you set up your python development environment. - -#. Clone the repo and install hatch. - - .. code-block:: bash - - $ git clone git@github.com:GreenBankObservatory/dysh.git - $ cd dysh - $ pip install hatch - - -#. Create and activate a virtual environment with hatch and install the packages required for development. -The virtual environment will be created the first time; subsequent invoking ``hatch shell`` will simply load the created environment. - - .. code-block:: bash - - $ hatch shell - (dysh) $ pip install -r requirements_dev.txt - - -#. Build and install the package - - .. code-block:: bash - - (dysh) $ hatch build - (dysh) $ pip install -e . - -#. You can exit this environment (which effectively had started a new shell). - - .. code-block:: bash - - (dysh) $ exit - $ - -#. Each time when you come back in this directory without being in this virtual environment, you'll need to load the virtual environment. - - .. code-block:: bash - - $ hatch shell - -Notice you can *only* do that from within the original install directory tree. - -Testing -------- - We use pytest for unit and integration testing. From the top-level dysh directory, run: - -.. code-block:: bash - - $ pytest +If you wish to install using a virtual environment, which we strongly recommend if you plan to contribute to the code, see :doc:`installation instructions for developers <../for_developers/install>`. diff --git a/docs/source/getting_started/tutorials/GBT/img/ps_152.png b/docs/source/getting_started/tutorials/GBT/img/ps_152.png new file mode 100644 index 00000000..b9a6360a Binary files /dev/null and b/docs/source/getting_started/tutorials/GBT/img/ps_152.png differ diff --git a/docs/source/getting_started/tutorials/GBT/img/ps_152_zoom.png b/docs/source/getting_started/tutorials/GBT/img/ps_152_zoom.png new file mode 100644 index 00000000..922903e7 Binary files /dev/null and b/docs/source/getting_started/tutorials/GBT/img/ps_152_zoom.png differ diff --git a/docs/source/getting_started/tutorials/GBT/index.rst b/docs/source/getting_started/tutorials/GBT/index.rst new file mode 100644 index 00000000..deafffec --- /dev/null +++ b/docs/source/getting_started/tutorials/GBT/index.rst @@ -0,0 +1,7 @@ +********************** +Tutorials for GBT Data +********************** + +.. toctree:: + :maxdepth: 2 + tutorial-positionswitch diff --git a/docs/source/getting_started/tutorials/GBT/tutorial-positionswitch.rst b/docs/source/getting_started/tutorials/GBT/tutorial-positionswitch.rst new file mode 100644 index 00000000..0eed9b88 --- /dev/null +++ b/docs/source/getting_started/tutorials/GBT/tutorial-positionswitch.rst @@ -0,0 +1,90 @@ +*************************************** +Working with GBT Position-Switched Data +*************************************** + +Learning Goals +============== + +* Installing `dysh` using `pip`. +* Showing a summary of your data. +* Calibrating a position switched pais of scans using `getps`. +* Plotting the time averaged calibrated data. + +Summary +======= + +In this tutorial you will learn how to use `dysh` to work with position switched data observed with the Green Bank Telescope (GBT). + +The tutorial will walk you through how to install `dysh`, download a raw GBT SDFITS file using `wget`, and then use `dysh` to get a summary of the contents of an SDFITS file, calibrate the raw data and display it. + +Tutorial +======== + +Installing `dysh` +----------------- + +You can install `dysh` using `pip`. From a terminal type + +.. code:: bash + + pip install dysh + +Downloading the raw data +------------------------ + +In a `Python` instance, type + +.. code:: python + + >>> import wget + >>> url = "http://www.gb.nrao.edu/dysh/example_data/onoff-L/data/TGBT21A_501_11.raw.vegas.fits" + >>> filename = wget.download(url) + >>> print(filename) + TGBT21A_501_11.raw.vegas.fits + +Keep the `Python` instance open, we will start working with `dysh` now. + +Inspecting the raw data +----------------------- + +To import the relevant `dysh` functions type + +.. code:: python + + >>> from dysh.fits.gbtfitsload import GBTFITSLoad + +Now you will load the raw data and show a summary of its contents + +.. code:: python + + >>> sdfits = GBTFITSLoad(filename) + >>> sdfits.summary() + SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL # INT # FEED AZIMUTH ELEVATIO + 0 152 NGC2415 3784.0 OnOff 1 1.617185 1.420406 5 2 151 1 286.218008 41.62843 + 1 153 NGC2415 3784.0 OnOff 2 1.617185 1.420406 5 2 151 1 286.886521 41.118134 + +Calibrating a position switched scan +------------------------------------ + +The following lines will let you calibrate and time average the position switched pair of scans 152 and 153. + +.. code:: python + + >>> psscan = sdfits.getps(152, ifnum=0, plnum=0) + PSSCAN nrows = 302 + >>> psscan.calibrate() + >>> ta = psscan.timeaverage(weights='tsys') + +Plotting the calibrated data +---------------------------- + +.. code:: python + + >>> ta.plot(xaxis_unit="km/s",yaxis_unit="mK",ymin=-100,ymax=500,xmin=3000,xmax=4500) + +.. figure:: img/ps_152_zoom.png + :alt: The spectrum plot zoomed in along both axes to frame a central emission line. + +.. WARNING:: + At this point, `dysh` does not handle Doppler corrections. + So the frequency and velocity information will be offset for observations requesting a reference frame other than Topocentric. diff --git a/docs/source/getting_started/tutorials/index.rst b/docs/source/getting_started/tutorials/index.rst new file mode 100644 index 00000000..b8bfda00 --- /dev/null +++ b/docs/source/getting_started/tutorials/index.rst @@ -0,0 +1,10 @@ +********* +Tutorials +********* + +Tutorials on how to use `dysh`. + +.. toctree:: + :maxdepth: 1 + + GBT/tutorial-positionswitch diff --git a/docs/source/index.rst b/docs/source/index.rst index 08a54861..19c20b23 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,5 +1,5 @@ ****************** -Dysh Documentation +``dysh`` Documentation ****************** ``dysh`` is a Python spectral line data reduction and analysis program for singledish data with specific emphasis on data from the Green Bank Telescope. It is currently under development in collaboration between the `Green Bank Observatory `_ @@ -15,13 +15,13 @@ Contents background/index getting_started/index - design/index - gui/index - modules/index examples/index - performance_testing/index + modules/index for_beta_testers/index for_developers/index + performance_testing/index + design/index + gui/index Indices and tables ================== @@ -34,8 +34,8 @@ Reporting Issues ================ If you find a bug or something you think is in error, please report it on -the `github issue tracker `_. -You must have a `Github account `_ to submit an issue. +the `GitHub issue tracker `_. +You must have a `GitHub account `_ to submit an issue. Credits diff --git a/docs/source/performance_testing/performance.rst b/docs/source/performance_testing/performance.rst index c110dbf8..297c1d43 100644 --- a/docs/source/performance_testing/performance.rst +++ b/docs/source/performance_testing/performance.rst @@ -13,7 +13,7 @@ Using our prototype design of `SDFITSLoad` and a spectrum class based on `specut 3. Creating a spectrum object for each row in the bintable 4. Removing baselines of order 1, 2 and 3 from each spectrum, excluding the inner 25% of channels from the fit. -The equivalent GBTIDL commands were also profiled, as well as a pure `numpy` and pure C approach for steps 1 and 4. The latter represents the maximum possible speed at which an operation could run. +The equivalent `GBTIDL` commands were also profiled, as well as a pure `numpy` and pure `C` approach for steps 1 and 4. The latter represents the maximum possible speed at which an operation could run. We used SDFITS files between 4MB and 23GB in size with number of rows ranging between 352 and 92032 and number of channels ranging between 1024 and 65536. @@ -25,3 +25,4 @@ The result is that `dysh` performs **better** than `GBTIDL` in loading and index Performance of `dysh` versus `GBTIDL` in common operations. `dysh` is significantly faster in loading SDFITS files and creating indices (equivalent of GBTIDL index file) and creating spectra. It is comparable in removing baselines of arbitrary order. No attempt was made to optimize the prototype `dysh` code. +For those interested, you can find the `GBTIDL` code used for this comparison in this `repo `_. diff --git a/notebooks/developer/frequency_axis.ipynb b/notebooks/developer/frequency_axis.ipynb new file mode 100644 index 00000000..23afd418 --- /dev/null +++ b/notebooks/developer/frequency_axis.ipynb @@ -0,0 +1,365 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c724d3b0-16fd-461e-a6f0-d19733e47f08", + "metadata": {}, + "source": [ + "Example notebook describing the problem with the current computation of the frequency axis in `dysh`.\n", + "\n", + "The filenames and paths are specified within the GBO hosts." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed0b1464-1ea7-4b89-a86e-10555e8ec09d", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f0b3d628-6453-4fa6-9834-eeee139b5205", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from astropy.io import fits\n", + "from astropy import units as u\n", + "from astropy import constants as ac\n", + "\n", + "from dysh.fits.gbtfitsload import GBTFITSLoad" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fcf224e9-b839-4212-bfa0-51b2ef37db1d", + "metadata": {}, + "outputs": [], + "source": [ + "# This assumes you are working in one of the Green Bank hosts.\n", + "filename = \"/home/dysh/example_data/onoff-L/data/TGBT21A_501_11.raw.vegas.fits\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "25f99d23-42b4-435b-9245-c80d564b053a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: UnitsWarning: 'mmHg' did not parse as fits unit: At col 0, Unit 'mmHg' not supported by the FITS standard. If this is meant to be a custom unit, define it with 'u.def_unit'. To have it recognized inside a file reader or other code, enable it with 'u.add_enabled_units'. For details, see https://docs.astropy.org/en/latest/units/combining_and_defining.html [astropy.units.core]\n", + "WARNING: UnitsWarning: 'UTC' did not parse as fits unit: At col 0, Unit 'UTC' not supported by the FITS standard. Did you mean TC, uC or uT? If this is meant to be a custom unit, define it with 'u.def_unit'. To have it recognized inside a file reader or other code, enable it with 'u.add_enabled_units'. For details, see https://docs.astropy.org/en/latest/units/combining_and_defining.html [astropy.units.core]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PSSCAN nrows = 302\n" + ] + } + ], + "source": [ + "# Load the data and calibrate to generate a `Spectrum1D` object with frequency information.\n", + "sdfits = GBTFITSLoad(filename)\n", + "psscan = sdfits.getps(152, ifnum=0, plnum=0)\n", + "psscan.calibrate()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e24355e3-7987-4c35-9716-8255ca5f6125", + "metadata": {}, + "outputs": [], + "source": [ + "# Save the frequency computed by `dysh` to compare.\n", + "freq_dysh = psscan.calibrated(0).spectral_axis" + ] + }, + { + "cell_type": "markdown", + "id": "331c02fd-6a44-449d-a74a-7aaf251270a1", + "metadata": {}, + "source": [ + "Now, let's compute the frequency in the frame requested at the time of the observations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7e15b90d-6fde-4514-bd52-6bdeacbbaf4e", + "metadata": {}, + "outputs": [], + "source": [ + "hdu = fits.open(filename)\n", + "table = hdu[1].data\n", + "# Extract frequency axis parameters, for the first row only.\n", + "crval1 = table[\"CRVAL1\"][0]\n", + "crpix1 = table[\"CRPIX1\"][0]\n", + "cdelt1 = table[\"CDELT1\"][0]\n", + "vframe = table['VFRAME'][0] * u.m/u.s # Use the velocity frame requested by the user.\n", + "\n", + "# Compute the correction factor.\n", + "beta = vframe/ac.c\n", + "vcorr = np.sqrt((1.0 + beta)/(1.0 - beta))\n", + "\n", + "# The +1 is to start counting from 1.\n", + "indx = np.arange(table[\"DATA\"].shape[1]) + 1\n", + "freq = (crval1 + cdelt1*(indx - crpix1))" + ] + }, + { + "cell_type": "markdown", + "id": "50dd3d82-9b54-41d5-9e24-6ead48861ac7", + "metadata": {}, + "source": [ + "It is worth pointing out that `vframe` is just the velocity of the corresponding reference frame, so the above can be generalized to any other reference frame by computing `vframe` for whichever velocity frame is desired. See freqtofreq.pro in `GBTIDL`.\n", + "\n", + "Compare the results on a figure." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b8516aad-fc66-4572-8dd3-d3905a549754", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c785d5000e854180912c5da27137c6e9", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.subplot(211)\n", + "plt.plot(freq, label=\"by hand\")\n", + "plt.plot(freq_dysh.to(\"Hz\").value, label=\"dysh\")\n", + "plt.legend()\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.subplot(212)\n", + "plt.plot(freq - freq_dysh.to(\"Hz\").value)\n", + "plt.ylabel(\"Difference (Hz)\")\n", + "plt.xlabel(\"Channel number\");" + ] + }, + { + "cell_type": "markdown", + "id": "51c59a8e-0af8-4ea7-b098-17f361dc405b", + "metadata": {}, + "source": [ + "Without any corrections we get the same answer.\n", + "\n", + "Now apply the correction factor to get the data in the requested reference frame." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f8ae2bc6-c4dc-42ce-aef2-f763ec392850", + "metadata": {}, + "outputs": [], + "source": [ + "freq_corr = freq * vcorr" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "28ff5834-08e1-44dc-a826-0abd54990877", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fcc4c0e29f4a4e229c10a5f3c409d20e", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.subplot(211)\n", + "plt.plot(freq_corr, label=\"by hand in reference frame\")\n", + "plt.plot(freq_dysh.to(\"Hz\").value, label=\"dysh\")\n", + "plt.legend()\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.subplot(212)\n", + "plt.plot(freq_corr - freq_dysh.to(\"Hz\").value)\n", + "plt.ylabel(\"Difference (Hz)\")\n", + "plt.xlabel(\"Channel number\");" + ] + }, + { + "cell_type": "markdown", + "id": "09357c7a-8034-4c48-b604-914a82deb65f", + "metadata": {}, + "source": [ + "The difference is ~71 kHz, but it is not a constant." + ] + }, + { + "cell_type": "markdown", + "id": "236219d2-dfa0-4a0f-a775-acb32b90d004", + "metadata": {}, + "source": [ + "Now compare with the output from `GBTIDL`.\n", + "\n", + "To generate the output from GBTIDL:\n", + "\n", + "```\n", + "filein,\"/home/dysh/example_data/onoff-L/data/TGBT21A_501_11.raw.vegas.fits\"\n", + "getps,152,intnum=0\n", + "dcascii,!g.s[0],file=\"/home/dysh/example_data/onoff-L/outputs/TGBT21A_501_11_getps_152_ifnum_0_plnum_0_intnum_0.ascii\"\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d9d30d94-36db-48db-ac86-7b360e9be26e", + "metadata": {}, + "outputs": [], + "source": [ + "filename_gtbidl = \"/home/dysh/example_data/onoff-L/outputs/TGBT21A_501_11_getps_152_ifnum_0_plnum_0_intnum_0.ascii\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2fc4d35a-8ccc-4332-b39b-1f4808182dca", + "metadata": {}, + "outputs": [], + "source": [ + "gbtidl_spec = np.loadtxt(filename_gtbidl, skiprows=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "07f94644-f366-4a2d-b21a-6e51c37e0aea", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bfe065022e5742ce80692a42aa534fcc", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.subplot(211)\n", + "plt.plot(freq_corr*1e-9, label=\"by hand in reference frame\")\n", + "plt.plot(gbtidl_spec[:,0], label=\"GBTIDL\")\n", + "plt.plot(freq_dysh.to(\"GHz\").value, label=\"dysh\")\n", + "plt.legend()\n", + "plt.ylabel(\"Frequency (GHz)\")\n", + "plt.subplot(212)\n", + "plt.plot(freq_corr - freq_dysh.to(\"Hz\").value, label=\"by hand - dysh\")\n", + "plt.plot(freq_corr - gbtidl_spec[:,0]*1e9, label=\"by hand - GBTIDL\")\n", + "plt.legend()\n", + "plt.ylabel(\"Difference (Hz)\")\n", + "plt.xlabel(\"Channel number\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67af1f63-7220-48f0-afdc-db824831f6b2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index 4f180c5e..5f6e9749 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -159,7 +159,6 @@ def summary(self, scans=None, verbose=False, bintable=0): [compressed_df,ser.to_frame().T], ignore_index=True) compressed_df = compressed_df.astype(col_dtypes) - print(compressed_df.to_string(index=False)) return compressed_df def velocity_convention(self,veldef,velframe):