diff --git a/.gitignore b/.gitignore index ed8d091fd..0ce7f1913 100644 --- a/.gitignore +++ b/.gitignore @@ -7,55 +7,9 @@ TAGS *egg-info lib/fftw_wisdom.txt -bin/GBT350filterbank -bin/accelsearch -bin/bary -bin/bincand -bin/cal2mjd -bin/check_parkes_raw -bin/dat2sdat -bin/dftfold -bin/downsample -bin/dump_spigot_zerolag -bin/exploredat -bin/explorefft -bin/fitsdelcol -bin/fitsdelrow -bin/makedata -bin/makeinf -bin/mjd2cal -bin/mpiprepsubband -bin/patchdata -bin/plotbincand -bin/prepdata -bin/prepfold -bin/prepsubband -bin/psrorbit -bin/psrfits_dumparrays -bin/quicklook -bin/readfile -bin/realfft -bin/rednoise -bin/rfifind -bin/sdat2dat -bin/search_bin -bin/search_rzw -bin/shiftdata -bin/show_pfd -bin/spigot2filterbank -bin/spigotSband2filterbank -bin/split_parkes_beams -bin/swap_endian -bin/taperaw -bin/toas2dat -bin/un_sc_td -bin/weight_psrfits -bin/window -bin/zapbirds lib/python/ppgplot/ lib/python/presto/ python/build/ -src/slalib/sla_test src/makewisdom src/fftw_wisdom.txt MANIFEST diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 000000000..f435cc073 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,64 @@ +## Version 5.0.0: New! + * This is a major release since I've moved to a completely different and modern build system: [meson](https://mesonbuild.com/), along with the [meson-python](https://meson-python.readthedocs.io/en/latest/) backend. This was required since *Numpy* has deprecated `numpy.distutils` and this caused python builds to stop working with Python v3.12. + * See the [INSTALL.md]()https://github.com/scottransom/presto/blob/master/INSTALL.md) for updated installation instructions. + * You will need to install **meson**, **meson-python**, and **ninja**, but that is easily done via `pip`! + * Python v3.8 or newer is now required. + * All of the old Spigot-related codes have been removed. If you need to process Spigot data, please use the `classis` branch that is mentioned in the README.md. + * All of the `slalib` codes (and the python interface to it) have been removed. If you need that stuff, you should transition to [ERFA](https://github.com/liberfa/erfa) and/or [Astropy](https://www.astropy.org/). + * There are two nice new python utilities: + * `binary_utils.py` reads a parfile of a binary pulsar and computes min/max observed barycentric spin periods or velocities as either a function of the orbit (default), or for a prescribed duration of time, and optionally plots those. It also shows basic information about the binary. + * `compare_periods.py` compares candidate spin periods and their integer and fractional harmonics with one or more parfiles to a prescribed fractional tolerance. + +## Version 4.0: + * This is a major release since it involves big changes to the Python portions of the codebase: + * Python v3.7 or newer is now required. + * A long-standing memory issue was fixed with Anaconda Python (running `python tests/test_presto_python.py` will tell you if you have that issue or not). + * Swig v4 is used to generate the Python wrappers of the PRESTO C library. + * Big thanks to **Shami Chatterjee** and **Bradley Meyers** who helped me get to the bottom of this! + * There is a [FAQ](https://github.com/scottransom/presto/blob/master/FAQ.md) with lots of information! + * PRESTO has a dockerfile that allows it to build on Docker Hub automatically. Thanks to **Nick Swainston** for this! (more testing and improvements would be welcome) + * `simple_zapbirds.py` makes it much easier to manually zap interference from simple searches (no need for copying ".inf" files and running both `makezaplist.py` and `zapbirds`). + * `realfft` and `zapbirds` can now be called on many files at once on the command line. This benefits HPC systems which often don't like many programs running serially on many small files. + * A new python interface to the internal `prepfold` folding code (`simplefold`), as well as wrappers of fast `C` implementations of $\chi^2$ and $Z^2_N$ (thanks to **Matteo Bachetti**). + * Many bug fixes and minor improvements, including one that would cause segfaults with very large dispersion sweeps in `prepdata` and `prepsubband`, and a problem with `prepfold` significance calculations. + +## Version 3.0.1: + * This is a minor release which fixes several issues and adds some minor improvements: + * Fix of long-standing `rfifind` bug that could cause the program to hang if channels had zero variance + * Multiple Python3-related bug fixes + * Added `-debug` flag to `prepfold` to allow debugging of TEMPO calls to make polycos + * `DDplan.py` can now read observation parameters from filterbank or PSRFITS input files. And you can write a `dedisp_*.py` dedispersion script, based on the plan, using the `-w` option + * The `rednoise` program now writes a corresponding *_red.inf file + * Update of the Tutorial document, including a new slide on red noise + +## Version 3.0: + * This major release of PRESTO includes a massive restructuring of python code and capabilities. Things should work with Python versions 2.7 and Python 3.6 and 3.7 at least. The installation of the python code has changed and has become more "pythonic" so that `PYTHONPATH` is not needed, and all of the various modules are now under a top-level "presto" module. For example, to use the psr_utils module you would now do: + + `import presto.psr_utils as pu` + + rather than + + `import psr_utils as pu` + + All of these changes will likely lead to code breakage and bugs! + + Please check your code and processing carefully and post issues (and hopefully pull requests) if you find them. + + The installation instructions have been updated in the INSTALL file. + + Huge thanks thanks go to **Gijs Molenaar, Matteo Bachetti, and Paul Ray** for the work that they have done helping with this! + + * There is also a new `examplescripts` directory where you will find some example code to do a lot of important things, like + * Fully dedispersing an observation: `dedisp.py` + * Fully searching a dedispersed observation: `full_analysis.py` + * Sifting the results of a full search: `ACCEL_sift.py` + * Searching short chunks of a long time series: `short_analysis_simple.py` + * Making a really nice P-Pdot plane: `ppdot_plane_plot.py` + * and a few others. + +## Version 2.2: + * Version 2.2 was the last version of PRESTO to work with the old-style python interface which requires Python v2.7 or earlier and is "installed" in-place and used via having `$PRESTO/lib/python` in your `PYTHONPATH`. There will probably be occasional bug fixes for v2.2 in the `v2.2maint` branch of PRESTO. You can get it using: `git checkout -b v2.2maint origin/v2.2maint`, and then installing as per the INSTALL file. + +## Version 2.1: + * `accelsearch` now has a "jerk" search capability (thanks to (then) UVA undergrad **Bridget Andersen** for help with this!). This makes searches take a *lot* longer, but definitely improves sensitivity when the observation duration is 5-15% of the duration of the orbital period. Typically `-wmax` should be set to 3-5x `-zmax` (and you probably never need to set `-zmax` to anything larger than 300). + * Ability to ignore bad channels on the command line (-ignorechan) (see `rfifind_stats.py` and `weights_to_ignorechan.py`) diff --git a/COPYRIGHT b/COPYRIGHT index 43bc7aa0e..0971166af 100644 --- a/COPYRIGHT +++ b/COPYRIGHT @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998-2021 Scott M. Ransom + * Copyright (c) 1998-2024 Scott M. Ransom * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/INSTALL.md b/INSTALL.md index c804bce0b..beb427116 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -1,134 +1,201 @@ -## Basic steps to install PRESTO: +# New and improved steps to install PRESTO! -**(Note: For Mac users, please see the bottom of the document!)** +## td;dr for experienced PRESTO builders: +With v5, we have switched to building and installing with [meson](https://mesonbuild.com/). -1. **Install FFTW3.X** - http://www.fftw.org +**MacOS users should see the comments at the bottom of this file!** - You need to compile FFTW for **single** precision (see the config flags I - recommend below). +As always, there are a set of essential packages required to build PRESTO. This command should do it on a Debian/Ubuntu-like system: +`apt install git build-essential libfftw3-bin libfftw3-dev pgplot5 libglib2.0-dev libcfitsio-bin libcfitsio-dev libpng-dev gfortran tcsh autoconf libx11-dev python3-dev python3-numpy python3-pip` - For all architectures I recommend the following configuration: `./configure - --enable-shared --enable-single` +Make sure that your `PRESTO` environment variable points to the top-level PRESTO git checkout. And make sure that `$PRESTO/lib` and `$PRESTO/bin` are **not** in your `PATH` or `LD_LIBRARY_PATH` or `PYTHONPATH` environment variables as we have required in the past. It is probably a good idea to clean your earlier compiles, as well. Just cd into the `src` directory and do a `make cleaner`, and then come back here. - Use the `--prefix=SOME_PATH` option to install the library and its related - files to SOME_PATH. If you have admin access to your machine, - `--prefix=/usr/local` is the default for FFTW and is a safe bet. +From your activated Python virtual or [Conda](https://docs.conda.io/) environment, make sure that you have `meson`, `meson-python`, `ninja`, and a recent `pip` installed (also Python >=3.8): - If you are on a modern Intel processor and have a recent version of GCC, you - can get much improved performance by adding: `--enable-sse --enable-sse2 - --enable-avx --enable-avx2 --enable-fma` +`pip install meson meson-python ninja` or `conda install meson meson-python ninja` - Ubuntu has good FFTW packages: `libfftw3-bin` and `libfftw3-dev` +and - Note that if you install to a non-default directory, you will likely need to - edit `setup.py` for the python install to add the locations of the include - files (in the `include_dirs` variable) as well as the path to the libraries - (in `presto_library_dirs`). +`pip install --upgrade pip`. -2. **Install PGPLOT** - http://www.astro.caltech.edu/~tjp/pgplot/ +Now setup the C/Fortran code builds: - You need the X-windows and postscript drivers at a minimum. Note that on - 64-bit systems, compiling and linking PGPLOT can be tricky! +`cd $PRESTO` - It is very likely that you will need to have the `PGPLOT_DIR` environment - variable specified to allow the programs to link and to allow PGPLOT to find - its important files. +`meson setup build --prefix=$CONDA_PREFIX` if you use Conda/Mamba/Anaconda - Ubuntu has a good PGPLOT package: `pgplot5` - And on Ubuntu, I have `PGPLOT_DIR=/usr/lib/pgplot5` +or - If you install to a non-standard location, see the note in #1 - about editing the setup.py file for the python install! +`meson setup build --prefix=$VIRTUAL_ENV` if you use a Python virtual environment -3. **Install TEMPO** - http://tempo.sourceforge.net/ +or - Make sure to set the `TEMPO` environment variable. +`meson setup build --prefix=$HOME` if you want things installed in your `$HOME/bin`, `$HOME/lib` directories. -4. **Install GLIB** (v2.X) - http://library.gnome.org/devel/glib/ +or, if you have `sudo` permissions and want to install to `/usr/local` (or equivalent system directory): + +`meson setup build`. + +Note that if you don't want to set `--prefix` on the command line, you can also edit the top-level `meson.build` file and add e.g. `'prefix=/home/sransom'` to the `default_options` variable in the project definition. + +In order to avoid the possible issues with linking and running, I recommend doing: + +`python check_meson_build.py`. + +If all looks good, it will let you know. If not, I recommend trying to fix the issues that it caught, and then starting again. + +Now do the actual build and install via: + + meson compile -C build + meson install -C build + +You will see a lot of compiler warnings due to my crappy C-coding (I should fix those...), but that's OK. There should be logs in case anything goes wrong in `$PRESTO/build/meson-logs`. You should be able to run `prepfold` (for example), at this time and see the usage information. If that doesn't work, see the **troubleshooting** information below. + +Then finally, install the Python codes and bindings via `pip`: + + cd $PRESTO/python + pip install --config-settings=builddir=build . + +And that should do it! You can quickly test to see if most things are working by doing: + + cd $PRESTO + python tests/test_presto_python.py + python examplescripts/ffdot_example.py + python python/fftfit_src/test_fftfit.py + +Another good test is to see if you can run and fit the default profile in `pygaussfit.py` + +If you want to run `makewisdom` for slightly faster FFT calls, it is located in `$PRESTO/build/src`. Just run it from there, and then copy or move the resulting `fftw_wisdom.txt` file to `$PRESTO/lib`. + +Note that you can uninstall everything via: + + cd $PRESTO/build + ninja uninstall + pip uninstall presto + +**Some quick troubleshooting info for the new meson build process:** + * If you get an error when trying to run one of the compiled executables (like `prepfold`) about shared libraries (e.g. `prepfold: error while loading shared libraries: libpresto.so: cannot open shared object file: No such file or directory`) you will need to add the install location of `libpresto.so` to your `LD_LIBRARY_PATH` environment variable. + * Note: You can find the install location by doing: `grep libpresto $PRESTO/build/meson-logs/install-log.txt` + * If you get an error when running `pip install ...` for the Python codes saying `../meson.build:29:15: ERROR: C shared or static library 'presto' not found`, you will need to do something similar to the above and add the install location of `libpresto.so` to `LIBRARY_PATH` (note that that is **not** `LD_LIBRARY_PATH`! The former is for runtime linking and the latter is for linking at compile time. Note that you might need to use `DYLD_LIBRARY_PATH` on macOS!) + +## Detailed install and build instructions: + +**(Note: For MacOS users, please see the bottom of the document!)** + +1. **Install [FFTW3](http://www.fftw.org)** + + I highly recommend that you use pre-compiled packages for your OS/distribution! FOr example, Ubuntu has good FFTW packages: `libfftw3-bin` and `libfftw3-dev`. + + If you compile your own, you need to compile FFTW for **single** precision. For all architectures I recommend the following configuration: `./configure --enable-shared --enable-single` + + If you are on a modern Intel processor and have a recent version of GCC, you can get much improved performance by adding: `--enable-sse --enable-sse2 --enable-avx --enable-avx2 --enable-fma` + +2. **Install [PGPLOT](http://www.astro.caltech.edu/~tjp/pgplot/)** + + I highly recommend that you use pre-compiled packages for your OS/distribution! FOr example, Ubuntu has a good PGPLOT package: `pgplot5`. You will likely need to set the `PGPLOT_DIR` environment variable. On Ubuntu, I have `PGPLOT_DIR=/usr/lib/pgplot5` + + If you want to try to compile your own (good luck!), you need the X-windows and postscript drivers at a minimum. + +3. **Install [TEMPO](http://tempo.sourceforge.net/)** + + Make sure to set the `TEMPO` environment variable so that it points to the top level of the `TEMPO` code base. + +4. **Install [GLIBv2](http://library.gnome.org/devel/glib/)** + + On Linux machines this is almost certainly already on your system (check in `/usr/lib` and `/usr/include/glib*`). Although you may need to install a glib development package in order to have the required include files. On Ubuntu, the package you need is: `libglib2.0-dev` + +5. **Install [CFITSIO](http://heasarc.gsfc.nasa.gov/fitsio/)** + + I highly recommend using pre-compiled packages, once again (on Ubuntu they are `libcfitsio-bin` and `libcfitsio-dev`), however, this is a very easy install via source. + +6. **Set the `PRESTO` environment variable** + + It should be set to the top level directory of the PRESTO distribution (i.e. this directory). And make sure that `$PRESTO/lib` and `$PRESTO/bin` are **not** in your `PATH` or `LD_LIBRARY_PATH` or `PYTHONPATH` environment variables as we have required in the past. + +7. **Activate your Python virtual environment *or* Conda/Mamba/Anaconda environment** + + * That environment should have `numpy` installed at a minimum + * Make sure that `pip` is recent (`pip install --upgrade pip`) + * Install the build tools: `pip install meson meson-python ninja` or `conda install meson meson-python ninja` + +8. **Configure the meson build** + + In the top level PRESTO directory (i.e. `cd $PRESTO`), configure `meson` via: + + `meson setup build --prefix=$CONDA_PREFIX` if you use Conda/Mamba/Anaconda - On Linux machines this is almost certainly already on your system (check in - `/usr/lib` and `/usr/include/glib*`). Although you may need to install a - glib development package in order to have the required include files... - - On Ubuntu, the package you need is: `libglib2.0-dev` - -5. **Install CFITSIO** - http://heasarc.gsfc.nasa.gov/fitsio/ - - This is a very easy install and is needed since PSRFITS is now being written - by several pulsar instruments. - - Ubuntu has CFITSIO packages: `libcfitsio-bin` and `libcfitsio-dev` - - If you install to a non-standard location, see the note in #1 about editing - the setup.py file for the python install! - -6. Define the `PRESTO` environment variable to the top level directory of the - PRESTO distribution (i.e. this directory). - -7. cd to `$PRESTO/src`. Check and modify the Makefile for your machine of - choice. Ensure that the library and include file directories are correct - for FFTW, PGPLOT, GLIB, CFITSIO, and TEMPO. - -8. If you are using FFTW, do a `make makewisdom`. This gets FFTW acquainted - with your system. It is best if you are the only user on the machine when - you run this, as it is very computation intensive and may take a while. - -9. Just for safety's sake, do a `make prep`. That will make sure that make - does not try to run Clig to re-generate all of the command line interface - files. - -10. Do a `make`. This will make all of the executables. If you want - `mpiprepsubband` (for parallel de-dispersion on clusters) you will need to - do a `make mpi` as well (and for that, you will need to have OpenMPI - installed!) - -11. The required libraries and miscellaneous files will be located in - `$PRESTO/lib`. The executables will be in `$PRESTO/bin`. You may copy or - move the executables wherever you like, but the library files should stay - put. (That's why you define the `PRESTO` variable -- so the routines can - find them). - - Given the new use of `-Wl,-rpath,$(PRESTO)/lib` during linking (thanks to - Mike Keith for the tip!), you no longer need `$PRESTO/lib` in your - `LD_LIBRARY_PATH` environment variable. However, you do still need - `$PRESTO/bin` in your `PATH`, or else you can copy/link all of the files - that are in `$PRESTO/bin` to somewhere that *is* in your path. - -12. If you want to save some disk space, do a `make clean` in the 'src' - directory. This will leave the libraries and binaries in their respective - directories but will get rid of all the extra stuff in the 'src' directory. - -13. If you want to use all the python routines (which if you are doing anything - but the most rudimentary analyses you will want to), you need Python >= - version 3.7, and [NumPy](http://www.numpy.org) and - [SciPy](http://www.scipy.org) - - In general, the following should work: `cd $PRESTO ; pip install .` if you - are using a virtual environment or have permissions for installing normal - Python packages. If not, you may need to install as an administrator or - with the `--user` flag. With this new and better Python installation you - do *not* need to set the `PYTHONPATH` environment variable anymore and so - you should ensure that it doesn't contain `$PRESTO/lib/python` as in the - past. - -14. It is highly recommended that you test some of the Python code that wraps - parts of the PRESTO C library. Once you have installed the python modules, - you should run: `python tests/test_presto_python.py`. If all is well, you - will get a bunch of tests and a bunch of `success`es. - -15. Go find pulsars! + or + + `meson setup build --prefix=$VIRTUAL_ENV` if you use a Python virtual environment + + or + + `meson setup build --prefix=$HOME` if you want things installed in your `$HOME/bin`, `$HOME/lib` directories. + + or, if you have sudo permissions and want to install to `/usr/local` (or equivalent): + + `meson setup build`. + +9. **Check your environment variables against the configuration** + + `python check_meson_build.py` + + If everything looks good, it will tell you. Otherwise, try fixing the issues and starting over from step #8. + +10. **Build and install all the C/Fortran codes and the PRESTO shared library (e.g. `libpresto.so`)** + + `meson compile -C build` + + `meson install -C build` + + There should be logs in case anything goes wrong in `$PRESTO/build/meson-logs`. Note that all PRESTO compiled binaries will be installed in `{prefix}/{bindir}`, and the PRESTO shared library (likely either `libpresto.so` or `libpreso.dylib`) will be installed in `{prefix}/{libdir}` as defined by `meson`. You can see the values of `{prefix}`, `{bindir}`, and `{libdir}` using the `check_meson_build.py` script from the previous step. + +11. **Try running a PRESTO command like `prepfold`** + + You should get the regular usage screen. If you get a shared library error, see the troubleshooting steps above or below. + +12. **Compile and install the PRESTO python codes and libraries** + + `cd $PRESTO/python` + + `pip install --config-settings=builddir=build .` + + If you get a shared library error, see the troubleshooting steps above or below. + +13. **Run some basic tests** + + `cd $PRESTO` + + `python tests/test_presto_python.py` + + `python examplescripts/ffdot_example.py` + + `python python/fftfit_src/test_fftfit.py` + + Another good test is to see if you can run and fit the default profile in `pygaussfit.py` + +14. **Run `makewisdom` to have (slightly) fast FFTs** + + Just run `$PRESTO/build/src/makewisdom`. It takes about 10-20 min to run, so be patient. Note that the `fftw_wosdom.txt` file will be located in `$PRESTO/build/src`, so you will need to move it to `$PRESTO/lib` so that PRESTO can find it. + +15. **Go find pulsars!** + + Everything should be ready to go now, and installed (likely) in the same place as the rest of your Python virtual environment and/or Conda/Mamba/Anaconda environment. + + If you want to uninstall everything you can do: + + `cd $PRESTO/build` + + `ninja uninstall` + + `pip uninstall presto` Scott Ransom -Updated May 2021 +Updated April 2024, for v5.0.0 ----------------------------------------------------------------- -## TROUBLE SHOOTING +## TROUBLESHOOTING -------------------- Couple quick trouble-shooting tips if you are having problems compiling and @@ -139,64 +206,59 @@ running: - Is `TEMPO` set to the top-level TEMPO source directory? - Is `PGPLOT_DIR` set to the location of the PGPLOT utility files? (Note: On Ubuntu, that should be `/usr/lib/pgplot5`) - - Is `$PRESTO/bin` in your `PATH`? (It should be!) - - Is `$PRESTO/lib/python` in your `PYTHONPATH`? (It shouldn't be now!) - -2. Have you have installed the relevant -dev packages for glib2, FFTW and - CFITSIO if you are using a Debian-based Linux distribution? Here are the - required packages on a clean Ubuntu: - - build-essential - - libfftw3-bin - - libfftw3-dev - - pgplot5 - - libglib2.0-dev - - libcfitsio-bin - - libcfitsio-dev - - libpng-dev - - gfortran - - tcsh - - autoconf - - libx11-dev - - python3-dev - - python3-numpy - - python3-pip + - Is `$PRESTO/bin` in your `PATH`? (It should *not* be!) + - Is `$PRESTO/lib` in your `LD_LIBRARY_PATH`? (It should *not* be!) + - Is there any `presto` stuff in your `PYTHONPATH`? (There should *not* be!) + +2. Have you have installed the relevant `-dev` packages for `glib2`, `FFTW` and `CFITSIO` if you are using a Debian-based Linux distribution? Here are the required packages on a clean Ubuntu: + - `git` + - `build-essential` + - `libfftw3-bin` + - `libfftw3-dev` + - `pgplot5` + - `libglib2.0-dev` + - `libcfitsio-bin` + - `libcfitsio-dev` + - `libpng-dev` + - `gfortran` + - `tcsh` + - `autoconf` + - `libx11-dev` + - `python3-dev` + - `python3-numpy` + - `python3-pip` - And the following command should get all of them: `apt install git - build-essential libfftw3-bin libfftw3-dev pgplot5 libglib2.0-dev - libcfitsio-bin libcfitsio-dev libpng-dev gfortran tcsh autoconf libx11-dev - python3-dev python3-numpy python3-pip` - -3. After the Python modules are built and installed, and you run `python - tests/test_presto_python.py`, if you get a memory error, there are - instructions for making a minor change to the `Makefile`. If you make that - change, you should re-run `make`, and re-build and install the Python - modules. Re-running the test *should* then work. - -4. If you are having trouble with PRESTO creating polycos, you can use prepfold - with the `-debug` option when folding using `-timing`. That will show you the - TEMPO call and keep all of the (usually) temporary output files. - -5. If you are using a Mac, Paul Ray has been running PRESTO a lot and knows - several tricks to get it working: - - PRESTO should build almost "out of the box" on a Mac. I have had - success using MacPorts to install the necessary dependencies. You - will need MacPorts packages: pgplot, cfitsio, glib2, fftw-3, - fftw-3-single, and gcc5 You can probably use a more recent gcc - instead, if you prefer (e.g. gcc8). It just needs to provide - gfortran. + And the following command should get all of them: `apt install git build-essential libfftw3-bin libfftw3-dev pgplot5 libglib2.0-dev libcfitsio-bin libcfitsio-dev libpng-dev gfortran tcsh autoconf libx11-dev python3-dev python3-numpy python3-pip` - TEMPO should build easily with gfortran. I did not make any changes - to the distro. - - Also you need to delete the line `#include "error.h"` from - `src/backend_common.c` - - For python, you will need to install numpy, scipy, etc. using - MacPorts or pip, as you prefer. +3. After the Python modules are built and installed, and you run `python tests/test_presto_python.py`, if you get a memory error, please contact Scott! I think that these issues are fixed, but if they are not, we will need to change the build process a tiny bit with a special variable define. + +4. If you are having trouble with PRESTO creating polycos, you can use `prepfold` with the `-debug` option when folding using `-timing`. That will show you the `TEMPO` call and keep all of the (usually) temporary output files. - Finally, in `$PRESTO/setup.py` you might need to add - `/opt/local/include` to the `include_dirs`. +5. If you are using **MacOS**, Paul Ray has been running PRESTO a lot and knows several tricks to get it working: - Then, just follow the PRESTO installation instructions: - `cd src; make; make makewisdom; cd .. ; pip install .` + - PRESTO should build almost "out of the box" on a Mac, once you have the external packages installed and after setting a few environment variables. + + - For MacPorts, which has worked well, this should install all the important packages. **This assumes you use Python 3.11 and gcc13. You may use different versions.**: + + ~~~ + % sudo port install mp-gcc13 python311 py311-ipython pip311 virtualenv311 virtualenvwrapper311 + % sudo port select --set gcc mp-gcc13 + % sudo port select --set python python311 + % sudo port select --set virtualenv virtualenv311 + % sudo port select --set virtualenvwrapper virtualenvwrapper311 + % sudo port install pgplot cfitsio glib2 fftw-3 fftw-3-single + ~~~ + + - TEMPO should build easily with gfortran. I did not make any changes to the distro. + + - Before you build, you will likely need to set the following environment variables. You probably do *not* need to have `DYLD_LIBRARY_PATH` set at runtime. + + ~~~ + # These are needed only at *BUILD* time + # This points to the MacPorts libraries and those installed in your virtualenv + export LIBRARY_PATH=/opt/local/lib:/opt/local/lib/libgcc + # This prevents using the macOS native "cc" command, in favor of the MacPorts gcc + export CC=gcc + # This makes sure the MacPorts includes can be found + export CFLAGS="-I/opt/local/include" + ~~~ \ No newline at end of file diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index 89d86bd28..000000000 --- a/MANIFEST.in +++ /dev/null @@ -1,4 +0,0 @@ -recursive-include bin * -include pyproject.toml -recursive-include include *.h -include python/presto/cosine_rand.json \ No newline at end of file diff --git a/README.md b/README.md index 461ef9ab3..e9227f5ac 100644 --- a/README.md +++ b/README.md @@ -1,126 +1,30 @@ [![PINT on ASCL](https://img.shields.io/badge/ascl-1107.017-blue.svg)](https://ascl.net/1107.017) -# PRESTO - -http://www.cv.nrao.edu/~sransom/presto/ - -PRESTO is a large suite of pulsar search and analysis software developed -primarily by Scott Ransom mostly from scratch, and released under the GPL (v2). -It was primarily designed to efficiently search for binary millisecond pulsars -from long observations of globular clusters (although it has since been used in -several surveys with short integrations and to process a lot of X-ray data as -well). It is written primarily in ANSI C, with many of the recent routines in -Python. According to Steve Eikenberry, PRESTO stands for: PulsaR Exploration -and Search TOolkit! - -**PRESTO has discovered over 1000 pulsars, including approximately 400 recycled -and/or binary pulsars!** - -## New in Version 4.0: - * This is a **major release** since it involves big changes to the Python - portions of the codebase: - * Python v3.7 or newer is now required. - * A long-standing memory issue was fixed with Anaconda Python (running - `python tests/test_presto_python.py` will tell you if you have that issue - or not). - * Swig v4 is used to generate the Python wrappers of the PRESTO C library. - * Big thanks to **Shami Chatterjee** and **Bradley Meyers** who helped me get - to the bottom of this! - * There is a [FAQ](https://github.com/scottransom/presto/blob/master/FAQ.md) - with lots of information! - * PRESTO has a dockerfile that allows it to build on Docker Hub automatically. - Thanks to **Nick Swainston** for this! (more testing and improvements would - be welcome) - * `simple_zapbirds.py` makes it much easier to manually zap interference from - simple searches (no need for copying ".inf" files and running both - `makezaplist.py` and `zapbirds`). - * `realfft` and `zapbirds` can now be called on many files at once on the - command line. This benefits HPC systems which often don't like many programs - running serially on many small files. - * A new python interface to the internal `prepfold` folding code - (`simplefold`), as well as wrappers of fast `C` implementations of $\chi^2$ - and $Z^2_N$ (thanks to **Matteo Bachetti**). - * Many bug fixes and minor improvements, including one that would cause - segfaults with very large dispersion sweeps in `prepdata` and `prepsubband`, - and a problem with `prepfold` significance calculations. - -## In Version 3.0.1: - * This is a minor release which fixes several issues and adds some minor - improvements: - * Fix of long-standing `rfifind` bug that could cause the program to hang if - channels had zero variance - * Multiple Python3-related bug fixes - * Added `-debug` flag to `prepfold` to allow debugging of TEMPO calls to make - polycos - * `DDplan.py` can now read observation parameters from filterbank or PSRFITS - input files. And you can write a `dedisp_*.py` dedispersion script, based - on the plan, using the `-w` option - * The `rednoise` program now writes a corresponding *_red.inf file - * Update of the Tutorial document, including a new slide on red noise - -## In Version 3.0: - * This major release of PRESTO includes a massive restructuring of python code - and capabilities. Things should work with Python versions 2.7 and Python 3.6 - and 3.7 at least. The installation of the python code has changed and has - become more "pythonic" so that `PYTHONPATH` is not needed, and all of the - various modules are now under a top-level "presto" module. For example, to - use the psr_utils module you would now do: - - `import presto.psr_utils as pu` - - rather than - - `import psr_utils as pu` - - All of these changes will likely lead to code breakage and bugs! - - Please check your code and processing carefully and post issues (and - hopefully pull requests) if you find them. - - The installation instructions have been updated in the INSTALL file. - - Huge thanks thanks go to **Gijs Molenaar, Matteo Bachetti, and - Paul Ray** for the work that they have done helping with this! - - * There is also a new `examplescripts` directory where you will find some - example code to do a lot of important things, like - * Fully dedispersing an observation: `dedisp.py` - * Fully searching a dedispersed observation: `full_analysis.py` - * Sifting the results of a full search: `ACCEL_sift.py` - * Searching short chunks of a long time series: `short_analysis_simple.py` - * Making a really nice P-Pdot plane: `ppdot_plane_plot.py` - * and a few others. - -## Status of Version 2.2: - * Version 2.2 was the last version of PRESTO to work with the old-style python - interface which requires Python v2.7 or earlier and is "installed" in-place - and used via having `$PRESTO/lib/python` in your `PYTHONPATH`. There will - probably be occasional bug fixes for v2.2 in the `v2.2maint` branch of - PRESTO. You can get it using: - - `git checkout -b v2.2maint origin/v2.2maint` - - and then installing as per the INSTALL file. - -## Improvements in Version 2.1: - * `accelsearch` now has a "jerk" search capability (thanks to (then) UVA - undergrad **Bridget Andersen** for help with this!). This makes searches - take a *lot* longer, but definitely improves sensitivity when the observation - duration is 5-15% of the duration of the orbital period. Typically `-wmax` - should be set to 3-5x `-zmax` (and you probably never need to set `-zmax` to - anything larger than 300). - * Ability to ignore bad channels on the command line (-ignorechan) (see - `rfifind_stats.py` and `weights_to_ignorechan.py`) +# [PRESTO](https://github.com/scottransom/presto/) + +PRESTO is a large suite of pulsar search and analysis software developed primarily by Scott Ransom mostly from scratch, and released under the GPL (v2). It was primarily designed to efficiently search for binary millisecond pulsars from long observations of globular clusters (although it has since been used in several surveys with short integrations and to process a lot of X-ray data as well). It is written primarily in ANSI C, with many of the recent routines in Python. According to Steve Eikenberry, PRESTO stands for: PulsaR Exploration and Search TOolkit! + +**PRESTO has discovered well over 1000 pulsars, including ~400 recycled and/or binary pulsars!** + +## New in Version 5.0.0!: + * This is a major release since I've moved to a completely different and modern build system: [meson](https://mesonbuild.com/), along with the [meson-python](https://meson-python.readthedocs.io/en/latest/) backend. This was required since *Numpy* has deprecated `numpy.distutils` and this caused python builds to stop working with Python v3.12. + * See the [INSTALL.md](https://github.com/scottransom/presto/blob/master/INSTALL.md) for updated installation instructions. + * You will need to install **meson**, **meson-python**, and **ninja**, but that is easily done via `pip`! + * Python v3.8 or newer is now required. + * All of the old Spigot-related codes have been removed. If you need to process Spigot data, please use the `classis` branch that is mentioned in the README.md. + * All of the `slalib` codes (and the python interface to it) have been removed. If you need that stuff, you should transition to [ERFA](https://github.com/liberfa/erfa) and/or [Astropy](https://www.astropy.org/). + * There are two nice new python utilities: + * `binary_utils.py` reads a parfile of a binary pulsar and computes min/max observed barycentric spin periods or velocities as either a function of the orbit (default), or for a prescribed duration of time, and optionally plots those. It also shows basic information about the binary. + * `compare_periods.py` compares candidate spin periods and their integer and fractional harmonics with one or more parfiles to a prescribed fractional tolerance. + +For information on older versions, please see the [CHANGELOG.md](https://github.com/scottransom/presto/blob/master/CHANGELOG.md). ## About PRESTO: -PRESTO is written with portability, ease-of-use, and memory efficiency in mind, -it can currently handle raw data from the following pulsar machines or formats: +PRESTO is written with portability, ease-of-use, and memory efficiency in mind, it can currently handle raw data from the following pulsar machines or formats: - * PSRFITS search-format data (as from GUPPI at the GBT, PUPPI and the Mock - Spectrometers at Arecibo, and much new and archived data from Parkes) + * PSRFITS search-format data (as from GUPPI at the GBT, PUPPI and the Mock Spectrometers at Arecibo, and much new and archived data from Parkes) * 1-, 2-, 4-, 8-, and 32-bit (float) filterbank format from SIGPROC - * A time series composed of single precision (i.e. 4-byte) floating point data - (with a text ".inf" file describing it) + * A time series composed of single precision (i.e. 4-byte) floating point data (with a text ".inf" file describing it) * Photon arrival times (or events) in ASCII or double-precision binary formats Notice that the following formats which *used* to be supported are not: @@ -130,60 +34,26 @@ Notice that the following formats which *used* to be supported are not: * SPIGOT at the GBT * Berkeley-Caltech Pulsar Machine (BCPM) at the GBT -If you need to process them, you can either checkout the "classic" branch of -PRESTO (see below), which is not being actively developed. Or you can use DSPSR -to convert those formats into SIGPROC filterbank or (even better) PSRFITS search -format. You can grab DSPSR [here](http://dspsr.sourceforge.net). If you -*really* need to get one of these machines working in modern PRESTO, let me know -and we can probably make it happen. - -The software is composed of numerous routines designed to handle three main -areas of pulsar analysis: - -1. Data Preparation: Interference detection (`rfifind`) and removal (`zapbirds`) - , de-dispersion (`prepdata`, `prepsubband`, and `mpiprepsubband`), - barycentering (via TEMPO). -2. Searching: Fourier-domain acceleration (`accelsearch`), single-pulse - (`single_pulse_search.py`), and phase-modulation or sideband searches - (`search_bin`). -3. Folding: Candidate optimization (`prepfold`) and Time-of-Arrival (TOA) - generation (`get_TOAs.py`). -4. Misc: Data exploration (`readfile`, `exploredat`, `explorefft`), - de-dispersion planning (`DDplan.py`), date conversion (`mjd2cal`, `cal2mjd`), - tons of python pulsar/astro libraries, average pulse creation, flux density - estimation, and more... -5. Post Single Pulse Searching Tools: Grouping algorithm (`rrattrap.py`), - Production and of single pulse diagnostic plots (`make_spd.py`, - `plot_spd.py`, and `waterfaller.py`). - -Many additional utilities are provided for various tasks that are often required -when working with pulsar data such as time conversions, Fourier transforms, time -series and FFT exploration, byte-swapping, etc. - -**References**: The Fourier-Domain acceleration search technique that PRESTO -uses in the routine `accelsearch` is described in [Ransom, Eikenberry, and -Middleditch -(2002)](https://ui.adsabs.harvard.edu/abs/2002AJ....124.1788R/abstract), the -"jerk" search capability is described in [Andersen & Ransom -(2018)](https://ui.adsabs.harvard.edu/abs/2018ApJ...863L..13A/abstract), and the -phase-modulation search technique used by `search_bin` is described in [Ransom, -Cordes, and Eikenberry -(2003)](https://ui.adsabs.harvard.edu/abs/2003ApJ...589..911R/abstract). Some -other basic information about PRESTO can be found in my -[thesis](http://www.cv.nrao.edu/~sransom/ransom_thesis_2001.pdf). - -**Support/Docs**: I may eventually get around to finishing the documentation -for PRESTO (or not), but until then you should know that each routine returns -its basic usage when you call it with no arguments. I am also willing to provide -limited support via email (see below). And make sure to check out the `FAQ.md`! - -**Tutorial**: There is a tutorial in the "docs" directory which walks you -through all the main steps of finding pulsars using PRESTO. +If you need to process them, you can either checkout the "classic" branch of PRESTO (see below), which is not being actively developed. Or you can use DSPSR to convert those formats into SIGPROC filterbank or (even better) PSRFITS search format. You can grab DSPSR [here](http://dspsr.sourceforge.net). If you *really* need to get one of these machines working in modern PRESTO, let me know and we can probably make it happen. + +The software is composed of numerous routines designed to handle three main areas of pulsar analysis: + +1. Data Preparation: Interference detection (`rfifind`) and removal (`zapbirds`), de-dispersion (`prepdata`, `prepsubband`, and `mpiprepsubband`), barycentering (via TEMPO). +2. Searching: Fourier-domain acceleration and jerk (`accelsearch`), single-pulse (`single_pulse_search.py`), and phase-modulation or sideband searches (`search_bin`). +3. Folding: Candidate optimization (`prepfold`) and Time-of-Arrival (TOA) generation (`get_TOAs.py`). +4. Misc: Data exploration (`readfile`, `exploredat`, `explorefft`), de-dispersion planning (`DDplan.py`), date conversion (`mjd2cal`, `cal2mjd`), tons of python pulsar/astro libraries, average pulse creation, flux density estimation, and more... +5. Post Single Pulse Searching Tools: Grouping algorithm (`rrattrap.py`), Production and of single pulse diagnostic plots (`make_spd.py`, `plot_spd.py`, and `waterfaller.py`). + +Many additional utilities are provided for various tasks that are often required when working with pulsar data such as time conversions, Fourier transforms, time series and FFT exploration, byte-swapping, etc. + +**References**: The Fourier-Domain acceleration search technique that PRESTO uses in the routine `accelsearch` is described in [Ransom, Eikenberry, and Middleditch (2002)](https://ui.adsabs.harvard.edu/abs/2002AJ....124.1788R/abstract), the "jerk" search capability is described in [Andersen & Ransom (2018)](https://ui.adsabs.harvard.edu/abs/2018ApJ...863L..13A/abstract), and the phase-modulation search technique used by `search_bin` is described in [Ransom, Cordes, and Eikenberry (2003)](https://ui.adsabs.harvard.edu/abs/2003ApJ...589..911R/abstract). Some other basic information about PRESTO can be found in my [thesis](http://www.cv.nrao.edu/~sransom/ransom_thesis_2001.pdf). + +**Support/Docs**: I may eventually get around to finishing the documentation for PRESTO (or not), but until then you should know that each routine returns its basic usage when you call it with no arguments. I am also willing to provide limited support via email (see below). And make sure to check out the `FAQ.md`! + +**Tutorial**: There is a tutorial in the "docs" directory which walks you through all the main steps of finding pulsars using PRESTO. ## Getting it: -The PRESTO source code is released under the GPL and can be browsed or gotten -from here in many different ways (including zipped or tar'd or via git). If you -are too lazy to read how to get it but have git on your system do: +The PRESTO source code is released under the GPL and can be browsed or gotten from here in many different ways (including zipped or tar'd or via git). If you are too lazy to read how to get it but have git on your system do: git clone git://github.com/scottransom/presto.git @@ -192,13 +62,9 @@ To update it on a regular basis do cd $PRESTO git pull -and then re-make things in $PRESTO/src. - -For more detailed installation instructions, see `INSTALL.md`. +and then re-build things in $PRESTO. -If you don't want to mess with git (which means that you will need to re-install -a tarball whenever there are updates) you can get it from the "Download Source" -link on the github page. +For more detailed installation instructions, see [INSTALL.md](https://github.com/scottransom/presto/blob/master/INSTALL.md). If you want the "classic" branch, do the following: @@ -209,35 +75,20 @@ If you want the "classic" branch, do the following: then build as per the (old) INSTALL file. ### Development: - -If you plan to tweak the code, I highly suggest that you use git and clone the -directory (or fork it using an account on github). And if you want to -contribute your changes back, please give me a "pull request"! +If you plan to tweak the code, I highly suggest that you use git and clone the directory (or fork it using an account on github). And if you want to contribute your changes back, please give me a "pull request"! **Code contributions and/or patches to fix bugs are most welcome!** ### Final Thoughts: -Please let me know if you decide to use PRESTO for any "real" searches, -especially if you find pulsars with it! +Please let me know if you decide to use PRESTO for any "real" searches, especially if you find pulsars with it! -And if you find anything with it, it would be great if you would cite either my -thesis or whichever of the three papers listed above is appropriate. +And if you find anything with it, it would be great if you would cite either my thesis or whichever of the three papers listed above is appropriate. -Also note that many people are now citing software using the ASCL. [PRESTO is -there as well](https://www.ascl.net/1107.017). +Also note that many people are now also citing software using the ASCL, in addition to the relevant papers: [PRESTO is there!](https://www.ascl.net/1107.017). Thanks! ### Acknowledgements: -Big thanks go to Steve Eikenberry for his help developing the algorithms, Dunc -Lorimer and David Kaplan for help with (retired) code to process BCPM, SCAMP, -and Spigot data, among other things, Jason Hessels and Patrick Lazarus for many -contributions to the Python routines, and (alphabetical): Bridget Andersen, Anne -Archibald, Cees Bassa, Matteo Bachetti, Slavko Bogdanov, Fernando Camilo, Shami -Chatterjee, Kathryn Crowter, Paul Demorest, Paulo Freire, Nate Garver-Daniels, -Chen Karako, Mike Keith, Maggie Livingstone, Ryan Lynch, Erik Madsen, Bradley -Meyers, Gijs Molenaar, Timothy Olszanski, Chitrang Patel, Paul Ray, Alessandro -Ridolfi, Paul Scholz, Maciej Serylak, Ingrid Stairs, Kevin Stovall, Nick -Swainston, and Joeri van Leeuwen for many comments, suggestions and patches! +Big thanks go to Steve Eikenberry for his help developing the algorithms, Dunc Lorimer and David Kaplan for help with (retired) code to process BCPM, SCAMP, and Spigot data, among other things, Jason Hessels and Patrick Lazarus for many contributions to the Python routines, and (alphabetical): Bridget Andersen, Anne Archibald, Cees Bassa, Matteo Bachetti, Slavko Bogdanov, Fernando Camilo, Shami Chatterjee, Kathryn Crowter, Paul Demorest, Paulo Freire, Nate Garver-Daniels, Chen Karako, Mike Keith, Maggie Livingstone, Ryan Lynch, Erik Madsen, Bradley Meyers, Gijs Molenaar, Timothy Olszanski, Chitrang Patel, Paul Ray, Alessandro Ridolfi, Paul Scholz, Maciej Serylak, Ingrid Stairs, Kevin Stovall, Nick Swainston, and Joeri van Leeuwen for many comments, suggestions and patches! Scott Ransom diff --git a/bin/DDplan.py b/bin/DDplan.py index 87591b41d..bd8095b7f 100755 --- a/bin/DDplan.py +++ b/bin/DDplan.py @@ -1,6 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function -from __future__ import absolute_import from builtins import zip import numpy as np from presto.Pgplot import * @@ -423,7 +421,6 @@ def dm_steps(loDM, hiDM, obs, cohdm=0.0, numsub=0, numprocs=1, return methods dedisp_template1 = """ -from __future__ import print_function from builtins import zip from builtins import range import os diff --git a/bin/GBNCC_search.py b/bin/GBNCC_search.py index 402308d8c..a6982cd47 100755 --- a/bin/GBNCC_search.py +++ b/bin/GBNCC_search.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import zip from builtins import str from builtins import range diff --git a/bin/GBT350_drift_prep.py b/bin/GBT350_drift_prep.py index 38b90e2cf..5109ea3b8 100755 --- a/bin/GBT350_drift_prep.py +++ b/bin/GBT350_drift_prep.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import sys, os, random from presto import sigproc diff --git a/bin/GBT350_drift_search.py b/bin/GBT350_drift_search.py index 04f492c69..ed4c38971 100755 --- a/bin/GBT350_drift_search.py +++ b/bin/GBT350_drift_search.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import zip from builtins import str from builtins import range diff --git a/bin/GUPPI_drift_prep.py b/bin/GUPPI_drift_prep.py index 6f8df8619..c6749cb8e 100755 --- a/bin/GUPPI_drift_prep.py +++ b/bin/GUPPI_drift_prep.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import sys, os, random from astropy.io import fits diff --git a/bin/PALFA_presto_search.py b/bin/PALFA_presto_search.py index ca1815749..815ec633e 100755 --- a/bin/PALFA_presto_search.py +++ b/bin/PALFA_presto_search.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import zip from builtins import str from builtins import range diff --git a/bin/chooseN.py b/bin/chooseN.py index b0c5f4211..85a0d0c21 100755 --- a/bin/chooseN.py +++ b/bin/chooseN.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import (print_function,division) import presto.psr_utils as pu import sys from presto.infodata import infodata diff --git a/bin/dat2tim.py b/bin/dat2tim.py index 2488d6327..4ca23c53a 100755 --- a/bin/dat2tim.py +++ b/bin/dat2tim.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function import os, struct, sys from presto import presto diff --git a/bin/downsample_filterbank.py b/bin/downsample_filterbank.py index d537b7858..9219d65ba 100755 --- a/bin/downsample_filterbank.py +++ b/bin/downsample_filterbank.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import sys import numpy as num diff --git a/bin/event_peak.py b/bin/event_peak.py index 18e97e63c..894f0f019 100755 --- a/bin/event_peak.py +++ b/bin/event_peak.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function import numpy as num import sys import presto.events as evts diff --git a/bin/fb_truncate.py b/bin/fb_truncate.py index 019761f59..fadc4e2c4 100755 --- a/bin/fb_truncate.py +++ b/bin/fb_truncate.py @@ -5,7 +5,6 @@ Patrick Lazarus, Aug 27, 2012 """ -from __future__ import print_function import sys import copy diff --git a/bin/filter_zerolags.py b/bin/filter_zerolags.py index e2a454c40..3e3453aff 100755 --- a/bin/filter_zerolags.py +++ b/bin/filter_zerolags.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import numpy as N import sys, scipy.io, scipy.signal diff --git a/bin/fit_circular_orbit.py b/bin/fit_circular_orbit.py index 913180865..1edaed113 100755 --- a/bin/fit_circular_orbit.py +++ b/bin/fit_circular_orbit.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import sys import numpy as num diff --git a/bin/fitorb.py b/bin/fitorb.py index 349185b2f..f3cdf22ec 100755 --- a/bin/fitorb.py +++ b/bin/fitorb.py @@ -3,7 +3,6 @@ """ fitorb: A non-linear optimizer for solving pulsar orbits by Ryan Lynch """ -from __future__ import print_function from builtins import range from numpy import * diff --git a/bin/get_TOAs.py b/bin/get_TOAs.py index d171a6995..56b954a63 100755 --- a/bin/get_TOAs.py +++ b/bin/get_TOAs.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import getopt, sys from presto import fftfit diff --git a/bin/guppidrift2fil.py b/bin/guppidrift2fil.py index 8e2f8d8f0..0af11ca76 100755 --- a/bin/guppidrift2fil.py +++ b/bin/guppidrift2fil.py @@ -1,7 +1,6 @@ #!/usr/bin/env python #Begun on 2/13/2014 from a copy of psrfits2fil.py //NEG-D// -from __future__ import print_function from builtins import range import numpy as np from astropy.io import fits as pyfits diff --git a/bin/injectpsr.py b/bin/injectpsr.py index ba995e234..ed93bbcf9 100755 --- a/bin/injectpsr.py +++ b/bin/injectpsr.py @@ -5,7 +5,6 @@ Patrick Lazarus, June 26, 2012 """ -from __future__ import print_function from builtins import zip from builtins import object import sys diff --git a/bin/make_spd.py b/bin/make_spd.py index ae677ddfa..6d4e3e3f3 100755 --- a/bin/make_spd.py +++ b/bin/make_spd.py @@ -10,7 +10,6 @@ Chitrang Patel - May. 21, 2015 -- Updated on June 10 2016 """ -from __future__ import print_function from builtins import map from builtins import range from time import strftime diff --git a/bin/makezaplist.py b/bin/makezaplist.py index c6a044fef..6e9b47230 100755 --- a/bin/makezaplist.py +++ b/bin/makezaplist.py @@ -1,6 +1,5 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import str from builtins import range from builtins import object diff --git a/bin/meson.build b/bin/meson.build new file mode 100644 index 000000000..5fe54aebe --- /dev/null +++ b/bin/meson.build @@ -0,0 +1,19 @@ +scripts = ['a2x.sh', 'binary_info.py', 'chooseN.py', 'combine_weights.py', + 'compare_periods.py', 'dat2tim.py', 'DDplan.py', 'detrend_dat.py', + 'downsample_filterbank.py', 'event_peak.py', 'fb_truncate.py', + 'filter_zerolags.py', 'fit_circular_orbit.py', 'fitorb.py', + 'GBNCC_search.py', 'GBT350_drift_prep.py', 'GBT350_drift_search.py', + 'get_TOAs.py', 'gotocand.py', 'guppidrift2fil.py', 'GUPPI_drift_prep.py', + 'injectpsr.py', 'make_spd.py', 'makezaplist.py', 'orbellipsefit.py', + 'PALFA_presto_search.py', 'pfd2png.sh', 'pfd_for_timing.py', 'plot_spd.py', + 'powerstats.py', 'psrfits2fil.py', 'psrfits_quick_bandpass.py', + 'pulsestack.py', 'pygaussfit.py', 'pyplotres.py', 'quickffdots.py', + 'quick_prune_cands.py', 'rfifind_stats.py', 'rrattrap.py', + 'simple_zapbirds.py', 'single_pulse_search.py', 'sortwappfiles.py', + 'subband_smearing.py', 'sum_profiles.py', 'tim2dat.py', + 'waterfaller.py', 'weights_to_ignorechan.py'] + +# This puts all the scripts into the requested binary directory +foreach script: scripts + install_data(script, install_dir: get_option('bindir')) +endforeach diff --git a/bin/orbellipsefit.py b/bin/orbellipsefit.py index 3a90442ca..e3545932c 100755 --- a/bin/orbellipsefit.py +++ b/bin/orbellipsefit.py @@ -5,7 +5,6 @@ # Inputs are a set of .bestprof files or .par files from which the P0 and P1 (or F0 and F1) values # and their errors are read. It can ignore points with too large an F1 error # -from __future__ import print_function from numpy import * from pylab import * from presto.psr_utils import * diff --git a/bin/pfd_for_timing.py b/bin/pfd_for_timing.py index 0d1929628..a78eac4b9 100755 --- a/bin/pfd_for_timing.py +++ b/bin/pfd_for_timing.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function import sys from presto import prepfold diff --git a/bin/powerstats.py b/bin/powerstats.py index 09a2ac3f7..95eb00626 100755 --- a/bin/powerstats.py +++ b/bin/powerstats.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import input from presto.events import * diff --git a/bin/psrfits2fil.py b/bin/psrfits2fil.py index 92ec10195..460ae07b2 100755 --- a/bin/psrfits2fil.py +++ b/bin/psrfits2fil.py @@ -1,6 +1,5 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import numpy as np from presto import psrfits diff --git a/bin/psrfits_quick_bandpass.py b/bin/psrfits_quick_bandpass.py index 19ac8358b..3be5556b0 100755 --- a/bin/psrfits_quick_bandpass.py +++ b/bin/psrfits_quick_bandpass.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import zip import numpy as np import matplotlib.pyplot as plt diff --git a/bin/pulsestack.py b/bin/pulsestack.py index 00e27bbf9..1bb921daf 100755 --- a/bin/pulsestack.py +++ b/bin/pulsestack.py @@ -19,7 +19,6 @@ # ###################################################################### -from __future__ import print_function from builtins import str from builtins import range import numpy as np diff --git a/bin/pyplotres.py b/bin/pyplotres.py index c45b840e1..3b09cf323 100755 --- a/bin/pyplotres.py +++ b/bin/pyplotres.py @@ -6,8 +6,6 @@ # Patrick Lazarus, Feb 26th, 2009 # Many other tweaks by S. Ransom, T. Pennucci et al over years # -from __future__ import print_function -from __future__ import absolute_import from builtins import input from builtins import str from builtins import range diff --git a/bin/quickffdots.py b/bin/quickffdots.py index ec1a0d4d3..63e4eb22f 100755 --- a/bin/quickffdots.py +++ b/bin/quickffdots.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range from presto.infodata import * from presto.presto import ffdot_plane, spectralpower diff --git a/bin/simple_zapbirds.py b/bin/simple_zapbirds.py index 1342a1f3c..77110368c 100755 --- a/bin/simple_zapbirds.py +++ b/bin/simple_zapbirds.py @@ -1,6 +1,5 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import str from builtins import range from builtins import object diff --git a/bin/single_pulse_search.py b/bin/single_pulse_search.py index fba9fba31..1fa9d6977 100755 --- a/bin/single_pulse_search.py +++ b/bin/single_pulse_search.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import str, zip from optparse import OptionParser import bisect, os, sys, glob, gzip diff --git a/bin/sortwappfiles.py b/bin/sortwappfiles.py index 6797f43b6..84a2f7502 100755 --- a/bin/sortwappfiles.py +++ b/bin/sortwappfiles.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import range import sys, re diff --git a/bin/subband_smearing.py b/bin/subband_smearing.py index 7cbbd48a8..8070a133b 100755 --- a/bin/subband_smearing.py +++ b/bin/subband_smearing.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function import matplotlib.pyplot as plt import numpy as num import presto.psr_utils as pu diff --git a/bin/sum_profiles.py b/bin/sum_profiles.py index bea21d3fb..5dec97871 100755 --- a/bin/sum_profiles.py +++ b/bin/sum_profiles.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import zip from builtins import range import getopt, sys diff --git a/bin/tim2dat.py b/bin/tim2dat.py index 9a164228b..b62be6ac2 100755 --- a/bin/tim2dat.py +++ b/bin/tim2dat.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function import astropy.coordinates as coords from builtins import str import os diff --git a/bin/waterfaller.py b/bin/waterfaller.py index ccff6101b..97a720744 100755 --- a/bin/waterfaller.py +++ b/bin/waterfaller.py @@ -197,7 +197,7 @@ def plot_waterfall(data, start, duration, # Set up axes if interactive: fig = plt.figure() - fig.canvas.set_window_title("Frequency vs. Time") + fig.canvas.manager.set_window_title("Frequency vs. Time") im_width = 0.6 if integrate_spec else 0.8 im_height = 0.6 if integrate_ts else 0.8 @@ -214,7 +214,7 @@ def plot_waterfall(data, start, duration, nbinlim = np.int64(duration/data.dt) img = ax_im.imshow(data.data[..., :nbinlim], aspect='auto', - cmap=matplotlib.cm.cmap_d[cmap_str], + cmap=cmap_str, interpolation='nearest', origin='upper', extent=(data.starttime, data.starttime+ nbinlim*data.dt, data.freqs.min(), data.freqs.max())) diff --git a/check_meson_build.py b/check_meson_build.py new file mode 100644 index 000000000..9b560e817 --- /dev/null +++ b/check_meson_build.py @@ -0,0 +1,176 @@ +import subprocess +import json +import os +import os.path +import platform +import sys + + +# For simple terminal colors +class bcolors: + HEADER = "\033[95m" + OKBLUE = "\033[94m" + OKCYAN = "\033[96m" + OKGREEN = "\033[92m" + WARNING = "\033[93m" + FAIL = "\033[91m" + ENDC = "\033[0m" + BOLD = "\033[1m" + UNDERLINE = "\033[4m" + + +# Bail with error +def bail(): + print( + f"\n{bcolors.FAIL}There seem to be some issues. Please fix before trying to build!{bcolors.ENDC}" + ) + sys.exit(1) + + +# Run meson introspect and get the key buildoptions as JSON +result = subprocess.run( + ["meson", "introspect", "build", "--buildoptions"], stdout=subprocess.PIPE +) + +# Process the JSON +vars = json.loads(result.stdout) + +# Which variables do we want to see? +grab = ["prefix", "libdir", "bindir"] +ourvars = {} + +# Grab the important values +for var in vars: + if var["name"] in grab: + ourvars[var["name"]] = var["value"] + +# Show the values for prefix and libdir +print("\nPRESTO's meson build directory currently has:") +print(f" prefix = {ourvars['prefix']}") +print(f" bindir = {ourvars['bindir']}") +print(f" libdir = {ourvars['libdir']}\n") +libinstall = os.path.join(ourvars["prefix"], ourvars["libdir"]) +bininstall = os.path.join(ourvars["prefix"], ourvars["bindir"]) + +# Now show the user what they should be setting +print( + f"Checking for {bcolors.BOLD}PRESTO{bcolors.ENDC} as an environment variable:", + end="", +) +presto = os.environ.get("PRESTO") +if presto is None: + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} PRESTO environment variable is not set!" + ) + print(" You can set it using something like:") + print(f" export PRESTO={os.getcwd()}") + bail() +else: + print(f" {bcolors.OKGREEN}yes{bcolors.ENDC}") + if os.getcwd() != os.path.realpath(presto): + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} PRESTO is set, but not to the current directory!" + ) + +print( + f"Checking for {bcolors.BOLD}TEMPO{bcolors.ENDC} as an environment variable:", + end="", +) +tempo = os.environ.get("TEMPO") +if tempo is None: + print(f" {bcolors.FAIL}no{bcolors.ENDC}") + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} TEMPO environment variable is not set!" + ) + print(" You need to set it to the location of the TEMPO code.") + bail() +else: + print(f" {bcolors.OKGREEN}yes{bcolors.ENDC}") + +chk = os.path.join(presto, "bin") +path = os.environ.get("PATH") +path = path.split(":") if path is not None else [] +path = [x.rstrip("/") for x in path] +if chk != bininstall: + print("Is $PRESTO/bin in PATH? (it shouldn't be):", end="") + if chk in path: + print(f" {bcolors.FAIL}yes{bcolors.ENDC}") + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} $PRESTO/bin should probably not be in your PATH!" + ) + bail() + else: + print(f" {bcolors.OKGREEN}no{bcolors.ENDC}") + +dlpath = "DYLD_LIBRARY_PATH" if platform.system() == "Darwin" else "LD_LIBRARY_PATH" +chk = os.path.join(presto, "lib") +if chk != libinstall: + print(f"Is $PRESTO/lib in {dlpath}? (it shouldn't be):", end="") + if chk in path: + print(f" {bcolors.FAIL}yes{bcolors.ENDC}") + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} $PRESTO/lib should probably not be in your {dlpath}!" + ) + bail() + else: + print(f" {bcolors.OKGREEN}no{bcolors.ENDC}") + +print(f"Is {bcolors.BOLD}{bininstall}{bcolors.ENDC} in PATH? (it should be):", end="") +if bininstall not in path: + print(f" {bcolors.FAIL}no{bcolors.ENDC}") + print(f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} {bininstall} is not in PATH!") + print( + f" That may cause issues with linking if {bininstall} is not a standard binary directory." + ) + print(" You can ensure that it is used by setting PATH using something like:") + print(f" export PATH={bininstall}:$PATH") + bail() +else: + print(f" {bcolors.OKGREEN}yes{bcolors.ENDC}") + +print( + f"Is {bcolors.BOLD}{libinstall}{bcolors.ENDC} in LIBRARY_PATH? (it probably should be)", + end="", +) +libpath = os.environ.get("LIBRARY_PATH") +libpath = libpath.split(":") if libpath is not None else [] +libpath = [x.rstrip("/") for x in libpath] +if libinstall not in libpath: + print(f" {bcolors.FAIL}no{bcolors.ENDC}") + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} {libinstall} is not in LIBRARY_PATH!" + ) + print( + f" That may cause link issues if {libinstall} is not a standard library directory." + ) + print( + " You can ensure that it is used by setting LIBRARY_PATH using something like:" + ) + print(f" export LIBRARY_PATH={libinstall}:$LIBRARY_PATH") + bail() +else: + print(f" {bcolors.OKGREEN}yes{bcolors.ENDC}") + +print( + f"Is {bcolors.BOLD}{libinstall}{bcolors.ENDC} in {dlpath}? (it probably should be)", + end="", +) +ldlibpath = os.environ.get(dlpath) +ldlibpath = ldlibpath.split(":") if ldlibpath is not None else [] +ldlibpath = [x.rstrip("/") for x in ldlibpath] +if libinstall not in ldlibpath: + print(f" {bcolors.FAIL}no{bcolors.ENDC}") + print( + f"\n {bcolors.WARNING}WARNING:{bcolors.ENDC} {libinstall} is not in {dlpath}!" + ) + print( + f" That may cause runtime issues if {libinstall} is not a standard library directory." + ) + print(f" You can ensure that it is used by setting {dlpath} using something like:") + print(f" export {dlpath}={libinstall}:${dlpath}") + bail() +else: + print(f" {bcolors.OKGREEN}yes{bcolors.ENDC}") + +print(f"\n{bcolors.OKGREEN}Everything looks good! Let's try to build:{bcolors.ENDC}\n" + " meson compile -C build\n meson install -C build") diff --git a/clig/spigot2filterbank.1 b/clig/spigot2filterbank.1 deleted file mode 100644 index 65e1dd3be..000000000 --- a/clig/spigot2filterbank.1 +++ /dev/null @@ -1,94 +0,0 @@ -.\" clig manual page template -.\" (C) 1995-2004 Harald Kirsch (clig@geggus.net) -.\" -.\" This file was generated by -.\" clig -- command line interface generator -.\" -.\" -.\" Clig will always edit the lines between pairs of `cligPart ...', -.\" but will not complain, if a pair is missing. So, if you want to -.\" make up a certain part of the manual page by hand rather than have -.\" it edited by clig, remove the respective pair of cligPart-lines. -.\" -.\" cligPart TITLE -.TH "spigot2filterbank" 1 "12Mar10" "Clig-manuals" "Programmer's Manual" -.\" cligPart TITLE end - -.\" cligPart NAME -.SH NAME -spigot2filterbank \- Converts raw GBT Spigot FITs files (lag data) into SIGPROC-style filterbank format. -.\" cligPart NAME end - -.\" cligPart SYNOPSIS -.SH SYNOPSIS -.B spigot2filterbank -[-o outfile] -[-nohdr] -[-stdout] -[-floats] -[-zerolags] -[-skip skip] -[-numout numout] -[-downsamp downsamp] -[-lokill lokill] -[-hikill hikill] -fitsfiles ... -.\" cligPart SYNOPSIS end - -.\" cligPart OPTIONS -.SH OPTIONS -.IP -o -Output file name (optional; for a single output file), -.br -1 String value -.IP -nohdr -Output just raw data. No headers are output. -.IP -stdout -Send the data to STDOUT instead of files. -.IP -floats -Output data as 32-bit floats instead of 8-bit unsigned chars. -.IP -zerolags -Dump the raw spigot zerolags in 32-bit floats format to a file. -.IP -skip -Number of spectra to skip from the initial value, -.br -1 Int value between 0 and oo. -.br -Default: `0' -.IP -numout -Number of spectra to output (default is all), -.br -1 Int value between 0 and oo. -.IP -downsamp -Number of spectra to average on output, -.br -1 Int value between 0 and oo. -.br -Default: `1' -.IP -lokill -Number of low-freq channels to ignore, -.br -1 Int value between 0 and oo. -.br -Default: `0' -.IP -hikill -Number of high-freq channels to ignore, -.br -1 Int value between 0 and oo. -.br -Default: `0' -.IP fitsfiles -Input Spigot FITs files.. -.\" cligPart OPTIONS end - -.\" cligPart DESCRIPTION -.SH DESCRIPTION -This manual page was generated automagically by clig, the -Command Line Interface Generator. Actually the programmer -using clig was supposed to edit this part of the manual -page after -generating it with clig, but obviously (s)he didn't. - -Sadly enough clig does not yet have the power to pick a good -program description out of blue air ;-( -.\" cligPart DESCRIPTION end diff --git a/clig/spigot2filterbank_cmd.cli b/clig/spigot2filterbank_cmd.cli deleted file mode 100644 index 3642d7cdd..000000000 --- a/clig/spigot2filterbank_cmd.cli +++ /dev/null @@ -1,32 +0,0 @@ -# Admin data - -Name spigot2filterbank - -Usage "Converts raw GBT Spigot FITs files (lag data) into SIGPROC-style filterbank format." - -Version [exec date +%d%b%y] - -Commandline full_cmd_line - -# Options (in order you want them to appear) - -String -o outfile {Output file name (optional; for a single output file)} -Flag -nohdr nohdr {Output just raw data. No headers are output} -Flag -stdout stdout {Send the data to STDOUT instead of files} -Flag -floats floats {Output data as 32-bit floats instead of 8-bit unsigned chars} -Flag -zerolags zerolags {Dump the raw spigot zerolags in 32-bit floats format to a file} -Int -skip skip {Number of spectra to skip from the initial value} \ - -r 0 oo -d 0 -Int -numout numout {Number of spectra to output (default is all)} \ - -r 0 oo -Int -downsamp downsamp {Number of spectra to average on output} \ - -r 0 oo -d 1 -Int -lokill lokill {Number of low-freq channels to ignore} \ - -r 0 oo -d 0 -Int -hikill hikill {Number of high-freq channels to ignore} \ - -r 0 oo -d 0 - -# Rest of command line: - -Rest fitsfiles {Input Spigot FITs files.} \ - -c 1 1024 diff --git a/docs/spigot2filterbank.1 b/docs/spigot2filterbank.1 deleted file mode 100644 index 65e1dd3be..000000000 --- a/docs/spigot2filterbank.1 +++ /dev/null @@ -1,94 +0,0 @@ -.\" clig manual page template -.\" (C) 1995-2004 Harald Kirsch (clig@geggus.net) -.\" -.\" This file was generated by -.\" clig -- command line interface generator -.\" -.\" -.\" Clig will always edit the lines between pairs of `cligPart ...', -.\" but will not complain, if a pair is missing. So, if you want to -.\" make up a certain part of the manual page by hand rather than have -.\" it edited by clig, remove the respective pair of cligPart-lines. -.\" -.\" cligPart TITLE -.TH "spigot2filterbank" 1 "12Mar10" "Clig-manuals" "Programmer's Manual" -.\" cligPart TITLE end - -.\" cligPart NAME -.SH NAME -spigot2filterbank \- Converts raw GBT Spigot FITs files (lag data) into SIGPROC-style filterbank format. -.\" cligPart NAME end - -.\" cligPart SYNOPSIS -.SH SYNOPSIS -.B spigot2filterbank -[-o outfile] -[-nohdr] -[-stdout] -[-floats] -[-zerolags] -[-skip skip] -[-numout numout] -[-downsamp downsamp] -[-lokill lokill] -[-hikill hikill] -fitsfiles ... -.\" cligPart SYNOPSIS end - -.\" cligPart OPTIONS -.SH OPTIONS -.IP -o -Output file name (optional; for a single output file), -.br -1 String value -.IP -nohdr -Output just raw data. No headers are output. -.IP -stdout -Send the data to STDOUT instead of files. -.IP -floats -Output data as 32-bit floats instead of 8-bit unsigned chars. -.IP -zerolags -Dump the raw spigot zerolags in 32-bit floats format to a file. -.IP -skip -Number of spectra to skip from the initial value, -.br -1 Int value between 0 and oo. -.br -Default: `0' -.IP -numout -Number of spectra to output (default is all), -.br -1 Int value between 0 and oo. -.IP -downsamp -Number of spectra to average on output, -.br -1 Int value between 0 and oo. -.br -Default: `1' -.IP -lokill -Number of low-freq channels to ignore, -.br -1 Int value between 0 and oo. -.br -Default: `0' -.IP -hikill -Number of high-freq channels to ignore, -.br -1 Int value between 0 and oo. -.br -Default: `0' -.IP fitsfiles -Input Spigot FITs files.. -.\" cligPart OPTIONS end - -.\" cligPart DESCRIPTION -.SH DESCRIPTION -This manual page was generated automagically by clig, the -Command Line Interface Generator. Actually the programmer -using clig was supposed to edit this part of the manual -page after -generating it with clig, but obviously (s)he didn't. - -Sadly enough clig does not yet have the power to pick a good -program description out of blue air ;-( -.\" cligPart DESCRIPTION end diff --git a/examplescripts/ACCEL_sift.py b/examplescripts/ACCEL_sift.py index 7c4e23ea2..5a78197ae 100644 --- a/examplescripts/ACCEL_sift.py +++ b/examplescripts/ACCEL_sift.py @@ -1,4 +1,3 @@ -from __future__ import absolute_import from builtins import map import re import glob diff --git a/examplescripts/concatdata.py b/examplescripts/concatdata.py index f21b89985..87df9cd94 100644 --- a/examplescripts/concatdata.py +++ b/examplescripts/concatdata.py @@ -1,4 +1,3 @@ -from __future__ import print_function from future import standard_library standard_library.install_aliases() from builtins import range diff --git a/examplescripts/dedisp.py b/examplescripts/dedisp.py index a01546053..5399af2a3 100644 --- a/examplescripts/dedisp.py +++ b/examplescripts/dedisp.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import zip from builtins import range import os diff --git a/examplescripts/ffdot_example.py b/examplescripts/ffdot_example.py index 2ef4877ca..c7cd0e521 100644 --- a/examplescripts/ffdot_example.py +++ b/examplescripts/ffdot_example.py @@ -1,4 +1,3 @@ -from __future__ import print_function import numpy as num from presto import presto import presto.ppgplot as ppgplot diff --git a/examplescripts/jerk_example.py b/examplescripts/jerk_example.py index 1de1724c2..64eeee8d4 100644 --- a/examplescripts/jerk_example.py +++ b/examplescripts/jerk_example.py @@ -1,4 +1,3 @@ -from __future__ import print_function import numpy as num from presto import presto import presto.ppgplot as ppgplot @@ -25,16 +24,16 @@ phss = 2.0 * num.pi * (us * (us * (us * w/6.0 + z0/2.0) + r0)) ft = presto.rfft(num.cos(phss)+noise) -a = time.clock() +a = time.time() vol = presto.fdotdot_vol(ft, rint-np/2*dr, dr, np, 0.0-np/2*dz, dz, np, 0.0-np/2*dw, dw, np) -print("First jerk vol took %.3f s" % (time.clock()-a)) -a = time.clock() +print("First jerk vol took %.3f s" % (time.time()-a)) +a = time.time() vol = presto.fdotdot_vol(ft, rint-np/2*dr, dr, np, 0.0-np/2*dz, dz, np, 0.0-np/2*dw, dw, np) -print("Second jerk vol took %.3f s" % (time.clock()-a)) +print("Second jerk vol took %.3f s" % (time.time()-a)) pvol = presto.spectralpower(vol.flat) theo_max_pow = N**2.0/4.0 frp = max(pvol) / theo_max_pow # Fraction of recovered power diff --git a/examplescripts/pdm2raw.py b/examplescripts/pdm2raw.py index 3c77c116f..4063b3660 100644 --- a/examplescripts/pdm2raw.py +++ b/examplescripts/pdm2raw.py @@ -1,4 +1,3 @@ -from __future__ import print_function from numpyio import fread, fwrite from sys import argv diff --git a/examplescripts/ppdot_plane_plot.py b/examplescripts/ppdot_plane_plot.py index 4f0d284e3..f8d6e2290 100644 --- a/examplescripts/ppdot_plane_plot.py +++ b/examplescripts/ppdot_plane_plot.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function from builtins import zip import numpy as np import presto.psr_utils as pu diff --git a/examplescripts/show_zresp.py b/examplescripts/show_zresp.py index 84730fe34..30202edc4 100644 --- a/examplescripts/show_zresp.py +++ b/examplescripts/show_zresp.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from numpy import * from presto.Pgplot import * diff --git a/examplescripts/testcorr.py b/examplescripts/testcorr.py index 54523ebe0..736a1fd13 100644 --- a/examplescripts/testcorr.py +++ b/examplescripts/testcorr.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from numpy import * from Pgplot import * diff --git a/include/spigot2filterbank_cmd.h b/include/spigot2filterbank_cmd.h deleted file mode 100644 index 76f459671..000000000 --- a/include/spigot2filterbank_cmd.h +++ /dev/null @@ -1,59 +0,0 @@ -#ifndef __spigot2filterbank_cmd__ -#define __spigot2filterbank_cmd__ -/***** - command line parser interface -- generated by clig - (http://wsd.iitb.fhg.de/~geg/clighome/) - - The command line parser `clig': - (C) 1995-2004 Harald Kirsch (clig@geggus.net) -*****/ - -typedef struct s_Cmdline { - /***** -o: Output file name (optional; for a single output file) */ - char outfileP; - char* outfile; - int outfileC; - /***** -nohdr: Output just raw data. No headers are output */ - char nohdrP; - /***** -stdout: Send the data to STDOUT instead of files */ - char stdoutP; - /***** -floats: Output data as 32-bit floats instead of 8-bit unsigned chars */ - char floatsP; - /***** -zerolags: Dump the raw spigot zerolags in 32-bit floats format to a file */ - char zerolagsP; - /***** -skip: Number of spectra to skip from the initial value */ - char skipP; - int skip; - int skipC; - /***** -numout: Number of spectra to output (default is all) */ - char numoutP; - int numout; - int numoutC; - /***** -downsamp: Number of spectra to average on output */ - char downsampP; - int downsamp; - int downsampC; - /***** -lokill: Number of low-freq channels to ignore */ - char lokillP; - int lokill; - int lokillC; - /***** -hikill: Number of high-freq channels to ignore */ - char hikillP; - int hikill; - int hikillC; - /***** uninterpreted command line parameters */ - int argc; - /*@null*/char **argv; - /***** the whole command line concatenated */ - char *full_cmd_line; -} Cmdline; - - -extern char *Program; -extern void usage(void); -extern /*@shared*/Cmdline *parseCmdline(int argc, char **argv); - -extern void showOptionValues(void); - -#endif - diff --git a/meson.build b/meson.build new file mode 100644 index 000000000..48fac4d64 --- /dev/null +++ b/meson.build @@ -0,0 +1,62 @@ +project('PRESTO', 'c', + version: '5.0.0', + license: 'GPL-2.0', + default_options: [ + 'buildtype=release', + 'prefix=/home/sransom' + ], +) +# Other buildtype possibilities: +# 'buildtype=debugoptimized', +# 'buildtype=debug', +# Can also set install prefix as option via e.g. 'prefix=/home/sransom' + +cc = meson.get_compiler('c') + +glib = dependency('glib-2.0') +fftw = dependency('fftw3f') # Note the 'f' for single-precision version! +fits = dependency('cfitsio') +x11 = dependency('x11') +png = dependency('libpng') +omp = dependency('openmp', required: false) +mpi = dependency('mpi', language: 'c', required: false, + not_found_message: 'MPI not found. Skipping mpiprepsubband build.') + +libm = cc.find_library('m', required: false) +pgplot = cc.find_library('pgplot', required: true) +cpgplot = cc.find_library('cpgplot', required: true) + +inc = include_directories('include') + +_global_c_args = cc.get_supported_arguments( + '-DUSE_FFTW_MALLOC', + '-Wno-unused-but-set-variable', + '-Wno-unused-function', + '-Wno-conversion', + '-Wno-misleading-indentation', + '-Wno-unused-result', + '-Wno-unused-but-set-parameter' +) +add_project_arguments(_global_c_args, language : 'c') + +# These next couple things are from the Scipy top-level meson.build +add_languages('fortran', native: false) +ff = meson.get_compiler('fortran') +if ff.has_argument('-Wno-conversion') + add_project_arguments('-Wno-conversion', language: 'fortran') +endif + +if host_machine.system() == 'darwin' and cc.has_link_argument('-Wl,-ld_classic') + # New linker introduced in macOS 14 not working yet, see gh-19357 and gh-19387 + add_project_link_arguments('-Wl,-ld_classic', language : ['c', 'cpp', 'fortran']) +endif + +subdir('src') +subdir('bin') + +import('pkgconfig').generate( + libpresto, + filebase: 'presto', + name: 'PRESTO', + description: 'PulsaR Exploration and Search TOolkit by Scott Ransom', +) diff --git a/pyproject.toml b/pyproject.toml deleted file mode 100644 index f55c15f22..000000000 --- a/pyproject.toml +++ /dev/null @@ -1,4 +0,0 @@ -# pep 518 way of specifying setup requirements -[build-system] -requires = ["setuptools", "wheel", "oldest-supported-numpy"] -#requires = ["setuptools", "wheel", "numpy==1.19"] diff --git a/python/binopttest/bindata.py b/python/binopttest/bindata.py index c442c3a47..e4180a477 100644 --- a/python/binopttest/bindata.py +++ b/python/binopttest/bindata.py @@ -1,4 +1,3 @@ -from __future__ import print_function from future import standard_library standard_library.install_aliases() from builtins import range diff --git a/python/binopttest/comb.py b/python/binopttest/comb.py index 11a951335..f8e11a22c 100644 --- a/python/binopttest/comb.py +++ b/python/binopttest/comb.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from Numeric import * from presto import * diff --git a/python/binopttest/montebinopt.py b/python/binopttest/montebinopt.py index dd5f9854a..504596d2a 100644 --- a/python/binopttest/montebinopt.py +++ b/python/binopttest/montebinopt.py @@ -1,4 +1,3 @@ -from __future__ import print_function from future import standard_library standard_library.install_aliases() from builtins import str diff --git a/python/binresponses/monte_ffdot.py b/python/binresponses/monte_ffdot.py index 46b24a105..10604d097 100644 --- a/python/binresponses/monte_ffdot.py +++ b/python/binresponses/monte_ffdot.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from math import * from Numeric import * diff --git a/python/binresponses/monte_short.py b/python/binresponses/monte_short.py index 1b9351a01..abddfcfd8 100644 --- a/python/binresponses/monte_short.py +++ b/python/binresponses/monte_short.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from math import * from Numeric import * diff --git a/python/binresponses/monte_sideb.py b/python/binresponses/monte_sideb.py index c26093691..286302f64 100644 --- a/python/binresponses/monte_sideb.py +++ b/python/binresponses/monte_sideb.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from math import * from Numeric import * diff --git a/python/binresponses/montebinresp.py b/python/binresponses/montebinresp.py index 15c80350b..8b8ec41c2 100644 --- a/python/binresponses/montebinresp.py +++ b/python/binresponses/montebinresp.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from math import * from Numeric import * diff --git a/python/fftfit_src/_fftfit.pyf b/python/fftfit_src/fftfit.pyf similarity index 96% rename from python/fftfit_src/_fftfit.pyf rename to python/fftfit_src/fftfit.pyf index 55811014b..734cd3def 100644 --- a/python/fftfit_src/_fftfit.pyf +++ b/python/fftfit_src/fftfit.pyf @@ -1,5 +1,5 @@ !%f90 -*- f90 -*- -python module _fftfit ! in +python module fftfit ! in interface ! in :fftfit subroutine cprof(y,nmax,nh,c,amp,pha) ! in :fftfit:brent.f,cprof.f,fccf.f,ffft.f,fftfit.f real*4 dimension(nmax) :: y @@ -23,7 +23,7 @@ python module _fftfit ! in integer intent(out) :: ngood end subroutine fftfit end interface -end python module _fftfit +end python module fftfit ! This file was auto-generated with f2py (version:2.13.175-1250). ! See http://cens.ioc.ee/projects/f2py2e/ diff --git a/python/fftfit_src/meson.build b/python/fftfit_src/meson.build new file mode 100644 index 000000000..1bb872908 --- /dev/null +++ b/python/fftfit_src/meson.build @@ -0,0 +1,15 @@ +fftfit_module = custom_target('fftfit_module', + output: 'fftfitmodule.c', + input: 'fftfit.pyf', + command : [py3, '-m', 'numpy.f2py', '@INPUT@', '--build-dir', '@OUTDIR@'] +) + +py3.extension_module('fftfit', + [fftfit_module, fortranobject_c, 'brent.f', 'cprof.f', 'fccf.f', 'ffft.f', 'fftfit.f'], + include_directories: [inc_np, inc_f2py], + c_args: [numpy_nodepr_api, '-Wno-unused-variable'], + dependencies : py3_dep, + link_language: 'fortran', + subdir: 'presto', + install : true, +) diff --git a/python/fftfit_src/test_fftfit.py b/python/fftfit_src/test_fftfit.py index ec7443de4..687610c74 100644 --- a/python/fftfit_src/test_fftfit.py +++ b/python/fftfit_src/test_fftfit.py @@ -1,4 +1,3 @@ -from __future__ import print_function #>>> print fftfit.__doc__ #This module 'fftfit' is auto-generated with f2py (version:2.13.175-1250). #Functions: diff --git a/python/meson.build b/python/meson.build new file mode 100644 index 000000000..7b2a0942c --- /dev/null +++ b/python/meson.build @@ -0,0 +1,62 @@ +project('PRESTO_python', 'c', 'fortran', + version: '5.0.0', + license: 'GPL-2.0', + default_options: [ + 'buildtype=release', + ], +) +# +# Other possibilities +# 'buildtype=debugoptimized', +# 'buildtype=debug', + +cc = meson.get_compiler('c') + +# Compile and prepare all PRESTO code and python packages +py_mod = import('python') +py3 = py_mod.find_installation(pure: false) +py3_dep = py3.dependency() + +# Check the python headers +cc.check_header('Python.h', dependencies: [py3_dep], required: true) +glib = dependency('glib-2.0') +fftw = dependency('fftw3f') # Note the 'f' for the single-precision version! +fits = dependency('cfitsio') +x11 = dependency('x11') +png = dependency('libpng') + +libm = cc.find_library('m', required: false) +libpresto = cc.find_library('presto', required: true) +pgplot = cc.find_library('pgplot', required: true) +cpgplot = cc.find_library('cpgplot', required: true) + +inc = include_directories('../include') + +incdir_numpy = run_command(py3, + [ + '-c', + 'import os; os.chdir(".."); import numpy; print(numpy.get_include())' + ], + check: true +).stdout().strip() + +inc_np = include_directories(incdir_numpy) + +# Don't use the deprecated NumPy C API. Define this to a fixed version instead of +# NPY_API_VERSION in order not to break compilation for released SciPy versions +# when NumPy introduces a new deprecation. Use in a meson.build file:: +# +# py3.extension_module('_name', +# 'source_fname', +# numpy_nodepr_api) +# +numpy_nodepr_api = '-DNPY_NO_DEPRECATED_API=NPY_1_9_API_VERSION' + +incdir_f2py = incdir_numpy / '..' / '..' / 'f2py' / 'src' +inc_f2py = include_directories(incdir_f2py) +fortranobject_c = incdir_f2py / 'fortranobject.c' + +subdir('fftfit_src') +subdir('ppgplot_src') +subdir('presto_src') +subdir('presto') diff --git a/python/ppgplot_src/meson.build b/python/ppgplot_src/meson.build new file mode 100644 index 000000000..90978fe92 --- /dev/null +++ b/python/ppgplot_src/meson.build @@ -0,0 +1,11 @@ +# Note: will need to fix Numpy API deprecation soon -SMR +# c_args: [numpy_nodepr_api, '-Wno-unused-variable'], +py3.extension_module('_ppgplot', '_ppgplot.c', + include_directories: inc_np, + dependencies : [py3_dep, libm, pgplot, cpgplot, x11, png], + install : true, +) + +py3.install_sources(['__init__.py'], + subdir: 'presto/ppgplot' +) diff --git a/python/presto/Pgplot.py b/python/presto/Pgplot.py index e49a9b4c8..0b534b53c 100644 --- a/python/presto/Pgplot.py +++ b/python/presto/Pgplot.py @@ -13,8 +13,6 @@ _or_ an updated version is available in the same directory where this file was found: ftp://cfa-ftp.harvard.edu/pub/ransom """ -from __future__ import print_function -from __future__ import absolute_import from builtins import range from builtins import object import sys diff --git a/python/presto/binary_psr.py b/python/presto/binary_psr.py index dd3c5b333..e218cedab 100644 --- a/python/presto/binary_psr.py +++ b/python/presto/binary_psr.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import object import numpy as Num from presto import parfile, psr_utils diff --git a/python/presto/cosine_rand.py b/python/presto/cosine_rand.py index a0ba67db5..b94872a62 100644 --- a/python/presto/cosine_rand.py +++ b/python/presto/cosine_rand.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from future import standard_library standard_library.install_aliases() import numpy as Num @@ -41,7 +39,7 @@ def cosine_rand(num): as per a sinusoid with maximum at phase=0 (0 < phase < 1). """ rands = n*Num.random.random(num) - indices = rands.astype(Num.int) + indices = rands.astype(int) fracts = rands-indices lo = Num.take(xs, indices) hi = Num.take(xs, indices+1) diff --git a/python/presto/events.py b/python/presto/events.py index 9d5115e84..1fafc5b99 100644 --- a/python/presto/events.py +++ b/python/presto/events.py @@ -1,4 +1,3 @@ -from __future__ import print_function import bisect from presto.psr_constants import PI, TWOPI, PIBYTWO from presto.simple_roots import newton_raphson diff --git a/python/presto/filterbank.py b/python/presto/filterbank.py index b3ebe11fe..1e1eaadf5 100644 --- a/python/presto/filterbank.py +++ b/python/presto/filterbank.py @@ -4,8 +4,6 @@ Patrick Lazarus, June 26, 2012 (Minor modification from file originally from June 6th, 2009) """ -from __future__ import print_function -from __future__ import absolute_import from builtins import object import sys diff --git a/python/presto/injectpsr.py b/python/presto/injectpsr.py index 9c011befc..9f97100c1 100755 --- a/python/presto/injectpsr.py +++ b/python/presto/injectpsr.py @@ -5,7 +5,6 @@ Patrick Lazarus, June 26, 2012 """ -from __future__ import print_function from builtins import zip from builtins import object import sys diff --git a/python/presto/kuiper.py b/python/presto/kuiper.py index 70f3f0c23..9e0c9b25b 100644 --- a/python/presto/kuiper.py +++ b/python/presto/kuiper.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import range import numpy as num from presto import Pgplot diff --git a/python/presto/meson.build b/python/presto/meson.build new file mode 100644 index 000000000..e10b18515 --- /dev/null +++ b/python/presto/meson.build @@ -0,0 +1,9 @@ +py3.install_sources( + ['barycenter.py', 'bestprof.py', 'binary_psr.py', 'cosine_rand.py', + 'events.py', 'fftfit.py', 'filterbank.py', 'infodata.py', 'injectpsr.py', + 'kuiper.py', 'mpfit.py', 'parfile.py', 'Pgplot.py', 'polycos.py', + 'prepfold.py', 'psr_constants.py', 'psrfits.py', 'psr_utils.py', 'pypsrcat.py', + 'residuals.py', 'rfifind.py', 'sifting.py', 'sigproc.py', 'simple_roots.py', + 'sinc_interp.py', 'spectra.py', 'waterfaller.py'], + subdir: 'presto' +) diff --git a/python/presto/mpfit.py b/python/presto/mpfit.py index 176dbcd26..1363d1e52 100644 --- a/python/presto/mpfit.py +++ b/python/presto/mpfit.py @@ -400,7 +400,6 @@ def myfunct(p, fjac=None, x=None, y=None, err=None) Translated from MPFIT (Craig Markwardt's IDL package) to Python, August, 2002. Mark Rivers """ -from __future__ import print_function from builtins import str from builtins import range from builtins import object diff --git a/python/presto/parfile.py b/python/presto/parfile.py index 34fc8b2c1..3b6d194f5 100644 --- a/python/presto/parfile.py +++ b/python/presto/parfile.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import object import six import math, re diff --git a/python/presto/polycos.py b/python/presto/polycos.py index ae32d0e21..f1c098199 100644 --- a/python/presto/polycos.py +++ b/python/presto/polycos.py @@ -1,4 +1,3 @@ -from __future__ import absolute_import from builtins import range from builtins import object import os diff --git a/python/presto/prepfold.py b/python/presto/prepfold.py index 02ddb6594..7be186855 100644 --- a/python/presto/prepfold.py +++ b/python/presto/prepfold.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import range from builtins import object import sys diff --git a/python/presto/psr_utils.py b/python/presto/psr_utils.py index 462b85feb..dd6814b6a 100644 --- a/python/presto/psr_utils.py +++ b/python/presto/psr_utils.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import str from builtins import range import bisect @@ -621,7 +619,7 @@ def PBDOT(porb, e, Mp, Mc): """ PBDOT(porb, e, Mp, Mc): Return the predicted orbital period derivative (s/s) given the - orbital period (s), eccentricity, and pulsar and companion masses. + orbital period (d), eccentricity, and pulsar and companion masses. """ return -192.0 * pc.PI / 5.0 * (porb * pc.SECPERDAY / pc.TWOPI) ** (-5.0 / 3.0) * \ (1.0 + 73.0 / 24.0 * e ** 2.0 + 37.0 / 96.0 * e ** 4.0) * \ diff --git a/python/presto/psrfits.py b/python/presto/psrfits.py index 5362b8ceb..8d42a8d51 100644 --- a/python/presto/psrfits.py +++ b/python/presto/psrfits.py @@ -8,8 +8,6 @@ Jul 4, 2016 (Scott Ransom added 2-bit reading) Mar 25, 2021 (Scott Ransom added 1-bit reading) """ -from __future__ import print_function -from __future__ import absolute_import from builtins import range from builtins import object import re diff --git a/python/presto/pypsrcat.py b/python/presto/pypsrcat.py index 1b5b9de1c..b2344a1ce 100644 --- a/python/presto/pypsrcat.py +++ b/python/presto/pypsrcat.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import object from operator import attrgetter import struct diff --git a/python/presto/residuals.py b/python/presto/residuals.py index f0e60e7fe..8bc30d75a 100644 --- a/python/presto/residuals.py +++ b/python/presto/residuals.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range from builtins import object import struct diff --git a/python/presto/rfifind.py b/python/presto/rfifind.py index a3265b5af..df0db3647 100644 --- a/python/presto/rfifind.py +++ b/python/presto/rfifind.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import zip from builtins import range from builtins import object diff --git a/python/presto/sifting.py b/python/presto/sifting.py index 94abfc156..0c2cbf5f5 100644 --- a/python/presto/sifting.py +++ b/python/presto/sifting.py @@ -1,6 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function -from __future__ import absolute_import from builtins import zip, str, range, object from operator import attrgetter import sys, re, os, copy diff --git a/python/presto/sigproc.py b/python/presto/sigproc.py index be5b42f51..b6335106e 100755 --- a/python/presto/sigproc.py +++ b/python/presto/sigproc.py @@ -1,6 +1,4 @@ #!/usr/bin/env python -from __future__ import print_function -from __future__ import absolute_import from builtins import zip import os import struct diff --git a/python/presto/simple_roots.py b/python/presto/simple_roots.py index af4d924ea..4cde8a07e 100644 --- a/python/presto/simple_roots.py +++ b/python/presto/simple_roots.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range # 'Safe' Newton-Raphson and Secant method # for numerical root-finding diff --git a/python/presto/sinc_interp.py b/python/presto/sinc_interp.py index 9eb22ee39..e8978baca 100644 --- a/python/presto/sinc_interp.py +++ b/python/presto/sinc_interp.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import import numpy as Num import numpy.fft as FFT diff --git a/python/presto/singlepulse/bary_and_topo.py b/python/presto/singlepulse/bary_and_topo.py index 972e4f86d..441ffd5ac 100755 --- a/python/presto/singlepulse/bary_and_topo.py +++ b/python/presto/singlepulse/bary_and_topo.py @@ -6,7 +6,6 @@ Modified to return topocentric and corresponding barycentric times. """ -from __future__ import print_function from presto.presto.prestoswig import * import numpy as Num from presto import psr_utils diff --git a/python/presto/singlepulse/make_spd.py b/python/presto/singlepulse/make_spd.py index c270bf1f9..ab9ac95b7 100755 --- a/python/presto/singlepulse/make_spd.py +++ b/python/presto/singlepulse/make_spd.py @@ -10,8 +10,6 @@ Chitrang Patel - May. 21, 2015 -- Updated on June 10 2016 """ -from __future__ import print_function -from __future__ import absolute_import from builtins import map from builtins import range diff --git a/python/presto/singlepulse/plot_spd.py b/python/presto/singlepulse/plot_spd.py index ca8751ecd..502122d09 100755 --- a/python/presto/singlepulse/plot_spd.py +++ b/python/presto/singlepulse/plot_spd.py @@ -8,7 +8,6 @@ Chitrang Patel - June 10, 2016. """ -from __future__ import print_function from builtins import map import numpy as np import optparse diff --git a/python/presto/singlepulse/rrattrap.py b/python/presto/singlepulse/rrattrap.py index b17590b4b..904f250bf 100755 --- a/python/presto/singlepulse/rrattrap.py +++ b/python/presto/singlepulse/rrattrap.py @@ -14,7 +14,6 @@ Chen Karako May 7, 2014 Updated by Chitrang Patel June 10, 2016. """ -from __future__ import print_function #from past.builtins import cmp from time import strftime from presto import infodata diff --git a/python/presto/singlepulse/sp_pgplot.py b/python/presto/singlepulse/sp_pgplot.py index ac383f7b3..19c9bd18c 100755 --- a/python/presto/singlepulse/sp_pgplot.py +++ b/python/presto/singlepulse/sp_pgplot.py @@ -13,7 +13,6 @@ _or_ an updated version is available in the same directory where this file was found: ftp://cfa-ftp.harvard.edu/pub/ransom """ -from __future__ import print_function from builtins import range from builtins import object import numpy as Num diff --git a/python/presto/singlepulse/spcand.py b/python/presto/singlepulse/spcand.py index ce215d6c2..dc79f5fa5 100755 --- a/python/presto/singlepulse/spcand.py +++ b/python/presto/singlepulse/spcand.py @@ -1,4 +1,3 @@ -from __future__ import absolute_import from builtins import object import numpy as np from . import bary_and_topo diff --git a/python/presto/singlepulse/spio.py b/python/presto/singlepulse/spio.py index 1c8df6f02..1dc9c14c8 100755 --- a/python/presto/singlepulse/spio.py +++ b/python/presto/singlepulse/spio.py @@ -1,4 +1,3 @@ -from __future__ import print_function from builtins import range import numpy as _np import fileinput as _fileinput diff --git a/python/presto_src/__init__.py b/python/presto_src/__init__.py index b0d26eb71..0d69fd6b2 100644 --- a/python/presto_src/__init__.py +++ b/python/presto_src/__init__.py @@ -1,5 +1,3 @@ -from __future__ import print_function -from __future__ import absolute_import from builtins import input from builtins import range from .prestoswig import * diff --git a/python/presto_src/meson.build b/python/presto_src/meson.build new file mode 100644 index 000000000..172ea1de4 --- /dev/null +++ b/python/presto_src/meson.build @@ -0,0 +1,12 @@ +# Note: will need to fix Numpy API deprecation soon -SMR +# c_args: [numpy_nodepr_api, '-Wno-unused-variable'], +py3.extension_module('_presto', 'presto_wrap.c', + include_directories: [inc, inc_np], + dependencies : [py3_dep, libm, fftw, libpresto], + install : true, +) + +py3.install_sources( + ['__init__.py', 'prestoswig.py'], + subdir: 'presto/presto' +) diff --git a/python/presto_src/presto_wrap.c b/python/presto_src/presto_wrap.c index cbdb31c70..293ca7d29 100644 --- a/python/presto_src/presto_wrap.c +++ b/python/presto_src/presto_wrap.c @@ -1,18 +1,14 @@ /* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 4.1.0 + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.3.0 * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. * ----------------------------------------------------------------------------- */ -#ifndef SWIGPYTHON +#define SWIG_VERSION 0x040300 #define SWIGPYTHON -#endif - #define SWIG_PYTHON_DIRECTOR_NO_VTABLE /* ----------------------------------------------------------------------------- @@ -139,14 +135,62 @@ # pragma warning disable 592 #endif +#if defined(__cplusplus) && __cplusplus >=201103L +# define SWIG_NULLPTR nullptr +#else +# define SWIG_NULLPTR NULL +#endif + +/* ----------------------------------------------------------------------------- + * swigcompat.swg + * + * Macros to provide support compatibility with older C and C++ standards. + * ----------------------------------------------------------------------------- */ + +/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF + * if you're missing it. + */ +#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \ + (defined __cplusplus && __cplusplus >= 201103L) || \ + defined SWIG_HAVE_SNPRINTF) && \ + !defined SWIG_NO_SNPRINTF +# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A) +# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B) +#else +/* Fallback versions ignore the buffer size, but most of our uses either have a + * fixed maximum possible size or dynamically allocate a buffer that's large + * enough. + */ +# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A) +# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B) +#endif + #if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) /* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ # include #endif +#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN) +#define PY_SSIZE_T_CLEAN +#endif + +#if __GNUC__ >= 7 +#pragma GCC diagnostic push +#if defined(__cplusplus) && __cplusplus >=201703L +#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */ +#endif +#endif + #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) /* Use debug wrappers with the Python release dll */ + +#if defined(_MSC_VER) && _MSC_VER >= 1929 +/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later + * See https://github.com/swig/swig/issues/2090 */ +# include +#endif + # undef _DEBUG # include # define _DEBUG 1 @@ -154,6 +198,12 @@ # include #endif +#if __GNUC__ >= 7 +#pragma GCC diagnostic pop +#endif + +#include + /* ----------------------------------------------------------------------------- * swigrun.swg * @@ -200,6 +250,8 @@ #define SWIG_POINTER_DISOWN 0x1 #define SWIG_CAST_NEW_MEMORY 0x2 #define SWIG_POINTER_NO_NULL 0x4 +#define SWIG_POINTER_CLEAR 0x8 +#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN) /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 @@ -271,7 +323,7 @@ SWIG errors code. Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this + allows returning the 'cast rank', for example, if you have this int food(double) int fooi(int); @@ -285,7 +337,13 @@ */ #define SWIG_OK (0) +/* Runtime errors are < 0 */ #define SWIG_ERROR (-1) +/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */ +/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */ +/* Errors < -200 are generic runtime specific errors */ +#define SWIG_ERROR_RELEASE_NOT_OWNED (-200) + #define SWIG_IsOK(r) (r >= 0) #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) @@ -293,14 +351,14 @@ #define SWIG_CASTRANKLIMIT (1 << 8) /* The NewMask denotes the object was created (using new/malloc) */ #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) -/* The TmpMask is for in/out typemaps that use temporal objects */ +/* The TmpMask is for in/out typemaps that use temporary objects */ #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) /* Simple returning values */ #define SWIG_BADOBJ (SWIG_ERROR) #define SWIG_OLDOBJ (SWIG_OK) #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) -/* Check, add and del mask methods */ +/* Check, add and del object mask methods */ #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) @@ -446,7 +504,7 @@ SWIG_TypeCheck(const char *c, swig_type_info *ty) { Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison */ SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { +SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) { if (ty) { swig_cast_info *iter = ty->cast; while (iter) { @@ -506,9 +564,9 @@ SWIG_TypeName(const swig_type_info *ty) { SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type) { /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ + type, separated by vertical-bar characters. Choose the last + name. It should be the most specific; a fully resolved name + but not necessarily with default template parameters expanded. */ if (!type) return NULL; if (type->str != NULL) { const char *last_name = type->str; @@ -728,7 +786,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { } #endif -/* Errors in SWIG */ +/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */ #define SWIG_UnknownError -1 #define SWIG_IOError -2 #define SWIG_RuntimeError -3 @@ -744,7 +802,6 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #define SWIG_NullReferenceError -13 - /* Compatibility macros for Python 3 */ #if PY_VERSION_HEX >= 0x03000000 @@ -760,15 +817,10 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #define PyString_Size(str) PyBytes_Size(str) #define PyString_InternFromString(key) PyUnicode_InternFromString(key) #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE -#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) #endif -#ifndef Py_TYPE -# define Py_TYPE(op) ((op)->ob_type) -#endif - /* SWIG APIs for compatibility of both Python 2 & 3 */ #if PY_VERSION_HEX >= 0x03000000 @@ -778,40 +830,30 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #endif -/* Warning: This function will allocate a new string in Python 3, - * so please call SWIG_Python_str_DelForPy3(x) to free the space. - */ -SWIGINTERN char* -SWIG_Python_str_AsChar(PyObject *str) +/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */ +SWIGINTERN const char * +SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes) { #if PY_VERSION_HEX >= 0x03030000 - return (char *)PyUnicode_AsUTF8(str); -#elif PY_VERSION_HEX >= 0x03000000 - char *newstr = 0; - str = PyUnicode_AsUTF8String(str); - if (str) { - char *cstr; - Py_ssize_t len; - if (PyBytes_AsStringAndSize(str, &cstr, &len) != -1) { - newstr = (char *) malloc(len+1); - if (newstr) - memcpy(newstr, cstr, len+1); - } - Py_XDECREF(str); - } - return newstr; +# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 + *pbytes = NULL; + return PyUnicode_AsUTF8AndSize(str, psize); +# else + const char *chars; + *pbytes = PyUnicode_AsUTF8String(str); + chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL; + if (chars && psize) + *psize = PyBytes_Size(*pbytes); + return chars; +# endif #else - return PyString_AsString(str); + char *chars = NULL; + *pbytes = NULL; + PyString_AsStringAndSize(str, &chars, psize); + return chars; #endif } -#if PY_VERSION_HEX >= 0x03030000 || PY_VERSION_HEX < 0x03000000 -# define SWIG_Python_str_DelForPy3(x) -#else -# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) -#endif - - SWIGINTERN PyObject* SWIG_Python_str_FromChar(const char *c) { @@ -822,13 +864,14 @@ SWIG_Python_str_FromChar(const char *c) #endif } -#ifndef PyObject_DEL -# define PyObject_DEL PyObject_Del -#endif - /* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */ # define SWIGPY_USE_CAPSULE -# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) +#ifdef SWIGPYTHON_BUILTIN +# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME +#else +# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME +#endif +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME) #if PY_VERSION_HEX < 0x03020000 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) @@ -836,6 +879,33 @@ SWIG_Python_str_FromChar(const char *c) #define Py_hash_t long #endif +#ifdef Py_LIMITED_API +# define PyTuple_GET_ITEM PyTuple_GetItem +/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used + interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */ +# define PyTuple_SET_ITEM PyTuple_SetItem +# define PyTuple_GET_SIZE PyTuple_Size +# define PyCFunction_GET_FLAGS PyCFunction_GetFlags +# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction +# define PyCFunction_GET_SELF PyCFunction_GetSelf +# define PyList_GET_ITEM PyList_GetItem +# define PyList_SET_ITEM PyList_SetItem +# define PySliceObject PyObject +#endif + +/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */ +#ifdef Py_LIMITED_API +# define SWIG_Py_INCREF Py_IncRef +# define SWIG_Py_XINCREF Py_IncRef +# define SWIG_Py_DECREF Py_DecRef +# define SWIG_Py_XDECREF Py_DecRef +#else +# define SWIG_Py_INCREF Py_INCREF +# define SWIG_Py_XINCREF Py_XINCREF +# define SWIG_Py_DECREF Py_DECREF +# define SWIG_Py_XDECREF Py_XDECREF +#endif + /* ----------------------------------------------------------------------------- * error manipulation * ----------------------------------------------------------------------------- */ @@ -895,16 +965,17 @@ SWIG_Python_AddErrorMsg(const char* mesg) PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); - const char *tmp = SWIG_Python_str_AsChar(old_str); + PyObject *bytes = NULL; + const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes); PyErr_Clear(); - Py_XINCREF(type); + SWIG_Py_XINCREF(type); if (tmp) PyErr_Format(type, "%s %s", tmp, mesg); else PyErr_Format(type, "%s", mesg); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); - Py_DECREF(value); + SWIG_Py_XDECREF(bytes); + SWIG_Py_DECREF(old_str); + SWIG_Py_DECREF(value); } else { PyErr_SetString(PyExc_RuntimeError, mesg); } @@ -933,8 +1004,12 @@ SWIG_Python_RaiseOrModifyTypeError(const char *message) #else newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); #endif - Py_XDECREF(value); - PyErr_Restore(type, newvalue, traceback); + if (newvalue) { + SWIG_Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + PyErr_Restore(type, value, traceback); + } } else { /* Raise TypeError using given message */ PyErr_SetString(PyExc_TypeError, message); @@ -971,7 +1046,7 @@ SWIG_Python_RaiseOrModifyTypeError(const char *message) bool status; PyThreadState *save; public: - void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + void end() { if (status) { status = false; PyEval_RestoreThread(save); }} SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} ~SWIG_Python_Thread_Allow() { end(); } }; @@ -1054,8 +1129,8 @@ typedef struct swig_const_info { # error "This version of SWIG only supports Python >= 2.7" #endif -#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 -# error "This version of SWIG only supports Python 3 >= 3.2" +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000 +# error "This version of SWIG only supports Python 3 >= 3.3" #endif /* Common SWIG API */ @@ -1115,7 +1190,7 @@ SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; PyErr_SetObject(errtype, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); SWIG_PYTHON_THREAD_END_BLOCK; } @@ -1136,13 +1211,13 @@ SWIGINTERN void SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { PyObject *s = PyString_InternFromString(key); PyList_Append(seq, s); - Py_DECREF(s); + SWIG_Py_DECREF(s); } SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { PyDict_SetItemString(d, name, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); if (public_interface) SwigPyBuiltin_AddPublicSymbol(public_interface, name); } @@ -1152,7 +1227,7 @@ SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *nam SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { PyDict_SetItemString(d, name, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } #endif @@ -1164,16 +1239,21 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { if (!result) { result = obj; } else if (result == Py_None) { - Py_DECREF(result); + SWIG_Py_DECREF(result); result = obj; } else { if (!PyList_Check(result)) { PyObject *o2 = result; result = PyList_New(1); - PyList_SetItem(result, 0, o2); + if (result) { + PyList_SET_ITEM(result, 0, o2); + } else { + SWIG_Py_DECREF(obj); + return o2; + } } PyList_Append(result,obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } return result; } @@ -1252,6 +1332,261 @@ SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) { #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var #endif +#ifdef __cplusplus +extern "C" { +#endif + +/* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + +/* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + +typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; +} swig_globalvar; + +typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; +} swig_varlinkobject; + +SWIGINTERN PyObject * +swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif +} + +SWIGINTERN PyObject * +swig_varlink_str(PyObject *o) { + swig_varlinkobject *v = (swig_varlinkobject *) o; +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + SWIG_Py_DECREF(str); + SWIG_Py_DECREF(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + SWIG_Py_DECREF(str); + SWIG_Py_DECREF(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + SWIG_Py_DECREF(str); + SWIG_Py_DECREF(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; +} + +SWIGINTERN void +swig_varlink_dealloc(PyObject *o) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } +} + +SWIGINTERN PyObject * +swig_varlink_getattr(PyObject *o, char *n) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; +} + +SWIGINTERN int +swig_varlink_setattr(PyObject *o, char *n, PyObject *p) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; +} + +SWIGINTERN PyTypeObject* +swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; +#ifndef Py_LIMITED_API + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)swig_varlink_dealloc }, + { Py_tp_repr, (void *)swig_varlink_repr }, + { Py_tp_getattr, (void *)swig_varlink_getattr }, + { Py_tp_setattr, (void *)swig_varlink_setattr }, + { Py_tp_str, (void *)swig_varlink_str }, + { Py_tp_doc, (void *)varlink__doc__ }, + { 0, NULL } + }; + PyType_Spec spec = { + "swigvarlink", + sizeof(swig_varlinkobject), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif +} + +/* Create a variable linking object for use later */ +SWIGINTERN PyObject * +SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); +} + +SWIGINTERN void +SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; +} + + +static PyObject *Swig_Globals_global = NULL; + +SWIGINTERN PyObject * +SWIG_globals(void) { + if (Swig_Globals_global == NULL) { + Swig_Globals_global = SWIG_newvarlink(); + } + return Swig_Globals_global; +} + +#ifdef __cplusplus +} +#endif + /* ----------------------------------------------------------------------------- * Pointer declarations * ----------------------------------------------------------------------------- */ @@ -1275,7 +1610,7 @@ SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void) { PyObject *none = Py_None; - Py_INCREF(none); + SWIG_Py_INCREF(none); return none; } @@ -1318,22 +1653,29 @@ SwigPyClientData_New(PyObject* obj) SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); /* the klass element */ data->klass = obj; - Py_INCREF(data->klass); + SWIG_Py_INCREF(data->klass); /* the newraw method and newargs arguments used to create a new raw instance */ if (PyClass_Check(obj)) { data->newraw = 0; + SWIG_Py_INCREF(obj); data->newargs = obj; - Py_INCREF(obj); } else { data->newraw = PyObject_GetAttrString(data->klass, "__new__"); if (data->newraw) { - Py_INCREF(data->newraw); - data->newargs = PyTuple_New(1); - PyTuple_SetItem(data->newargs, 0, obj); + data->newargs = PyTuple_New(1); + if (data->newargs) { + SWIG_Py_INCREF(obj); + PyTuple_SET_ITEM(data->newargs, 0, obj); + } else { + SWIG_Py_DECREF(data->newraw); + SWIG_Py_DECREF(data->klass); + free(data); + return 0; + } } else { - data->newargs = obj; + SWIG_Py_INCREF(obj); + data->newargs = obj; } - Py_INCREF(data->newargs); } /* the destroy method, aka as the C++ delete method */ data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); @@ -1342,10 +1684,7 @@ SwigPyClientData_New(PyObject* obj) data->destroy = 0; } if (data->destroy) { - int flags; - Py_INCREF(data->destroy); - flags = PyCFunction_GET_FLAGS(data->destroy); - data->delargs = !(flags & (METH_O)); + data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O); } else { data->delargs = 0; } @@ -1356,10 +1695,13 @@ SwigPyClientData_New(PyObject* obj) } SWIGRUNTIME void -SwigPyClientData_Del(SwigPyClientData *data) { - Py_XDECREF(data->newraw); - Py_XDECREF(data->newargs); - Py_XDECREF(data->destroy); +SwigPyClientData_Del(SwigPyClientData *data) +{ + SWIG_Py_XDECREF(data->klass); + SWIG_Py_XDECREF(data->newraw); + SWIG_Py_XDECREF(data->newargs); + SWIG_Py_XDECREF(data->destroy); + free(data); } /* =============== SwigPyObject =====================*/ @@ -1386,7 +1728,7 @@ SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) if (!sobj->dict) sobj->dict = PyDict_New(); - Py_INCREF(sobj->dict); + SWIG_Py_XINCREF(sobj->dict); return sobj->dict; } @@ -1404,18 +1746,21 @@ SwigPyObject_format(const char* fmt, SwigPyObject *v) PyObject *res = NULL; PyObject *args = PyTuple_New(1); if (args) { - if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { - PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + PyObject *val = SwigPyObject_long(v); + if (val) { + PyObject *ofmt; + PyTuple_SET_ITEM(args, 0, val); + ofmt = SWIG_Python_str_FromChar(fmt); if (ofmt) { #if PY_VERSION_HEX >= 0x03000000 - res = PyUnicode_Format(ofmt,args); + res = PyUnicode_Format(ofmt,args); #else - res = PyString_Format(ofmt,args); + res = PyString_Format(ofmt,args); #endif - Py_DECREF(ofmt); + SWIG_Py_DECREF(ofmt); } - Py_DECREF(args); } + SWIG_Py_DECREF(args); } return res; } @@ -1437,18 +1782,23 @@ SwigPyObject_repr(SwigPyObject *v) { const char *name = SWIG_TypePrettyName(v->ty); PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); - if (v->next) { + if (repr && v->next) { PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); + if (nrep) { # if PY_VERSION_HEX >= 0x03000000 - PyObject *joined = PyUnicode_Concat(repr, nrep); - Py_DecRef(repr); - Py_DecRef(nrep); - repr = joined; + PyObject *joined = PyUnicode_Concat(repr, nrep); + SWIG_Py_DECREF(repr); + SWIG_Py_DECREF(nrep); + repr = joined; # else - PyString_ConcatAndDel(&repr,nrep); + PyString_ConcatAndDel(&repr,nrep); # endif + } else { + SWIG_Py_DECREF(repr); + repr = NULL; + } } - return repr; + return repr; } /* We need a version taking two PyObject* parameters so it's a valid @@ -1471,12 +1821,14 @@ SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) SWIGRUNTIME PyObject* SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) { - PyObject* res; - if( op != Py_EQ && op != Py_NE ) { - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + PyObject* res = NULL; + if (!PyErr_Occurred()) { + if (op != Py_EQ && op != Py_NE) { + SWIG_Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); } - res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); return res; } @@ -1504,20 +1856,37 @@ SwigPyObject_type(void) { SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op) { -#ifdef SWIGPYTHON_BUILTIN PyTypeObject *target_tp = SwigPyObject_type(); - if (PyType_IsSubtype(op->ob_type, target_tp)) + PyTypeObject *op_type = Py_TYPE(op); +#ifdef SWIGPYTHON_BUILTIN + if (PyType_IsSubtype(op_type, target_tp)) return 1; - return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); + return (strcmp(op_type->tp_name, "SwigPyObject") == 0); #else - return (Py_TYPE(op) == SwigPyObject_type()) - || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +# ifdef Py_LIMITED_API + int cmp; + PyObject *tp_name; +#endif + if (op_type == target_tp) + return 1; +# ifdef Py_LIMITED_API + tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); + if (!tp_name) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject"); + SWIG_Py_DECREF(tp_name); + return cmp == 0; +# else + return (strcmp(op_type->tp_name, "SwigPyObject") == 0); +# endif #endif } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own); +static PyObject* Swig_Capsule_global = NULL; + SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v) { @@ -1544,8 +1913,12 @@ SwigPyObject_dealloc(PyObject *v) if (data->delargs) { /* we need to create a temporary object to carry the destroy operation */ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); - res = SWIG_Python_CallFunctor(destroy, tmp); - Py_DECREF(tmp); + if (tmp) { + res = SWIG_Python_CallFunctor(destroy, tmp); + } else { + res = 0; + } + SWIG_Py_XDECREF(tmp); } else { PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); PyObject *mself = PyCFunction_GET_SELF(destroy); @@ -1556,7 +1929,7 @@ SwigPyObject_dealloc(PyObject *v) PyErr_Restore(type, value, traceback); - Py_XDECREF(res); + SWIG_Py_XDECREF(res); } #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) else { @@ -1564,9 +1937,13 @@ SwigPyObject_dealloc(PyObject *v) printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); } #endif - } - Py_XDECREF(next); - PyObject_DEL(v); + SWIG_Py_XDECREF(Swig_Capsule_global); + } + SWIG_Py_XDECREF(next); +#ifdef SWIGPYTHON_BUILTIN + SWIG_Py_XDECREF(sobj->dict); +#endif + PyObject_Free(v); } SWIGRUNTIME PyObject* @@ -1577,8 +1954,9 @@ SwigPyObject_append(PyObject* v, PyObject* next) PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); return NULL; } + ((SwigPyObject *)next)->next = sobj->next; sobj->next = next; - Py_INCREF(next); + SWIG_Py_INCREF(next); return SWIG_Py_Void(); } @@ -1587,7 +1965,7 @@ SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) { SwigPyObject *sobj = (SwigPyObject *) v; if (sobj->next) { - Py_INCREF(sobj->next); + SWIG_Py_INCREF(sobj->next); return sobj->next; } else { return SWIG_Py_Void(); @@ -1621,9 +1999,9 @@ SwigPyObject_own(PyObject *v, PyObject *args) PyObject *obj = PyBool_FromLong(sobj->own); if (val) { if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v,args); + SWIG_Py_DECREF(SwigPyObject_acquire(v,args)); } else { - SwigPyObject_disown(v,args); + SWIG_Py_DECREF(SwigPyObject_disown(v,args)); } } return obj; @@ -1644,7 +2022,7 @@ swigobject_methods[] = { SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void) { static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; - +#ifndef Py_LIMITED_API static PyNumberMethods SwigPyObject_as_number = { (binaryfunc)0, /*nb_add*/ (binaryfunc)0, /*nb_subtract*/ @@ -1703,7 +2081,11 @@ SwigPyObject_TypeOnce(void) { sizeof(SwigPyObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ - 0, /* tp_print */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX >= 0x03000000 @@ -1758,6 +2140,9 @@ SwigPyObject_TypeOnce(void) { #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) 0, /* tp_print */ #endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ @@ -1768,21 +2153,50 @@ SwigPyObject_TypeOnce(void) { }; swigpyobject_type = tmp; type_init = 1; - if (PyType_Ready(&swigpyobject_type) < 0) + if (PyType_Ready(&swigpyobject_type) != 0) return NULL; } return &swigpyobject_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)SwigPyObject_dealloc }, + { Py_tp_repr, (void *)SwigPyObject_repr }, + { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, + { Py_tp_doc, (void *)swigobject_doc }, + { Py_tp_richcompare, (void *)SwigPyObject_richcompare }, + { Py_tp_methods, (void *)swigobject_methods }, + { Py_nb_int, (void *)SwigPyObject_long }, + { 0, NULL } + }; + PyType_Spec spec = { + "SwigPyObject", + sizeof(SwigPyObject), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own) { - SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type()); if (sobj) { sobj->ptr = ptr; sobj->ty = ty; sobj->own = own; sobj->next = 0; +#ifdef SWIGPYTHON_BUILTIN + sobj->dict = 0; +#endif + if (own == SWIG_POINTER_OWN) { + /* Obtain a reference to the Python capsule wrapping the module information, so that the + * module information is correctly destroyed after all SWIG python objects have been freed + * by the GC (and corresponding destructors invoked) */ + SWIG_Py_XINCREF(Swig_Capsule_global); + } } return (PyObject *)sobj; } @@ -1839,8 +2253,23 @@ SwigPyPacked_type(void) { SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op) { - return ((op)->ob_type == SwigPyPacked_TypeOnce()) - || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +#ifdef Py_LIMITED_API + int cmp; + PyObject *tp_name; +#endif + PyTypeObject* op_type = Py_TYPE(op); + if (op_type == SwigPyPacked_TypeOnce()) + return 1; +#ifdef Py_LIMITED_API + tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); + if (!tp_name) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked"); + SWIG_Py_DECREF(tp_name); + return cmp == 0; +#else + return (strcmp(op_type->tp_name, "SwigPyPacked") == 0); +#endif } SWIGRUNTIME void @@ -1850,12 +2279,13 @@ SwigPyPacked_dealloc(PyObject *v) SwigPyPacked *sobj = (SwigPyPacked *) v; free(sobj->pack); } - PyObject_DEL(v); + PyObject_Free(v); } SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void) { static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; +#ifndef Py_LIMITED_API static PyTypeObject swigpypacked_type; static int type_init = 0; if (!type_init) { @@ -1870,7 +2300,11 @@ SwigPyPacked_TypeOnce(void) { sizeof(SwigPyPacked), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ - 0, /* tp_print */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX>=0x03000000 @@ -1925,6 +2359,9 @@ SwigPyPacked_TypeOnce(void) { #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) 0, /* tp_print */ #endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ @@ -1935,16 +2372,34 @@ SwigPyPacked_TypeOnce(void) { }; swigpypacked_type = tmp; type_init = 1; - if (PyType_Ready(&swigpypacked_type) < 0) + if (PyType_Ready(&swigpypacked_type) != 0) return NULL; } return &swigpypacked_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)SwigPyPacked_dealloc }, + { Py_tp_repr, (void *)SwigPyPacked_repr }, + { Py_tp_str, (void *)SwigPyPacked_str }, + { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, + { Py_tp_doc, (void *)swigpacked_doc }, + { 0, NULL } + }; + PyType_Spec spec = { + "SwigPyPacked", + sizeof(SwigPyPacked), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif } SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) { - SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type()); if (sobj) { void *pack = malloc(size); if (pack) { @@ -1953,7 +2408,7 @@ SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) sobj->ty = ty; sobj->size = size; } else { - PyObject_DEL((PyObject *) sobj); + PyObject_Free((PyObject *)sobj); sobj = 0; } } @@ -2033,7 +2488,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) #endif obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; @@ -2043,7 +2498,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) #else obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; @@ -2125,12 +2580,19 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int } } if (sobj) { - if (own) - *own = *own | sobj->own; - if (flags & SWIG_POINTER_DISOWN) { - sobj->own = 0; + if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) { + res = SWIG_ERROR_RELEASE_NOT_OWNED; + } else { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + if (flags & SWIG_POINTER_CLEAR) { + sobj->ptr = 0; + } + res = SWIG_OK; } - res = SWIG_OK; } else { if (implicit_conv) { SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; @@ -2162,7 +2624,7 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int } } } - Py_DECREF(impconv); + SWIG_Py_DECREF(impconv); } } } @@ -2189,10 +2651,20 @@ SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { swig_cast_info *tc; /* here we get the method pointer for callbacks */ +#ifndef Py_LIMITED_API const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); +#else + PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__"); + PyObject *bytes = NULL; + const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0; +#endif const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; if (desc) desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; +#ifdef Py_LIMITED_API + SWIG_Py_XDECREF(bytes); + SWIG_Py_XDECREF(pystr_doc); +#endif if (!desc) return SWIG_ERROR; tc = SWIG_TypeCheck(desc,ty); @@ -2243,16 +2715,21 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { - PyObject *dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - PyDict_SetItem(dict, SWIG_This(), swig_this); - } + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + SWIG_Py_DECREF(inst); + inst = 0; + } } #else if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { - Py_DECREF(inst); + SWIG_Py_DECREF(inst); inst = 0; } #endif @@ -2263,25 +2740,30 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) if (empty_args) { PyObject *empty_kwargs = PyDict_New(); if (empty_kwargs) { - inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); - Py_DECREF(empty_kwargs); +#ifndef Py_LIMITED_API + newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new; +#else + newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new); +#endif + inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + SWIG_Py_DECREF(empty_kwargs); if (inst) { if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { - Py_DECREF(inst); + SWIG_Py_DECREF(inst); inst = 0; } else { - Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + PyType_Modified(Py_TYPE(inst)); } } } - Py_DECREF(empty_args); + SWIG_Py_DECREF(empty_args); } #else PyObject *dict = PyDict_New(); if (dict) { PyDict_SetItem(dict, SWIG_This(), swig_this); inst = PyInstance_NewRaw(data->newargs, dict); - Py_DECREF(dict); + SWIG_Py_DECREF(dict); } #endif } @@ -2299,7 +2781,11 @@ SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) dict = PyDict_New(); *dictptr = dict; } - return PyDict_SetItem(dict, SWIG_This(), swig_this); + if (dict) { + return PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + return -1; + } } #endif return PyObject_SetAttr(inst, SWIG_This(), swig_this); @@ -2314,7 +2800,7 @@ SWIG_Python_InitShadowInstance(PyObject *args) { } else { SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); if (sthis) { - SwigPyObject_append((PyObject*) sthis, obj[1]); + SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1])); } else { if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0) return NULL; @@ -2341,7 +2827,12 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f if (flags & SWIG_BUILTIN_TP_INIT) { newobj = (SwigPyObject*) self; if (newobj->ptr) { - PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); +#ifndef Py_LIMITED_API + allocfunc alloc = clientdata->pytype->tp_alloc; +#else + allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc); +#endif + PyObject *next_self = alloc(clientdata->pytype, 0); while (newobj->next) newobj = (SwigPyObject *) newobj->next; newobj->next = next_self; @@ -2353,7 +2844,9 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f } else { newobj = PyObject_New(SwigPyObject, clientdata->pytype); #ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; + if (newobj) { + newobj->dict = 0; + } #endif } if (newobj) { @@ -2371,7 +2864,7 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f robj = SwigPyObject_New(ptr, type, own); if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); - Py_DECREF(robj); + SWIG_Py_DECREF(robj); robj = inst; } return robj; @@ -2392,39 +2885,61 @@ SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { void *SWIG_ReturnGlobalTypeList(void *); #endif +static PyObject *Swig_TypeCache_global = NULL; + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + if (Swig_TypeCache_global == NULL) { + Swig_TypeCache_global = PyDict_New(); + } + return Swig_TypeCache_global; +} + SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { +#ifdef SWIG_LINK_RUNTIME static void *type_pointer = (void *)0; /* first check if module already created */ if (!type_pointer) { -#ifdef SWIG_LINK_RUNTIME type_pointer = SWIG_ReturnGlobalTypeList((void *)0); + } #else - type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); - if (PyErr_Occurred()) { - PyErr_Clear(); - type_pointer = (void *)0; - } -#endif + void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; } +#endif return (swig_module_info *) type_pointer; } + +static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */ + SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj) { swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); swig_type_info **types = swig_module->types; size_t i; + if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */ + return; for (i =0; i < swig_module->size; ++i) { swig_type_info *ty = types[i]; if (ty->owndata) { SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + ty->clientdata = 0; if (data) SwigPyClientData_Del(data); } } - Py_DECREF(SWIG_This()); + SWIG_Py_DECREF(SWIG_This()); Swig_This_global = NULL; + SWIG_Py_DECREF(SWIG_globals()); + Swig_Globals_global = NULL; + SWIG_Py_DECREF(SWIG_Python_TypeCache()); + Swig_TypeCache_global = NULL; + Swig_Capsule_global = NULL; } SWIGRUNTIME void @@ -2438,19 +2953,17 @@ SWIG_Python_SetModule(swig_module_info *swig_module) { #endif PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); if (pointer && module) { - PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) { + ++interpreter_counter; + Swig_Capsule_global = pointer; + } else { + SWIG_Py_DECREF(pointer); + } } else { - Py_XDECREF(pointer); + SWIG_Py_XDECREF(pointer); } } -/* The python cached type query */ -SWIGRUNTIME PyObject * -SWIG_Python_TypeCache(void) { - static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); - return cache; -} - SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type) { @@ -2465,11 +2978,13 @@ SWIG_Python_TypeQuery(const char *type) descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { obj = PyCapsule_New((void*) descriptor, NULL, NULL); - PyDict_SetItem(cache, key, obj); - Py_DECREF(obj); + if (obj) { + PyDict_SetItem(cache, key, obj); + SWIG_Py_DECREF(obj); + } } } - Py_DECREF(key); + SWIG_Py_DECREF(key); return descriptor; } @@ -2490,17 +3005,18 @@ SWIG_Python_AddErrMesg(const char* mesg, int infront) PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); - const char *tmp = SWIG_Python_str_AsChar(old_str); + PyObject *bytes = NULL; + const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes); const char *errmesg = tmp ? tmp : "Invalid error message"; - Py_XINCREF(type); + SWIG_Py_XINCREF(type); PyErr_Clear(); if (infront) { PyErr_Format(type, "%s %s", mesg, errmesg); } else { PyErr_Format(type, "%s %s", errmesg, mesg); } - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); + SWIG_Py_XDECREF(bytes); + SWIG_Py_DECREF(old_str); } return 1; } else { @@ -2532,6 +3048,7 @@ SwigPyObject_GetDesc(PyObject *self) SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj) { + (void) obj; if (type) { #if defined(SWIG_COBJECT_TYPES) if (obj && SwigPyObject_Check(obj)) { @@ -2544,21 +3061,25 @@ SWIG_Python_TypeError(const char *type, PyObject *obj) } else #endif { +#ifndef Py_LIMITED_API + /* tp_name is not accessible */ const char *otype = (obj ? obj->ob_type->tp_name : 0); if (otype) { PyObject *str = PyObject_Str(obj); - const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + PyObject *bytes = NULL; + const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0; if (cstr) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", type, otype, cstr); - SWIG_Python_str_DelForPy3(cstr); } else { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", type, otype); } - Py_XDECREF(str); + SWIG_Py_XDECREF(bytes); + SWIG_Py_XDECREF(str); return; } +#endif } PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); } else { @@ -2573,12 +3094,6 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(arg void *result; if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { PyErr_Clear(); -#if SWIG_POINTER_EXCEPTION - if (flags) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - SWIG_Python_ArgFail(argnum); - } -#endif } return result; } @@ -2605,11 +3120,11 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); return -1; } else { - Py_INCREF(name); + SWIG_Py_INCREF(name); } if (!tp->tp_dict) { - if (PyType_Ready(tp) < 0) + if (PyType_Ready(tp) != 0) goto done; } @@ -2620,20 +3135,20 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { if (!f) { if (PyString_Check(name)) { encoded_name = name; - Py_INCREF(name); + SWIG_Py_INCREF(name); } else { encoded_name = PyUnicode_AsUTF8String(name); if (!encoded_name) - return -1; + goto done; } PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); - Py_DECREF(encoded_name); + SWIG_Py_DECREF(encoded_name); } else { res = f(descr, obj, value); } done: - Py_DECREF(name); + SWIG_Py_DECREF(name); return res; } #endif @@ -2647,23 +3162,8 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) -#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else - - - -#ifdef __cplusplus -extern "C" { -#endif - -/* Method creation and docstring support functions */ - -SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); -SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); -SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) -#ifdef __cplusplus -} -#endif /* -------- TYPES TABLE (BEGIN) -------- */ @@ -2715,10 +3215,6 @@ static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; #endif #define SWIG_name "_presto" -#define SWIGVERSION 0x040100 -#define SWIG_VERSION SWIGVERSION - - #define SWIG_as_voidptr(a) (void *)((const void *)(a)) #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) @@ -2771,10 +3267,6 @@ inline int SWIG_isfinite_func(T x) { # define SWIG_isfinite(X) (SWIG_isfinite_func(X)) # elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) # define SWIG_isfinite(X) (__builtin_isfinite(X)) -# elif defined(__clang__) && defined(__has_builtin) -# if __has_builtin(__builtin_isfinite) -# define SWIG_isfinite(X) (__builtin_isfinite(X)) -# endif # elif defined(_MSC_VER) # define SWIG_isfinite(X) (_finite(X)) # elif defined(__sun) && defined(__SVR4) @@ -2875,9 +3367,11 @@ SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max) { double x = *d; if ((min <= x && x <= max)) { - double fx = floor(x); - double cx = ceil(x); - double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + double fx, cx, rd; + errno = 0; + fx = floor(x); + cx = ceil(x); + rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ if ((errno == EDOM) || (errno == ERANGE)) { errno = 0; } else { @@ -2933,7 +3427,12 @@ SWIG_AsVal_long (PyObject *obj, long* val) if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + // Largest double not larger than LONG_MAX (not portably calculated easily) + // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long) + // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0)) + const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX; + // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) { if (val) *val = (long)(d); return res; } @@ -3513,8 +4012,10 @@ SWIG_pchar_descriptor(void) } +/* Return string from Python obj. NOTE: obj must remain in scope in order + to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */ SWIGINTERN int -SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc) { #if PY_VERSION_HEX>=0x03000000 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) @@ -3527,55 +4028,31 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #endif { char *cstr; Py_ssize_t len; + PyObject *bytes = NULL; int ret = SWIG_OK; -#if PY_VERSION_HEX>=0x03000000 -#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - if (!alloc && cptr) { - /* We can't allow converting without allocation, since the internal - representation of string in Python 3 is UCS-2/UCS-4 but we require - a UTF-8 representation. - TODO(bhy) More detailed explanation */ - return SWIG_RuntimeError; - } - obj = PyUnicode_AsUTF8String(obj); - if (!obj) - return SWIG_TypeError; if (alloc) - *alloc = SWIG_NEWOBJ; -#endif + *alloc = SWIG_OLDOBJ; +#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR) if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1) return SWIG_TypeError; #else - if (PyString_AsStringAndSize(obj, &cstr, &len) == -1) + cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes); + if (!cstr) return SWIG_TypeError; -#endif - if (cptr) { + /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */ + if (bytes && cptr) { if (alloc) { - if (*alloc == SWIG_NEWOBJ) { - *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); - *alloc = SWIG_NEWOBJ; - } else { - *cptr = cstr; - *alloc = SWIG_OLDOBJ; - } + cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); + *alloc = SWIG_NEWOBJ; } else { -#if PY_VERSION_HEX>=0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - *cptr = PyBytes_AsString(obj); -#else - assert(0); /* Should never reach here with Unicode strings in Python 3 */ -#endif -#else - *cptr = SWIG_Python_str_AsChar(obj); - if (!*cptr) - ret = SWIG_TypeError; -#endif + /* alloc must be set in order to clean up allocated memory */ + return SWIG_RuntimeError; } } - if (psize) *psize = len + 1; -#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - Py_XDECREF(obj); #endif + if (cptr) *cptr = cstr; + if (psize) *psize = len + 1; + SWIG_Py_XDECREF(bytes); return ret; } else { #if defined(SWIG_PYTHON_2_UNICODE) @@ -3598,10 +4075,10 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) } if (psize) *psize = len + 1; - Py_XDECREF(obj); + SWIG_Py_XDECREF(obj); return SWIG_OK; } else { - Py_XDECREF(obj); + SWIG_Py_XDECREF(obj); } } #endif @@ -3874,7 +4351,11 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { + // Largest double not larger than ULONG_MAX (not portably calculated easily) + // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long) + // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0)) + const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) { if (val) *val = (unsigned long)(d); return res; } @@ -4013,7 +4494,7 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; float arg2 ; @@ -4023,6 +4504,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *SWIGUNUSEDPARM(self), PyObje int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fcomplex_r_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4042,7 +4524,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; void *argp1 = 0 ; @@ -4050,6 +4532,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); @@ -4065,7 +4548,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; float arg2 ; @@ -4075,6 +4558,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *SWIGUNUSEDPARM(self), PyObje int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fcomplex_i_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4094,7 +4578,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; void *argp1 = 0 ; @@ -4102,6 +4586,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); @@ -4117,10 +4602,11 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_new_fcomplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_fcomplex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_fcomplex", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -4146,13 +4632,14 @@ SWIGINTERN PyObject *_wrap_new_fcomplex(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_delete_fcomplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_fcomplex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, SWIG_POINTER_DISOWN | 0 ); @@ -4195,9 +4682,10 @@ SWIGINTERN PyObject *fcomplex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_read_wisdom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_read_wisdom(PyObject *self, PyObject *args) { PyObject *resultobj = 0; + (void)self; if (!SWIG_Python_UnpackTuple(args, "read_wisdom", 0, 0, 0)) SWIG_fail; read_wisdom(); resultobj = SWIG_Py_Void(); @@ -4207,7 +4695,7 @@ SWIGINTERN PyObject *_wrap_read_wisdom(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_good_factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_good_factor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -4215,6 +4703,7 @@ SWIGINTERN PyObject *_wrap_good_factor(PyObject *SWIGUNUSEDPARM(self), PyObject PyObject *swig_obj[1] ; long long result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -4230,7 +4719,7 @@ SWIGINTERN PyObject *_wrap_good_factor(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_fftwcall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fftwcall(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -4241,6 +4730,7 @@ SWIGINTERN PyObject *_wrap_fftwcall(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fftwcall", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -4263,7 +4753,7 @@ SWIGINTERN PyObject *_wrap_fftwcall(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -4274,6 +4764,7 @@ SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "tablesixstepfft", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -4296,7 +4787,7 @@ SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_realfft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_realfft(PyObject *self, PyObject *args) { PyObject *resultobj = 0; float *arg1 = (float *) 0 ; long arg2 ; @@ -4307,6 +4798,7 @@ SWIGINTERN PyObject *_wrap_realfft(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "realfft", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_FLOAT); @@ -4329,7 +4821,7 @@ SWIGINTERN PyObject *_wrap_realfft(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4339,6 +4831,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_ra_s_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4358,7 +4851,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4366,6 +4859,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4381,7 +4875,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4391,6 +4885,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dec_s_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4410,7 +4905,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4418,6 +4913,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4433,7 +4929,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4443,6 +4939,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *SWIGUNUSEDPARM(self), PyObje int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_N_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4462,7 +4959,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4470,6 +4967,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4485,7 +4983,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4495,6 +4993,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dt_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4514,7 +5013,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4522,6 +5021,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4537,7 +5037,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4547,6 +5047,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_fov_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4566,7 +5067,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4574,6 +5075,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4589,7 +5091,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4599,6 +5101,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_mjd_f_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4618,7 +5121,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4626,6 +5129,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4641,7 +5145,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4651,6 +5155,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dm_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4670,7 +5175,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4678,6 +5183,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4693,7 +5199,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4703,6 +5209,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_freq_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4722,7 +5229,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4730,6 +5237,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4745,7 +5253,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4755,6 +5263,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_freqband_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4774,7 +5283,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4782,6 +5291,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4797,7 +5307,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4807,6 +5317,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_chan_wid_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4826,7 +5337,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4834,6 +5345,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4849,7 +5361,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4859,6 +5371,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_wavelen_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4878,7 +5391,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4886,6 +5399,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4901,7 +5415,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4911,6 +5425,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_waveband_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4930,7 +5445,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4938,6 +5453,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4953,7 +5469,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4963,6 +5479,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *SWIGUNUSEDPARM(self), P int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_energy_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4982,7 +5499,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4990,6 +5507,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5005,7 +5523,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -5015,6 +5533,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_energyband_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5034,7 +5553,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5042,6 +5561,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5057,7 +5577,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5067,6 +5587,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_num_chan_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5086,7 +5607,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5094,6 +5615,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5109,7 +5631,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5119,6 +5641,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_mjd_i_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5138,7 +5661,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5146,6 +5669,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5161,7 +5685,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5171,6 +5695,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_ra_h_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5190,7 +5715,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5198,6 +5723,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5213,7 +5739,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5223,6 +5749,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_ra_m_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5242,7 +5769,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5250,6 +5777,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5265,7 +5793,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5275,6 +5803,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dec_d_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5294,7 +5823,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5302,6 +5831,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5317,7 +5847,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5327,6 +5857,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dec_m_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5346,7 +5877,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5354,6 +5885,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5369,7 +5901,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5379,6 +5911,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_bary_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5398,7 +5931,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5406,6 +5939,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5421,7 +5955,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5431,6 +5965,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_numonoff_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5450,7 +5985,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5458,6 +5993,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5473,7 +6009,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5484,6 +6020,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *SWIGUNUSEDPARM(self), Py int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_notes_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5505,7 +6042,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5513,6 +6050,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5528,7 +6066,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5539,6 +6077,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *SWIGUNUSEDPARM(self), PyO int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_name_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5560,7 +6099,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5568,6 +6107,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5583,7 +6123,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5594,6 +6134,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_object_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5615,7 +6156,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5623,6 +6164,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5638,7 +6180,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5649,6 +6191,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *SWIGUNUSEDPARM(self int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_instrument_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5670,7 +6213,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5678,6 +6221,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5693,7 +6237,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5704,6 +6248,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *SWIGUNUSEDPARM(self), int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_observer_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5725,7 +6270,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5733,6 +6278,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5748,7 +6294,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5759,6 +6305,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *SWIGUNUSEDPARM(self), int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_analyzer_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5780,7 +6327,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5788,6 +6335,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5803,7 +6351,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5814,6 +6362,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *SWIGUNUSEDPARM(self) int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_telescope_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5835,7 +6384,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5843,6 +6392,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5858,7 +6408,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5869,6 +6419,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *SWIGUNUSEDPARM(self), PyO int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_band_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5890,7 +6441,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5898,6 +6449,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5913,7 +6465,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5924,6 +6476,7 @@ SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *SWIGUNUSEDPARM(self), PyO int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_filt_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5945,7 +6498,7 @@ SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5953,6 +6506,7 @@ SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5968,10 +6522,11 @@ SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_new_infodata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_infodata(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_infodata", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -5997,13 +6552,14 @@ SWIGINTERN PyObject *_wrap_new_infodata(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_delete_infodata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_infodata(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, SWIG_POINTER_DISOWN | 0 ); @@ -6046,7 +6602,7 @@ SWIGINTERN PyObject *infodata_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_readinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_readinf(PyObject *self, PyObject *args) { PyObject *resultobj = 0; infodata *arg1 = (infodata *) 0 ; char *arg2 = (char *) 0 ; @@ -6057,6 +6613,7 @@ SWIGINTERN PyObject *_wrap_readinf(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "readinf", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6078,13 +6635,14 @@ SWIGINTERN PyObject *_wrap_readinf(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_writeinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_writeinf(PyObject *self, PyObject *args) { PyObject *resultobj = 0; infodata *arg1 = (infodata *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -6100,7 +6658,7 @@ SWIGINTERN PyObject *_wrap_writeinf(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6110,6 +6668,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_p_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6129,7 +6688,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6137,6 +6696,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6152,7 +6712,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6162,6 +6722,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_e_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6181,7 +6742,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6189,6 +6750,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6204,7 +6766,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6214,6 +6776,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_x_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6233,7 +6796,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6241,6 +6804,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6256,7 +6820,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6266,6 +6830,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_w_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6285,7 +6850,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6293,6 +6858,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6308,7 +6874,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6318,6 +6884,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_t_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6337,7 +6904,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6345,6 +6912,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6360,7 +6928,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6370,6 +6938,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_pd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6389,7 +6958,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6397,6 +6966,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6412,7 +6982,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6422,6 +6992,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_wd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6441,7 +7012,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6449,6 +7020,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6464,10 +7036,11 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_orbitparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_orbitparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_orbitparams", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -6493,13 +7066,14 @@ SWIGINTERN PyObject *_wrap_new_orbitparams(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_delete_orbitparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_orbitparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, SWIG_POINTER_DISOWN | 0 ); @@ -6542,7 +7116,7 @@ SWIGINTERN PyObject *orbitparams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; char *arg2 = (char *) 0 ; @@ -6553,6 +7127,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_jname_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6574,7 +7149,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6582,6 +7157,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6597,7 +7173,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; char *arg2 = (char *) 0 ; @@ -6608,6 +7184,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_bname_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6629,7 +7206,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6637,6 +7214,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6652,7 +7230,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; char *arg2 = (char *) 0 ; @@ -6663,6 +7241,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_alias_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6684,7 +7263,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6692,6 +7271,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6707,7 +7287,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6717,6 +7297,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_ra2000_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6736,7 +7317,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6744,6 +7325,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6759,7 +7341,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6769,6 +7351,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_dec2000_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6788,7 +7371,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6796,6 +7379,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6811,7 +7395,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6821,6 +7405,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_dm_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6840,7 +7425,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6848,6 +7433,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6863,7 +7449,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6873,6 +7459,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_timepoch_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6892,7 +7479,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6900,6 +7487,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6915,7 +7503,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6925,6 +7513,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_p_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6944,7 +7533,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6952,6 +7541,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6967,7 +7557,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6977,6 +7567,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_pd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6996,7 +7587,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7004,6 +7595,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7019,7 +7611,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7029,6 +7621,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_pdd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7048,7 +7641,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7056,6 +7649,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7071,7 +7665,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7081,6 +7675,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_f_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7100,7 +7695,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7108,6 +7703,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7123,7 +7719,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7133,6 +7729,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_fd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7152,7 +7749,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7160,6 +7757,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7175,7 +7773,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7185,6 +7783,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_fdd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7204,7 +7803,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7212,6 +7811,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7227,7 +7827,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; orbitparams *arg2 = (orbitparams *) 0 ; @@ -7237,6 +7837,7 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_orb_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7256,7 +7857,7 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7264,6 +7865,7 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; orbitparams *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7279,10 +7881,11 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_new_psrparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_psrparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_psrparams", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -7308,13 +7911,14 @@ SWIGINTERN PyObject *_wrap_new_psrparams(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_delete_psrparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_psrparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, SWIG_POINTER_DISOWN | 0 ); @@ -7357,7 +7961,7 @@ SWIGINTERN PyObject *psrparams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -7372,6 +7976,7 @@ SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_psr_at_epoch", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -7398,7 +8003,7 @@ SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -7413,6 +8018,7 @@ SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_psr_from_parfile", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -7439,7 +8045,7 @@ SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; char *arg2 = (char *) 0 ; @@ -7450,6 +8056,7 @@ SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *SWIGUNUSEDPARM(self), PyObje int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "mjd_to_datestr", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -7471,7 +8078,7 @@ SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fresnl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fresnl(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double *arg2 = (double *) 0 ; @@ -7487,6 +8094,7 @@ SWIGINTERN PyObject *_wrap_fresnl(PyObject *SWIGUNUSEDPARM(self), PyObject *args arg2 = &temp2; arg3 = &temp3; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -7514,7 +8122,7 @@ SWIGINTERN PyObject *_wrap_fresnl(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7524,6 +8132,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_pow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7543,7 +8152,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7551,6 +8160,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7566,7 +8176,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7576,6 +8186,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_phs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7595,7 +8206,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7603,6 +8214,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7618,7 +8230,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7628,6 +8240,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_dpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7647,7 +8260,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7655,6 +8268,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7670,7 +8284,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7680,6 +8294,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_dphs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7699,7 +8314,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7707,6 +8322,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7722,7 +8338,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7732,6 +8348,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_d2pow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7751,7 +8368,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7759,6 +8376,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7774,7 +8392,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7784,6 +8402,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_d2phs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7803,7 +8422,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7811,6 +8430,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7826,7 +8446,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7836,6 +8456,7 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_locpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7855,7 +8476,7 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7863,6 +8484,7 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7878,10 +8500,11 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_rderivs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_rderivs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_rderivs", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -7907,13 +8530,14 @@ SWIGINTERN PyObject *_wrap_new_rderivs(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_delete_rderivs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_rderivs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, SWIG_POINTER_DISOWN | 0 ); @@ -7956,7 +8580,7 @@ SWIGINTERN PyObject *rderivs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; double arg2 ; @@ -7966,6 +8590,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_r_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7985,7 +8610,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -7993,6 +8618,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8008,7 +8634,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8018,6 +8644,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_rerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8037,7 +8664,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8045,6 +8672,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8060,7 +8688,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; double arg2 ; @@ -8070,6 +8698,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_z_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8089,7 +8718,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8097,6 +8726,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8112,7 +8742,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8122,6 +8752,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_zerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8141,7 +8772,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8149,6 +8780,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8164,7 +8796,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; double arg2 ; @@ -8174,6 +8806,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_w_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8193,7 +8826,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8201,6 +8834,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8216,7 +8850,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8226,6 +8860,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_werr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8245,7 +8880,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8253,6 +8888,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8268,7 +8904,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8278,6 +8914,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_pow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8297,7 +8934,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8305,6 +8942,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8320,7 +8958,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8330,6 +8968,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_powerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8349,7 +8988,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8357,6 +8996,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8372,7 +9012,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8382,6 +9022,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_sig_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8401,7 +9042,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8409,6 +9050,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8424,7 +9066,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8434,6 +9076,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_rawpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8453,7 +9096,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8461,6 +9104,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8476,7 +9120,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8486,6 +9130,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_phs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8505,7 +9150,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8513,6 +9158,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8528,7 +9174,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8538,6 +9184,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_phserr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8557,7 +9204,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8565,6 +9212,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8580,7 +9228,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8590,6 +9238,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_cen_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8609,7 +9258,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8617,6 +9266,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8632,7 +9282,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8642,6 +9292,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_cenerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8661,7 +9312,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8669,6 +9320,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8684,7 +9336,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8694,6 +9346,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_pur_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8713,7 +9366,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8721,6 +9374,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8736,7 +9390,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8746,6 +9400,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_purerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8765,7 +9420,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8773,6 +9428,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8788,7 +9444,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8798,6 +9454,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_locpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8817,7 +9474,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8825,6 +9482,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8840,10 +9498,11 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_fourierprops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_fourierprops(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_fourierprops", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -8869,13 +9528,14 @@ SWIGINTERN PyObject *_wrap_new_fourierprops(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_delete_fourierprops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_fourierprops(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, SWIG_POINTER_DISOWN | 0 ); @@ -8918,7 +9578,7 @@ SWIGINTERN PyObject *fourierprops_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -8928,6 +9588,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_numdata_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8947,7 +9608,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -8955,6 +9616,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -8970,7 +9632,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -8980,6 +9642,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_data_avg_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8999,7 +9662,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9007,6 +9670,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9022,7 +9686,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9032,6 +9696,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_data_var_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9051,7 +9716,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9059,6 +9724,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9074,7 +9740,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9084,6 +9750,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_numprof_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9103,7 +9770,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9111,6 +9778,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9126,7 +9794,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9136,6 +9804,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_prof_avg_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9155,7 +9824,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9163,6 +9832,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9178,7 +9848,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9188,6 +9858,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_prof_var_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9207,7 +9878,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9215,6 +9886,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9230,7 +9902,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9240,6 +9912,7 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_redchi_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9259,7 +9932,7 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9267,6 +9940,7 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9282,10 +9956,11 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_foldstats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_foldstats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_foldstats", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -9311,13 +9986,14 @@ SWIGINTERN PyObject *_wrap_new_foldstats(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_delete_foldstats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_foldstats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, SWIG_POINTER_DISOWN | 0 ); @@ -9360,7 +10036,7 @@ SWIGINTERN PyObject *foldstats_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long arg1 ; float **arg2 = (float **) 0 ; @@ -9375,6 +10051,7 @@ SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg2 = &data_temp2; arg3 = &dim_temp2; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); @@ -9429,7 +10106,7 @@ SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long arg1 ; fcomplex **arg2 = (fcomplex **) 0 ; @@ -9444,6 +10121,7 @@ SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg2 = &data_temp2; arg3 = &dim_temp2; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); @@ -9498,7 +10176,7 @@ SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_power_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_power_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -9514,6 +10192,7 @@ SWIGINTERN PyObject *_wrap_power_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg3 = &data_temp3; arg4 = &dim_temp3; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; { @@ -9571,7 +10250,7 @@ SWIGINTERN PyObject *_wrap_power_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_phase_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_phase_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -9587,6 +10266,7 @@ SWIGINTERN PyObject *_wrap_phase_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg3 = &data_temp3; arg4 = &dim_temp3; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; { @@ -9644,7 +10324,7 @@ SWIGINTERN PyObject *_wrap_phase_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_frotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_frotate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; float *arg1 = (float *) 0 ; long arg2 ; @@ -9655,6 +10335,7 @@ SWIGINTERN PyObject *_wrap_frotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "frotate", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_FLOAT); @@ -9693,7 +10374,7 @@ SWIGINTERN PyObject *_wrap_frotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_drotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_drotate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9704,6 +10385,7 @@ SWIGINTERN PyObject *_wrap_drotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "drotate", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9742,7 +10424,7 @@ SWIGINTERN PyObject *_wrap_drotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -9759,6 +10441,7 @@ SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *SWIGUNUSEDPARM(self), PyObject PyObject *swig_obj[4] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "keplers_eqn", 4, 4, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -9804,7 +10487,7 @@ SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9815,6 +10498,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_phib", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9853,7 +10537,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_E_to_v(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_v(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9864,6 +10548,7 @@ SWIGINTERN PyObject *_wrap_E_to_v(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_v", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9902,7 +10587,7 @@ SWIGINTERN PyObject *_wrap_E_to_v(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_E_to_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_p(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9916,6 +10601,7 @@ SWIGINTERN PyObject *_wrap_E_to_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res4 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_p", 3, 3, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9959,7 +10645,7 @@ SWIGINTERN PyObject *_wrap_E_to_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_E_to_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_z(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9976,6 +10662,7 @@ SWIGINTERN PyObject *_wrap_E_to_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res5 = 0 ; PyObject *swig_obj[4] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_z", 4, 4, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -10024,7 +10711,7 @@ SWIGINTERN PyObject *_wrap_E_to_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -10035,6 +10722,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_phib_BT", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -10073,7 +10761,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_dorbint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_dorbint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double **arg1 = (double **) 0 ; long *arg2 = (long *) 0 ; @@ -10097,6 +10785,7 @@ SWIGINTERN PyObject *_wrap_dorbint(PyObject *SWIGUNUSEDPARM(self), PyObject *arg arg1 = &data_temp1; arg2 = &dim_temp1; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "dorbint", 4, 4, swig_obj)) SWIG_fail; ecode3 = SWIG_AsVal_double(swig_obj[0], &val3); if (!SWIG_IsOK(ecode3)) { @@ -10165,7 +10854,7 @@ SWIGINTERN PyObject *_wrap_dorbint(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; orbitparams *arg2 = (orbitparams *) 0 ; @@ -10183,6 +10872,7 @@ SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *SWIGUNUSEDPARM(self), PyObj arg3 = &temp3; arg4 = &temp4; + (void)self; if (!SWIG_Python_UnpackTuple(args, "binary_velocity", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10230,7 +10920,7 @@ SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; presto_interp_acc arg1 ; int val1 ; @@ -10238,6 +10928,7 @@ SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); @@ -10269,7 +10960,7 @@ SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; presto_interp_acc arg2 ; @@ -10280,6 +10971,7 @@ SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[2] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "z_resp_halfwidth", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10315,7 +11007,7 @@ SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -10329,6 +11021,7 @@ SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "w_resp_halfwidth", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10369,7 +11062,7 @@ SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -10383,6 +11076,7 @@ SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "bin_resp_halfwidth", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10423,7 +11117,7 @@ SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10444,6 +11138,7 @@ SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *SWIGUNUSEDPARM(self), PyObje arg4 = &data_temp4; arg5 = &dim_temp4; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_r_response", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10507,7 +11202,7 @@ SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10531,6 +11226,7 @@ SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *SWIGUNUSEDPARM(self), PyObje arg5 = &data_temp5; arg6 = &dim_temp5; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_z_response", 4, 4, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10599,7 +11295,7 @@ SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10626,6 +11322,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *SWIGUNUSEDPARM(self), PyObje arg6 = &data_temp6; arg7 = &dim_temp6; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_w_response", 5, 5, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10699,7 +11396,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10726,6 +11423,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *SWIGUNUSEDPARM(self), PyObj arg6 = &data_temp6; arg7 = &dim_temp6; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_w_response2", 5, 5, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10799,7 +11497,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10829,6 +11527,7 @@ SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *SWIGUNUSEDPARM(self), PyOb arg7 = &data_temp7; arg8 = &dim_temp7; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_bin_response", 6, 6, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10907,7 +11606,7 @@ SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_get_localpower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_localpower(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -10919,6 +11618,7 @@ SWIGINTERN PyObject *_wrap_get_localpower(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[2] ; float result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_localpower", 2, 2, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -10973,7 +11673,7 @@ SWIGINTERN PyObject *_wrap_get_localpower(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -10991,6 +11691,7 @@ SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[4] ; float result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_localpower3d", 4, 4, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -11055,7 +11756,7 @@ SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -11080,6 +11781,7 @@ SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *SWIGUNUSEDPARM(self), PyObject int res7 = 0 ; PyObject *swig_obj[7] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_derivs3d", 7, 7, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -11140,7 +11842,7 @@ SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_calc_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_calc_props(PyObject *self, PyObject *args) { PyObject *resultobj = 0; rderivs arg1 ; double arg2 ; @@ -11159,6 +11861,7 @@ SWIGINTERN PyObject *_wrap_calc_props(PyObject *SWIGUNUSEDPARM(self), PyObject * int res5 = 0 ; PyObject *swig_obj[5] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "calc_props", 5, 5, swig_obj)) SWIG_fail; { res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RDERIVS, 0 ); @@ -11215,7 +11918,7 @@ SWIGINTERN PyObject *_wrap_calc_props(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fourierprops *arg1 = (fourierprops *) 0 ; double arg2 ; @@ -11234,6 +11937,7 @@ SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *SWIGUNUSEDPARM(self), PyObjec int res5 = 0 ; PyObject *swig_obj[5] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "calc_binprops", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -11284,7 +11988,7 @@ SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fourierprops *arg1 = (fourierprops *) 0 ; double arg2 ; @@ -11297,6 +12001,7 @@ SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "calc_rzwerrs", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -11337,7 +12042,7 @@ SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -11345,6 +12050,7 @@ SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *SWIGUNUSEDPAR PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -11376,7 +12082,7 @@ SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11387,6 +12093,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *SWIGUNUSEDPA PyObject *swig_obj[2] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "log_asymtotic_incomplete_gamma", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11422,7 +12129,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -11430,6 +12137,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -11461,7 +12169,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -11469,6 +12177,7 @@ SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *SWIGUNUSEDPARM(se PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -11500,7 +12209,7 @@ SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11511,6 +12220,7 @@ SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *SWIGUNUSEDPARM(self), PyObject *a PyObject *swig_obj[2] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "chi2_logp", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11546,7 +12256,7 @@ SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11557,6 +12267,7 @@ SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *swig_obj[2] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "chi2_sigma", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11592,7 +12303,7 @@ SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -11606,6 +12317,7 @@ SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "candidate_sigma", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11646,7 +12358,7 @@ SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -11660,6 +12372,7 @@ SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "power_for_sigma", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11700,7 +12413,7 @@ SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11725,6 +12438,7 @@ SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *SWIGUNUSEDPARM(self), PyObje arg4 = &temp4; arg5 = &temp5; arg6 = &temp6; + (void)self; if (!SWIG_Python_UnpackTuple(args, "switch_f_and_p", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11783,7 +12497,7 @@ SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_chisqr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_chisqr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -11798,6 +12512,7 @@ SWIGINTERN PyObject *_wrap_chisqr(PyObject *SWIGUNUSEDPARM(self), PyObject *args PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "chisqr", 3, 3, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -11857,7 +12572,7 @@ SWIGINTERN PyObject *_wrap_chisqr(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_z2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_z2n(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -11872,6 +12587,7 @@ SWIGINTERN PyObject *_wrap_z2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "z2n", 3, 3, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -11931,7 +12647,7 @@ SWIGINTERN PyObject *_wrap_z2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { } -SWIGINTERN PyObject *_wrap_print_candidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_print_candidate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fourierprops *arg1 = (fourierprops *) 0 ; double arg2 ; @@ -11950,6 +12666,7 @@ SWIGINTERN PyObject *_wrap_print_candidate(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode5 = 0 ; PyObject *swig_obj[5] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "print_candidate", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12000,7 +12717,7 @@ SWIGINTERN PyObject *_wrap_print_candidate(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; binaryprops *arg1 = (binaryprops *) 0 ; int arg2 ; @@ -12010,6 +12727,7 @@ SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *SWIGUNUSEDPARM(self), P int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "print_bin_candidate", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_binaryprops, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12045,7 +12763,7 @@ SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; FILE *arg1 = (FILE *) 0 ; fourierprops *arg2 = (fourierprops *) 0 ; @@ -12056,6 +12774,7 @@ SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[2] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "read_rzw_cand", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12091,7 +12810,7 @@ SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; @@ -12105,6 +12824,7 @@ SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_rzw_cand", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -12147,7 +12867,7 @@ SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; FILE *arg1 = (FILE *) 0 ; binaryprops *arg2 = (binaryprops *) 0 ; @@ -12158,6 +12878,7 @@ SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[2] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "read_bin_cand", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12193,7 +12914,7 @@ SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; @@ -12207,6 +12928,7 @@ SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_bin_cand", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -12249,7 +12971,7 @@ SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -12257,6 +12979,7 @@ SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *swig_obj[1] ; long long result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -12288,7 +13011,7 @@ SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -12296,6 +13019,7 @@ SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -12327,7 +13051,7 @@ SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -12335,6 +13059,7 @@ SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[1] ; long long result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -12366,7 +13091,7 @@ SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_dms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_dms2rad(PyObject *self, PyObject *args) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -12380,6 +13105,7 @@ SWIGINTERN PyObject *_wrap_dms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "dms2rad", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -12420,7 +13146,7 @@ SWIGINTERN PyObject *_wrap_dms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_hms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_hms2rad(PyObject *self, PyObject *args) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -12434,6 +13160,7 @@ SWIGINTERN PyObject *_wrap_hms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "hms2rad", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -12474,7 +13201,7 @@ SWIGINTERN PyObject *_wrap_hms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_hours2hms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_hours2hms(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int *arg2 = (int *) 0 ; @@ -12493,6 +13220,7 @@ SWIGINTERN PyObject *_wrap_hours2hms(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg2 = &temp2; arg3 = &temp3; arg4 = &temp4; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -12542,7 +13270,7 @@ SWIGINTERN PyObject *_wrap_hours2hms(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_deg2dms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_deg2dms(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int *arg2 = (int *) 0 ; @@ -12561,6 +13289,7 @@ SWIGINTERN PyObject *_wrap_deg2dms(PyObject *SWIGUNUSEDPARM(self), PyObject *arg arg2 = &temp2; arg3 = &temp3; arg4 = &temp4; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -12610,7 +13339,7 @@ SWIGINTERN PyObject *_wrap_deg2dms(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -12627,6 +13356,7 @@ SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[4] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "sphere_ang_diff", 4, 4, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -12672,7 +13402,7 @@ SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -12712,6 +13442,7 @@ SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *SWIGUNUSEDPARM(self), PyObjec arg11 = &dim1_temp10; arg12 = &dim2_temp10; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "corr_rz_plane", 8, 8, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -12803,7 +13534,7 @@ SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -12855,6 +13586,7 @@ SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *SWIGUNUSEDPARM(self), PyObject arg15 = &dim2_temp13; arg16 = &dim3_temp13; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "corr_rzw_vol", 11, 11, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -12961,7 +13693,7 @@ SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -12983,6 +13715,7 @@ SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg5 = &temp5; arg6 = &temp6; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_r_arr", 3, 3, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13038,7 +13771,7 @@ SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13067,6 +13800,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *SWIGUNUSEDPARM(self), PyObject * arg6 = &temp6; arg7 = &temp7; arg8 = &temp8; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rz_arr", 4, 4, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13133,7 +13867,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13159,6 +13893,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), arg7 = &temp7; arg8 = &temp8; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rz_arr_harmonics", 4, 4, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13222,7 +13957,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13255,6 +13990,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), arg8 = &temp8; arg9 = &temp9; arg10 = &temp10; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rzw_arr_harmonics", 5, 5, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13329,7 +14065,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13365,6 +14101,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *SWIGUNUSEDPARM(self), PyObject arg8 = &temp8; arg9 = &temp9; arg10 = &temp10; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rzw_arr", 5, 5, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13442,7 +14179,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_barycenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_barycenter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -13474,6 +14211,7 @@ SWIGINTERN PyObject *_wrap_barycenter(PyObject *SWIGUNUSEDPARM(self), PyObject * int alloc10 = 0 ; PyObject *swig_obj[7] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "barycenter", 7, 7, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -13551,7 +14289,7 @@ SWIGINTERN PyObject *_wrap_barycenter(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -13559,6 +14297,7 @@ SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *SWIGUNUSEDPARM(self), PyObject *ar PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -13590,7 +14329,7 @@ SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_simplefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_simplefold(PyObject *self, PyObject *args) { PyObject *resultobj = 0; float *arg1 = (float *) 0 ; long arg2 ; @@ -13624,6 +14363,7 @@ SWIGINTERN PyObject *_wrap_simplefold(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *swig_obj[9] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "simplefold", 9, 9, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_FLOAT); @@ -13700,7 +14440,7 @@ SWIGINTERN PyObject *_wrap_simplefold(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -13718,6 +14458,7 @@ SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[4] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "nice_output_1", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -13765,7 +14506,7 @@ SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -13783,6 +14524,7 @@ SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[4] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "nice_output_2", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -13831,7 +14573,6 @@ SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { - { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "fcomplex_r_set", _wrap_fcomplex_r_set, METH_VARARGS, NULL}, { "fcomplex_r_get", _wrap_fcomplex_r_get, METH_O, NULL}, { "fcomplex_i_set", _wrap_fcomplex_i_set, METH_VARARGS, NULL}, @@ -14110,35 +14851,31 @@ static PyMethodDef SwigMethods[] = { { NULL, NULL, 0, NULL } }; -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; - /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_FCOMPLEX = {"_p_FCOMPLEX", "fcomplex *|struct FCOMPLEX *|FCOMPLEX *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_FOURIERPROPS = {"_p_FOURIERPROPS", "struct FOURIERPROPS *|FOURIERPROPS *|fourierprops *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_FOURIERPROPS = {"_p_FOURIERPROPS", "fourierprops *|struct FOURIERPROPS *|FOURIERPROPS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_INFODATA = {"_p_INFODATA", "infodata *|struct INFODATA *|INFODATA *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PSRPARAMS = {"_p_PSRPARAMS", "psrparams *|struct PSRPARAMS *|PSRPARAMS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_RDERIVS = {"_p_RDERIVS", "rderivs *|struct RDERIVS *|RDERIVS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_binaryprops = {"_p_binaryprops", "binaryprops *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_foldstats = {"_p_foldstats", "struct foldstats *|foldstats *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_foldstats = {"_p_foldstats", "foldstats *|struct foldstats *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_orbitparams = {"_p_orbitparams", "struct orbitparams *|orbitparams *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_p_FCOMPLEX = {"_p_p_FCOMPLEX", "struct FCOMPLEX **|fcomplex **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_orbitparams = {"_p_orbitparams", "orbitparams *|struct orbitparams *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_FCOMPLEX = {"_p_p_FCOMPLEX", "fcomplex **|struct FCOMPLEX **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_checkaliased = {"_p_presto_checkaliased", "enum presto_checkaliased *|presto_checkaliased *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_datainf = {"_p_presto_datainf", "enum presto_datainf *|presto_datainf *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_ffts = {"_p_presto_ffts", "enum presto_ffts *|presto_ffts *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_interp_acc = {"_p_presto_interp_acc", "enum presto_interp_acc *|presto_interp_acc *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_interptype = {"_p_presto_interptype", "enum presto_interptype *|presto_interptype *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_optype = {"_p_presto_optype", "enum presto_optype *|presto_optype *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_checkaliased = {"_p_presto_checkaliased", "presto_checkaliased *|enum presto_checkaliased *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_datainf = {"_p_presto_datainf", "presto_datainf *|enum presto_datainf *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_ffts = {"_p_presto_ffts", "presto_ffts *|enum presto_ffts *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_interp_acc = {"_p_presto_interp_acc", "presto_interp_acc *|enum presto_interp_acc *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_interptype = {"_p_presto_interptype", "presto_interptype *|enum presto_interptype *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_optype = {"_p_presto_optype", "presto_optype *|enum presto_optype *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_rzwerrs = {"_p_rzwerrs", "rzwerrs *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { @@ -14466,220 +15203,6 @@ SWIG_PropagateClientData(void) { extern "C" { #endif - /* Python-specific SWIG API */ -#define SWIG_newvarlink() SWIG_Python_newvarlink() -#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) -#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) - - /* ----------------------------------------------------------------------------- - * global variable support code. - * ----------------------------------------------------------------------------- */ - - typedef struct swig_globalvar { - char *name; /* Name of global variable */ - PyObject *(*get_attr)(void); /* Return the current value */ - int (*set_attr)(PyObject *); /* Set the value */ - struct swig_globalvar *next; - } swig_globalvar; - - typedef struct swig_varlinkobject { - PyObject_HEAD - swig_globalvar *vars; - } swig_varlinkobject; - - SWIGINTERN PyObject * - swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { -#if PY_VERSION_HEX >= 0x03000000 - return PyUnicode_InternFromString(""); -#else - return PyString_FromString(""); -#endif - } - - SWIGINTERN PyObject * - swig_varlink_str(swig_varlinkobject *v) { -#if PY_VERSION_HEX >= 0x03000000 - PyObject *str = PyUnicode_InternFromString("("); - PyObject *tail; - PyObject *joined; - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - tail = PyUnicode_FromString(var->name); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - if (var->next) { - tail = PyUnicode_InternFromString(", "); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - } - } - tail = PyUnicode_InternFromString(")"); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; -#else - PyObject *str = PyString_FromString("("); - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - PyString_ConcatAndDel(&str,PyString_FromString(var->name)); - if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); - } - PyString_ConcatAndDel(&str,PyString_FromString(")")); -#endif - return str; - } - - SWIGINTERN void - swig_varlink_dealloc(swig_varlinkobject *v) { - swig_globalvar *var = v->vars; - while (var) { - swig_globalvar *n = var->next; - free(var->name); - free(var); - var = n; - } - } - - SWIGINTERN PyObject * - swig_varlink_getattr(swig_varlinkobject *v, char *n) { - PyObject *res = NULL; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->get_attr)(); - break; - } - var = var->next; - } - if (res == NULL && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN int - swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { - int res = 1; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->set_attr)(p); - break; - } - var = var->next; - } - if (res == 1 && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN PyTypeObject* - swig_varlink_type(void) { - static char varlink__doc__[] = "Swig var link object"; - static PyTypeObject varlink_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { -#if PY_VERSION_HEX >= 0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) -#else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - "swigvarlink", /* tp_name */ - sizeof(swig_varlinkobject), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor) swig_varlink_dealloc, /* tp_dealloc */ - 0, /* tp_print */ - (getattrfunc) swig_varlink_getattr, /* tp_getattr */ - (setattrfunc) swig_varlink_setattr, /* tp_setattr */ - 0, /* tp_compare */ - (reprfunc) swig_varlink_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - (reprfunc) swig_varlink_str, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - 0, /* tp_flags */ - varlink__doc__, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ - 0, /* tp_del */ - 0, /* tp_version_tag */ -#if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ -#endif -#if PY_VERSION_HEX >= 0x03080000 - 0, /* tp_vectorcall */ -#endif -#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) - 0, /* tp_print */ -#endif -#ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ - 0, /* tp_prev */ - 0 /* tp_next */ -#endif - }; - varlink_type = tmp; - type_init = 1; - if (PyType_Ready(&varlink_type) < 0) - return NULL; - } - return &varlink_type; - } - - /* Create a variable linking object for use later */ - SWIGINTERN PyObject * - SWIG_Python_newvarlink(void) { - swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); - if (result) { - result->vars = 0; - } - return ((PyObject*) result); - } - - SWIGINTERN void - SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { - swig_varlinkobject *v = (swig_varlinkobject *) p; - swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); - if (gv) { - size_t size = strlen(name)+1; - gv->name = (char *)malloc(size); - if (gv->name) { - memcpy(gv->name, name, size); - gv->get_attr = get_attr; - gv->set_attr = set_attr; - gv->next = v->vars; - } - } - v->vars = gv; - } - - SWIGINTERN PyObject * - SWIG_globals(void) { - static PyObject *globals = 0; - if (!globals) { - globals = SWIG_newvarlink(); - } - return globals; - } - /* ----------------------------------------------------------------------------- * constants/methods manipulation * ----------------------------------------------------------------------------- */ @@ -14703,20 +15226,17 @@ extern "C" { } if (obj) { PyDict_SetItemString(d, constants[i].name, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } } } - /* -----------------------------------------------------------------------------*/ - /* Fix SwigMethods to carry the callback ptrs when needed */ - /* -----------------------------------------------------------------------------*/ + /* ----------------------------------------------------------------------------- + * Patch %callback methods' docstrings to hold the callback ptrs + * -----------------------------------------------------------------------------*/ SWIGINTERN void - SWIG_Python_FixMethods(PyMethodDef *methods, - swig_const_info *const_table, - swig_type_info **types, - swig_type_info **types_initial) { + SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) { size_t i; for (i = 0; methods[i].ml_name; ++i) { const char *c = methods[i].ml_doc; @@ -14724,7 +15244,7 @@ extern "C" { c = strstr(c, "swig_ptr: "); if (c) { int j; - swig_const_info *ci = 0; + const swig_const_info *ci = 0; const char *name = c + 10; for (j = 0; const_table[j].type; ++j) { if (strncmp(const_table[j].name, name, @@ -14756,68 +15276,13 @@ extern "C" { } } - /* ----------------------------------------------------------------------------- - * Method creation and docstring support functions - * ----------------------------------------------------------------------------- */ - - /* ----------------------------------------------------------------------------- - * Function to find the method definition with the correct docstring for the - * proxy module as opposed to the low-level API - * ----------------------------------------------------------------------------- */ - - SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { - /* Find the function in the modified method table */ - size_t offset = 0; - int found = 0; - while (SwigMethods_proxydocs[offset].ml_meth != NULL) { - if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { - found = 1; - break; - } - offset++; - } - /* Use the copy with the modified docstring if available */ - return found ? &SwigMethods_proxydocs[offset] : NULL; - } - - /* ----------------------------------------------------------------------------- - * Wrapper of PyInstanceMethod_New() used in Python 3 - * It is exported to the generated module, used for -fastproxy - * ----------------------------------------------------------------------------- */ - - SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { - if (PyCFunction_Check(func)) { - PyCFunctionObject *funcobj = (PyCFunctionObject *)func; - PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); - if (ml) - func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); - } -#if PY_VERSION_HEX >= 0x03000000 - return PyInstanceMethod_New(func); -#else - return PyMethod_New(func, NULL, NULL); -#endif - } - - /* ----------------------------------------------------------------------------- - * Wrapper of PyStaticMethod_New() - * It is exported to the generated module, used for -fastproxy - * ----------------------------------------------------------------------------- */ - - SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { - if (PyCFunction_Check(func)) { - PyCFunctionObject *funcobj = (PyCFunctionObject *)func; - PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); - if (ml) - func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); - } - return PyStaticMethod_New(func); - } - #ifdef __cplusplus } #endif + + + /* -----------------------------------------------------------------------------* * Partial Init method * -----------------------------------------------------------------------------*/ @@ -14944,7 +15409,7 @@ SWIG_init(void) { (void)public_symbol; PyDict_SetItemString(md, "__all__", public_interface); - Py_DECREF(public_interface); + SWIG_Py_DECREF(public_interface); for (i = 0; SwigMethods[i].ml_name != NULL; ++i) SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); for (i = 0; swig_const_table[i].name != 0; ++i) diff --git a/python/presto_src/prestoswig.py b/python/presto_src/prestoswig.py index 2d0bce4cb..13c3a3dc5 100644 --- a/python/presto_src/prestoswig.py +++ b/python/presto_src/prestoswig.py @@ -1,13 +1,10 @@ -# This file was automatically generated by SWIG (http://www.swig.org). -# Version 4.1.0 +# This file was automatically generated by SWIG (https://www.swig.org). +# Version 4.3.0 # -# Do not make changes to this file unless you know what you are doing--modify +# Do not make changes to this file unless you know what you are doing - modify # the SWIG interface file instead. from sys import version_info as _swig_python_version_info -if _swig_python_version_info < (2, 7, 0): - raise RuntimeError("Python 2.7 or later required") - import _presto try: @@ -25,10 +22,10 @@ def _swig_repr(self): def _swig_setattr_nondynamic_instance_variable(set): def set_instance_attr(self, name, value): - if name == "thisown": - self.this.own(value) - elif name == "this": + if name == "this": set(self, name, value) + elif name == "thisown": + self.this.own(value) elif hasattr(self, name) and isinstance(getattr(type(self), name), property): set(self, name, value) else: @@ -69,7 +66,6 @@ def __init__(self): # Register fcomplex in _presto: _presto.fcomplex_swigregister(fcomplex) - SQRT2 = _presto.SQRT2 PI = _presto.PI TWOPI = _presto.TWOPI @@ -100,19 +96,19 @@ def __init__(self): FFT = _presto.FFT SAME = _presto.SAME -def read_wisdom() -> "void": +def read_wisdom(): return _presto.read_wisdom() -def good_factor(nn: "long long") -> "long long": +def good_factor(nn): return _presto.good_factor(nn) -def fftwcall(indata: "fcomplex", isign: "int") -> "void": +def fftwcall(indata, isign): return _presto.fftwcall(indata, isign) -def tablesixstepfft(indata: "fcomplex", isign: "int") -> "void": +def tablesixstepfft(indata, isign): return _presto.tablesixstepfft(indata, isign) -def realfft(data: "float *", isign: "int") -> "void": +def realfft(data, isign): return _presto.realfft(data, isign) class infodata(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -156,11 +152,10 @@ def __init__(self): # Register infodata in _presto: _presto.infodata_swigregister(infodata) - -def readinf(data: "infodata", filenm: "char *") -> "void": +def readinf(data, filenm): return _presto.readinf(data, filenm) -def writeinf(data: "infodata") -> "void": +def writeinf(data): return _presto.writeinf(data) class orbitparams(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -179,7 +174,6 @@ def __init__(self): # Register orbitparams in _presto: _presto.orbitparams_swigregister(orbitparams) - class psrparams(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -205,17 +199,16 @@ def __init__(self): # Register psrparams in _presto: _presto.psrparams_swigregister(psrparams) - -def get_psr_at_epoch(psrname: "char *", epoch: "double", psr: "psrparams") -> "int": +def get_psr_at_epoch(psrname, epoch, psr): return _presto.get_psr_at_epoch(psrname, epoch, psr) -def get_psr_from_parfile(parfilenm: "char *", epoch: "double", psr: "psrparams") -> "int": +def get_psr_from_parfile(parfilenm, epoch, psr): return _presto.get_psr_from_parfile(parfilenm, epoch, psr) -def mjd_to_datestr(mjd: "double", datestr: "char *") -> "void": +def mjd_to_datestr(mjd, datestr): return _presto.mjd_to_datestr(mjd, datestr) -def fresnl(xxa: "double") -> "double *, double *": +def fresnl(xxa): return _presto.fresnl(xxa) class rderivs(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -234,7 +227,6 @@ def __init__(self): # Register rderivs in _presto: _presto.rderivs_swigregister(rderivs) - class fourierprops(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -262,7 +254,6 @@ def __init__(self): # Register fourierprops in _presto: _presto.fourierprops_swigregister(fourierprops) - class foldstats(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -281,203 +272,201 @@ def __init__(self): # Register foldstats in _presto: _presto.foldstats_swigregister(foldstats) - -def gen_fvect(nl: "long") -> "long *": +def gen_fvect(nl): return _presto.gen_fvect(nl) -def gen_cvect(nl: "long") -> "long *": +def gen_cvect(nl): return _presto.gen_cvect(nl) -def power_arr(dft: "fcomplex") -> "long *": +def power_arr(dft): return _presto.power_arr(dft) -def phase_arr(dft: "fcomplex") -> "long *": +def phase_arr(dft): return _presto.phase_arr(dft) -def frotate(data: "float *", bins_to_left: "float") -> "void": +def frotate(data, bins_to_left): return _presto.frotate(data, bins_to_left) -def drotate(data: "double *", bins_to_left: "double") -> "void": +def drotate(data, bins_to_left): return _presto.drotate(data, bins_to_left) -def keplers_eqn(t: "double", p_orb: "double", e: "double", Eacc: "double") -> "double": +def keplers_eqn(t, p_orb, e, Eacc): return _presto.keplers_eqn(t, p_orb, e, Eacc) -def E_to_phib(E: "double *", orb: "orbitparams") -> "void": +def E_to_phib(E, orb): return _presto.E_to_phib(E, orb) -def E_to_v(E: "double *", orb: "orbitparams") -> "void": +def E_to_v(E, orb): return _presto.E_to_v(E, orb) -def E_to_p(E: "double *", p_psr: "double", orb: "orbitparams") -> "void": +def E_to_p(E, p_psr, orb): return _presto.E_to_p(E, p_psr, orb) -def E_to_z(E: "double *", p_psr: "double", T: "double", orb: "orbitparams") -> "void": +def E_to_z(E, p_psr, T, orb): return _presto.E_to_z(E, p_psr, T, orb) -def E_to_phib_BT(E: "double *", orb: "orbitparams") -> "void": +def E_to_phib_BT(E, orb): return _presto.E_to_phib_BT(E, orb) -def dorbint(Eo: "double", numpts: "long", dt: "double", orb: "orbitparams") -> "long *": +def dorbint(Eo, numpts, dt, orb): return _presto.dorbint(Eo, numpts, dt, orb) -def binary_velocity(T: "double", orbit: "orbitparams") -> "double *, double *": +def binary_velocity(T, orbit): return _presto.binary_velocity(T, orbit) -def r_resp_halfwidth(accuracy: "presto_interp_acc") -> "int": +def r_resp_halfwidth(accuracy): return _presto.r_resp_halfwidth(accuracy) -def z_resp_halfwidth(z: "double", accuracy: "presto_interp_acc") -> "int": +def z_resp_halfwidth(z, accuracy): return _presto.z_resp_halfwidth(z, accuracy) -def w_resp_halfwidth(z: "double", w: "double", accuracy: "presto_interp_acc") -> "int": +def w_resp_halfwidth(z, w, accuracy): return _presto.w_resp_halfwidth(z, w, accuracy) -def bin_resp_halfwidth(ppsr: "double", T: "double", orbit: "orbitparams") -> "int": +def bin_resp_halfwidth(ppsr, T, orbit): return _presto.bin_resp_halfwidth(ppsr, T, orbit) -def gen_r_response(roffset: "double", numbetween: "int", numkern: "int") -> "long *": +def gen_r_response(roffset, numbetween, numkern): return _presto.gen_r_response(roffset, numbetween, numkern) -def gen_z_response(roffset: "double", numbetween: "int", numkern: "int", z: "double") -> "long *": +def gen_z_response(roffset, numbetween, numkern, z): return _presto.gen_z_response(roffset, numbetween, numkern, z) -def gen_w_response(roffset: "double", numbetween: "int", numkern: "int", z: "double", w: "double") -> "long *": +def gen_w_response(roffset, numbetween, numkern, z, w): return _presto.gen_w_response(roffset, numbetween, numkern, z, w) -def gen_w_response2(roffset: "double", numbetween: "int", numkern: "int", z: "double", w: "double") -> "long *": +def gen_w_response2(roffset, numbetween, numkern, z, w): return _presto.gen_w_response2(roffset, numbetween, numkern, z, w) -def gen_bin_response(roffset: "double", numbetween: "int", numkern: "int", ppsr: "double", T: "double", orbit: "orbitparams") -> "long *": +def gen_bin_response(roffset, numbetween, numkern, ppsr, T, orbit): return _presto.gen_bin_response(roffset, numbetween, numkern, ppsr, T, orbit) -def get_localpower(data: "fcomplex", r: "double") -> "float": +def get_localpower(data, r): return _presto.get_localpower(data, r) -def get_localpower3d(data: "fcomplex", r: "double", z: "double", w: "double") -> "float": +def get_localpower3d(data, r, z, w): return _presto.get_localpower3d(data, r, z, w) -def get_derivs3d(data: "fcomplex", numdata: "long", r: "double", z: "double", w: "double", localpower: "float", result: "rderivs") -> "void": +def get_derivs3d(data, numdata, r, z, w, localpower, result): return _presto.get_derivs3d(data, numdata, r, z, w, localpower, result) -def calc_props(data: "rderivs", r: "double", z: "double", w: "double", result: "fourierprops") -> "void": +def calc_props(data, r, z, w, result): return _presto.calc_props(data, r, z, w, result) -def calc_binprops(props: "fourierprops", T: "double", lowbin: "int", nfftbins: "int", result: "binaryprops *") -> "void": +def calc_binprops(props, T, lowbin, nfftbins, result): return _presto.calc_binprops(props, T, lowbin, nfftbins, result) -def calc_rzwerrs(props: "fourierprops", T: "double", result: "rzwerrs *") -> "void": +def calc_rzwerrs(props, T, result): return _presto.calc_rzwerrs(props, T, result) -def extended_equiv_gaussian_sigma(logp: "double") -> "double": +def extended_equiv_gaussian_sigma(logp): return _presto.extended_equiv_gaussian_sigma(logp) -def log_asymtotic_incomplete_gamma(a: "double", z: "double") -> "double": +def log_asymtotic_incomplete_gamma(a, z): return _presto.log_asymtotic_incomplete_gamma(a, z) -def log_asymtotic_gamma(z: "double") -> "double": +def log_asymtotic_gamma(z): return _presto.log_asymtotic_gamma(z) -def equivalent_gaussian_sigma(logp: "double") -> "double": +def equivalent_gaussian_sigma(logp): return _presto.equivalent_gaussian_sigma(logp) -def chi2_logp(chi2: "double", dof: "double") -> "double": +def chi2_logp(chi2, dof): return _presto.chi2_logp(chi2, dof) -def chi2_sigma(chi2: "double", dof: "double") -> "double": +def chi2_sigma(chi2, dof): return _presto.chi2_sigma(chi2, dof) -def candidate_sigma(power: "double", numsum: "int", numtrials: "double") -> "double": +def candidate_sigma(power, numsum, numtrials): return _presto.candidate_sigma(power, numsum, numtrials) -def power_for_sigma(sigma: "double", numsum: "int", numtrials: "double") -> "double": +def power_for_sigma(sigma, numsum, numtrials): return _presto.power_for_sigma(sigma, numsum, numtrials) -def switch_f_and_p(_in: "double", ind: "double", indd: "double") -> "double *, double *, double *": +def switch_f_and_p(_in, ind, indd): return _presto.switch_f_and_p(_in, ind, indd) -def chisqr(data: "double *", avg: "double", var: "double") -> "double": +def chisqr(data, avg, var): return _presto.chisqr(data, avg, var) -def z2n(data: "double *", var: "double", n: "int") -> "double": +def z2n(data, var, n): return _presto.z2n(data, var, n) -def print_candidate(cand: "fourierprops", dt: "double", N: "unsigned long", nph: "float", numerrdigits: "int") -> "void": +def print_candidate(cand, dt, N, nph, numerrdigits): return _presto.print_candidate(cand, dt, N, nph, numerrdigits) -def print_bin_candidate(cand: "binaryprops *", numerrdigits: "int") -> "void": +def print_bin_candidate(cand, numerrdigits): return _presto.print_bin_candidate(cand, numerrdigits) -def read_rzw_cand(file: "FILE *", cands: "fourierprops") -> "int": +def read_rzw_cand(file, cands): return _presto.read_rzw_cand(file, cands) -def get_rzw_cand(filenm: "char *", candnum: "int", cand: "fourierprops") -> "void": +def get_rzw_cand(filenm, candnum, cand): return _presto.get_rzw_cand(filenm, candnum, cand) -def read_bin_cand(file: "FILE *", cands: "binaryprops *") -> "int": +def read_bin_cand(file, cands): return _presto.read_bin_cand(file, cands) -def get_bin_cand(filenm: "char *", candnum: "int", cand: "binaryprops *") -> "void": +def get_bin_cand(filenm, candnum, cand): return _presto.get_bin_cand(filenm, candnum, cand) -def next2_to_n(x: "long long") -> "long long": +def next2_to_n(x): return _presto.next2_to_n(x) -def is_power_of_10(n: "long long") -> "int": +def is_power_of_10(n): return _presto.is_power_of_10(n) -def choose_good_N(orig_N: "long long") -> "long long": +def choose_good_N(orig_N): return _presto.choose_good_N(orig_N) -def dms2rad(deg: "int", min: "int", sec: "double") -> "double": +def dms2rad(deg, min, sec): return _presto.dms2rad(deg, min, sec) -def hms2rad(hour: "int", min: "int", sec: "double") -> "double": +def hms2rad(hour, min, sec): return _presto.hms2rad(hour, min, sec) -def hours2hms(hours: "double") -> "int *, int *, double *": +def hours2hms(hours): return _presto.hours2hms(hours) -def deg2dms(degrees: "double") -> "int *, int *, double *": +def deg2dms(degrees): return _presto.deg2dms(degrees) -def sphere_ang_diff(ra1: "double", dec1: "double", ra2: "double", dec2: "double") -> "double": +def sphere_ang_diff(ra1, dec1, ra2, dec2): return _presto.sphere_ang_diff(ra1, dec1, ra2, dec2) -def corr_rz_plane(data: "fcomplex", numbetween: "int", startbin: "int", zlo: "double", zhi: "double", numz: "int", fftlen: "int", accuracy: "presto_interp_acc") -> "long *": +def corr_rz_plane(data, numbetween, startbin, zlo, zhi, numz, fftlen, accuracy): return _presto.corr_rz_plane(data, numbetween, startbin, zlo, zhi, numz, fftlen, accuracy) -def corr_rzw_vol(data: "fcomplex", numbetween: "int", startbin: "int", zlo: "double", zhi: "double", numz: "int", wlo: "double", whi: "double", numw: "int", fftlen: "int", accuracy: "presto_interp_acc") -> "long *": +def corr_rzw_vol(data, numbetween, startbin, zlo, zhi, numz, wlo, whi, numw, fftlen, accuracy): return _presto.corr_rzw_vol(data, numbetween, startbin, zlo, zhi, numz, wlo, whi, numw, fftlen, accuracy) -def max_r_arr(data: "fcomplex", rin: "double", derivs: "rderivs") -> "double *, double *": +def max_r_arr(data, rin, derivs): return _presto.max_r_arr(data, rin, derivs) -def max_rz_arr(data: "fcomplex", rin: "double", zin: "double", derivs: "rderivs") -> "double *, double *, double *": +def max_rz_arr(data, rin, zin, derivs): return _presto.max_rz_arr(data, rin, zin, derivs) -def max_rz_arr_harmonics(data: "fcomplex", rin: "double", zin: "double", derivdata: "double *") -> "double *, double *": +def max_rz_arr_harmonics(data, rin, zin, derivdata): return _presto.max_rz_arr_harmonics(data, rin, zin, derivdata) -def max_rzw_arr_harmonics(data: "fcomplex", rin: "double", zin: "double", win: "double", derivdata: "double *") -> "double *, double *, double *": +def max_rzw_arr_harmonics(data, rin, zin, win, derivdata): return _presto.max_rzw_arr_harmonics(data, rin, zin, win, derivdata) -def max_rzw_arr(data: "fcomplex", rin: "double", zin: "double", win: "double", derivs: "rderivs") -> "double *, double *, double *, double *": +def max_rzw_arr(data, rin, zin, win, derivs): return _presto.max_rzw_arr(data, rin, zin, win, derivs) -def barycenter(topotimes: "double *", barytimes: "double *", voverc: "double *", ra: "char *", dec: "char *", obs: "char *", ephem: "char *") -> "void": +def barycenter(topotimes, barytimes, voverc, ra, dec, obs, ephem): return _presto.barycenter(topotimes, barytimes, voverc, ra, dec, obs, ephem) -def DOF_corr(dt_per_bin: "double") -> "double": +def DOF_corr(dt_per_bin): return _presto.DOF_corr(dt_per_bin) -def simplefold(data: "float *", dt: "double", tlo: "double", prof: "double *", startphs: "double", f0: "double", fdot: "double", fdotdot: "double", standard: "int") -> "double": +def simplefold(data, dt, tlo, prof, startphs, f0, fdot, fdotdot, standard): return _presto.simplefold(data, dt, tlo, prof, startphs, f0, fdot, fdotdot, standard) -def nice_output_1(output: "char *", val: "double", err: "double", len: "int") -> "int": +def nice_output_1(output, val, err, len): return _presto.nice_output_1(output, val, err, len) -def nice_output_2(output: "char *", val: "double", err: "double", len: "int") -> "int": +def nice_output_2(output, val, err, len): return _presto.nice_output_2(output, val, err, len) - diff --git a/python/pyproject.toml b/python/pyproject.toml new file mode 100644 index 000000000..d4e223ef8 --- /dev/null +++ b/python/pyproject.toml @@ -0,0 +1,17 @@ +[build-system] +build-backend = 'mesonpy' +requires = ['meson-python', 'numpy'] + +[project] +name = 'presto' +version = '5.0.0' +description = 'PulsaR Exploration and Search TOolkit' +requires-python = '>=3.8' +dependencies = ['numpy', 'scipy', 'astropy', 'matplotlib'] +authors = [ + {name = 'Scott Ransom', email = 'sransom@nrao.edu'}, +] + +[project.urls] +"Source" = "https://github.com/scottransom/presto" +"ASCL" = "https://ascl.net/1107.017" diff --git a/python/wrappers/presto.py b/python/wrappers/presto.py index 2d0bce4cb..13c3a3dc5 100644 --- a/python/wrappers/presto.py +++ b/python/wrappers/presto.py @@ -1,13 +1,10 @@ -# This file was automatically generated by SWIG (http://www.swig.org). -# Version 4.1.0 +# This file was automatically generated by SWIG (https://www.swig.org). +# Version 4.3.0 # -# Do not make changes to this file unless you know what you are doing--modify +# Do not make changes to this file unless you know what you are doing - modify # the SWIG interface file instead. from sys import version_info as _swig_python_version_info -if _swig_python_version_info < (2, 7, 0): - raise RuntimeError("Python 2.7 or later required") - import _presto try: @@ -25,10 +22,10 @@ def _swig_repr(self): def _swig_setattr_nondynamic_instance_variable(set): def set_instance_attr(self, name, value): - if name == "thisown": - self.this.own(value) - elif name == "this": + if name == "this": set(self, name, value) + elif name == "thisown": + self.this.own(value) elif hasattr(self, name) and isinstance(getattr(type(self), name), property): set(self, name, value) else: @@ -69,7 +66,6 @@ def __init__(self): # Register fcomplex in _presto: _presto.fcomplex_swigregister(fcomplex) - SQRT2 = _presto.SQRT2 PI = _presto.PI TWOPI = _presto.TWOPI @@ -100,19 +96,19 @@ def __init__(self): FFT = _presto.FFT SAME = _presto.SAME -def read_wisdom() -> "void": +def read_wisdom(): return _presto.read_wisdom() -def good_factor(nn: "long long") -> "long long": +def good_factor(nn): return _presto.good_factor(nn) -def fftwcall(indata: "fcomplex", isign: "int") -> "void": +def fftwcall(indata, isign): return _presto.fftwcall(indata, isign) -def tablesixstepfft(indata: "fcomplex", isign: "int") -> "void": +def tablesixstepfft(indata, isign): return _presto.tablesixstepfft(indata, isign) -def realfft(data: "float *", isign: "int") -> "void": +def realfft(data, isign): return _presto.realfft(data, isign) class infodata(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -156,11 +152,10 @@ def __init__(self): # Register infodata in _presto: _presto.infodata_swigregister(infodata) - -def readinf(data: "infodata", filenm: "char *") -> "void": +def readinf(data, filenm): return _presto.readinf(data, filenm) -def writeinf(data: "infodata") -> "void": +def writeinf(data): return _presto.writeinf(data) class orbitparams(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -179,7 +174,6 @@ def __init__(self): # Register orbitparams in _presto: _presto.orbitparams_swigregister(orbitparams) - class psrparams(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -205,17 +199,16 @@ def __init__(self): # Register psrparams in _presto: _presto.psrparams_swigregister(psrparams) - -def get_psr_at_epoch(psrname: "char *", epoch: "double", psr: "psrparams") -> "int": +def get_psr_at_epoch(psrname, epoch, psr): return _presto.get_psr_at_epoch(psrname, epoch, psr) -def get_psr_from_parfile(parfilenm: "char *", epoch: "double", psr: "psrparams") -> "int": +def get_psr_from_parfile(parfilenm, epoch, psr): return _presto.get_psr_from_parfile(parfilenm, epoch, psr) -def mjd_to_datestr(mjd: "double", datestr: "char *") -> "void": +def mjd_to_datestr(mjd, datestr): return _presto.mjd_to_datestr(mjd, datestr) -def fresnl(xxa: "double") -> "double *, double *": +def fresnl(xxa): return _presto.fresnl(xxa) class rderivs(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -234,7 +227,6 @@ def __init__(self): # Register rderivs in _presto: _presto.rderivs_swigregister(rderivs) - class fourierprops(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -262,7 +254,6 @@ def __init__(self): # Register fourierprops in _presto: _presto.fourierprops_swigregister(fourierprops) - class foldstats(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -281,203 +272,201 @@ def __init__(self): # Register foldstats in _presto: _presto.foldstats_swigregister(foldstats) - -def gen_fvect(nl: "long") -> "long *": +def gen_fvect(nl): return _presto.gen_fvect(nl) -def gen_cvect(nl: "long") -> "long *": +def gen_cvect(nl): return _presto.gen_cvect(nl) -def power_arr(dft: "fcomplex") -> "long *": +def power_arr(dft): return _presto.power_arr(dft) -def phase_arr(dft: "fcomplex") -> "long *": +def phase_arr(dft): return _presto.phase_arr(dft) -def frotate(data: "float *", bins_to_left: "float") -> "void": +def frotate(data, bins_to_left): return _presto.frotate(data, bins_to_left) -def drotate(data: "double *", bins_to_left: "double") -> "void": +def drotate(data, bins_to_left): return _presto.drotate(data, bins_to_left) -def keplers_eqn(t: "double", p_orb: "double", e: "double", Eacc: "double") -> "double": +def keplers_eqn(t, p_orb, e, Eacc): return _presto.keplers_eqn(t, p_orb, e, Eacc) -def E_to_phib(E: "double *", orb: "orbitparams") -> "void": +def E_to_phib(E, orb): return _presto.E_to_phib(E, orb) -def E_to_v(E: "double *", orb: "orbitparams") -> "void": +def E_to_v(E, orb): return _presto.E_to_v(E, orb) -def E_to_p(E: "double *", p_psr: "double", orb: "orbitparams") -> "void": +def E_to_p(E, p_psr, orb): return _presto.E_to_p(E, p_psr, orb) -def E_to_z(E: "double *", p_psr: "double", T: "double", orb: "orbitparams") -> "void": +def E_to_z(E, p_psr, T, orb): return _presto.E_to_z(E, p_psr, T, orb) -def E_to_phib_BT(E: "double *", orb: "orbitparams") -> "void": +def E_to_phib_BT(E, orb): return _presto.E_to_phib_BT(E, orb) -def dorbint(Eo: "double", numpts: "long", dt: "double", orb: "orbitparams") -> "long *": +def dorbint(Eo, numpts, dt, orb): return _presto.dorbint(Eo, numpts, dt, orb) -def binary_velocity(T: "double", orbit: "orbitparams") -> "double *, double *": +def binary_velocity(T, orbit): return _presto.binary_velocity(T, orbit) -def r_resp_halfwidth(accuracy: "presto_interp_acc") -> "int": +def r_resp_halfwidth(accuracy): return _presto.r_resp_halfwidth(accuracy) -def z_resp_halfwidth(z: "double", accuracy: "presto_interp_acc") -> "int": +def z_resp_halfwidth(z, accuracy): return _presto.z_resp_halfwidth(z, accuracy) -def w_resp_halfwidth(z: "double", w: "double", accuracy: "presto_interp_acc") -> "int": +def w_resp_halfwidth(z, w, accuracy): return _presto.w_resp_halfwidth(z, w, accuracy) -def bin_resp_halfwidth(ppsr: "double", T: "double", orbit: "orbitparams") -> "int": +def bin_resp_halfwidth(ppsr, T, orbit): return _presto.bin_resp_halfwidth(ppsr, T, orbit) -def gen_r_response(roffset: "double", numbetween: "int", numkern: "int") -> "long *": +def gen_r_response(roffset, numbetween, numkern): return _presto.gen_r_response(roffset, numbetween, numkern) -def gen_z_response(roffset: "double", numbetween: "int", numkern: "int", z: "double") -> "long *": +def gen_z_response(roffset, numbetween, numkern, z): return _presto.gen_z_response(roffset, numbetween, numkern, z) -def gen_w_response(roffset: "double", numbetween: "int", numkern: "int", z: "double", w: "double") -> "long *": +def gen_w_response(roffset, numbetween, numkern, z, w): return _presto.gen_w_response(roffset, numbetween, numkern, z, w) -def gen_w_response2(roffset: "double", numbetween: "int", numkern: "int", z: "double", w: "double") -> "long *": +def gen_w_response2(roffset, numbetween, numkern, z, w): return _presto.gen_w_response2(roffset, numbetween, numkern, z, w) -def gen_bin_response(roffset: "double", numbetween: "int", numkern: "int", ppsr: "double", T: "double", orbit: "orbitparams") -> "long *": +def gen_bin_response(roffset, numbetween, numkern, ppsr, T, orbit): return _presto.gen_bin_response(roffset, numbetween, numkern, ppsr, T, orbit) -def get_localpower(data: "fcomplex", r: "double") -> "float": +def get_localpower(data, r): return _presto.get_localpower(data, r) -def get_localpower3d(data: "fcomplex", r: "double", z: "double", w: "double") -> "float": +def get_localpower3d(data, r, z, w): return _presto.get_localpower3d(data, r, z, w) -def get_derivs3d(data: "fcomplex", numdata: "long", r: "double", z: "double", w: "double", localpower: "float", result: "rderivs") -> "void": +def get_derivs3d(data, numdata, r, z, w, localpower, result): return _presto.get_derivs3d(data, numdata, r, z, w, localpower, result) -def calc_props(data: "rderivs", r: "double", z: "double", w: "double", result: "fourierprops") -> "void": +def calc_props(data, r, z, w, result): return _presto.calc_props(data, r, z, w, result) -def calc_binprops(props: "fourierprops", T: "double", lowbin: "int", nfftbins: "int", result: "binaryprops *") -> "void": +def calc_binprops(props, T, lowbin, nfftbins, result): return _presto.calc_binprops(props, T, lowbin, nfftbins, result) -def calc_rzwerrs(props: "fourierprops", T: "double", result: "rzwerrs *") -> "void": +def calc_rzwerrs(props, T, result): return _presto.calc_rzwerrs(props, T, result) -def extended_equiv_gaussian_sigma(logp: "double") -> "double": +def extended_equiv_gaussian_sigma(logp): return _presto.extended_equiv_gaussian_sigma(logp) -def log_asymtotic_incomplete_gamma(a: "double", z: "double") -> "double": +def log_asymtotic_incomplete_gamma(a, z): return _presto.log_asymtotic_incomplete_gamma(a, z) -def log_asymtotic_gamma(z: "double") -> "double": +def log_asymtotic_gamma(z): return _presto.log_asymtotic_gamma(z) -def equivalent_gaussian_sigma(logp: "double") -> "double": +def equivalent_gaussian_sigma(logp): return _presto.equivalent_gaussian_sigma(logp) -def chi2_logp(chi2: "double", dof: "double") -> "double": +def chi2_logp(chi2, dof): return _presto.chi2_logp(chi2, dof) -def chi2_sigma(chi2: "double", dof: "double") -> "double": +def chi2_sigma(chi2, dof): return _presto.chi2_sigma(chi2, dof) -def candidate_sigma(power: "double", numsum: "int", numtrials: "double") -> "double": +def candidate_sigma(power, numsum, numtrials): return _presto.candidate_sigma(power, numsum, numtrials) -def power_for_sigma(sigma: "double", numsum: "int", numtrials: "double") -> "double": +def power_for_sigma(sigma, numsum, numtrials): return _presto.power_for_sigma(sigma, numsum, numtrials) -def switch_f_and_p(_in: "double", ind: "double", indd: "double") -> "double *, double *, double *": +def switch_f_and_p(_in, ind, indd): return _presto.switch_f_and_p(_in, ind, indd) -def chisqr(data: "double *", avg: "double", var: "double") -> "double": +def chisqr(data, avg, var): return _presto.chisqr(data, avg, var) -def z2n(data: "double *", var: "double", n: "int") -> "double": +def z2n(data, var, n): return _presto.z2n(data, var, n) -def print_candidate(cand: "fourierprops", dt: "double", N: "unsigned long", nph: "float", numerrdigits: "int") -> "void": +def print_candidate(cand, dt, N, nph, numerrdigits): return _presto.print_candidate(cand, dt, N, nph, numerrdigits) -def print_bin_candidate(cand: "binaryprops *", numerrdigits: "int") -> "void": +def print_bin_candidate(cand, numerrdigits): return _presto.print_bin_candidate(cand, numerrdigits) -def read_rzw_cand(file: "FILE *", cands: "fourierprops") -> "int": +def read_rzw_cand(file, cands): return _presto.read_rzw_cand(file, cands) -def get_rzw_cand(filenm: "char *", candnum: "int", cand: "fourierprops") -> "void": +def get_rzw_cand(filenm, candnum, cand): return _presto.get_rzw_cand(filenm, candnum, cand) -def read_bin_cand(file: "FILE *", cands: "binaryprops *") -> "int": +def read_bin_cand(file, cands): return _presto.read_bin_cand(file, cands) -def get_bin_cand(filenm: "char *", candnum: "int", cand: "binaryprops *") -> "void": +def get_bin_cand(filenm, candnum, cand): return _presto.get_bin_cand(filenm, candnum, cand) -def next2_to_n(x: "long long") -> "long long": +def next2_to_n(x): return _presto.next2_to_n(x) -def is_power_of_10(n: "long long") -> "int": +def is_power_of_10(n): return _presto.is_power_of_10(n) -def choose_good_N(orig_N: "long long") -> "long long": +def choose_good_N(orig_N): return _presto.choose_good_N(orig_N) -def dms2rad(deg: "int", min: "int", sec: "double") -> "double": +def dms2rad(deg, min, sec): return _presto.dms2rad(deg, min, sec) -def hms2rad(hour: "int", min: "int", sec: "double") -> "double": +def hms2rad(hour, min, sec): return _presto.hms2rad(hour, min, sec) -def hours2hms(hours: "double") -> "int *, int *, double *": +def hours2hms(hours): return _presto.hours2hms(hours) -def deg2dms(degrees: "double") -> "int *, int *, double *": +def deg2dms(degrees): return _presto.deg2dms(degrees) -def sphere_ang_diff(ra1: "double", dec1: "double", ra2: "double", dec2: "double") -> "double": +def sphere_ang_diff(ra1, dec1, ra2, dec2): return _presto.sphere_ang_diff(ra1, dec1, ra2, dec2) -def corr_rz_plane(data: "fcomplex", numbetween: "int", startbin: "int", zlo: "double", zhi: "double", numz: "int", fftlen: "int", accuracy: "presto_interp_acc") -> "long *": +def corr_rz_plane(data, numbetween, startbin, zlo, zhi, numz, fftlen, accuracy): return _presto.corr_rz_plane(data, numbetween, startbin, zlo, zhi, numz, fftlen, accuracy) -def corr_rzw_vol(data: "fcomplex", numbetween: "int", startbin: "int", zlo: "double", zhi: "double", numz: "int", wlo: "double", whi: "double", numw: "int", fftlen: "int", accuracy: "presto_interp_acc") -> "long *": +def corr_rzw_vol(data, numbetween, startbin, zlo, zhi, numz, wlo, whi, numw, fftlen, accuracy): return _presto.corr_rzw_vol(data, numbetween, startbin, zlo, zhi, numz, wlo, whi, numw, fftlen, accuracy) -def max_r_arr(data: "fcomplex", rin: "double", derivs: "rderivs") -> "double *, double *": +def max_r_arr(data, rin, derivs): return _presto.max_r_arr(data, rin, derivs) -def max_rz_arr(data: "fcomplex", rin: "double", zin: "double", derivs: "rderivs") -> "double *, double *, double *": +def max_rz_arr(data, rin, zin, derivs): return _presto.max_rz_arr(data, rin, zin, derivs) -def max_rz_arr_harmonics(data: "fcomplex", rin: "double", zin: "double", derivdata: "double *") -> "double *, double *": +def max_rz_arr_harmonics(data, rin, zin, derivdata): return _presto.max_rz_arr_harmonics(data, rin, zin, derivdata) -def max_rzw_arr_harmonics(data: "fcomplex", rin: "double", zin: "double", win: "double", derivdata: "double *") -> "double *, double *, double *": +def max_rzw_arr_harmonics(data, rin, zin, win, derivdata): return _presto.max_rzw_arr_harmonics(data, rin, zin, win, derivdata) -def max_rzw_arr(data: "fcomplex", rin: "double", zin: "double", win: "double", derivs: "rderivs") -> "double *, double *, double *, double *": +def max_rzw_arr(data, rin, zin, win, derivs): return _presto.max_rzw_arr(data, rin, zin, win, derivs) -def barycenter(topotimes: "double *", barytimes: "double *", voverc: "double *", ra: "char *", dec: "char *", obs: "char *", ephem: "char *") -> "void": +def barycenter(topotimes, barytimes, voverc, ra, dec, obs, ephem): return _presto.barycenter(topotimes, barytimes, voverc, ra, dec, obs, ephem) -def DOF_corr(dt_per_bin: "double") -> "double": +def DOF_corr(dt_per_bin): return _presto.DOF_corr(dt_per_bin) -def simplefold(data: "float *", dt: "double", tlo: "double", prof: "double *", startphs: "double", f0: "double", fdot: "double", fdotdot: "double", standard: "int") -> "double": +def simplefold(data, dt, tlo, prof, startphs, f0, fdot, fdotdot, standard): return _presto.simplefold(data, dt, tlo, prof, startphs, f0, fdot, fdotdot, standard) -def nice_output_1(output: "char *", val: "double", err: "double", len: "int") -> "int": +def nice_output_1(output, val, err, len): return _presto.nice_output_1(output, val, err, len) -def nice_output_2(output: "char *", val: "double", err: "double", len: "int") -> "int": +def nice_output_2(output, val, err, len): return _presto.nice_output_2(output, val, err, len) - diff --git a/python/wrappers/presto_wrap.c b/python/wrappers/presto_wrap.c index cbdb31c70..293ca7d29 100644 --- a/python/wrappers/presto_wrap.c +++ b/python/wrappers/presto_wrap.c @@ -1,18 +1,14 @@ /* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 4.1.0 + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.3.0 * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. * ----------------------------------------------------------------------------- */ -#ifndef SWIGPYTHON +#define SWIG_VERSION 0x040300 #define SWIGPYTHON -#endif - #define SWIG_PYTHON_DIRECTOR_NO_VTABLE /* ----------------------------------------------------------------------------- @@ -139,14 +135,62 @@ # pragma warning disable 592 #endif +#if defined(__cplusplus) && __cplusplus >=201103L +# define SWIG_NULLPTR nullptr +#else +# define SWIG_NULLPTR NULL +#endif + +/* ----------------------------------------------------------------------------- + * swigcompat.swg + * + * Macros to provide support compatibility with older C and C++ standards. + * ----------------------------------------------------------------------------- */ + +/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF + * if you're missing it. + */ +#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \ + (defined __cplusplus && __cplusplus >= 201103L) || \ + defined SWIG_HAVE_SNPRINTF) && \ + !defined SWIG_NO_SNPRINTF +# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A) +# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B) +#else +/* Fallback versions ignore the buffer size, but most of our uses either have a + * fixed maximum possible size or dynamically allocate a buffer that's large + * enough. + */ +# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A) +# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B) +#endif + #if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) /* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ # include #endif +#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN) +#define PY_SSIZE_T_CLEAN +#endif + +#if __GNUC__ >= 7 +#pragma GCC diagnostic push +#if defined(__cplusplus) && __cplusplus >=201703L +#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */ +#endif +#endif + #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) /* Use debug wrappers with the Python release dll */ + +#if defined(_MSC_VER) && _MSC_VER >= 1929 +/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later + * See https://github.com/swig/swig/issues/2090 */ +# include +#endif + # undef _DEBUG # include # define _DEBUG 1 @@ -154,6 +198,12 @@ # include #endif +#if __GNUC__ >= 7 +#pragma GCC diagnostic pop +#endif + +#include + /* ----------------------------------------------------------------------------- * swigrun.swg * @@ -200,6 +250,8 @@ #define SWIG_POINTER_DISOWN 0x1 #define SWIG_CAST_NEW_MEMORY 0x2 #define SWIG_POINTER_NO_NULL 0x4 +#define SWIG_POINTER_CLEAR 0x8 +#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN) /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 @@ -271,7 +323,7 @@ SWIG errors code. Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this + allows returning the 'cast rank', for example, if you have this int food(double) int fooi(int); @@ -285,7 +337,13 @@ */ #define SWIG_OK (0) +/* Runtime errors are < 0 */ #define SWIG_ERROR (-1) +/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */ +/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */ +/* Errors < -200 are generic runtime specific errors */ +#define SWIG_ERROR_RELEASE_NOT_OWNED (-200) + #define SWIG_IsOK(r) (r >= 0) #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) @@ -293,14 +351,14 @@ #define SWIG_CASTRANKLIMIT (1 << 8) /* The NewMask denotes the object was created (using new/malloc) */ #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) -/* The TmpMask is for in/out typemaps that use temporal objects */ +/* The TmpMask is for in/out typemaps that use temporary objects */ #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) /* Simple returning values */ #define SWIG_BADOBJ (SWIG_ERROR) #define SWIG_OLDOBJ (SWIG_OK) #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) -/* Check, add and del mask methods */ +/* Check, add and del object mask methods */ #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) @@ -446,7 +504,7 @@ SWIG_TypeCheck(const char *c, swig_type_info *ty) { Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison */ SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { +SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) { if (ty) { swig_cast_info *iter = ty->cast; while (iter) { @@ -506,9 +564,9 @@ SWIG_TypeName(const swig_type_info *ty) { SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type) { /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ + type, separated by vertical-bar characters. Choose the last + name. It should be the most specific; a fully resolved name + but not necessarily with default template parameters expanded. */ if (!type) return NULL; if (type->str != NULL) { const char *last_name = type->str; @@ -728,7 +786,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { } #endif -/* Errors in SWIG */ +/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */ #define SWIG_UnknownError -1 #define SWIG_IOError -2 #define SWIG_RuntimeError -3 @@ -744,7 +802,6 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #define SWIG_NullReferenceError -13 - /* Compatibility macros for Python 3 */ #if PY_VERSION_HEX >= 0x03000000 @@ -760,15 +817,10 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #define PyString_Size(str) PyBytes_Size(str) #define PyString_InternFromString(key) PyUnicode_InternFromString(key) #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE -#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) #endif -#ifndef Py_TYPE -# define Py_TYPE(op) ((op)->ob_type) -#endif - /* SWIG APIs for compatibility of both Python 2 & 3 */ #if PY_VERSION_HEX >= 0x03000000 @@ -778,40 +830,30 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #endif -/* Warning: This function will allocate a new string in Python 3, - * so please call SWIG_Python_str_DelForPy3(x) to free the space. - */ -SWIGINTERN char* -SWIG_Python_str_AsChar(PyObject *str) +/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */ +SWIGINTERN const char * +SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes) { #if PY_VERSION_HEX >= 0x03030000 - return (char *)PyUnicode_AsUTF8(str); -#elif PY_VERSION_HEX >= 0x03000000 - char *newstr = 0; - str = PyUnicode_AsUTF8String(str); - if (str) { - char *cstr; - Py_ssize_t len; - if (PyBytes_AsStringAndSize(str, &cstr, &len) != -1) { - newstr = (char *) malloc(len+1); - if (newstr) - memcpy(newstr, cstr, len+1); - } - Py_XDECREF(str); - } - return newstr; +# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 + *pbytes = NULL; + return PyUnicode_AsUTF8AndSize(str, psize); +# else + const char *chars; + *pbytes = PyUnicode_AsUTF8String(str); + chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL; + if (chars && psize) + *psize = PyBytes_Size(*pbytes); + return chars; +# endif #else - return PyString_AsString(str); + char *chars = NULL; + *pbytes = NULL; + PyString_AsStringAndSize(str, &chars, psize); + return chars; #endif } -#if PY_VERSION_HEX >= 0x03030000 || PY_VERSION_HEX < 0x03000000 -# define SWIG_Python_str_DelForPy3(x) -#else -# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) -#endif - - SWIGINTERN PyObject* SWIG_Python_str_FromChar(const char *c) { @@ -822,13 +864,14 @@ SWIG_Python_str_FromChar(const char *c) #endif } -#ifndef PyObject_DEL -# define PyObject_DEL PyObject_Del -#endif - /* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */ # define SWIGPY_USE_CAPSULE -# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) +#ifdef SWIGPYTHON_BUILTIN +# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME +#else +# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME +#endif +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME) #if PY_VERSION_HEX < 0x03020000 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) @@ -836,6 +879,33 @@ SWIG_Python_str_FromChar(const char *c) #define Py_hash_t long #endif +#ifdef Py_LIMITED_API +# define PyTuple_GET_ITEM PyTuple_GetItem +/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used + interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */ +# define PyTuple_SET_ITEM PyTuple_SetItem +# define PyTuple_GET_SIZE PyTuple_Size +# define PyCFunction_GET_FLAGS PyCFunction_GetFlags +# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction +# define PyCFunction_GET_SELF PyCFunction_GetSelf +# define PyList_GET_ITEM PyList_GetItem +# define PyList_SET_ITEM PyList_SetItem +# define PySliceObject PyObject +#endif + +/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */ +#ifdef Py_LIMITED_API +# define SWIG_Py_INCREF Py_IncRef +# define SWIG_Py_XINCREF Py_IncRef +# define SWIG_Py_DECREF Py_DecRef +# define SWIG_Py_XDECREF Py_DecRef +#else +# define SWIG_Py_INCREF Py_INCREF +# define SWIG_Py_XINCREF Py_XINCREF +# define SWIG_Py_DECREF Py_DECREF +# define SWIG_Py_XDECREF Py_XDECREF +#endif + /* ----------------------------------------------------------------------------- * error manipulation * ----------------------------------------------------------------------------- */ @@ -895,16 +965,17 @@ SWIG_Python_AddErrorMsg(const char* mesg) PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); - const char *tmp = SWIG_Python_str_AsChar(old_str); + PyObject *bytes = NULL; + const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes); PyErr_Clear(); - Py_XINCREF(type); + SWIG_Py_XINCREF(type); if (tmp) PyErr_Format(type, "%s %s", tmp, mesg); else PyErr_Format(type, "%s", mesg); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); - Py_DECREF(value); + SWIG_Py_XDECREF(bytes); + SWIG_Py_DECREF(old_str); + SWIG_Py_DECREF(value); } else { PyErr_SetString(PyExc_RuntimeError, mesg); } @@ -933,8 +1004,12 @@ SWIG_Python_RaiseOrModifyTypeError(const char *message) #else newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); #endif - Py_XDECREF(value); - PyErr_Restore(type, newvalue, traceback); + if (newvalue) { + SWIG_Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + PyErr_Restore(type, value, traceback); + } } else { /* Raise TypeError using given message */ PyErr_SetString(PyExc_TypeError, message); @@ -971,7 +1046,7 @@ SWIG_Python_RaiseOrModifyTypeError(const char *message) bool status; PyThreadState *save; public: - void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + void end() { if (status) { status = false; PyEval_RestoreThread(save); }} SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} ~SWIG_Python_Thread_Allow() { end(); } }; @@ -1054,8 +1129,8 @@ typedef struct swig_const_info { # error "This version of SWIG only supports Python >= 2.7" #endif -#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 -# error "This version of SWIG only supports Python 3 >= 3.2" +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000 +# error "This version of SWIG only supports Python 3 >= 3.3" #endif /* Common SWIG API */ @@ -1115,7 +1190,7 @@ SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; PyErr_SetObject(errtype, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); SWIG_PYTHON_THREAD_END_BLOCK; } @@ -1136,13 +1211,13 @@ SWIGINTERN void SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { PyObject *s = PyString_InternFromString(key); PyList_Append(seq, s); - Py_DECREF(s); + SWIG_Py_DECREF(s); } SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { PyDict_SetItemString(d, name, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); if (public_interface) SwigPyBuiltin_AddPublicSymbol(public_interface, name); } @@ -1152,7 +1227,7 @@ SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *nam SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { PyDict_SetItemString(d, name, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } #endif @@ -1164,16 +1239,21 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { if (!result) { result = obj; } else if (result == Py_None) { - Py_DECREF(result); + SWIG_Py_DECREF(result); result = obj; } else { if (!PyList_Check(result)) { PyObject *o2 = result; result = PyList_New(1); - PyList_SetItem(result, 0, o2); + if (result) { + PyList_SET_ITEM(result, 0, o2); + } else { + SWIG_Py_DECREF(obj); + return o2; + } } PyList_Append(result,obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } return result; } @@ -1252,6 +1332,261 @@ SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) { #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var #endif +#ifdef __cplusplus +extern "C" { +#endif + +/* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + +/* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + +typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; +} swig_globalvar; + +typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; +} swig_varlinkobject; + +SWIGINTERN PyObject * +swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif +} + +SWIGINTERN PyObject * +swig_varlink_str(PyObject *o) { + swig_varlinkobject *v = (swig_varlinkobject *) o; +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + SWIG_Py_DECREF(str); + SWIG_Py_DECREF(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + SWIG_Py_DECREF(str); + SWIG_Py_DECREF(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + SWIG_Py_DECREF(str); + SWIG_Py_DECREF(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; +} + +SWIGINTERN void +swig_varlink_dealloc(PyObject *o) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } +} + +SWIGINTERN PyObject * +swig_varlink_getattr(PyObject *o, char *n) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; +} + +SWIGINTERN int +swig_varlink_setattr(PyObject *o, char *n, PyObject *p) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; +} + +SWIGINTERN PyTypeObject* +swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; +#ifndef Py_LIMITED_API + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)swig_varlink_dealloc }, + { Py_tp_repr, (void *)swig_varlink_repr }, + { Py_tp_getattr, (void *)swig_varlink_getattr }, + { Py_tp_setattr, (void *)swig_varlink_setattr }, + { Py_tp_str, (void *)swig_varlink_str }, + { Py_tp_doc, (void *)varlink__doc__ }, + { 0, NULL } + }; + PyType_Spec spec = { + "swigvarlink", + sizeof(swig_varlinkobject), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif +} + +/* Create a variable linking object for use later */ +SWIGINTERN PyObject * +SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); +} + +SWIGINTERN void +SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; +} + + +static PyObject *Swig_Globals_global = NULL; + +SWIGINTERN PyObject * +SWIG_globals(void) { + if (Swig_Globals_global == NULL) { + Swig_Globals_global = SWIG_newvarlink(); + } + return Swig_Globals_global; +} + +#ifdef __cplusplus +} +#endif + /* ----------------------------------------------------------------------------- * Pointer declarations * ----------------------------------------------------------------------------- */ @@ -1275,7 +1610,7 @@ SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void) { PyObject *none = Py_None; - Py_INCREF(none); + SWIG_Py_INCREF(none); return none; } @@ -1318,22 +1653,29 @@ SwigPyClientData_New(PyObject* obj) SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); /* the klass element */ data->klass = obj; - Py_INCREF(data->klass); + SWIG_Py_INCREF(data->klass); /* the newraw method and newargs arguments used to create a new raw instance */ if (PyClass_Check(obj)) { data->newraw = 0; + SWIG_Py_INCREF(obj); data->newargs = obj; - Py_INCREF(obj); } else { data->newraw = PyObject_GetAttrString(data->klass, "__new__"); if (data->newraw) { - Py_INCREF(data->newraw); - data->newargs = PyTuple_New(1); - PyTuple_SetItem(data->newargs, 0, obj); + data->newargs = PyTuple_New(1); + if (data->newargs) { + SWIG_Py_INCREF(obj); + PyTuple_SET_ITEM(data->newargs, 0, obj); + } else { + SWIG_Py_DECREF(data->newraw); + SWIG_Py_DECREF(data->klass); + free(data); + return 0; + } } else { - data->newargs = obj; + SWIG_Py_INCREF(obj); + data->newargs = obj; } - Py_INCREF(data->newargs); } /* the destroy method, aka as the C++ delete method */ data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); @@ -1342,10 +1684,7 @@ SwigPyClientData_New(PyObject* obj) data->destroy = 0; } if (data->destroy) { - int flags; - Py_INCREF(data->destroy); - flags = PyCFunction_GET_FLAGS(data->destroy); - data->delargs = !(flags & (METH_O)); + data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O); } else { data->delargs = 0; } @@ -1356,10 +1695,13 @@ SwigPyClientData_New(PyObject* obj) } SWIGRUNTIME void -SwigPyClientData_Del(SwigPyClientData *data) { - Py_XDECREF(data->newraw); - Py_XDECREF(data->newargs); - Py_XDECREF(data->destroy); +SwigPyClientData_Del(SwigPyClientData *data) +{ + SWIG_Py_XDECREF(data->klass); + SWIG_Py_XDECREF(data->newraw); + SWIG_Py_XDECREF(data->newargs); + SWIG_Py_XDECREF(data->destroy); + free(data); } /* =============== SwigPyObject =====================*/ @@ -1386,7 +1728,7 @@ SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) if (!sobj->dict) sobj->dict = PyDict_New(); - Py_INCREF(sobj->dict); + SWIG_Py_XINCREF(sobj->dict); return sobj->dict; } @@ -1404,18 +1746,21 @@ SwigPyObject_format(const char* fmt, SwigPyObject *v) PyObject *res = NULL; PyObject *args = PyTuple_New(1); if (args) { - if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { - PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + PyObject *val = SwigPyObject_long(v); + if (val) { + PyObject *ofmt; + PyTuple_SET_ITEM(args, 0, val); + ofmt = SWIG_Python_str_FromChar(fmt); if (ofmt) { #if PY_VERSION_HEX >= 0x03000000 - res = PyUnicode_Format(ofmt,args); + res = PyUnicode_Format(ofmt,args); #else - res = PyString_Format(ofmt,args); + res = PyString_Format(ofmt,args); #endif - Py_DECREF(ofmt); + SWIG_Py_DECREF(ofmt); } - Py_DECREF(args); } + SWIG_Py_DECREF(args); } return res; } @@ -1437,18 +1782,23 @@ SwigPyObject_repr(SwigPyObject *v) { const char *name = SWIG_TypePrettyName(v->ty); PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); - if (v->next) { + if (repr && v->next) { PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); + if (nrep) { # if PY_VERSION_HEX >= 0x03000000 - PyObject *joined = PyUnicode_Concat(repr, nrep); - Py_DecRef(repr); - Py_DecRef(nrep); - repr = joined; + PyObject *joined = PyUnicode_Concat(repr, nrep); + SWIG_Py_DECREF(repr); + SWIG_Py_DECREF(nrep); + repr = joined; # else - PyString_ConcatAndDel(&repr,nrep); + PyString_ConcatAndDel(&repr,nrep); # endif + } else { + SWIG_Py_DECREF(repr); + repr = NULL; + } } - return repr; + return repr; } /* We need a version taking two PyObject* parameters so it's a valid @@ -1471,12 +1821,14 @@ SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) SWIGRUNTIME PyObject* SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) { - PyObject* res; - if( op != Py_EQ && op != Py_NE ) { - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + PyObject* res = NULL; + if (!PyErr_Occurred()) { + if (op != Py_EQ && op != Py_NE) { + SWIG_Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); } - res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); return res; } @@ -1504,20 +1856,37 @@ SwigPyObject_type(void) { SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op) { -#ifdef SWIGPYTHON_BUILTIN PyTypeObject *target_tp = SwigPyObject_type(); - if (PyType_IsSubtype(op->ob_type, target_tp)) + PyTypeObject *op_type = Py_TYPE(op); +#ifdef SWIGPYTHON_BUILTIN + if (PyType_IsSubtype(op_type, target_tp)) return 1; - return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); + return (strcmp(op_type->tp_name, "SwigPyObject") == 0); #else - return (Py_TYPE(op) == SwigPyObject_type()) - || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +# ifdef Py_LIMITED_API + int cmp; + PyObject *tp_name; +#endif + if (op_type == target_tp) + return 1; +# ifdef Py_LIMITED_API + tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); + if (!tp_name) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject"); + SWIG_Py_DECREF(tp_name); + return cmp == 0; +# else + return (strcmp(op_type->tp_name, "SwigPyObject") == 0); +# endif #endif } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own); +static PyObject* Swig_Capsule_global = NULL; + SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v) { @@ -1544,8 +1913,12 @@ SwigPyObject_dealloc(PyObject *v) if (data->delargs) { /* we need to create a temporary object to carry the destroy operation */ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); - res = SWIG_Python_CallFunctor(destroy, tmp); - Py_DECREF(tmp); + if (tmp) { + res = SWIG_Python_CallFunctor(destroy, tmp); + } else { + res = 0; + } + SWIG_Py_XDECREF(tmp); } else { PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); PyObject *mself = PyCFunction_GET_SELF(destroy); @@ -1556,7 +1929,7 @@ SwigPyObject_dealloc(PyObject *v) PyErr_Restore(type, value, traceback); - Py_XDECREF(res); + SWIG_Py_XDECREF(res); } #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) else { @@ -1564,9 +1937,13 @@ SwigPyObject_dealloc(PyObject *v) printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); } #endif - } - Py_XDECREF(next); - PyObject_DEL(v); + SWIG_Py_XDECREF(Swig_Capsule_global); + } + SWIG_Py_XDECREF(next); +#ifdef SWIGPYTHON_BUILTIN + SWIG_Py_XDECREF(sobj->dict); +#endif + PyObject_Free(v); } SWIGRUNTIME PyObject* @@ -1577,8 +1954,9 @@ SwigPyObject_append(PyObject* v, PyObject* next) PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); return NULL; } + ((SwigPyObject *)next)->next = sobj->next; sobj->next = next; - Py_INCREF(next); + SWIG_Py_INCREF(next); return SWIG_Py_Void(); } @@ -1587,7 +1965,7 @@ SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) { SwigPyObject *sobj = (SwigPyObject *) v; if (sobj->next) { - Py_INCREF(sobj->next); + SWIG_Py_INCREF(sobj->next); return sobj->next; } else { return SWIG_Py_Void(); @@ -1621,9 +1999,9 @@ SwigPyObject_own(PyObject *v, PyObject *args) PyObject *obj = PyBool_FromLong(sobj->own); if (val) { if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v,args); + SWIG_Py_DECREF(SwigPyObject_acquire(v,args)); } else { - SwigPyObject_disown(v,args); + SWIG_Py_DECREF(SwigPyObject_disown(v,args)); } } return obj; @@ -1644,7 +2022,7 @@ swigobject_methods[] = { SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void) { static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; - +#ifndef Py_LIMITED_API static PyNumberMethods SwigPyObject_as_number = { (binaryfunc)0, /*nb_add*/ (binaryfunc)0, /*nb_subtract*/ @@ -1703,7 +2081,11 @@ SwigPyObject_TypeOnce(void) { sizeof(SwigPyObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ - 0, /* tp_print */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX >= 0x03000000 @@ -1758,6 +2140,9 @@ SwigPyObject_TypeOnce(void) { #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) 0, /* tp_print */ #endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ @@ -1768,21 +2153,50 @@ SwigPyObject_TypeOnce(void) { }; swigpyobject_type = tmp; type_init = 1; - if (PyType_Ready(&swigpyobject_type) < 0) + if (PyType_Ready(&swigpyobject_type) != 0) return NULL; } return &swigpyobject_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)SwigPyObject_dealloc }, + { Py_tp_repr, (void *)SwigPyObject_repr }, + { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, + { Py_tp_doc, (void *)swigobject_doc }, + { Py_tp_richcompare, (void *)SwigPyObject_richcompare }, + { Py_tp_methods, (void *)swigobject_methods }, + { Py_nb_int, (void *)SwigPyObject_long }, + { 0, NULL } + }; + PyType_Spec spec = { + "SwigPyObject", + sizeof(SwigPyObject), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own) { - SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type()); if (sobj) { sobj->ptr = ptr; sobj->ty = ty; sobj->own = own; sobj->next = 0; +#ifdef SWIGPYTHON_BUILTIN + sobj->dict = 0; +#endif + if (own == SWIG_POINTER_OWN) { + /* Obtain a reference to the Python capsule wrapping the module information, so that the + * module information is correctly destroyed after all SWIG python objects have been freed + * by the GC (and corresponding destructors invoked) */ + SWIG_Py_XINCREF(Swig_Capsule_global); + } } return (PyObject *)sobj; } @@ -1839,8 +2253,23 @@ SwigPyPacked_type(void) { SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op) { - return ((op)->ob_type == SwigPyPacked_TypeOnce()) - || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +#ifdef Py_LIMITED_API + int cmp; + PyObject *tp_name; +#endif + PyTypeObject* op_type = Py_TYPE(op); + if (op_type == SwigPyPacked_TypeOnce()) + return 1; +#ifdef Py_LIMITED_API + tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); + if (!tp_name) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked"); + SWIG_Py_DECREF(tp_name); + return cmp == 0; +#else + return (strcmp(op_type->tp_name, "SwigPyPacked") == 0); +#endif } SWIGRUNTIME void @@ -1850,12 +2279,13 @@ SwigPyPacked_dealloc(PyObject *v) SwigPyPacked *sobj = (SwigPyPacked *) v; free(sobj->pack); } - PyObject_DEL(v); + PyObject_Free(v); } SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void) { static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; +#ifndef Py_LIMITED_API static PyTypeObject swigpypacked_type; static int type_init = 0; if (!type_init) { @@ -1870,7 +2300,11 @@ SwigPyPacked_TypeOnce(void) { sizeof(SwigPyPacked), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ - 0, /* tp_print */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX>=0x03000000 @@ -1925,6 +2359,9 @@ SwigPyPacked_TypeOnce(void) { #if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) 0, /* tp_print */ #endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ @@ -1935,16 +2372,34 @@ SwigPyPacked_TypeOnce(void) { }; swigpypacked_type = tmp; type_init = 1; - if (PyType_Ready(&swigpypacked_type) < 0) + if (PyType_Ready(&swigpypacked_type) != 0) return NULL; } return &swigpypacked_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)SwigPyPacked_dealloc }, + { Py_tp_repr, (void *)SwigPyPacked_repr }, + { Py_tp_str, (void *)SwigPyPacked_str }, + { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, + { Py_tp_doc, (void *)swigpacked_doc }, + { 0, NULL } + }; + PyType_Spec spec = { + "SwigPyPacked", + sizeof(SwigPyPacked), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif } SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) { - SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type()); if (sobj) { void *pack = malloc(size); if (pack) { @@ -1953,7 +2408,7 @@ SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) sobj->ty = ty; sobj->size = size; } else { - PyObject_DEL((PyObject *) sobj); + PyObject_Free((PyObject *)sobj); sobj = 0; } } @@ -2033,7 +2488,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) #endif obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; @@ -2043,7 +2498,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) #else obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; @@ -2125,12 +2580,19 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int } } if (sobj) { - if (own) - *own = *own | sobj->own; - if (flags & SWIG_POINTER_DISOWN) { - sobj->own = 0; + if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) { + res = SWIG_ERROR_RELEASE_NOT_OWNED; + } else { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + if (flags & SWIG_POINTER_CLEAR) { + sobj->ptr = 0; + } + res = SWIG_OK; } - res = SWIG_OK; } else { if (implicit_conv) { SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; @@ -2162,7 +2624,7 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int } } } - Py_DECREF(impconv); + SWIG_Py_DECREF(impconv); } } } @@ -2189,10 +2651,20 @@ SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { swig_cast_info *tc; /* here we get the method pointer for callbacks */ +#ifndef Py_LIMITED_API const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); +#else + PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__"); + PyObject *bytes = NULL; + const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0; +#endif const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; if (desc) desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; +#ifdef Py_LIMITED_API + SWIG_Py_XDECREF(bytes); + SWIG_Py_XDECREF(pystr_doc); +#endif if (!desc) return SWIG_ERROR; tc = SWIG_TypeCheck(desc,ty); @@ -2243,16 +2715,21 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { - PyObject *dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - PyDict_SetItem(dict, SWIG_This(), swig_this); - } + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + SWIG_Py_DECREF(inst); + inst = 0; + } } #else if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { - Py_DECREF(inst); + SWIG_Py_DECREF(inst); inst = 0; } #endif @@ -2263,25 +2740,30 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) if (empty_args) { PyObject *empty_kwargs = PyDict_New(); if (empty_kwargs) { - inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); - Py_DECREF(empty_kwargs); +#ifndef Py_LIMITED_API + newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new; +#else + newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new); +#endif + inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + SWIG_Py_DECREF(empty_kwargs); if (inst) { if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { - Py_DECREF(inst); + SWIG_Py_DECREF(inst); inst = 0; } else { - Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + PyType_Modified(Py_TYPE(inst)); } } } - Py_DECREF(empty_args); + SWIG_Py_DECREF(empty_args); } #else PyObject *dict = PyDict_New(); if (dict) { PyDict_SetItem(dict, SWIG_This(), swig_this); inst = PyInstance_NewRaw(data->newargs, dict); - Py_DECREF(dict); + SWIG_Py_DECREF(dict); } #endif } @@ -2299,7 +2781,11 @@ SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) dict = PyDict_New(); *dictptr = dict; } - return PyDict_SetItem(dict, SWIG_This(), swig_this); + if (dict) { + return PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + return -1; + } } #endif return PyObject_SetAttr(inst, SWIG_This(), swig_this); @@ -2314,7 +2800,7 @@ SWIG_Python_InitShadowInstance(PyObject *args) { } else { SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); if (sthis) { - SwigPyObject_append((PyObject*) sthis, obj[1]); + SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1])); } else { if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0) return NULL; @@ -2341,7 +2827,12 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f if (flags & SWIG_BUILTIN_TP_INIT) { newobj = (SwigPyObject*) self; if (newobj->ptr) { - PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); +#ifndef Py_LIMITED_API + allocfunc alloc = clientdata->pytype->tp_alloc; +#else + allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc); +#endif + PyObject *next_self = alloc(clientdata->pytype, 0); while (newobj->next) newobj = (SwigPyObject *) newobj->next; newobj->next = next_self; @@ -2353,7 +2844,9 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f } else { newobj = PyObject_New(SwigPyObject, clientdata->pytype); #ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; + if (newobj) { + newobj->dict = 0; + } #endif } if (newobj) { @@ -2371,7 +2864,7 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f robj = SwigPyObject_New(ptr, type, own); if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); - Py_DECREF(robj); + SWIG_Py_DECREF(robj); robj = inst; } return robj; @@ -2392,39 +2885,61 @@ SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { void *SWIG_ReturnGlobalTypeList(void *); #endif +static PyObject *Swig_TypeCache_global = NULL; + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + if (Swig_TypeCache_global == NULL) { + Swig_TypeCache_global = PyDict_New(); + } + return Swig_TypeCache_global; +} + SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { +#ifdef SWIG_LINK_RUNTIME static void *type_pointer = (void *)0; /* first check if module already created */ if (!type_pointer) { -#ifdef SWIG_LINK_RUNTIME type_pointer = SWIG_ReturnGlobalTypeList((void *)0); + } #else - type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); - if (PyErr_Occurred()) { - PyErr_Clear(); - type_pointer = (void *)0; - } -#endif + void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; } +#endif return (swig_module_info *) type_pointer; } + +static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */ + SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj) { swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); swig_type_info **types = swig_module->types; size_t i; + if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */ + return; for (i =0; i < swig_module->size; ++i) { swig_type_info *ty = types[i]; if (ty->owndata) { SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + ty->clientdata = 0; if (data) SwigPyClientData_Del(data); } } - Py_DECREF(SWIG_This()); + SWIG_Py_DECREF(SWIG_This()); Swig_This_global = NULL; + SWIG_Py_DECREF(SWIG_globals()); + Swig_Globals_global = NULL; + SWIG_Py_DECREF(SWIG_Python_TypeCache()); + Swig_TypeCache_global = NULL; + Swig_Capsule_global = NULL; } SWIGRUNTIME void @@ -2438,19 +2953,17 @@ SWIG_Python_SetModule(swig_module_info *swig_module) { #endif PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); if (pointer && module) { - PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) { + ++interpreter_counter; + Swig_Capsule_global = pointer; + } else { + SWIG_Py_DECREF(pointer); + } } else { - Py_XDECREF(pointer); + SWIG_Py_XDECREF(pointer); } } -/* The python cached type query */ -SWIGRUNTIME PyObject * -SWIG_Python_TypeCache(void) { - static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); - return cache; -} - SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type) { @@ -2465,11 +2978,13 @@ SWIG_Python_TypeQuery(const char *type) descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { obj = PyCapsule_New((void*) descriptor, NULL, NULL); - PyDict_SetItem(cache, key, obj); - Py_DECREF(obj); + if (obj) { + PyDict_SetItem(cache, key, obj); + SWIG_Py_DECREF(obj); + } } } - Py_DECREF(key); + SWIG_Py_DECREF(key); return descriptor; } @@ -2490,17 +3005,18 @@ SWIG_Python_AddErrMesg(const char* mesg, int infront) PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); - const char *tmp = SWIG_Python_str_AsChar(old_str); + PyObject *bytes = NULL; + const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes); const char *errmesg = tmp ? tmp : "Invalid error message"; - Py_XINCREF(type); + SWIG_Py_XINCREF(type); PyErr_Clear(); if (infront) { PyErr_Format(type, "%s %s", mesg, errmesg); } else { PyErr_Format(type, "%s %s", errmesg, mesg); } - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); + SWIG_Py_XDECREF(bytes); + SWIG_Py_DECREF(old_str); } return 1; } else { @@ -2532,6 +3048,7 @@ SwigPyObject_GetDesc(PyObject *self) SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj) { + (void) obj; if (type) { #if defined(SWIG_COBJECT_TYPES) if (obj && SwigPyObject_Check(obj)) { @@ -2544,21 +3061,25 @@ SWIG_Python_TypeError(const char *type, PyObject *obj) } else #endif { +#ifndef Py_LIMITED_API + /* tp_name is not accessible */ const char *otype = (obj ? obj->ob_type->tp_name : 0); if (otype) { PyObject *str = PyObject_Str(obj); - const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + PyObject *bytes = NULL; + const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0; if (cstr) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", type, otype, cstr); - SWIG_Python_str_DelForPy3(cstr); } else { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", type, otype); } - Py_XDECREF(str); + SWIG_Py_XDECREF(bytes); + SWIG_Py_XDECREF(str); return; } +#endif } PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); } else { @@ -2573,12 +3094,6 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(arg void *result; if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { PyErr_Clear(); -#if SWIG_POINTER_EXCEPTION - if (flags) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - SWIG_Python_ArgFail(argnum); - } -#endif } return result; } @@ -2605,11 +3120,11 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); return -1; } else { - Py_INCREF(name); + SWIG_Py_INCREF(name); } if (!tp->tp_dict) { - if (PyType_Ready(tp) < 0) + if (PyType_Ready(tp) != 0) goto done; } @@ -2620,20 +3135,20 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { if (!f) { if (PyString_Check(name)) { encoded_name = name; - Py_INCREF(name); + SWIG_Py_INCREF(name); } else { encoded_name = PyUnicode_AsUTF8String(name); if (!encoded_name) - return -1; + goto done; } PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); - Py_DECREF(encoded_name); + SWIG_Py_DECREF(encoded_name); } else { res = f(descr, obj, value); } done: - Py_DECREF(name); + SWIG_Py_DECREF(name); return res; } #endif @@ -2647,23 +3162,8 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) -#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else - - - -#ifdef __cplusplus -extern "C" { -#endif - -/* Method creation and docstring support functions */ - -SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); -SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); -SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) -#ifdef __cplusplus -} -#endif /* -------- TYPES TABLE (BEGIN) -------- */ @@ -2715,10 +3215,6 @@ static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; #endif #define SWIG_name "_presto" -#define SWIGVERSION 0x040100 -#define SWIG_VERSION SWIGVERSION - - #define SWIG_as_voidptr(a) (void *)((const void *)(a)) #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) @@ -2771,10 +3267,6 @@ inline int SWIG_isfinite_func(T x) { # define SWIG_isfinite(X) (SWIG_isfinite_func(X)) # elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) # define SWIG_isfinite(X) (__builtin_isfinite(X)) -# elif defined(__clang__) && defined(__has_builtin) -# if __has_builtin(__builtin_isfinite) -# define SWIG_isfinite(X) (__builtin_isfinite(X)) -# endif # elif defined(_MSC_VER) # define SWIG_isfinite(X) (_finite(X)) # elif defined(__sun) && defined(__SVR4) @@ -2875,9 +3367,11 @@ SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max) { double x = *d; if ((min <= x && x <= max)) { - double fx = floor(x); - double cx = ceil(x); - double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + double fx, cx, rd; + errno = 0; + fx = floor(x); + cx = ceil(x); + rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ if ((errno == EDOM) || (errno == ERANGE)) { errno = 0; } else { @@ -2933,7 +3427,12 @@ SWIG_AsVal_long (PyObject *obj, long* val) if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + // Largest double not larger than LONG_MAX (not portably calculated easily) + // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long) + // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0)) + const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX; + // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) { if (val) *val = (long)(d); return res; } @@ -3513,8 +4012,10 @@ SWIG_pchar_descriptor(void) } +/* Return string from Python obj. NOTE: obj must remain in scope in order + to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */ SWIGINTERN int -SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc) { #if PY_VERSION_HEX>=0x03000000 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) @@ -3527,55 +4028,31 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #endif { char *cstr; Py_ssize_t len; + PyObject *bytes = NULL; int ret = SWIG_OK; -#if PY_VERSION_HEX>=0x03000000 -#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - if (!alloc && cptr) { - /* We can't allow converting without allocation, since the internal - representation of string in Python 3 is UCS-2/UCS-4 but we require - a UTF-8 representation. - TODO(bhy) More detailed explanation */ - return SWIG_RuntimeError; - } - obj = PyUnicode_AsUTF8String(obj); - if (!obj) - return SWIG_TypeError; if (alloc) - *alloc = SWIG_NEWOBJ; -#endif + *alloc = SWIG_OLDOBJ; +#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR) if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1) return SWIG_TypeError; #else - if (PyString_AsStringAndSize(obj, &cstr, &len) == -1) + cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes); + if (!cstr) return SWIG_TypeError; -#endif - if (cptr) { + /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */ + if (bytes && cptr) { if (alloc) { - if (*alloc == SWIG_NEWOBJ) { - *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); - *alloc = SWIG_NEWOBJ; - } else { - *cptr = cstr; - *alloc = SWIG_OLDOBJ; - } + cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); + *alloc = SWIG_NEWOBJ; } else { -#if PY_VERSION_HEX>=0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - *cptr = PyBytes_AsString(obj); -#else - assert(0); /* Should never reach here with Unicode strings in Python 3 */ -#endif -#else - *cptr = SWIG_Python_str_AsChar(obj); - if (!*cptr) - ret = SWIG_TypeError; -#endif + /* alloc must be set in order to clean up allocated memory */ + return SWIG_RuntimeError; } } - if (psize) *psize = len + 1; -#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - Py_XDECREF(obj); #endif + if (cptr) *cptr = cstr; + if (psize) *psize = len + 1; + SWIG_Py_XDECREF(bytes); return ret; } else { #if defined(SWIG_PYTHON_2_UNICODE) @@ -3598,10 +4075,10 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) } if (psize) *psize = len + 1; - Py_XDECREF(obj); + SWIG_Py_XDECREF(obj); return SWIG_OK; } else { - Py_XDECREF(obj); + SWIG_Py_XDECREF(obj); } } #endif @@ -3874,7 +4351,11 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { + // Largest double not larger than ULONG_MAX (not portably calculated easily) + // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long) + // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0)) + const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) { if (val) *val = (unsigned long)(d); return res; } @@ -4013,7 +4494,7 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; float arg2 ; @@ -4023,6 +4504,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *SWIGUNUSEDPARM(self), PyObje int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fcomplex_r_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4042,7 +4524,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_set(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; void *argp1 = 0 ; @@ -4050,6 +4532,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); @@ -4065,7 +4548,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_r_get(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; float arg2 ; @@ -4075,6 +4558,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *SWIGUNUSEDPARM(self), PyObje int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fcomplex_i_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4094,7 +4578,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_set(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; void *argp1 = 0 ; @@ -4102,6 +4586,7 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); @@ -4117,10 +4602,11 @@ SWIGINTERN PyObject *_wrap_fcomplex_i_get(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_new_fcomplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_fcomplex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_fcomplex", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -4146,13 +4632,14 @@ SWIGINTERN PyObject *_wrap_new_fcomplex(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_delete_fcomplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_fcomplex(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FCOMPLEX *arg1 = (struct FCOMPLEX *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, SWIG_POINTER_DISOWN | 0 ); @@ -4195,9 +4682,10 @@ SWIGINTERN PyObject *fcomplex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_read_wisdom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_read_wisdom(PyObject *self, PyObject *args) { PyObject *resultobj = 0; + (void)self; if (!SWIG_Python_UnpackTuple(args, "read_wisdom", 0, 0, 0)) SWIG_fail; read_wisdom(); resultobj = SWIG_Py_Void(); @@ -4207,7 +4695,7 @@ SWIGINTERN PyObject *_wrap_read_wisdom(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_good_factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_good_factor(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -4215,6 +4703,7 @@ SWIGINTERN PyObject *_wrap_good_factor(PyObject *SWIGUNUSEDPARM(self), PyObject PyObject *swig_obj[1] ; long long result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -4230,7 +4719,7 @@ SWIGINTERN PyObject *_wrap_good_factor(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_fftwcall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fftwcall(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -4241,6 +4730,7 @@ SWIGINTERN PyObject *_wrap_fftwcall(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fftwcall", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -4263,7 +4753,7 @@ SWIGINTERN PyObject *_wrap_fftwcall(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -4274,6 +4764,7 @@ SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "tablesixstepfft", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -4296,7 +4787,7 @@ SWIGINTERN PyObject *_wrap_tablesixstepfft(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_realfft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_realfft(PyObject *self, PyObject *args) { PyObject *resultobj = 0; float *arg1 = (float *) 0 ; long arg2 ; @@ -4307,6 +4798,7 @@ SWIGINTERN PyObject *_wrap_realfft(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "realfft", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_FLOAT); @@ -4329,7 +4821,7 @@ SWIGINTERN PyObject *_wrap_realfft(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4339,6 +4831,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_ra_s_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4358,7 +4851,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4366,6 +4859,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4381,7 +4875,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_s_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4391,6 +4885,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dec_s_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4410,7 +4905,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4418,6 +4913,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4433,7 +4929,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_s_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4443,6 +4939,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *SWIGUNUSEDPARM(self), PyObje int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_N_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4462,7 +4959,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_set(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4470,6 +4967,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4485,7 +4983,7 @@ SWIGINTERN PyObject *_wrap_infodata_N_get(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4495,6 +4993,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dt_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4514,7 +5013,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4522,6 +5021,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4537,7 +5037,7 @@ SWIGINTERN PyObject *_wrap_infodata_dt_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4547,6 +5047,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_fov_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4566,7 +5067,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4574,6 +5075,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4589,7 +5091,7 @@ SWIGINTERN PyObject *_wrap_infodata_fov_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4599,6 +5101,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_mjd_f_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4618,7 +5121,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4626,6 +5129,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4641,7 +5145,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_f_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4651,6 +5155,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dm_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4670,7 +5175,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4678,6 +5183,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4693,7 +5199,7 @@ SWIGINTERN PyObject *_wrap_infodata_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4703,6 +5209,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_freq_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4722,7 +5229,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4730,6 +5237,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4745,7 +5253,7 @@ SWIGINTERN PyObject *_wrap_infodata_freq_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4755,6 +5263,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_freqband_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4774,7 +5283,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4782,6 +5291,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4797,7 +5307,7 @@ SWIGINTERN PyObject *_wrap_infodata_freqband_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4807,6 +5317,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_chan_wid_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4826,7 +5337,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4834,6 +5345,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4849,7 +5361,7 @@ SWIGINTERN PyObject *_wrap_infodata_chan_wid_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4859,6 +5371,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_wavelen_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4878,7 +5391,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4886,6 +5399,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4901,7 +5415,7 @@ SWIGINTERN PyObject *_wrap_infodata_wavelen_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4911,6 +5425,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_waveband_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4930,7 +5445,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4938,6 +5453,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -4953,7 +5469,7 @@ SWIGINTERN PyObject *_wrap_infodata_waveband_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -4963,6 +5479,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *SWIGUNUSEDPARM(self), P int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_energy_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -4982,7 +5499,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -4990,6 +5507,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5005,7 +5523,7 @@ SWIGINTERN PyObject *_wrap_infodata_energy_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; double arg2 ; @@ -5015,6 +5533,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_energyband_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5034,7 +5553,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5042,6 +5561,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5057,7 +5577,7 @@ SWIGINTERN PyObject *_wrap_infodata_energyband_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5067,6 +5587,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_num_chan_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5086,7 +5607,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5094,6 +5615,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5109,7 +5631,7 @@ SWIGINTERN PyObject *_wrap_infodata_num_chan_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5119,6 +5641,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_mjd_i_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5138,7 +5661,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5146,6 +5669,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5161,7 +5685,7 @@ SWIGINTERN PyObject *_wrap_infodata_mjd_i_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5171,6 +5695,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_ra_h_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5190,7 +5715,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5198,6 +5723,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5213,7 +5739,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_h_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5223,6 +5749,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_ra_m_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5242,7 +5769,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5250,6 +5777,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5265,7 +5793,7 @@ SWIGINTERN PyObject *_wrap_infodata_ra_m_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5275,6 +5803,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dec_d_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5294,7 +5823,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5302,6 +5831,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5317,7 +5847,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_d_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5327,6 +5857,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_dec_m_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5346,7 +5877,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5354,6 +5885,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5369,7 +5901,7 @@ SWIGINTERN PyObject *_wrap_infodata_dec_m_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5379,6 +5911,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_bary_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5398,7 +5931,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5406,6 +5939,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5421,7 +5955,7 @@ SWIGINTERN PyObject *_wrap_infodata_bary_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; int arg2 ; @@ -5431,6 +5965,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_numonoff_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5450,7 +5985,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5458,6 +5993,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5473,7 +6009,7 @@ SWIGINTERN PyObject *_wrap_infodata_numonoff_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5484,6 +6020,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *SWIGUNUSEDPARM(self), Py int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_notes_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5505,7 +6042,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5513,6 +6050,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5528,7 +6066,7 @@ SWIGINTERN PyObject *_wrap_infodata_notes_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5539,6 +6077,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *SWIGUNUSEDPARM(self), PyO int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_name_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5560,7 +6099,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5568,6 +6107,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5583,7 +6123,7 @@ SWIGINTERN PyObject *_wrap_infodata_name_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5594,6 +6134,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_object_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5615,7 +6156,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5623,6 +6164,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5638,7 +6180,7 @@ SWIGINTERN PyObject *_wrap_infodata_object_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5649,6 +6191,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *SWIGUNUSEDPARM(self int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_instrument_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5670,7 +6213,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5678,6 +6221,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5693,7 +6237,7 @@ SWIGINTERN PyObject *_wrap_infodata_instrument_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5704,6 +6248,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *SWIGUNUSEDPARM(self), int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_observer_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5725,7 +6270,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5733,6 +6278,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5748,7 +6294,7 @@ SWIGINTERN PyObject *_wrap_infodata_observer_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5759,6 +6305,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *SWIGUNUSEDPARM(self), int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_analyzer_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5780,7 +6327,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5788,6 +6335,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5803,7 +6351,7 @@ SWIGINTERN PyObject *_wrap_infodata_analyzer_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5814,6 +6362,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *SWIGUNUSEDPARM(self) int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_telescope_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5835,7 +6384,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5843,6 +6392,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5858,7 +6408,7 @@ SWIGINTERN PyObject *_wrap_infodata_telescope_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5869,6 +6419,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *SWIGUNUSEDPARM(self), PyO int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_band_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5890,7 +6441,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5898,6 +6449,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5913,7 +6465,7 @@ SWIGINTERN PyObject *_wrap_infodata_band_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; char *arg2 = (char *) 0 ; @@ -5924,6 +6476,7 @@ SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *SWIGUNUSEDPARM(self), PyO int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "infodata_filt_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -5945,7 +6498,7 @@ SWIGINTERN PyObject *_wrap_infodata_filt_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; @@ -5953,6 +6506,7 @@ SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -5968,10 +6522,11 @@ SWIGINTERN PyObject *_wrap_infodata_filt_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_new_infodata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_infodata(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_infodata", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -5997,13 +6552,14 @@ SWIGINTERN PyObject *_wrap_new_infodata(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_delete_infodata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_infodata(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct INFODATA *arg1 = (struct INFODATA *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, SWIG_POINTER_DISOWN | 0 ); @@ -6046,7 +6602,7 @@ SWIGINTERN PyObject *infodata_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_readinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_readinf(PyObject *self, PyObject *args) { PyObject *resultobj = 0; infodata *arg1 = (infodata *) 0 ; char *arg2 = (char *) 0 ; @@ -6057,6 +6613,7 @@ SWIGINTERN PyObject *_wrap_readinf(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "readinf", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6078,13 +6635,14 @@ SWIGINTERN PyObject *_wrap_readinf(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_writeinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_writeinf(PyObject *self, PyObject *args) { PyObject *resultobj = 0; infodata *arg1 = (infodata *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_INFODATA, 0 | 0 ); @@ -6100,7 +6658,7 @@ SWIGINTERN PyObject *_wrap_writeinf(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6110,6 +6668,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_p_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6129,7 +6688,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6137,6 +6696,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6152,7 +6712,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6162,6 +6722,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_e_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6181,7 +6742,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6189,6 +6750,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6204,7 +6766,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_e_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6214,6 +6776,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_x_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6233,7 +6796,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6241,6 +6804,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6256,7 +6820,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_x_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6266,6 +6830,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_w_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6285,7 +6850,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6293,6 +6858,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6308,7 +6874,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_w_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6318,6 +6884,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_t_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6337,7 +6904,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6345,6 +6912,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6360,7 +6928,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_t_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6370,6 +6938,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_pd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6389,7 +6958,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6397,6 +6966,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6412,7 +6982,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_pd_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; double arg2 ; @@ -6422,6 +6992,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "orbitparams_wd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6441,7 +7012,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; @@ -6449,6 +7020,7 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, 0 | 0 ); @@ -6464,10 +7036,11 @@ SWIGINTERN PyObject *_wrap_orbitparams_wd_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_orbitparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_orbitparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_orbitparams", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -6493,13 +7066,14 @@ SWIGINTERN PyObject *_wrap_new_orbitparams(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_delete_orbitparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_orbitparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct orbitparams *arg1 = (struct orbitparams *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_orbitparams, SWIG_POINTER_DISOWN | 0 ); @@ -6542,7 +7116,7 @@ SWIGINTERN PyObject *orbitparams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; char *arg2 = (char *) 0 ; @@ -6553,6 +7127,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_jname_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6574,7 +7149,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6582,6 +7157,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6597,7 +7173,7 @@ SWIGINTERN PyObject *_wrap_psrparams_jname_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; char *arg2 = (char *) 0 ; @@ -6608,6 +7184,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_bname_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6629,7 +7206,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6637,6 +7214,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6652,7 +7230,7 @@ SWIGINTERN PyObject *_wrap_psrparams_bname_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; char *arg2 = (char *) 0 ; @@ -6663,6 +7241,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *SWIGUNUSEDPARM(self), P int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_alias_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6684,7 +7263,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_set(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6692,6 +7271,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; char *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6707,7 +7287,7 @@ SWIGINTERN PyObject *_wrap_psrparams_alias_get(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6717,6 +7297,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_ra2000_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6736,7 +7317,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6744,6 +7325,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6759,7 +7341,7 @@ SWIGINTERN PyObject *_wrap_psrparams_ra2000_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6769,6 +7351,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_dec2000_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6788,7 +7371,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6796,6 +7379,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6811,7 +7395,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dec2000_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6821,6 +7405,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_dm_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6840,7 +7425,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6848,6 +7433,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6863,7 +7449,7 @@ SWIGINTERN PyObject *_wrap_psrparams_dm_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6873,6 +7459,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_timepoch_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6892,7 +7479,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6900,6 +7487,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6915,7 +7503,7 @@ SWIGINTERN PyObject *_wrap_psrparams_timepoch_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6925,6 +7513,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_p_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6944,7 +7533,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -6952,6 +7541,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -6967,7 +7557,7 @@ SWIGINTERN PyObject *_wrap_psrparams_p_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -6977,6 +7567,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_pd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -6996,7 +7587,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7004,6 +7595,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7019,7 +7611,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pd_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7029,6 +7621,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_pdd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7048,7 +7641,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7056,6 +7649,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7071,7 +7665,7 @@ SWIGINTERN PyObject *_wrap_psrparams_pdd_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7081,6 +7675,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_f_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7100,7 +7695,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7108,6 +7703,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7123,7 +7719,7 @@ SWIGINTERN PyObject *_wrap_psrparams_f_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7133,6 +7729,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_fd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7152,7 +7749,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7160,6 +7757,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7175,7 +7773,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fd_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; double arg2 ; @@ -7185,6 +7783,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_fdd_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7204,7 +7803,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7212,6 +7811,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7227,7 +7827,7 @@ SWIGINTERN PyObject *_wrap_psrparams_fdd_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; orbitparams *arg2 = (orbitparams *) 0 ; @@ -7237,6 +7837,7 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "psrparams_orb_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7256,7 +7857,7 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; @@ -7264,6 +7865,7 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; orbitparams *result = 0 ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, 0 | 0 ); @@ -7279,10 +7881,11 @@ SWIGINTERN PyObject *_wrap_psrparams_orb_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_new_psrparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_psrparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_psrparams", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -7308,13 +7911,14 @@ SWIGINTERN PyObject *_wrap_new_psrparams(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_delete_psrparams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_psrparams(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct PSRPARAMS *arg1 = (struct PSRPARAMS *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PSRPARAMS, SWIG_POINTER_DISOWN | 0 ); @@ -7357,7 +7961,7 @@ SWIGINTERN PyObject *psrparams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -7372,6 +7976,7 @@ SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_psr_at_epoch", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -7398,7 +8003,7 @@ SWIGINTERN PyObject *_wrap_get_psr_at_epoch(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -7413,6 +8018,7 @@ SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_psr_from_parfile", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -7439,7 +8045,7 @@ SWIGINTERN PyObject *_wrap_get_psr_from_parfile(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; char *arg2 = (char *) 0 ; @@ -7450,6 +8056,7 @@ SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *SWIGUNUSEDPARM(self), PyObje int alloc2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "mjd_to_datestr", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -7471,7 +8078,7 @@ SWIGINTERN PyObject *_wrap_mjd_to_datestr(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_fresnl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fresnl(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double *arg2 = (double *) 0 ; @@ -7487,6 +8094,7 @@ SWIGINTERN PyObject *_wrap_fresnl(PyObject *SWIGUNUSEDPARM(self), PyObject *args arg2 = &temp2; arg3 = &temp3; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -7514,7 +8122,7 @@ SWIGINTERN PyObject *_wrap_fresnl(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7524,6 +8132,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_pow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7543,7 +8152,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7551,6 +8160,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7566,7 +8176,7 @@ SWIGINTERN PyObject *_wrap_rderivs_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7576,6 +8186,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_phs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7595,7 +8206,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7603,6 +8214,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7618,7 +8230,7 @@ SWIGINTERN PyObject *_wrap_rderivs_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7628,6 +8240,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_dpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7647,7 +8260,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7655,6 +8268,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7670,7 +8284,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dpow_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7680,6 +8294,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_dphs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7699,7 +8314,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_set(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7707,6 +8322,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7722,7 +8338,7 @@ SWIGINTERN PyObject *_wrap_rderivs_dphs_get(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7732,6 +8348,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_d2pow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7751,7 +8368,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7759,6 +8376,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7774,7 +8392,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2pow_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7784,6 +8402,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_d2phs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7803,7 +8422,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_set(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7811,6 +8430,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *SWIGUNUSEDPARM(self), PyO PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7826,7 +8446,7 @@ SWIGINTERN PyObject *_wrap_rderivs_d2phs_get(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; double arg2 ; @@ -7836,6 +8456,7 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "rderivs_locpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7855,7 +8476,7 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; @@ -7863,6 +8484,7 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, 0 | 0 ); @@ -7878,10 +8500,11 @@ SWIGINTERN PyObject *_wrap_rderivs_locpow_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_rderivs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_rderivs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_rderivs", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -7907,13 +8530,14 @@ SWIGINTERN PyObject *_wrap_new_rderivs(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_delete_rderivs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_rderivs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct RDERIVS *arg1 = (struct RDERIVS *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDERIVS, SWIG_POINTER_DISOWN | 0 ); @@ -7956,7 +8580,7 @@ SWIGINTERN PyObject *rderivs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; double arg2 ; @@ -7966,6 +8590,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_r_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -7985,7 +8610,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -7993,6 +8618,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8008,7 +8634,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_r_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8018,6 +8644,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_rerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8037,7 +8664,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8045,6 +8672,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8060,7 +8688,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rerr_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; double arg2 ; @@ -8070,6 +8698,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_z_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8089,7 +8718,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8097,6 +8726,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8112,7 +8742,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_z_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8122,6 +8752,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_zerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8141,7 +8772,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8149,6 +8780,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8164,7 +8796,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_zerr_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; double arg2 ; @@ -8174,6 +8806,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_w_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8193,7 +8826,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_set(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8201,6 +8834,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8216,7 +8850,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_w_get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8226,6 +8860,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_werr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8245,7 +8880,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8253,6 +8888,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8268,7 +8904,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_werr_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8278,6 +8914,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_pow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8297,7 +8934,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8305,6 +8942,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8320,7 +8958,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pow_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8330,6 +8968,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_powerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8349,7 +8988,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8357,6 +8996,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8372,7 +9012,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_powerr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8382,6 +9022,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_sig_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8401,7 +9042,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8409,6 +9050,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8424,7 +9066,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_sig_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8434,6 +9076,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_rawpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8453,7 +9096,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8461,6 +9104,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8476,7 +9120,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_rawpow_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8486,6 +9130,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_phs_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8505,7 +9150,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8513,6 +9158,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8528,7 +9174,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phs_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8538,6 +9184,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_phserr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8557,7 +9204,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8565,6 +9212,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8580,7 +9228,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_phserr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8590,6 +9238,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_cen_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8609,7 +9258,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8617,6 +9266,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8632,7 +9282,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cen_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8642,6 +9292,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_cenerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8661,7 +9312,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8669,6 +9320,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8684,7 +9336,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_cenerr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8694,6 +9346,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_pur_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8713,7 +9366,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8721,6 +9374,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8736,7 +9390,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_pur_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8746,6 +9400,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_purerr_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8765,7 +9420,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8773,6 +9428,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8788,7 +9444,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_purerr_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; float arg2 ; @@ -8798,6 +9454,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "fourierprops_locpow_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8817,7 +9474,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_set(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; @@ -8825,6 +9482,7 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *SWIGUNUSEDPARM(self PyObject *swig_obj[1] ; float result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); @@ -8840,10 +9498,11 @@ SWIGINTERN PyObject *_wrap_fourierprops_locpow_get(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_fourierprops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_fourierprops(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_fourierprops", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -8869,13 +9528,14 @@ SWIGINTERN PyObject *_wrap_new_fourierprops(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_delete_fourierprops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_fourierprops(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct FOURIERPROPS *arg1 = (struct FOURIERPROPS *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, SWIG_POINTER_DISOWN | 0 ); @@ -8918,7 +9578,7 @@ SWIGINTERN PyObject *fourierprops_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -8928,6 +9588,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_numdata_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8947,7 +9608,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -8955,6 +9616,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -8970,7 +9632,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numdata_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -8980,6 +9642,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_data_avg_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -8999,7 +9662,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9007,6 +9670,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9022,7 +9686,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_avg_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9032,6 +9696,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_data_var_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9051,7 +9716,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9059,6 +9724,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9074,7 +9740,7 @@ SWIGINTERN PyObject *_wrap_foldstats_data_var_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9084,6 +9750,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_numprof_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9103,7 +9770,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9111,6 +9778,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9126,7 +9794,7 @@ SWIGINTERN PyObject *_wrap_foldstats_numprof_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9136,6 +9804,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_prof_avg_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9155,7 +9824,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9163,6 +9832,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9178,7 +9848,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_avg_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9188,6 +9858,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *SWIGUNUSEDPARM(self) int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_prof_var_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9207,7 +9878,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9215,6 +9886,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *SWIGUNUSEDPARM(self) PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9230,7 +9902,7 @@ SWIGINTERN PyObject *_wrap_foldstats_prof_var_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; double arg2 ; @@ -9240,6 +9912,7 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "foldstats_redchi_set", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -9259,7 +9932,7 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; @@ -9267,6 +9940,7 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, 0 | 0 ); @@ -9282,10 +9956,11 @@ SWIGINTERN PyObject *_wrap_foldstats_redchi_get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_foldstats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_foldstats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *result = 0 ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "new_foldstats", 0, 0, 0)) SWIG_fail; { errno = 0; @@ -9311,13 +9986,14 @@ SWIGINTERN PyObject *_wrap_new_foldstats(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_delete_foldstats(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_foldstats(PyObject *self, PyObject *args) { PyObject *resultobj = 0; struct foldstats *arg1 = (struct foldstats *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_foldstats, SWIG_POINTER_DISOWN | 0 ); @@ -9360,7 +10036,7 @@ SWIGINTERN PyObject *foldstats_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long arg1 ; float **arg2 = (float **) 0 ; @@ -9375,6 +10051,7 @@ SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg2 = &data_temp2; arg3 = &dim_temp2; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); @@ -9429,7 +10106,7 @@ SWIGINTERN PyObject *_wrap_gen_fvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long arg1 ; fcomplex **arg2 = (fcomplex **) 0 ; @@ -9444,6 +10121,7 @@ SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg2 = &data_temp2; arg3 = &dim_temp2; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); @@ -9498,7 +10176,7 @@ SWIGINTERN PyObject *_wrap_gen_cvect(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_power_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_power_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -9514,6 +10192,7 @@ SWIGINTERN PyObject *_wrap_power_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg3 = &data_temp3; arg4 = &dim_temp3; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; { @@ -9571,7 +10250,7 @@ SWIGINTERN PyObject *_wrap_power_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_phase_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_phase_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -9587,6 +10266,7 @@ SWIGINTERN PyObject *_wrap_phase_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg3 = &data_temp3; arg4 = &dim_temp3; } + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; { @@ -9644,7 +10324,7 @@ SWIGINTERN PyObject *_wrap_phase_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_frotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_frotate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; float *arg1 = (float *) 0 ; long arg2 ; @@ -9655,6 +10335,7 @@ SWIGINTERN PyObject *_wrap_frotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "frotate", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_FLOAT); @@ -9693,7 +10374,7 @@ SWIGINTERN PyObject *_wrap_frotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_drotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_drotate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9704,6 +10385,7 @@ SWIGINTERN PyObject *_wrap_drotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "drotate", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9742,7 +10424,7 @@ SWIGINTERN PyObject *_wrap_drotate(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -9759,6 +10441,7 @@ SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *SWIGUNUSEDPARM(self), PyObject PyObject *swig_obj[4] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "keplers_eqn", 4, 4, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -9804,7 +10487,7 @@ SWIGINTERN PyObject *_wrap_keplers_eqn(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9815,6 +10498,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_phib", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9853,7 +10537,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_E_to_v(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_v(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9864,6 +10548,7 @@ SWIGINTERN PyObject *_wrap_E_to_v(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_v", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9902,7 +10587,7 @@ SWIGINTERN PyObject *_wrap_E_to_v(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_E_to_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_p(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9916,6 +10601,7 @@ SWIGINTERN PyObject *_wrap_E_to_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res4 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_p", 3, 3, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -9959,7 +10645,7 @@ SWIGINTERN PyObject *_wrap_E_to_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_E_to_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_z(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -9976,6 +10662,7 @@ SWIGINTERN PyObject *_wrap_E_to_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res5 = 0 ; PyObject *swig_obj[4] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_z", 4, 4, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -10024,7 +10711,7 @@ SWIGINTERN PyObject *_wrap_E_to_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -10035,6 +10722,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "E_to_phib_BT", 2, 2, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -10073,7 +10761,7 @@ SWIGINTERN PyObject *_wrap_E_to_phib_BT(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_dorbint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_dorbint(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double **arg1 = (double **) 0 ; long *arg2 = (long *) 0 ; @@ -10097,6 +10785,7 @@ SWIGINTERN PyObject *_wrap_dorbint(PyObject *SWIGUNUSEDPARM(self), PyObject *arg arg1 = &data_temp1; arg2 = &dim_temp1; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "dorbint", 4, 4, swig_obj)) SWIG_fail; ecode3 = SWIG_AsVal_double(swig_obj[0], &val3); if (!SWIG_IsOK(ecode3)) { @@ -10165,7 +10854,7 @@ SWIGINTERN PyObject *_wrap_dorbint(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; orbitparams *arg2 = (orbitparams *) 0 ; @@ -10183,6 +10872,7 @@ SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *SWIGUNUSEDPARM(self), PyObj arg3 = &temp3; arg4 = &temp4; + (void)self; if (!SWIG_Python_UnpackTuple(args, "binary_velocity", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10230,7 +10920,7 @@ SWIGINTERN PyObject *_wrap_binary_velocity(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; presto_interp_acc arg1 ; int val1 ; @@ -10238,6 +10928,7 @@ SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); @@ -10269,7 +10960,7 @@ SWIGINTERN PyObject *_wrap_r_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; presto_interp_acc arg2 ; @@ -10280,6 +10971,7 @@ SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[2] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "z_resp_halfwidth", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10315,7 +11007,7 @@ SWIGINTERN PyObject *_wrap_z_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -10329,6 +11021,7 @@ SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "w_resp_halfwidth", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10369,7 +11062,7 @@ SWIGINTERN PyObject *_wrap_w_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -10383,6 +11076,7 @@ SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), Py PyObject *swig_obj[3] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "bin_resp_halfwidth", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10423,7 +11117,7 @@ SWIGINTERN PyObject *_wrap_bin_resp_halfwidth(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10444,6 +11138,7 @@ SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *SWIGUNUSEDPARM(self), PyObje arg4 = &data_temp4; arg5 = &dim_temp4; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_r_response", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10507,7 +11202,7 @@ SWIGINTERN PyObject *_wrap_gen_r_response(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10531,6 +11226,7 @@ SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *SWIGUNUSEDPARM(self), PyObje arg5 = &data_temp5; arg6 = &dim_temp5; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_z_response", 4, 4, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10599,7 +11295,7 @@ SWIGINTERN PyObject *_wrap_gen_z_response(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10626,6 +11322,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *SWIGUNUSEDPARM(self), PyObje arg6 = &data_temp6; arg7 = &dim_temp6; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_w_response", 5, 5, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10699,7 +11396,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10726,6 +11423,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *SWIGUNUSEDPARM(self), PyObj arg6 = &data_temp6; arg7 = &dim_temp6; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_w_response2", 5, 5, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10799,7 +11497,7 @@ SWIGINTERN PyObject *_wrap_gen_w_response2(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -10829,6 +11527,7 @@ SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *SWIGUNUSEDPARM(self), PyOb arg7 = &data_temp7; arg8 = &dim_temp7; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "gen_bin_response", 6, 6, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -10907,7 +11606,7 @@ SWIGINTERN PyObject *_wrap_gen_bin_response(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_get_localpower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_localpower(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -10919,6 +11618,7 @@ SWIGINTERN PyObject *_wrap_get_localpower(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[2] ; float result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_localpower", 2, 2, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -10973,7 +11673,7 @@ SWIGINTERN PyObject *_wrap_get_localpower(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -10991,6 +11691,7 @@ SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *SWIGUNUSEDPARM(self), PyOb PyObject *swig_obj[4] ; float result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_localpower3d", 4, 4, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -11055,7 +11756,7 @@ SWIGINTERN PyObject *_wrap_get_localpower3d(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -11080,6 +11781,7 @@ SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *SWIGUNUSEDPARM(self), PyObject int res7 = 0 ; PyObject *swig_obj[7] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_derivs3d", 7, 7, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FCOMPLEX, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -11140,7 +11842,7 @@ SWIGINTERN PyObject *_wrap_get_derivs3d(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_calc_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_calc_props(PyObject *self, PyObject *args) { PyObject *resultobj = 0; rderivs arg1 ; double arg2 ; @@ -11159,6 +11861,7 @@ SWIGINTERN PyObject *_wrap_calc_props(PyObject *SWIGUNUSEDPARM(self), PyObject * int res5 = 0 ; PyObject *swig_obj[5] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "calc_props", 5, 5, swig_obj)) SWIG_fail; { res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RDERIVS, 0 ); @@ -11215,7 +11918,7 @@ SWIGINTERN PyObject *_wrap_calc_props(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fourierprops *arg1 = (fourierprops *) 0 ; double arg2 ; @@ -11234,6 +11937,7 @@ SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *SWIGUNUSEDPARM(self), PyObjec int res5 = 0 ; PyObject *swig_obj[5] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "calc_binprops", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -11284,7 +11988,7 @@ SWIGINTERN PyObject *_wrap_calc_binprops(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fourierprops *arg1 = (fourierprops *) 0 ; double arg2 ; @@ -11297,6 +12001,7 @@ SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "calc_rzwerrs", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -11337,7 +12042,7 @@ SWIGINTERN PyObject *_wrap_calc_rzwerrs(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -11345,6 +12050,7 @@ SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *SWIGUNUSEDPAR PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -11376,7 +12082,7 @@ SWIGINTERN PyObject *_wrap_extended_equiv_gaussian_sigma(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11387,6 +12093,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *SWIGUNUSEDPA PyObject *swig_obj[2] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "log_asymtotic_incomplete_gamma", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11422,7 +12129,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_incomplete_gamma(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -11430,6 +12137,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *SWIGUNUSEDPARM(self), P PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -11461,7 +12169,7 @@ SWIGINTERN PyObject *_wrap_log_asymtotic_gamma(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -11469,6 +12177,7 @@ SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *SWIGUNUSEDPARM(se PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -11500,7 +12209,7 @@ SWIGINTERN PyObject *_wrap_equivalent_gaussian_sigma(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11511,6 +12220,7 @@ SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *SWIGUNUSEDPARM(self), PyObject *a PyObject *swig_obj[2] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "chi2_logp", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11546,7 +12256,7 @@ SWIGINTERN PyObject *_wrap_chi2_logp(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11557,6 +12267,7 @@ SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *swig_obj[2] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "chi2_sigma", 2, 2, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11592,7 +12303,7 @@ SWIGINTERN PyObject *_wrap_chi2_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -11606,6 +12317,7 @@ SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "candidate_sigma", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11646,7 +12358,7 @@ SWIGINTERN PyObject *_wrap_candidate_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -11660,6 +12372,7 @@ SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "power_for_sigma", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11700,7 +12413,7 @@ SWIGINTERN PyObject *_wrap_power_for_sigma(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -11725,6 +12438,7 @@ SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *SWIGUNUSEDPARM(self), PyObje arg4 = &temp4; arg5 = &temp5; arg6 = &temp6; + (void)self; if (!SWIG_Python_UnpackTuple(args, "switch_f_and_p", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -11783,7 +12497,7 @@ SWIGINTERN PyObject *_wrap_switch_f_and_p(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_chisqr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_chisqr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -11798,6 +12512,7 @@ SWIGINTERN PyObject *_wrap_chisqr(PyObject *SWIGUNUSEDPARM(self), PyObject *args PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "chisqr", 3, 3, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -11857,7 +12572,7 @@ SWIGINTERN PyObject *_wrap_chisqr(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_z2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_z2n(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -11872,6 +12587,7 @@ SWIGINTERN PyObject *_wrap_z2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "z2n", 3, 3, swig_obj)) SWIG_fail; { npy_intp size[1] = { @@ -11931,7 +12647,7 @@ SWIGINTERN PyObject *_wrap_z2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { } -SWIGINTERN PyObject *_wrap_print_candidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_print_candidate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fourierprops *arg1 = (fourierprops *) 0 ; double arg2 ; @@ -11950,6 +12666,7 @@ SWIGINTERN PyObject *_wrap_print_candidate(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode5 = 0 ; PyObject *swig_obj[5] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "print_candidate", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FOURIERPROPS, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12000,7 +12717,7 @@ SWIGINTERN PyObject *_wrap_print_candidate(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *self, PyObject *args) { PyObject *resultobj = 0; binaryprops *arg1 = (binaryprops *) 0 ; int arg2 ; @@ -12010,6 +12727,7 @@ SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *SWIGUNUSEDPARM(self), P int ecode2 = 0 ; PyObject *swig_obj[2] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "print_bin_candidate", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_binaryprops, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12045,7 +12763,7 @@ SWIGINTERN PyObject *_wrap_print_bin_candidate(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; FILE *arg1 = (FILE *) 0 ; fourierprops *arg2 = (fourierprops *) 0 ; @@ -12056,6 +12774,7 @@ SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[2] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "read_rzw_cand", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12091,7 +12810,7 @@ SWIGINTERN PyObject *_wrap_read_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; @@ -12105,6 +12824,7 @@ SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_rzw_cand", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -12147,7 +12867,7 @@ SWIGINTERN PyObject *_wrap_get_rzw_cand(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; FILE *arg1 = (FILE *) 0 ; binaryprops *arg2 = (binaryprops *) 0 ; @@ -12158,6 +12878,7 @@ SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[2] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "read_bin_cand", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -12193,7 +12914,7 @@ SWIGINTERN PyObject *_wrap_read_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; @@ -12207,6 +12928,7 @@ SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; PyObject *swig_obj[3] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "get_bin_cand", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -12249,7 +12971,7 @@ SWIGINTERN PyObject *_wrap_get_bin_cand(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -12257,6 +12979,7 @@ SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *swig_obj[1] ; long long result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -12288,7 +13011,7 @@ SWIGINTERN PyObject *_wrap_next2_to_n(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -12296,6 +13019,7 @@ SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *swig_obj[1] ; int result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -12327,7 +13051,7 @@ SWIGINTERN PyObject *_wrap_is_power_of_10(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *self, PyObject *args) { PyObject *resultobj = 0; long long arg1 ; long long val1 ; @@ -12335,6 +13059,7 @@ SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[1] ; long long result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); @@ -12366,7 +13091,7 @@ SWIGINTERN PyObject *_wrap_choose_good_N(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_dms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_dms2rad(PyObject *self, PyObject *args) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -12380,6 +13105,7 @@ SWIGINTERN PyObject *_wrap_dms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "dms2rad", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -12420,7 +13146,7 @@ SWIGINTERN PyObject *_wrap_dms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_hms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_hms2rad(PyObject *self, PyObject *args) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -12434,6 +13160,7 @@ SWIGINTERN PyObject *_wrap_hms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg PyObject *swig_obj[3] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "hms2rad", 3, 3, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -12474,7 +13201,7 @@ SWIGINTERN PyObject *_wrap_hms2rad(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_hours2hms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_hours2hms(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int *arg2 = (int *) 0 ; @@ -12493,6 +13220,7 @@ SWIGINTERN PyObject *_wrap_hours2hms(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg2 = &temp2; arg3 = &temp3; arg4 = &temp4; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -12542,7 +13270,7 @@ SWIGINTERN PyObject *_wrap_hours2hms(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_deg2dms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_deg2dms(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; int *arg2 = (int *) 0 ; @@ -12561,6 +13289,7 @@ SWIGINTERN PyObject *_wrap_deg2dms(PyObject *SWIGUNUSEDPARM(self), PyObject *arg arg2 = &temp2; arg3 = &temp3; arg4 = &temp4; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -12610,7 +13339,7 @@ SWIGINTERN PyObject *_wrap_deg2dms(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -12627,6 +13356,7 @@ SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *swig_obj[4] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "sphere_ang_diff", 4, 4, swig_obj)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { @@ -12672,7 +13402,7 @@ SWIGINTERN PyObject *_wrap_sphere_ang_diff(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -12712,6 +13442,7 @@ SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *SWIGUNUSEDPARM(self), PyObjec arg11 = &dim1_temp10; arg12 = &dim2_temp10; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "corr_rz_plane", 8, 8, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -12803,7 +13534,7 @@ SWIGINTERN PyObject *_wrap_corr_rz_plane(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -12855,6 +13586,7 @@ SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *SWIGUNUSEDPARM(self), PyObject arg15 = &dim2_temp13; arg16 = &dim3_temp13; } + (void)self; if (!SWIG_Python_UnpackTuple(args, "corr_rzw_vol", 11, 11, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -12961,7 +13693,7 @@ SWIGINTERN PyObject *_wrap_corr_rzw_vol(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -12983,6 +13715,7 @@ SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a arg5 = &temp5; arg6 = &temp6; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_r_arr", 3, 3, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13038,7 +13771,7 @@ SWIGINTERN PyObject *_wrap_max_r_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13067,6 +13800,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *SWIGUNUSEDPARM(self), PyObject * arg6 = &temp6; arg7 = &temp7; arg8 = &temp8; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rz_arr", 4, 4, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13133,7 +13867,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13159,6 +13893,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), arg7 = &temp7; arg8 = &temp8; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rz_arr_harmonics", 4, 4, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13222,7 +13957,7 @@ SWIGINTERN PyObject *_wrap_max_rz_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13255,6 +13990,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), arg8 = &temp8; arg9 = &temp9; arg10 = &temp10; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rzw_arr_harmonics", 5, 5, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13329,7 +14065,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr_harmonics(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; fcomplex *arg1 = (fcomplex *) 0 ; long arg2 ; @@ -13365,6 +14101,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *SWIGUNUSEDPARM(self), PyObject arg8 = &temp8; arg9 = &temp9; arg10 = &temp10; + (void)self; if (!SWIG_Python_UnpackTuple(args, "max_rzw_arr", 5, 5, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_CFLOAT); @@ -13442,7 +14179,7 @@ SWIGINTERN PyObject *_wrap_max_rzw_arr(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_barycenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_barycenter(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; long arg2 ; @@ -13474,6 +14211,7 @@ SWIGINTERN PyObject *_wrap_barycenter(PyObject *SWIGUNUSEDPARM(self), PyObject * int alloc10 = 0 ; PyObject *swig_obj[7] ; + (void)self; if (!SWIG_Python_UnpackTuple(args, "barycenter", 7, 7, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_DOUBLE); @@ -13551,7 +14289,7 @@ SWIGINTERN PyObject *_wrap_barycenter(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *self, PyObject *args) { PyObject *resultobj = 0; double arg1 ; double val1 ; @@ -13559,6 +14297,7 @@ SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *SWIGUNUSEDPARM(self), PyObject *ar PyObject *swig_obj[1] ; double result; + (void)self; if (!args) SWIG_fail; swig_obj[0] = args; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); @@ -13590,7 +14329,7 @@ SWIGINTERN PyObject *_wrap_DOF_corr(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_simplefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_simplefold(PyObject *self, PyObject *args) { PyObject *resultobj = 0; float *arg1 = (float *) 0 ; long arg2 ; @@ -13624,6 +14363,7 @@ SWIGINTERN PyObject *_wrap_simplefold(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *swig_obj[9] ; double result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "simplefold", 9, 9, swig_obj)) SWIG_fail; { array1 = obj_to_array_no_conversion(swig_obj[0], NPY_FLOAT); @@ -13700,7 +14440,7 @@ SWIGINTERN PyObject *_wrap_simplefold(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -13718,6 +14458,7 @@ SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[4] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "nice_output_1", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -13765,7 +14506,7 @@ SWIGINTERN PyObject *_wrap_nice_output_1(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *self, PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; double arg2 ; @@ -13783,6 +14524,7 @@ SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *swig_obj[4] ; int result; + (void)self; if (!SWIG_Python_UnpackTuple(args, "nice_output_2", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { @@ -13831,7 +14573,6 @@ SWIGINTERN PyObject *_wrap_nice_output_2(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { - { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "fcomplex_r_set", _wrap_fcomplex_r_set, METH_VARARGS, NULL}, { "fcomplex_r_get", _wrap_fcomplex_r_get, METH_O, NULL}, { "fcomplex_i_set", _wrap_fcomplex_i_set, METH_VARARGS, NULL}, @@ -14110,35 +14851,31 @@ static PyMethodDef SwigMethods[] = { { NULL, NULL, 0, NULL } }; -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; - /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_FCOMPLEX = {"_p_FCOMPLEX", "fcomplex *|struct FCOMPLEX *|FCOMPLEX *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_FOURIERPROPS = {"_p_FOURIERPROPS", "struct FOURIERPROPS *|FOURIERPROPS *|fourierprops *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_FOURIERPROPS = {"_p_FOURIERPROPS", "fourierprops *|struct FOURIERPROPS *|FOURIERPROPS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_INFODATA = {"_p_INFODATA", "infodata *|struct INFODATA *|INFODATA *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PSRPARAMS = {"_p_PSRPARAMS", "psrparams *|struct PSRPARAMS *|PSRPARAMS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_RDERIVS = {"_p_RDERIVS", "rderivs *|struct RDERIVS *|RDERIVS *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_binaryprops = {"_p_binaryprops", "binaryprops *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_foldstats = {"_p_foldstats", "struct foldstats *|foldstats *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_foldstats = {"_p_foldstats", "foldstats *|struct foldstats *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_orbitparams = {"_p_orbitparams", "struct orbitparams *|orbitparams *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_p_FCOMPLEX = {"_p_p_FCOMPLEX", "struct FCOMPLEX **|fcomplex **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_orbitparams = {"_p_orbitparams", "orbitparams *|struct orbitparams *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_FCOMPLEX = {"_p_p_FCOMPLEX", "fcomplex **|struct FCOMPLEX **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_checkaliased = {"_p_presto_checkaliased", "enum presto_checkaliased *|presto_checkaliased *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_datainf = {"_p_presto_datainf", "enum presto_datainf *|presto_datainf *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_ffts = {"_p_presto_ffts", "enum presto_ffts *|presto_ffts *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_interp_acc = {"_p_presto_interp_acc", "enum presto_interp_acc *|presto_interp_acc *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_interptype = {"_p_presto_interptype", "enum presto_interptype *|presto_interptype *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_presto_optype = {"_p_presto_optype", "enum presto_optype *|presto_optype *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_checkaliased = {"_p_presto_checkaliased", "presto_checkaliased *|enum presto_checkaliased *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_datainf = {"_p_presto_datainf", "presto_datainf *|enum presto_datainf *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_ffts = {"_p_presto_ffts", "presto_ffts *|enum presto_ffts *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_interp_acc = {"_p_presto_interp_acc", "presto_interp_acc *|enum presto_interp_acc *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_interptype = {"_p_presto_interptype", "presto_interptype *|enum presto_interptype *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_presto_optype = {"_p_presto_optype", "presto_optype *|enum presto_optype *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_rzwerrs = {"_p_rzwerrs", "rzwerrs *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { @@ -14466,220 +15203,6 @@ SWIG_PropagateClientData(void) { extern "C" { #endif - /* Python-specific SWIG API */ -#define SWIG_newvarlink() SWIG_Python_newvarlink() -#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) -#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) - - /* ----------------------------------------------------------------------------- - * global variable support code. - * ----------------------------------------------------------------------------- */ - - typedef struct swig_globalvar { - char *name; /* Name of global variable */ - PyObject *(*get_attr)(void); /* Return the current value */ - int (*set_attr)(PyObject *); /* Set the value */ - struct swig_globalvar *next; - } swig_globalvar; - - typedef struct swig_varlinkobject { - PyObject_HEAD - swig_globalvar *vars; - } swig_varlinkobject; - - SWIGINTERN PyObject * - swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { -#if PY_VERSION_HEX >= 0x03000000 - return PyUnicode_InternFromString(""); -#else - return PyString_FromString(""); -#endif - } - - SWIGINTERN PyObject * - swig_varlink_str(swig_varlinkobject *v) { -#if PY_VERSION_HEX >= 0x03000000 - PyObject *str = PyUnicode_InternFromString("("); - PyObject *tail; - PyObject *joined; - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - tail = PyUnicode_FromString(var->name); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - if (var->next) { - tail = PyUnicode_InternFromString(", "); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - } - } - tail = PyUnicode_InternFromString(")"); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; -#else - PyObject *str = PyString_FromString("("); - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - PyString_ConcatAndDel(&str,PyString_FromString(var->name)); - if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); - } - PyString_ConcatAndDel(&str,PyString_FromString(")")); -#endif - return str; - } - - SWIGINTERN void - swig_varlink_dealloc(swig_varlinkobject *v) { - swig_globalvar *var = v->vars; - while (var) { - swig_globalvar *n = var->next; - free(var->name); - free(var); - var = n; - } - } - - SWIGINTERN PyObject * - swig_varlink_getattr(swig_varlinkobject *v, char *n) { - PyObject *res = NULL; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->get_attr)(); - break; - } - var = var->next; - } - if (res == NULL && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN int - swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { - int res = 1; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->set_attr)(p); - break; - } - var = var->next; - } - if (res == 1 && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN PyTypeObject* - swig_varlink_type(void) { - static char varlink__doc__[] = "Swig var link object"; - static PyTypeObject varlink_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { -#if PY_VERSION_HEX >= 0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) -#else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - "swigvarlink", /* tp_name */ - sizeof(swig_varlinkobject), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor) swig_varlink_dealloc, /* tp_dealloc */ - 0, /* tp_print */ - (getattrfunc) swig_varlink_getattr, /* tp_getattr */ - (setattrfunc) swig_varlink_setattr, /* tp_setattr */ - 0, /* tp_compare */ - (reprfunc) swig_varlink_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - (reprfunc) swig_varlink_str, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - 0, /* tp_flags */ - varlink__doc__, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ - 0, /* tp_del */ - 0, /* tp_version_tag */ -#if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ -#endif -#if PY_VERSION_HEX >= 0x03080000 - 0, /* tp_vectorcall */ -#endif -#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) - 0, /* tp_print */ -#endif -#ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ - 0, /* tp_prev */ - 0 /* tp_next */ -#endif - }; - varlink_type = tmp; - type_init = 1; - if (PyType_Ready(&varlink_type) < 0) - return NULL; - } - return &varlink_type; - } - - /* Create a variable linking object for use later */ - SWIGINTERN PyObject * - SWIG_Python_newvarlink(void) { - swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); - if (result) { - result->vars = 0; - } - return ((PyObject*) result); - } - - SWIGINTERN void - SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { - swig_varlinkobject *v = (swig_varlinkobject *) p; - swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); - if (gv) { - size_t size = strlen(name)+1; - gv->name = (char *)malloc(size); - if (gv->name) { - memcpy(gv->name, name, size); - gv->get_attr = get_attr; - gv->set_attr = set_attr; - gv->next = v->vars; - } - } - v->vars = gv; - } - - SWIGINTERN PyObject * - SWIG_globals(void) { - static PyObject *globals = 0; - if (!globals) { - globals = SWIG_newvarlink(); - } - return globals; - } - /* ----------------------------------------------------------------------------- * constants/methods manipulation * ----------------------------------------------------------------------------- */ @@ -14703,20 +15226,17 @@ extern "C" { } if (obj) { PyDict_SetItemString(d, constants[i].name, obj); - Py_DECREF(obj); + SWIG_Py_DECREF(obj); } } } - /* -----------------------------------------------------------------------------*/ - /* Fix SwigMethods to carry the callback ptrs when needed */ - /* -----------------------------------------------------------------------------*/ + /* ----------------------------------------------------------------------------- + * Patch %callback methods' docstrings to hold the callback ptrs + * -----------------------------------------------------------------------------*/ SWIGINTERN void - SWIG_Python_FixMethods(PyMethodDef *methods, - swig_const_info *const_table, - swig_type_info **types, - swig_type_info **types_initial) { + SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) { size_t i; for (i = 0; methods[i].ml_name; ++i) { const char *c = methods[i].ml_doc; @@ -14724,7 +15244,7 @@ extern "C" { c = strstr(c, "swig_ptr: "); if (c) { int j; - swig_const_info *ci = 0; + const swig_const_info *ci = 0; const char *name = c + 10; for (j = 0; const_table[j].type; ++j) { if (strncmp(const_table[j].name, name, @@ -14756,68 +15276,13 @@ extern "C" { } } - /* ----------------------------------------------------------------------------- - * Method creation and docstring support functions - * ----------------------------------------------------------------------------- */ - - /* ----------------------------------------------------------------------------- - * Function to find the method definition with the correct docstring for the - * proxy module as opposed to the low-level API - * ----------------------------------------------------------------------------- */ - - SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { - /* Find the function in the modified method table */ - size_t offset = 0; - int found = 0; - while (SwigMethods_proxydocs[offset].ml_meth != NULL) { - if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { - found = 1; - break; - } - offset++; - } - /* Use the copy with the modified docstring if available */ - return found ? &SwigMethods_proxydocs[offset] : NULL; - } - - /* ----------------------------------------------------------------------------- - * Wrapper of PyInstanceMethod_New() used in Python 3 - * It is exported to the generated module, used for -fastproxy - * ----------------------------------------------------------------------------- */ - - SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { - if (PyCFunction_Check(func)) { - PyCFunctionObject *funcobj = (PyCFunctionObject *)func; - PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); - if (ml) - func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); - } -#if PY_VERSION_HEX >= 0x03000000 - return PyInstanceMethod_New(func); -#else - return PyMethod_New(func, NULL, NULL); -#endif - } - - /* ----------------------------------------------------------------------------- - * Wrapper of PyStaticMethod_New() - * It is exported to the generated module, used for -fastproxy - * ----------------------------------------------------------------------------- */ - - SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { - if (PyCFunction_Check(func)) { - PyCFunctionObject *funcobj = (PyCFunctionObject *)func; - PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); - if (ml) - func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); - } - return PyStaticMethod_New(func); - } - #ifdef __cplusplus } #endif + + + /* -----------------------------------------------------------------------------* * Partial Init method * -----------------------------------------------------------------------------*/ @@ -14944,7 +15409,7 @@ SWIG_init(void) { (void)public_symbol; PyDict_SetItemString(md, "__all__", public_interface); - Py_DECREF(public_interface); + SWIG_Py_DECREF(public_interface); for (i = 0; SwigMethods[i].ml_name != NULL; ++i) SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); for (i = 0; swig_const_table[i].name != 0; ++i) diff --git a/setup.py b/setup.py deleted file mode 100644 index 6d353fc4a..000000000 --- a/setup.py +++ /dev/null @@ -1,94 +0,0 @@ -from __future__ import print_function -import os -import sys -import numpy - -# setuptools has to be imported before numpy.distutils.core -import setuptools -from numpy.distutils.core import Extension, setup - -version = "4.0" - -define_macros = [] -undef_macros = [] -extra_compile_args = ["-DUSEFFTW"] -include_dirs = [numpy.get_include()] -# For MacOS with MacPorts use the following -# include_dirs.append("/opt/local/include") - -# Note: you might need to add "gfortran" to the following list if -# you see errors relating to missing "g" functions.... -ppgplot_libraries = ["cpgplot", "pgplot", "X11", "png", "m"] -ppgplot_library_dirs = ["/usr/X11R6/lib"] - -presto_libraries = ["presto", "fftw3f", "m"] -presto_library_dirs = [] - -ppgplot_include_dirs = include_dirs -presto_include_dirs = include_dirs -undef_macros.append('USE_NUMARRAY') - -if os.name != "posix": - raise Exception("os not supported") - -if "PGPLOT_DIR" in os.environ: - ppgplot_library_dirs.append(os.environ["PGPLOT_DIR"]) - ppgplot_include_dirs.append(os.environ["PGPLOT_DIR"]) -else: - print("PGPLOT_DIR env var not defined!", file=sys.stderr) -if "PRESTO" in os.environ: - presto_library_dirs.append(os.path.join(os.environ["PRESTO"], "lib")) - presto_include_dirs.append(os.path.join(os.environ["PRESTO"], "include")) - extra_link_args = ["-Wl,-rpath,"+os.path.join(os.environ["PRESTO"], "lib")] -else: - print("PRESTO env var not defined!", file=sys.stderr) - presto_include_dirs.append(os.path.join(os.path.dirname(__file__), - 'include')) - extra_link_args = ["-Wl,-rpath,"+os.path.join(os.path.dirname(__file__), - "lib")] - -ext_ppgplot = Extension('_ppgplot', - ['python/ppgplot_src/_ppgplot.c'], - include_dirs=ppgplot_include_dirs, - libraries=ppgplot_libraries, - library_dirs=ppgplot_library_dirs, - define_macros=define_macros, - extra_compile_args=extra_compile_args, - extra_link_args=extra_link_args) - -ext_presto = Extension('_presto', - ['python/presto_src/presto_wrap.c'], - include_dirs=presto_include_dirs, - libraries=presto_libraries, - library_dirs=presto_library_dirs, - define_macros=define_macros, - extra_compile_args=extra_compile_args, - extra_link_args=extra_link_args) - -ext_fftfit = Extension('_fftfit', sources=['python/fftfit_src/brent.f', - 'python/fftfit_src/cprof.f', - 'python/fftfit_src/fccf.f', - 'python/fftfit_src/ffft.f', - 'python/fftfit_src/fftfit.f', - 'python/fftfit_src/_fftfit.pyf']) - - -scripts = ['bin/' + i for i in os.listdir('bin') if i.endswith('.py') or i.endswith('.sh')] - - -setup(name="presto", - version=version, - install_requires=['numpy', 'future', 'six', 'scipy', 'matplotlib', 'astropy', 'pyslalib'], - scripts=scripts, - description="Python interfaces to PGPLOT and PRESTO", - author="Scott Ransom (ppgplot from Nick Patavlis)", - author_email="sransom@nrao.edu", - url="https://github.com/scottransom/presto", - packages=['presto', 'presto.ppgplot', 'presto.presto', 'presto.singlepulse'], - package_dir={'presto.ppgplot': 'python/ppgplot_src', - 'presto.presto': 'python/presto_src', - 'presto': 'python/presto', - 'presto.singlepulse': 'python/presto/singlepulse', - }, - package_data={'presto': ['*.json']}, - ext_modules=[ext_ppgplot, ext_presto, ext_fftfit]) diff --git a/src/GBT350filterbank.c b/src/GBT350filterbank.c deleted file mode 100644 index 9344ff9b8..000000000 --- a/src/GBT350filterbank.c +++ /dev/null @@ -1,177 +0,0 @@ -#include "presto.h" -#include "mask.h" -#include "spigot.h" -#include "sigproc_fb.h" -#include "fitsfile.h" -#include "fitshead.h" - -void spigot2sigprocfb(SPIGOT_INFO * spigot, sigprocfb * fb, char *filenmbase) -{ - int h_or_d, m; - double s; - char *path, *filenm; - - split_path_file(filenmbase, &path, &filenm); - strncpy(fb->inpfile, filenm, 40); - strncpy(fb->source_name, spigot->object, 80); - fb->nifs = 1; - if (spigot->num_samplers == 1) - strncpy(fb->ifstream, "YXXX", 8); - else if (spigot->num_samplers == 2) - strncpy(fb->ifstream, "YYXX", 8); - fb->tstart = spigot->MJD_obs + spigot->elapsed_time / SECPERDAY; - fb->tsamp = spigot->dt_us / 1e6; - hours2hms(spigot->ra / 15.0, &h_or_d, &m, &s); - fb->src_raj = h_or_d * 10000.0 + m * 100.0 + s; - deg2dms(spigot->dec, &h_or_d, &m, &s); - if (h_or_d < 0) { - h_or_d = abs(h_or_d); - fb->src_dej = h_or_d * 10000.0 + m * 100.0 + s; - fb->src_dej *= -1.0; - } else { - fb->src_dej = h_or_d * 10000.0 + m * 100.0 + s; - } - fb->az_start = 0.0; - fb->za_start = 0.0; - fb->nchans = spigot->lags_per_sample; - fb->foff = spigot->bandwidth / fb->nchans; - fb->fch1 = spigot->freq_ctr + (fb->nchans / 2 - 0.5) * fb->foff; - fb->foff = -fb->foff; - fb->machine_id = 7; - fb->telescope_id = 6; - fb->nbits = 8; - fb->sumifs = spigot->summed_pols; - if (fb->sumifs) - fb->nifs = 1; - else { - if (spigot->num_samplers == 2) - fb->nifs = 2; - else - fb->nifs = 1; - } - - /* The following are not necessary for writing filterbank files */ - fb->headerlen = 0; - fb->N = spigot->samples_per_file; - free(path); - free(filenm); -} - - -int main(int argc, char *argv[]) -{ - FILE **infiles, *outfile = NULL, *offsetfile = NULL; - int filenum, argnum = 1, ii = 0, ptsperblock, numlags, numfiles; - int bytes_per_read, offset = 0, numoffsets, output = 1; - long long N; - char *path, *filenm; - char outfilenm[200], filenmbase[200], offsetnm[200], rawlags[4096]; - unsigned char output_samples[2048]; - float *offsets = NULL; - double dt, T; - SPIGOT_INFO *spigots; - sigprocfb fb; - infodata idata; - - if (argc == 1) { - fprintf(stderr, "Usage: GBT350filterbank SPIGOT_fits_files\n"); - exit(0); - } - - /* Determine the filename base in order to read the offsets */ - strncpy(filenmbase, argv[argnum], strlen(argv[argnum]) - 10); - filenmbase[strlen(argv[argnum]) - 10] = '\0'; - - /* Attempt to read a file with lag offsets in it */ - - /* First try the same path as the input file */ - sprintf(offsetnm, "%s.offset", filenmbase); - offsetfile = fopen(offsetnm, "rb"); - if (!offsetfile) { - /* Now try the current working directory */ - split_path_file(filenmbase, &path, &filenm); - sprintf(offsetnm, "%s.offset", filenm); - offsetfile = fopen(offsetnm, "rb"); - free(path); - free(filenm); - } - if (offsetfile) { - /* Determine the length of the file */ - numoffsets = (int) chkfilelen(offsetfile, sizeof(float)); - /* Create the array and read 'em */ - offsets = gen_fvect(numoffsets); - chkfread(offsets, sizeof(float), numoffsets, offsetfile); - offset = 1; - /* close the offset file */ - fclose(offsetfile); - printf("Offseting the spectra with the %d values found in '%s'\n\n", - numoffsets, offsetnm); - } - - /* Read and convert the basic SPIGOT file information */ - - numfiles = argc - 1; - printf("Spigot card input file information:\n"); - spigots = (SPIGOT_INFO *) malloc(sizeof(SPIGOT_INFO) * numfiles); - infiles = (FILE **) malloc(sizeof(FILE *) * numfiles); - for (filenum = 0; filenum < numfiles; filenum++, argnum++) { - printf(" '%s'\n", argv[argnum]); - infiles[filenum] = chkfopen(argv[argnum], "rb"); - read_SPIGOT_header(argv[argnum], spigots + filenum); - rewind(infiles[filenum]); - } - printf("\n"); - - /* The following is necessary in order to initialize all the */ - /* static variables in spigot.c */ - get_SPIGOT_file_info(infiles, spigots, numfiles, 0, 0, &N, - &ptsperblock, &numlags, &dt, &T, &idata, output); - spigot2sigprocfb(&(spigots[0]), &fb, filenmbase); - fb.N = N; - free(spigots); - - /* Determine the output file name */ - sprintf(outfilenm, "GBT350_%s_%.0f_%04d.fil", - spigots[0].object, floor(spigots[0].MJD_obs), spigots[0].scan_number); - printf("Writing data to file '%s'.\n\n", outfilenm); - - /* Write the header */ - outfile = chkfopen(outfilenm, "wb"); - write_filterbank_header(&fb, outfile); - - /* Step through the SPIGOT files */ - ii = 0; - for (filenum = 0, argnum = 1; filenum < numfiles; filenum++, argnum++) { - printf("Reading from file '%s'...\n", argv[argnum]); - chkfseek(infiles[filenum], spigots[0].header_len, SEEK_SET); - bytes_per_read = spigots[0].lags_per_sample * spigots[0].bits_per_lag / 8; - - /* Loop over the samples in the file */ - while (chkfread(rawlags, bytes_per_read, 1, infiles[filenum])) { - if (offset) - convert_SPIGOT_point(rawlags, output_samples, SUMIFS, offsets[ii]); - else - convert_SPIGOT_point(rawlags, output_samples, SUMIFS, 1.0); - ii++; - /* Invert the band so that the high freqs are first */ - /* This is how SIGPROC stores its data. */ - { - int jj; - unsigned char tempzz = 0.0, *loptr, *hiptr; - loptr = output_samples + 0; - hiptr = output_samples + fb.nchans - 1; - for (jj = 0; jj < fb.nchans / 2; jj++, loptr++, hiptr--) { - SWAP(*loptr, *hiptr); - } - } - chkfwrite(output_samples, sizeof(unsigned char), fb.nchans, outfile); - } - fclose(infiles[filenum]); - } - if (offset) - vect_free(offsets); - fclose(outfile); - printf("Converted and wrote %d samples.\n\n", ii); - free(infiles); - return 0; -} diff --git a/src/Makefile b/src/Makefile index 07ff787ce..4cfbec8ce 100644 --- a/src/Makefile +++ b/src/Makefile @@ -156,7 +156,7 @@ BINARIES = makedata makeinf mjd2cal realfft quicklook\ rfifind zapbirds explorefft exploredat\ weight_psrfits fitsdelrow fitsdelcol psrfits_dumparrays -all: libpresto slalib binaries +all: libpresto binaries # Default indentation is K&R style with no-tabs, # an indentation level of 4 (default), and a line-length of 85 @@ -182,15 +182,6 @@ libpresto: libpresto$(LIBSUFFIX) libpresto$(LIBSUFFIX): $(PRESTOOBJS) $(LINKCOMMAND) $(PRESTO)/lib/$@ $(PRESTOOBJS) -slalib: libsla$(LIBSUFFIX) - cd slalib ; $(FC) -o sla_test sla_test.f -fno-second-underscore -L$(PRESTO)/lib -lsla - slalib/sla_test - -libsla$(LIBSUFFIX): - cd slalib ; $(FC) $(FFLAGS) -fno-second-underscore -c -I. *.f *.F - rm slalib/sla_test.o - cd slalib ; $(FC) $(LIBCMD) -o $(PRESTO)/lib/libsla$(LIBSUFFIX) -fno-second-underscore *.o - binaries: $(BINARIES) mpi: mpiprepsubband @@ -249,18 +240,6 @@ prepsubband: prepsubband_cmd.c prepsubband_cmd.o prepsubband.o $(INSTRUMENTOBJS) prepfold: prepfold_cmd.c prepfold_cmd.o prepfold.o prepfold_utils.o prepfold_plot.o least_squares.o polycos.o readpar.o $(INSTRUMENTOBJS) $(PLOT2DOBJS) libpresto $(FC) $(FLINKFLAGS) -o $(PRESTO)/bin/$@ prepfold.o prepfold_utils.o prepfold_plot.o prepfold_cmd.o least_squares.o polycos.o readpar.o $(PLOT2DOBJS) $(INSTRUMENTOBJS) $(LAPACKLINK) $(PRESTOLINK) $(PGPLOTLINK) -lcfitsio -lm -dump_spigot_zerolag: dump_spigot_zerolag.o spigot.o libpresto - $(CC) $(CLINKFLAGS) -o $(PRESTO)/bin/$@ dump_spigot_zerolag.o spigot.o $(PRESTOLINK) -lm - -spigot2filterbank: spigot2filterbank_cmd.c spigot2filterbank_cmd.o spigot2filterbank.o spigot.o sigproc_fb.o sla.o libpresto - $(CC) $(CLINKFLAGS) -o $(PRESTO)/bin/$@ spigot2filterbank.o spigot.o sigproc_fb.o spigot2filterbank_cmd.o sla.o $(PRESTOLINK) -lsla -lm - -GBT350filterbank: GBT350filterbank.o spigot.o sigproc_fb.o libpresto - $(CC) $(CLINKFLAGS) -o $(PRESTO)/bin/$@ GBT350filterbank.o spigot.o sigproc_fb.o $(PRESTOLINK) -lm - -spigotSband2filterbank: spigotSband2filterbank.o spigot.o sigproc_fb.o libpresto - $(CC) $(CLINKFLAGS) -o $(PRESTO)/bin/$@ spigotSband2filterbank.o spigot.o sigproc_fb.o $(PRESTOLINK) -lm - show_pfd: show_pfd_cmd.c show_pfd.o show_pfd_cmd.o prepfold_utils.o prepfold_plot.o least_squares.o $(PLOT2DOBJS) libpresto $(FC) $(FLINKFLAGS) -o $(PRESTO)/bin/$@ show_pfd.o show_pfd_cmd.o prepfold_utils.o prepfold_plot.o least_squares.o $(PLOT2DOBJS) $(LAPACKLINK) $(PRESTOLINK) $(PGPLOTLINK) -lm @@ -338,11 +317,10 @@ fitsdelcol: fitsdelcol.o clean: rm -f *.o *~ *# - rm -f slalib/*.o slalib/sla_test cleaner: clean cd ../bin ; rm -f $(BINARIES) - rm -f $(PRESTO)/lib/libpresto.* $(PRESTO)/lib/libsla.* + rm -f $(PRESTO)/lib/libpresto.* squeaky: cleaner rm -f *.dat *.fft *.inf fftw_wisdom.txt diff --git a/src/dump_spigot_zerolag.c b/src/dump_spigot_zerolag.c deleted file mode 100644 index ccc543f51..000000000 --- a/src/dump_spigot_zerolag.c +++ /dev/null @@ -1,58 +0,0 @@ -#include "presto.h" -#include "mask.h" -#include "spigot.h" -#include "fitsfile.h" -#include "fitshead.h" - -extern void get_calibrated_lags(void *rawlags, float *calibrated_lags); - -int main(int argc, char *argv[]) -{ - FILE *infile, *outfile; - int filenum, ii = 0, offset = 0; - char *path, *filenm; - char outfilenm[200], rawlags[4096]; - float lags[2048]; - SPIGOT_INFO spigot; - - if (argc == 1) { - fprintf(stderr, "Usage: dump_spigot_zerolags SPIGOT_files\n"); - exit(0); - } - split_path_file(argv[1], &path, &filenm); - strncpy(outfilenm, filenm, strlen(filenm) - 10); - strncpy(outfilenm + strlen(filenm) - 10, ".zerolags", 10); - free(path); - free(filenm); - outfile = chkfopen(outfilenm, "wb"); - - for (filenum = 1; filenum < argc; filenum++) { - fprintf(stderr, "Reading from file '%s'...\n", argv[filenum]); - infile = chkfopen(argv[filenum], "r"); - if (read_SPIGOT_header(argv[filenum], &spigot)) { - - /* Upper or lower sideband? */ - //if (spigot.upper_sideband){ - //offset = spigot.lags_per_sample-1; - //fprintf(stderr, "Using lag #%d\n", offset); - //} - - /* Position the file stream at the beginning of the data */ - chkfseek(infile, spigot.header_len, SEEK_SET); - - /* Loop over the samples in the file */ - while (chkfread(rawlags, sizeof(char), - spigot.lags_per_sample * spigot.bits_per_lag / 8, - infile)) { - get_calibrated_lags(rawlags, lags); - ii++; - /* fprintf(stderr, "%f\n", lags[offset]); */ - fwrite(lags + offset, sizeof(float), 1, outfile); - } - } - fclose(infile); - } - fclose(outfile); - fprintf(stderr, "Wrote %d zerolags to '%s'.\n", ii, outfilenm); - return 0; -} diff --git a/src/meson.build b/src/meson.build new file mode 100644 index 000000000..f34bbf054 --- /dev/null +++ b/src/meson.build @@ -0,0 +1,171 @@ +executable('cal2mjd', 'cal2mjd.c', 'cldj.c', + dependencies: libm, include_directories: inc, install: true) + +executable('fitsdelcol', 'fitsdelcol.c', + dependencies: [fits, libm], include_directories: inc, install: true) + +executable('fitsdelrow', 'fitsdelrow.c', + dependencies: [fits, libm], include_directories: inc, install: true) + +executable('makewisdom', 'makewisdom.c', + dependencies: [fftw, libm], include_directories: inc, install: false) + +executable('mjd2cal', 'mjd2cal.c', 'djcl.c', + dependencies: libm, include_directories: inc, install: true) + +executable('patchdata', 'patchdata.c', install: false) + +executable('psrfits_dumparrays', 'psrfits_dumparrays.c', + dependencies: [fits, libm], include_directories: inc, install: true) + +executable('shiftdata', 'shiftdata.c', install: false) + +executable('split_parkes_beams', 'split_parkes_beams.c', install: false) + +executable('swap_endian', 'swap_endian.c', install: false) + +executable('taperaw', 'taperaw.c', install: false) + +executable('toas2dat', 'toas2dat.c', 'toas2dat_cmd.c', + dependencies: libm, include_directories: inc, install: true) + +executable('un_sc_td', 'un_sc_td.c', install: false) + +libpresto = library( + 'presto', 'amoeba.c', 'atwood.c', 'barycenter.c', 'birdzap.c', + 'cand_output.c', 'characteristics.c', 'chkio.c', 'cldj.c', + 'clipping.c', 'corr_prep.c', 'corr_routines.c', 'correlations.c', + 'database.c', 'dcdflib.c', 'dispersion.c', 'djcl.c', 'fastffts.c', + 'fftcalls.c', 'fitsfile.c', 'fminbr.c', 'fold.c', 'fresnl.c', + 'get_candidates.c', 'hget.c', 'hput.c', 'imio.c', 'ioinf.c', + 'iomak.c', 'ipmpar.c', 'mask.c', 'maximize_r.c', 'maximize_rz.c', + 'maximize_rzw.c', 'median.c', 'minifft.c', 'misc_utils.c', 'orbint.c', + 'output.c', 'range_parse.c', 'read_fft.c', 'readpar.c', 'responses.c', + 'rzinterp.c', 'rzwinterp.c', 'select.c', 'sorter.c', 'swapendian.c', + 'transpose.c', 'twopass.c', 'twopass_real_fwd.c', + 'twopass_real_inv.c', 'vectors.c', + dependencies: [glib, fftw, libm, omp], + include_directories: inc, + install: true +) + +INSTRUMENTOBJS= ['backend_common.c', 'psrfits.c', 'sigproc_fb.c', 'zerodm.c'] +PLOT2DOBJS = ['powerplot.c', 'xyline.c'] + +executable('accelsearch', 'accelsearch.c', 'accelsearch_cmd.c', 'accel_utils.c', 'zapping.c', + dependencies: [glib, fftw, libm, omp], c_args: '-DUSEMMAP', + include_directories: inc, link_with: libpresto, install: true) + +executable('bary', 'bary.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('bincand', 'bincand.c', 'bincand_cmd.c', + dependencies: [glib, fftw, libm, omp], + include_directories: inc, link_with: libpresto, install: true) + +executable('check_parkes_raw', 'check_parkes_raw.c', 'multibeam.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('dat2sdat', 'dat2sdat.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('dftfold', 'dftfold_cmd.c', 'dftfold.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('downsample', 'downsample.c', 'downsample_cmd.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('exploredat', + sources: ['exploredat.c'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], c_args: '-DUSEMMAP', + include_directories: inc, link_with: libpresto, install: true) + +executable('explorefft', + sources: ['explorefft.c'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], c_args: '-DUSEMMAP', + include_directories: inc, link_with: libpresto, install: true) + +executable('makedata', 'makedata.c', 'com.c', 'randlib.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('makeinf', 'makeinf.c', 'ioinf.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +if mpi.found() + executable('mpiprepsubband', + sources: ['mpiprepsubband.c', 'mpiprepsubband_cmd.c', 'mpiprepsubband_utils.c'] + INSTRUMENTOBJS, + dependencies: [glib, fftw, libm, fits, omp, mpi], + include_directories: inc, link_with: libpresto, install: true) +endif + +executable('plotbincand', + sources: ['plotbincand.c'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('prepdata', + sources: ['prepdata.c', 'prepdata_cmd.c'] + INSTRUMENTOBJS, + dependencies: [glib, fftw, libm, fits, omp], + include_directories: inc, link_with: libpresto, install: true) + +executable('prepfold', + sources: ['prepfold.c', 'prepfold_cmd.c', 'prepfold_utils.c', 'prepfold_plot.c', 'polycos.c', 'least_squares.f'] + INSTRUMENTOBJS + PLOT2DOBJS, + dependencies: [glib, fftw, libm, fits, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('prepsubband', + sources: ['prepsubband.c', 'prepsubband_cmd.c'] + INSTRUMENTOBJS, + dependencies: [glib, fftw, libm, fits, omp], + include_directories: inc, link_with: libpresto, install: true) + +executable('psrorbit', + sources: ['psrorbit.c'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('quicklook', 'quicklook.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('readfile', + sources: ['readfile.c', 'readfile_cmd.c', 'multibeam.c', 'bpp.c', 'spigot.c', 'wapp.c', 'wapp_head_parse.c', 'wapp_y.tab.c'] + INSTRUMENTOBJS, + dependencies: [glib, fftw, libm, fits], + include_directories: inc, link_with: libpresto, install: true) + +executable('realfft', 'realfft.c', 'realfft_cmd.c', + dependencies: [fftw, libm], + include_directories: inc, link_with: libpresto, install: true) + +executable('rednoise', 'rednoise.c', 'rednoise_cmd.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('rfifind', + sources: ['rfifind.c', 'rfifind_cmd.c', 'rfi_utils.c', 'rfifind_plot.c'] + INSTRUMENTOBJS + PLOT2DOBJS, + dependencies: [glib, fftw, libm, fits, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('sdat2dat', 'sdat2dat.c', + dependencies: [fftw, libm], include_directories: inc, link_with: libpresto, install: true) + +executable('search_bin', 'search_bin.c', 'search_bin_cmd.c', + dependencies: [glib, fftw, libm], + include_directories: inc, link_with: libpresto, install: true) + +executable('show_pfd', + sources: ['show_pfd.c', 'show_pfd_cmd.c', 'prepfold_utils.c', 'prepfold_plot.c', 'least_squares.f'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('weight_psrfits', + sources: ['weight_psrfits.c'] + INSTRUMENTOBJS, + dependencies: [glib, fftw, libm, fits, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('window', + sources: ['window.c'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) + +executable('zapbirds', + sources: ['zapbirds.c', 'zapbirds_cmd.c', 'zapping.c'] + PLOT2DOBJS, + dependencies: [glib, fftw, libm, pgplot, cpgplot, x11, png], + include_directories: inc, link_with: libpresto, install: true) diff --git a/src/sla.c b/src/sla.c deleted file mode 100644 index f4aeb43ec..000000000 --- a/src/sla.c +++ /dev/null @@ -1,1659 +0,0 @@ -/* -* Name: -* sla.c - -* Purpose: -* Implement a C interface to the Fortran SLALIB library. - -* Description: -* This file implements a C interface to the Fortran version of the -* SLALIB library. - -* Notes: -* This interface only supports a subset of the functions provided by -* SLALIB. It should be extended as and when necessary. - -* Copyright: -* Copyright (C) 2006 Council for the Central Laboratory of the -* Research Councils - -* Licence: -* This program is free software; you can redistribute it and/or -* modify it under the terms of the GNU General Public Licence as -* published by the Free Software Foundation; either version 2 of -* the Licence, or (at your option) any later version. -* -* This program is distributed in the hope that it will be -* useful,but WITHOUT ANY WARRANTY; without even the implied -* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -* PURPOSE. See the GNU General Public Licence for more details. -* -* You should have received a copy of the GNU General Public Licence -* along with this program; if not, write to the Free Software -* Foundation, Inc., 59 Temple Place,Suite 330, Boston, MA -* 02111-1307, USA - -* Authors: -* RFWS: R.F. Warren-Smith (STARLINK) -* DSB: David S. Berry (STARLINK) -* TIMJ: Tim Jenness (JAC, Hawaii) -* SMR: Scott M. RAnsom (NRAO) - -* History: -* 12-NOV-1996 (RFWS): -* Original version. -* 28-APR-1997 (RFWS): -* Added SLA_DJCAL. -* 26-SEP-1997 (DSB): -* Added SLA_DD2TF, SLA_DJCL. -* 21-JUN-2001 (DSB): -* Added SLA_DBEAR, SLA_DVDV. -* 23-AUG-2001 (DSB): -* Added SLA_SVD and SLA_SVDSOL -* 11-NOV-2002 (DSB): -* Added SLA_RVEROT, SLA_GMST, SLA_EQEQX, SLA_RVLSRK, SLA_RVLSRD, -* SLA_RVLG, SLA_RVGALC. -* 11-JUN-2003 (DSB): -* Added SLA_GEOC, SLA_HFK5Z and SLA_FK5HZ. -* 2-DEC-2004 (DSB): -* Added SLA_DEULER. -* 29-SEP-2005 (DSB): -* Added SLA_DE2H and SLA_DH2E -* 12-JUN-2006 (DSB): -* Moved from AST to SLALIB. -* 25-JUN-2006 (TIMJ): -* Add SLA_AIRMAS. -* 07-AUG-2006 (TIMJ): -* Import cnfImprt from CNF. -* Add SLA_OBS -* 08-AUG-2006 (TIMJ): -* Add SLA_PA -* 12-DEC-2006 (TIMJ): -* Add SLA_DTT and SLA_DAT -* 21-DEC-2006 (TIMJ): -* Add SLA_RDPLAN -* 04-JUN-2007 (SMR): -* Add SLA_OAP and SLA_AMP - -*- -*/ - -/* Header files. */ -/* ============= */ -#include "f77.h" /* FORTRAN <-> C interface macros (SUN/209) */ -#include "slalib.h" /* Prototypes for C SLALIB functions */ -#include /* Malloc etc */ -#include /* string manipulation */ - - -/* Functions needed to avoid a dependence on CNF. */ -/* ============================================== */ - -static void slaStringExport(const char *, char *, int); -static void slaStringImport(const char *source_f, int source_len, char *dest_c); - -static void slaStringExport(const char *source_c, char *dest_f, int dest_len) -{ -/* -*+ -* Name: -* slaStringExport - -* Purpose: -* Export a C string to a FORTRAN string. - -* Type: -* Protected function. - -* Synopsis: -* void slaStringExport( const char *source_c, char *dest_f, int dest_len ) - -* Description: -* This function creates a FORTRAN string from a C string, storing -* it in the supplied memory. If the C string is shorter than the -* space allocated for the FORTRAN string, then it is padded with -* blanks. If the C string is longer than the space allocated for -* the FORTRAN string, then the string is truncated. - -* Parameters: -* source_c -* A pointer to the input C string. -* dest_f -* A pointer to the output FORTRAN string. -* dest_len -* The length of the output FORTRAN string. - -* Notes: -* - This function is potentially platform-specific. For example, -* if FORTRAN strings were passed by descriptor, then the -* descriptor address would be passed as "dest_f" and this must -* then be used to locate the actual FORTRAN character data. -* - This function is equivalent to cnfExprt but is included here to -* avoid SLALIB becoming dependent on CNF. -*- -*/ - -/* Local Variables:*/ - int i; /* Loop counter for characters */ - -/* Check the supplied pointers. */ - if (!source_c || !dest_f) - return; - -/* Copy the characters of the input C string to the output FORTRAN - string, taking care not to go beyond the end of the FORTRAN - string.*/ - for (i = 0; source_c[i] && (i < dest_len); i++) { - dest_f[i] = source_c[i]; - } - -/* Fill the rest of the output FORTRAN string with blanks. */ - for (; i < dest_len; i++) - dest_f[i] = ' '; -} - -void slaStringImport(const char *source_f, int source_len, char *dest_c) - -/* -*+ -* Name: -* slaStringImportt - -* Purpose: -* Import a FORTRAN string into a C string - -* Type: -* Protected function. - -* Language: -* ANSI C - -* Invocation: -* slaStringImport( source_f, source_len, dest_c ) - -* Description: -* Import a FORTRAN string into a C string, discarding trailing -* blanks. The NUL character is appended to the C string after -* the last non-blank character. The input string and output string -* pointers can point to the same location if the string is to be -* modified in place (but care must be taken to allow for the additional -* C terminator when allocating memory). - -* Arguments: -* const char *source_f (Given) -* A pointer to the input FORTRAN string -* int source_len (Given) -* The length of the input FORTRAN string -* char *dest_c (Returned via pointer) -* A pointer to the output C string. Can be same as source. - -* Notes: -* - No check is made that there is sufficient space allocated to -* the C string to hold the FORTRAN string and a terminating null. -* It is responsibility of the programmer to check this. -* - This function is equivalent to cnfImprt but is included here to -* avoid SLALIB becoming dependent on CNF. - -* Authors: -* PMA: Peter Allan (Starlink, RAL) -* AJC: Alan Chipperfield (Starlink, RAL) -* TIMJ: Tim Jenness (JAC, Hawaii) -* {enter_new_authors_here} - -* History: -* 27-MAR-1991 (PMA): -* Original version. -* 22-MAY-1996 (AJC): -* Correct description re trailing blanks -* 24-SEP-1998 (AJC): -* Specify const char * for input strings -* 25-NOV-2005 (TIMJ): -* Allow the strings to be identical -* {enter_changes_here} - -*- - -*...........................................................................*/ -{ -/* Local Variables: */ - - int i; /* Loop counter */ - - -/* Find the last non blank character in the input FORTRAN string. */ - - for (i = source_len - 1; (i >= 0) && (source_f[i] == ' '); i--); - -/* Put a null character at the end of the output C string. */ - - dest_c[i + 1] = '\0'; - -/* Copy the characters from the input FORTRAN string to the output C */ -/* string if the strings are different. */ - - if (dest_c != source_f) { - memmove(dest_c, source_f, (size_t) i + 1); - } -} - - - - -/* SLALIB wrapper implementations. */ -/* =============================== */ -/* Fortran routine prototype. */ -F77_SUBROUTINE(sla_addet) (DOUBLE(RM), - DOUBLE(DM), DOUBLE(EQ), DOUBLE(RC), DOUBLE(DC)); - -/* C interface implementation. */ -void slaAddet(double rm, double dm, double eq, double *rc, double *dc) -{ - DECLARE_DOUBLE(RM); - DECLARE_DOUBLE(DM); - DECLARE_DOUBLE(EQ); - DECLARE_DOUBLE(RC); - DECLARE_DOUBLE(DC); - RM = rm; - DM = dm; - EQ = eq; - F77_CALL(sla_addet) (DOUBLE_ARG(&RM), - DOUBLE_ARG(&DM), - DOUBLE_ARG(&EQ), DOUBLE_ARG(&RC), DOUBLE_ARG(&DC)); - *rc = RC; - *dc = DC; -} - -/* etc... */ -F77_SUBROUTINE(sla_amp) (DOUBLE(RA), - DOUBLE(DA), - DOUBLE(DATE), DOUBLE(EQ), DOUBLE(RM), DOUBLE(DM)); - -void slaAmp(double ra, double da, double date, double eq, double *rm, double *dm) -{ - DECLARE_DOUBLE(RA); - DECLARE_DOUBLE(DA); - DECLARE_DOUBLE(DATE); - DECLARE_DOUBLE(EQ); - DECLARE_DOUBLE(RM); - DECLARE_DOUBLE(DM); - RA = ra; - DA = da; - DATE = date; - EQ = eq; - F77_CALL(sla_amp) (DOUBLE_ARG(&RA), - DOUBLE_ARG(&DA), - DOUBLE_ARG(&DATE), - DOUBLE_ARG(&EQ), DOUBLE_ARG(&RM), DOUBLE_ARG(&DM)); - *rm = RM; - *dm = DM; -} - -F77_SUBROUTINE(sla_ampqk) (DOUBLE(RA), - DOUBLE(DA), DOUBLE_ARRAY(AMPRMS), DOUBLE(RM), DOUBLE(DM)); - -void slaAmpqk(double ra, double da, double amprms[21], double *rm, double *dm) -{ - DECLARE_DOUBLE(RA); - DECLARE_DOUBLE(DA); - DECLARE_DOUBLE_ARRAY(AMPRMS, 21); - DECLARE_DOUBLE(RM); - DECLARE_DOUBLE(DM); - int i; - RA = ra; - DA = da; - for (i = 0; i < 21; i++) - AMPRMS[i] = amprms[i]; - F77_CALL(sla_ampqk) (DOUBLE_ARG(&RA), - DOUBLE_ARG(&DA), - DOUBLE_ARRAY_ARG(AMPRMS), DOUBLE_ARG(&RM), DOUBLE_ARG(&DM)); - *rm = RM; - *dm = DM; -} - -F77_DOUBLE_FUNCTION(sla_airmas) (DOUBLE(ZD)); - -double slaAirmas(double zd) -{ - DECLARE_DOUBLE(ZD); - double result; - ZD = zd; - result = F77_CALL(sla_airmas) (DOUBLE_ARG(&ZD)); - return result; -} - -F77_SUBROUTINE(sla_caldj) (INTEGER(IY), - INTEGER(IM), INTEGER(ID), DOUBLE(DJM), INTEGER(J)); - -void slaCaldj(int iy, int im, int id, double *djm, int *j) -{ - DECLARE_INTEGER(IY); - DECLARE_INTEGER(IM); - DECLARE_INTEGER(ID); - DECLARE_DOUBLE(DJM); - DECLARE_INTEGER(J); - IY = iy; - IM = im; - ID = id; - F77_CALL(sla_caldj) (INTEGER_ARG(&IY), - INTEGER_ARG(&IM), - INTEGER_ARG(&ID), DOUBLE_ARG(&DJM), INTEGER_ARG(&J)); - *djm = DJM; - *j = J; -} - -F77_SUBROUTINE(sla_daf2r) (INTEGER(IDEG), - INTEGER(IAMIN), DOUBLE(ASEC), DOUBLE(RAD), INTEGER(J)); - -void slaDaf2r(int ideg, int iamin, double asec, double *rad, int *j) -{ - DECLARE_INTEGER(IDEG); - DECLARE_INTEGER(IAMIN); - DECLARE_DOUBLE(ASEC); - DECLARE_DOUBLE(RAD); - DECLARE_INTEGER(J); - IDEG = ideg; - IAMIN = iamin; - ASEC = asec; - F77_CALL(sla_daf2r) (INTEGER_ARG(&IDEG), - INTEGER_ARG(&IAMIN), - DOUBLE_ARG(&ASEC), DOUBLE_ARG(&RAD), INTEGER_ARG(&J)); - *rad = RAD; - *j = J; -} - -F77_SUBROUTINE(sla_dav2m) (DOUBLE_ARRAY(AXVEC), DOUBLE_ARRAY(RMAT)); - -void slaDav2m(double axvec[3], double rmat[3][3]) -{ - DECLARE_DOUBLE_ARRAY(AXVEC, 3); - DECLARE_DOUBLE_ARRAY(RMAT, 9); - int i; - int j; - for (i = 0; i < 3; i++) - AXVEC[i] = axvec[i]; - F77_CALL(sla_dav2m) (DOUBLE_ARRAY_ARG(AXVEC), DOUBLE_ARRAY_ARG(RMAT)); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - rmat[i][j] = RMAT[i + 3 * j]; - } -} - -F77_SUBROUTINE(sla_dcc2s) (DOUBLE_ARRAY(V), DOUBLE(A), DOUBLE(B)); - -void slaDcc2s(double v[3], double *a, double *b) -{ - DECLARE_DOUBLE_ARRAY(V, 3); - DECLARE_DOUBLE(A); - DECLARE_DOUBLE(B); - int i; - for (i = 0; i < 3; i++) - V[i] = v[i]; - F77_CALL(sla_dcc2s) (DOUBLE_ARRAY_ARG(V), DOUBLE_ARG(&A), DOUBLE_ARG(&B)); - *a = A; - *b = B; -} - -F77_SUBROUTINE(sla_dcs2c) (DOUBLE(A), DOUBLE(B), DOUBLE_ARRAY(V)); - -void slaDcs2c(double a, double b, double v[3]) -{ - DECLARE_DOUBLE(A); - DECLARE_DOUBLE(B); - DECLARE_DOUBLE_ARRAY(V, 3); - int i; - A = a; - B = b; - F77_CALL(sla_dcs2c) (DOUBLE_ARG(&A), DOUBLE_ARG(&B), DOUBLE_ARRAY_ARG(V)); - for (i = 0; i < 3; i++) - v[i] = V[i]; -} - -F77_SUBROUTINE(sla_dd2tf) (INTEGER(NDP), - DOUBLE(DAYS), CHARACTER(SIGN), INTEGER_ARRAY(IHMSF) - TRAIL(SIGN)); - -void slaDd2tf(int ndp, double days, char *sign, int ihmsf[4]) -{ - DECLARE_INTEGER(NDP); - DECLARE_DOUBLE(DAYS); - DECLARE_CHARACTER(SIGN, 2); - DECLARE_INTEGER_ARRAY(IHMSF, 4); - int i; - - NDP = ndp; - DAYS = days; - F77_CALL(sla_dd2tf) (INTEGER_ARG(&NDP), - DOUBLE_ARG(&DAYS), - CHARACTER_ARG(SIGN), INTEGER_ARRAY_ARG(IHMSF) - TRAIL_ARG(SIGN)); - sign[0] = SIGN[0]; - sign[1] = 0; - for (i = 0; i < 4; i++) - ihmsf[i] = IHMSF[i]; -} - -F77_SUBROUTINE(sla_dimxv) (DOUBLE_ARRAY(DM), DOUBLE_ARRAY(VA), DOUBLE_ARRAY(VB)); - -void slaDimxv(double dm[3][3], double va[3], double vb[3]) -{ - DECLARE_DOUBLE_ARRAY(DM, 9); - DECLARE_DOUBLE_ARRAY(VA, 3); - DECLARE_DOUBLE_ARRAY(VB, 3); - int i; - int j; - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - DM[i + j * 3] = dm[i][j]; - VA[i] = va[i]; - } - F77_CALL(sla_dimxv) (DOUBLE_ARRAY_ARG(DM), - DOUBLE_ARRAY_ARG(VA), DOUBLE_ARRAY_ARG(VB)); - for (i = 0; i < 3; i++) - vb[i] = VB[i]; -} - -F77_SUBROUTINE(sla_djcal) (INTEGER(NDP), - DOUBLE(DJM), INTEGER_ARRAY(IYMDF), INTEGER(J)); - -void slaDjcal(int ndp, double djm, int iymdf[4], int *j) -{ - DECLARE_INTEGER(NDP); - DECLARE_DOUBLE(DJM); - DECLARE_INTEGER_ARRAY(IYMDF, 4); - DECLARE_INTEGER(J); - int i; - - NDP = ndp; - DJM = djm; - F77_CALL(sla_djcal) (INTEGER_ARG(&NDP), - DOUBLE_ARG(&DJM), - INTEGER_ARRAY_ARG(IYMDF), INTEGER_ARG(&J)); - for (i = 0; i < 4; i++) - iymdf[i] = IYMDF[i]; - *j = J; -} - -F77_SUBROUTINE(sla_djcl) (DOUBLE(DJM), - INTEGER(IY), - INTEGER(IM), INTEGER(ID), DOUBLE(FD), INTEGER(J)); - -void slaDjcl(double djm, int *iy, int *im, int *id, double *fd, int *j) -{ - DECLARE_DOUBLE(DJM); - DECLARE_INTEGER(IY); - DECLARE_INTEGER(IM); - DECLARE_INTEGER(ID); - DECLARE_DOUBLE(FD); - DECLARE_INTEGER(J); - - DJM = djm; - F77_CALL(sla_djcl) (DOUBLE_ARG(&DJM), - INTEGER_ARG(&IY), - INTEGER_ARG(&IM), - INTEGER_ARG(&ID), DOUBLE_ARG(&FD), INTEGER_ARG(&J)); - *iy = IY; - *im = IM; - *id = ID; - *fd = FD; - *j = J; -} - -F77_SUBROUTINE(sla_dmat) (INTEGER(N), - DOUBLE_ARRAY(A), - DOUBLE_ARRAY(Y), - DOUBLE(D), INTEGER(JF), INTEGER_ARRAY(IW)); - -void slaDmat(int n, double *a, double *y, double *d, int *jf, int *iw) -{ - DECLARE_INTEGER(N); - F77_DOUBLE_TYPE *A; - F77_DOUBLE_TYPE *Y; - DECLARE_DOUBLE(D); - DECLARE_INTEGER(JF); - F77_INTEGER_TYPE *IW; - int i; - int j; - A = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) (n * n)); - Y = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) n); - if (sizeof(F77_INTEGER_TYPE) > sizeof(int)) { - IW = malloc(sizeof(F77_INTEGER_TYPE) * (size_t) n); - } else { - IW = (F77_INTEGER_TYPE *) iw; - } - if (IW) { - N = n; - for (i = 0; i < n; i++) { - for (j = 0; j < n; j++) - A[i + n * j] = a[n * i + j]; - Y[i] = y[i]; - } - F77_CALL(sla_dmat) (INTEGER_ARG(&N), DOUBLE_ARRAY_ARG(A), - DOUBLE_ARRAY_ARG(Y), DOUBLE_ARG(&D), - INTEGER_ARG(&JF), INTEGER_ARG(IW)); - for (i = 0; i < n; i++) { - for (j = 0; j < n; j++) - a[n * i + j] = A[i + n * j]; - y[i] = Y[i]; - } - *d = D; - *jf = JF; - } - free(A); - free(Y); - if (sizeof(F77_INTEGER_TYPE) > sizeof(int)) - free(IW); -} - -F77_SUBROUTINE(sla_dmxm) (DOUBLE_ARRAY(A), DOUBLE_ARRAY(B), DOUBLE_ARRAY(C)); - -void slaDmxm(double a[3][3], double b[3][3], double c[3][3]) -{ - DECLARE_DOUBLE_ARRAY(A, 9); - DECLARE_DOUBLE_ARRAY(B, 9); - DECLARE_DOUBLE_ARRAY(C, 9); - int i; - int j; - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) { - A[i + 3 * j] = a[i][j]; - B[i + 3 * j] = b[i][j]; - } - } - F77_CALL(sla_dmxm) (DOUBLE_ARRAY_ARG(A), - DOUBLE_ARRAY_ARG(B), DOUBLE_ARRAY_ARG(C)); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - c[i][j] = C[i + 3 * j]; - } -} - -F77_SUBROUTINE(sla_dmxv) (DOUBLE_ARRAY(DM), DOUBLE_ARRAY(VA), DOUBLE_ARRAY(VB)); - -void slaDmxv(double dm[3][3], double va[3], double vb[3]) -{ - DECLARE_DOUBLE_ARRAY(DM, 9); - DECLARE_DOUBLE_ARRAY(VA, 3); - DECLARE_DOUBLE_ARRAY(VB, 3); - int i; - int j; - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - DM[i + 3 * j] = dm[i][j]; - VA[i] = va[i]; - } - F77_CALL(sla_dmxv) (DOUBLE_ARRAY_ARG(DM), - DOUBLE_ARRAY_ARG(VA), DOUBLE_ARRAY_ARG(VB)); - for (i = 0; i < 3; i++) - vb[i] = VB[i]; -} - -F77_DOUBLE_FUNCTION(sla_dbear) (DOUBLE(A1), DOUBLE(B1), DOUBLE(A2), DOUBLE(B2)); - -double slaDbear(double a1, double b1, double a2, double b2) -{ - DECLARE_DOUBLE(A1); - DECLARE_DOUBLE(B1); - DECLARE_DOUBLE(A2); - DECLARE_DOUBLE(B2); - double result; - A1 = a1; - B1 = b1; - A2 = a2; - B2 = b2; - result = F77_CALL(sla_dbear) (DOUBLE_ARG(&A1), DOUBLE_ARG(&B1), - DOUBLE_ARG(&A2), DOUBLE_ARG(&B2)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_drange) (DOUBLE(ANGLE)); - -double slaDrange(double angle) -{ - DECLARE_DOUBLE(ANGLE); - double result; - ANGLE = angle; - result = F77_CALL(sla_drange) (DOUBLE_ARG(&ANGLE)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_dranrm) (DOUBLE(ANGLE)); - -double slaDranrm(double angle) -{ - DECLARE_DOUBLE(ANGLE); - double result; - ANGLE = angle; - result = F77_CALL(sla_dranrm) (DOUBLE_ARG(&ANGLE)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_dsep) (DOUBLE(A1), DOUBLE(B1), DOUBLE(A2), DOUBLE(B2)); - -double slaDsep(double a1, double b1, double a2, double b2) -{ - DECLARE_DOUBLE(A1); - DECLARE_DOUBLE(B1); - DECLARE_DOUBLE(A2); - DECLARE_DOUBLE(B2); - double result; - A1 = a1; - B1 = b1; - A2 = a2; - B2 = b2; - result = F77_CALL(sla_dsep) (DOUBLE_ARG(&A1), - DOUBLE_ARG(&B1), DOUBLE_ARG(&A2), DOUBLE_ARG(&B2)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_dvdv) (DOUBLE_ARRAY(VA), DOUBLE_ARRAY(VB)); - -double slaDvdv(double va[3], double vb[3]) -{ - DECLARE_DOUBLE_ARRAY(VA, 3); - DECLARE_DOUBLE_ARRAY(VB, 3); - double result; - int i; - for (i = 0; i < 3; i++) { - VA[i] = va[i]; - VB[i] = vb[i]; - } - result = F77_CALL(sla_dvdv) (DOUBLE_ARRAY_ARG(VA), DOUBLE_ARRAY_ARG(VB)); - return result; -} - -F77_SUBROUTINE(sla_dtf2d) (INTEGER(IHOUR), - INTEGER(IMIN), DOUBLE(SEC), DOUBLE(DAYS), INTEGER(J)); - -void slaDtf2d(int ihour, int imin, double sec, double *days, int *j) -{ - DECLARE_INTEGER(IHOUR); - DECLARE_INTEGER(IMIN); - DECLARE_DOUBLE(SEC); - DECLARE_DOUBLE(DAYS); - DECLARE_INTEGER(J); - IHOUR = ihour; - IMIN = imin; - SEC = sec; - F77_CALL(sla_dtf2d) (INTEGER_ARG(&IHOUR), - INTEGER_ARG(&IMIN), - DOUBLE_ARG(&SEC), DOUBLE_ARG(&DAYS), INTEGER_ARG(&J)); - *days = DAYS; - *j = J; -} - -F77_SUBROUTINE(sla_dtf2r) (INTEGER(IHOUR), - INTEGER(IMIN), DOUBLE(SEC), DOUBLE(RAD), INTEGER(J)); - -void slaDtf2r(int ihour, int imin, double sec, double *rad, int *j) -{ - DECLARE_INTEGER(IHOUR); - DECLARE_INTEGER(IMIN); - DECLARE_DOUBLE(SEC); - DECLARE_DOUBLE(RAD); - DECLARE_INTEGER(J); - IHOUR = ihour; - IMIN = imin; - SEC = sec; - F77_CALL(sla_dtf2r) (INTEGER_ARG(&IHOUR), - INTEGER_ARG(&IMIN), - DOUBLE_ARG(&SEC), DOUBLE_ARG(&RAD), INTEGER_ARG(&J)); - *rad = RAD; - *j = J; -} - -F77_DOUBLE_FUNCTION(sla_dt) (DOUBLE(EPOCH)); - -double slaDt(double epoch) -{ - DECLARE_DOUBLE(EPOCH); - double result; - EPOCH = epoch; - result = F77_CALL(sla_dt) (DOUBLE_ARG(&EPOCH)); - return result; -} - -F77_SUBROUTINE(sla_dvn) (DOUBLE_ARRAY(V), DOUBLE_ARRAY(UV), DOUBLE(VM)); - -void slaDvn(double v[3], double uv[3], double *vm) -{ - DECLARE_DOUBLE_ARRAY(V, 3); - DECLARE_DOUBLE_ARRAY(UV, 3); - DECLARE_DOUBLE(VM); - int i; - for (i = 0; i < 3; i++) - V[i] = v[i]; - F77_CALL(sla_dvn) (DOUBLE_ARRAY_ARG(V), DOUBLE_ARRAY_ARG(UV), DOUBLE_ARG(&VM)); - for (i = 0; i < 3; i++) - uv[i] = UV[i]; - *vm = VM; -} - -F77_SUBROUTINE(sla_dvxv) (DOUBLE_ARRAY(VA), DOUBLE_ARRAY(VB), DOUBLE_ARRAY(VC)); - -void slaDvxv(double va[3], double vb[3], double vc[3]) -{ - DECLARE_DOUBLE_ARRAY(VA, 3); - DECLARE_DOUBLE_ARRAY(VB, 3); - DECLARE_DOUBLE_ARRAY(VC, 3); - int i; - for (i = 0; i < 3; i++) { - VA[i] = va[i]; - VB[i] = vb[i]; - } - F77_CALL(sla_dvxv) (DOUBLE_ARRAY_ARG(VA), - DOUBLE_ARRAY_ARG(VB), DOUBLE_ARRAY_ARG(VC)); - for (i = 0; i < 3; i++) - vc[i] = VC[i]; -} - -F77_SUBROUTINE(sla_ecmat) (DOUBLE(DATE), DOUBLE_ARRAY(RMAT)); - -void slaEcmat(double date, double rmat[3][3]) -{ - DECLARE_DOUBLE(DATE); - DECLARE_DOUBLE_ARRAY(RMAT, 9); - int i; - int j; - DATE = date; - F77_CALL(sla_ecmat) (DOUBLE_ARG(&DATE), DOUBLE_ARRAY_ARG(RMAT)); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - rmat[i][j] = RMAT[i + 3 * j]; - } -} - -F77_DOUBLE_FUNCTION(sla_epb) (DOUBLE(DATE)); - -double slaEpb(double date) -{ - DECLARE_DOUBLE(DATE); - double result; - DATE = date; - result = F77_CALL(sla_epb) (DOUBLE_ARG(&DATE)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_epb2d) (DOUBLE(EPB)); - -double slaEpb2d(double epb) -{ - DECLARE_DOUBLE(EPB); - double result; - EPB = epb; - result = F77_CALL(sla_epb2d) (DOUBLE_ARG(&EPB)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_epj) (DOUBLE(DATE)); - -double slaEpj(double date) -{ - DECLARE_DOUBLE(DATE); - double result; - DATE = date; - result = F77_CALL(sla_epj) (DOUBLE_ARG(&DATE)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_epj2d) (DOUBLE(EPJ)); - -double slaEpj2d(double epj) -{ - DECLARE_DOUBLE(EPJ); - double result; - EPJ = epj; - result = F77_CALL(sla_epj2d) (DOUBLE_ARG(&EPJ)); - return result; -} - -F77_DOUBLE_FUNCTION(sla_eqeqx) (DOUBLE(DATE)); - -double slaEqeqx(double date) -{ - DECLARE_DOUBLE(DATE); - double result; - DATE = date; - result = F77_CALL(sla_eqeqx) (DOUBLE_ARG(&DATE)); - return result; -} - -F77_SUBROUTINE(sla_eqgal) (DOUBLE(DR), DOUBLE(DD), DOUBLE(DL), DOUBLE(DB)); - -void slaEqgal(double dr, double dd, double *dl, double *db) -{ - DECLARE_DOUBLE(DR); - DECLARE_DOUBLE(DD); - DECLARE_DOUBLE(DL); - DECLARE_DOUBLE(DB); - DR = dr; - DD = dd; - F77_CALL(sla_eqgal) (DOUBLE_ARG(&DR), - DOUBLE_ARG(&DD), DOUBLE_ARG(&DL), DOUBLE_ARG(&DB)); - *dl = DL; - *db = DB; -} - -F77_SUBROUTINE(sla_fk45z) (DOUBLE(R1950), - DOUBLE(D1950), - DOUBLE(BEPOCH), DOUBLE(R2000), DOUBLE(D2000)); - -void slaFk45z(double r1950, double d1950, double bepoch, - double *r2000, double *d2000) -{ - DECLARE_DOUBLE(R1950); - DECLARE_DOUBLE(D1950); - DECLARE_DOUBLE(BEPOCH); - DECLARE_DOUBLE(R2000); - DECLARE_DOUBLE(D2000); - R1950 = r1950; - D1950 = d1950; - BEPOCH = bepoch; - F77_CALL(sla_fk45z) (DOUBLE_ARG(&R1950), - DOUBLE_ARG(&D1950), - DOUBLE_ARG(&BEPOCH), - DOUBLE_ARG(&R2000), DOUBLE_ARG(&D2000)); - *r2000 = R2000; - *d2000 = D2000; -} - -F77_SUBROUTINE(sla_fk54z) (DOUBLE(R2000), - DOUBLE(D2000), - DOUBLE(BEPOCH), - DOUBLE(R1950), - DOUBLE(D1950), DOUBLE(DR1950), DOUBLE(DD1950)); - -void slaFk54z(double r2000, double d2000, double bepoch, - double *r1950, double *d1950, double *dr1950, double *dd1950) -{ - DECLARE_DOUBLE(R2000); - DECLARE_DOUBLE(D2000); - DECLARE_DOUBLE(BEPOCH); - DECLARE_DOUBLE(R1950); - DECLARE_DOUBLE(D1950); - DECLARE_DOUBLE(DR1950); - DECLARE_DOUBLE(DD1950); - R2000 = r2000; - D2000 = d2000; - BEPOCH = bepoch; - F77_CALL(sla_fk54z) (DOUBLE_ARG(&R2000), - DOUBLE_ARG(&D2000), - DOUBLE_ARG(&BEPOCH), - DOUBLE_ARG(&R1950), - DOUBLE_ARG(&D1950), - DOUBLE_ARG(&DR1950), DOUBLE_ARG(&DD1950)); - *r1950 = R1950; - *d1950 = D1950; - *dr1950 = DR1950; - *dd1950 = DD1950; -} - -F77_SUBROUTINE(sla_galeq) (DOUBLE(DL), DOUBLE(DB), DOUBLE(DR), DOUBLE(DD)); - -void slaGaleq(double dl, double db, double *dr, double *dd) -{ - DECLARE_DOUBLE(DL); - DECLARE_DOUBLE(DB); - DECLARE_DOUBLE(DR); - DECLARE_DOUBLE(DD); - DL = dl; - DB = db; - F77_CALL(sla_galeq) (DOUBLE_ARG(&DL), - DOUBLE_ARG(&DB), DOUBLE_ARG(&DR), DOUBLE_ARG(&DD)); - *dr = DR; - *dd = DD; -} - -F77_SUBROUTINE(sla_galsup) (DOUBLE(DL), DOUBLE(DB), DOUBLE(DSL), DOUBLE(DSB)); - -void slaGalsup(double dl, double db, double *dsl, double *dsb) -{ - DECLARE_DOUBLE(DL); - DECLARE_DOUBLE(DB); - DECLARE_DOUBLE(DSL); - DECLARE_DOUBLE(DSB); - DL = dl; - DB = db; - F77_CALL(sla_galsup) (DOUBLE_ARG(&DL), - DOUBLE_ARG(&DB), DOUBLE_ARG(&DSL), DOUBLE_ARG(&DSB)); - *dsl = DSL; - *dsb = DSB; -} - -F77_DOUBLE_FUNCTION(sla_gmst) (DOUBLE(UT1)); - -double slaGmst(double ut1) -{ - DECLARE_DOUBLE(UT1); - double result; - UT1 = ut1; - result = F77_CALL(sla_gmst) (DOUBLE_ARG(&UT1)); - return result; -} - -F77_SUBROUTINE(sla_mappa) (DOUBLE(EQ), DOUBLE(DATE), DOUBLE_ARRAY(AMPRMS)); - -void slaMappa(double eq, double date, double amprms[21]) -{ - DECLARE_DOUBLE(EQ); - DECLARE_DOUBLE(DATE); - DECLARE_DOUBLE_ARRAY(AMPRMS, 21); - int i; - EQ = eq; - DATE = date; - F77_CALL(sla_mappa) (DOUBLE_ARG(&EQ), - DOUBLE_ARG(&DATE), DOUBLE_ARRAY_ARG(AMPRMS)); - for (i = 0; i < 21; i++) - amprms[i] = AMPRMS[i]; -} - -F77_SUBROUTINE(sla_mapqkz) (DOUBLE(RM), - DOUBLE(DM), - DOUBLE_ARRAY(AMPRMS), DOUBLE(RA), DOUBLE(DA)); - -void slaMapqkz(double rm, double dm, double amprms[21], double *ra, double *da) -{ - DECLARE_DOUBLE(RM); - DECLARE_DOUBLE(DM); - DECLARE_DOUBLE_ARRAY(AMPRMS, 21); - DECLARE_DOUBLE(RA); - DECLARE_DOUBLE(DA); - int i; - RM = rm; - DM = dm; - for (i = 0; i < 21; i++) - AMPRMS[i] = amprms[i]; - F77_CALL(sla_mapqkz) (DOUBLE_ARG(&RM), - DOUBLE_ARG(&DM), - DOUBLE_ARRAY_ARG(AMPRMS), - DOUBLE_ARG(&RA), DOUBLE_ARG(&DA)); - *ra = RA; - *da = DA; -} - -F77_SUBROUTINE(sla_prebn) (DOUBLE(BEP0), DOUBLE(BEP1), DOUBLE_ARRAY(RMATP)); - -void slaPrebn(double bep0, double bep1, double rmatp[3][3]) -{ - DECLARE_DOUBLE(BEP0); - DECLARE_DOUBLE(BEP1); - DECLARE_DOUBLE_ARRAY(RMATP, 9); - int i; - int j; - BEP0 = bep0; - BEP1 = bep1; - F77_CALL(sla_prebn) (DOUBLE_ARG(&BEP0), - DOUBLE_ARG(&BEP1), DOUBLE_ARRAY_ARG(RMATP)); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - rmatp[i][j] = RMATP[i + 3 * j]; - } -} - -F77_SUBROUTINE(sla_prec) (DOUBLE(EP0), DOUBLE(EP1), DOUBLE_ARRAY(RMATP)); - -void slaPrec(double ep0, double ep1, double rmatp[3][3]) -{ - DECLARE_DOUBLE(EP0); - DECLARE_DOUBLE(EP1); - DECLARE_DOUBLE_ARRAY(RMATP, 9); - int i; - int j; - EP0 = ep0; - EP1 = ep1; - F77_CALL(sla_prec) (DOUBLE_ARG(&EP0), DOUBLE_ARG(&EP1), DOUBLE_ARRAY_ARG(RMATP)); - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - rmatp[i][j] = RMATP[i + 3 * j]; - } -} - -F77_REAL_FUNCTION(sla_rverot) (REAL(PHI), REAL(RA), REAL(DEC), REAL(ST)); - -float slaRverot(float phi, float ra, float dec, float st) -{ - DECLARE_REAL(PHI); - DECLARE_REAL(RA); - DECLARE_REAL(DEC); - DECLARE_REAL(ST); - float result; - PHI = phi; - RA = ra; - DEC = dec; - ST = st; - result = F77_CALL(sla_rverot) (REAL_ARG(&PHI), - REAL_ARG(&RA), REAL_ARG(&DEC), REAL_ARG(&ST)); - return result; -} - -F77_REAL_FUNCTION(sla_rvgalc) (REAL(RA), REAL(DEC)); - -float slaRvgalc(float ra, float dec) -{ - DECLARE_REAL(RA); - DECLARE_REAL(DEC); - float result; - RA = ra; - DEC = dec; - result = F77_CALL(sla_rvgalc) (REAL_ARG(&RA), REAL_ARG(&DEC)); - return result; -} - -F77_REAL_FUNCTION(sla_rvlg) (REAL(RA), REAL(DEC)); - -float slaRvlg(float ra, float dec) -{ - DECLARE_REAL(RA); - DECLARE_REAL(DEC); - float result; - RA = ra; - DEC = dec; - result = F77_CALL(sla_rvlg) (REAL_ARG(&RA), REAL_ARG(&DEC)); - return result; -} - -F77_REAL_FUNCTION(sla_rvlsrd) (REAL(RA), REAL(DEC)); - -float slaRvlsrd(float ra, float dec) -{ - DECLARE_REAL(RA); - DECLARE_REAL(DEC); - float result; - RA = ra; - DEC = dec; - result = F77_CALL(sla_rvlsrd) (REAL_ARG(&RA), REAL_ARG(&DEC)); - return result; -} - -F77_REAL_FUNCTION(sla_rvlsrk) (REAL(RA), REAL(DEC)); - -float slaRvlsrk(float ra, float dec) -{ - DECLARE_REAL(RA); - DECLARE_REAL(DEC); - float result; - RA = ra; - DEC = dec; - result = F77_CALL(sla_rvlsrk) (REAL_ARG(&RA), REAL_ARG(&DEC)); - return result; -} - - -F77_SUBROUTINE(sla_subet) (DOUBLE(RC), - DOUBLE(DC), DOUBLE(EQ), DOUBLE(RM), DOUBLE(DM)); - -void slaSubet(double rc, double dc, double eq, double *rm, double *dm) -{ - DECLARE_DOUBLE(RC); - DECLARE_DOUBLE(DC); - DECLARE_DOUBLE(EQ); - DECLARE_DOUBLE(RM); - DECLARE_DOUBLE(DM); - RC = rc; - DC = dc; - EQ = eq; - F77_CALL(sla_subet) (DOUBLE_ARG(&RC), - DOUBLE_ARG(&DC), - DOUBLE_ARG(&EQ), DOUBLE_ARG(&RM), DOUBLE_ARG(&DM)); - *rm = RM; - *dm = DM; -} - -F77_SUBROUTINE(sla_supgal) (DOUBLE(DSL), DOUBLE(DSB), DOUBLE(DL), DOUBLE(DB)); - -void slaSupgal(double dsl, double dsb, double *dl, double *db) -{ - DECLARE_DOUBLE(DSL); - DECLARE_DOUBLE(DSB); - DECLARE_DOUBLE(DL); - DECLARE_DOUBLE(DB); - DSL = dsl; - DSB = dsb; - F77_CALL(sla_supgal) (DOUBLE_ARG(&DSL), - DOUBLE_ARG(&DSB), DOUBLE_ARG(&DL), DOUBLE_ARG(&DB)); - *dl = DL; - *db = DB; -} - - - -F77_SUBROUTINE(sla_svd) (INTEGER(M), - INTEGER(N), - INTEGER(MP), - INTEGER(NP), - DOUBLE_ARRAY(A), - DOUBLE_ARRAY(W), - DOUBLE_ARRAY(V), DOUBLE_ARRAY(WORK), INTEGER(JSTAT)); - -void slaSvd(int m, int n, int mp, int np, - double *a, double *w, double *v, double *work, int *jstat) -{ - DECLARE_INTEGER(M); - DECLARE_INTEGER(N); - DECLARE_INTEGER(MP); - DECLARE_INTEGER(NP); - F77_DOUBLE_TYPE *A; - F77_DOUBLE_TYPE *W; - F77_DOUBLE_TYPE *V; - F77_DOUBLE_TYPE *WORK; - DECLARE_INTEGER(JSTAT); - - - int i; - int j; - - A = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) (mp * np)); - W = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) n); - V = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) (np * np)); - WORK = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) n); - - if (WORK) { - M = m; - N = n; - MP = mp; - NP = np; - - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) - A[i + mp * j] = a[np * i + j]; - } - - F77_CALL(sla_svd) (INTEGER_ARG(&M), - INTEGER_ARG(&N), - INTEGER_ARG(&MP), - INTEGER_ARG(&NP), - DOUBLE_ARRAY_ARG(A), - DOUBLE_ARRAY_ARG(W), - DOUBLE_ARRAY_ARG(V), - DOUBLE_ARRAY_ARG(WORK), INTEGER_ARG(&JSTAT)); - - - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) - a[np * i + j] = A[i + mp * j]; - } - - for (i = 0; i < n; i++) { - w[i] = W[i]; - work[i] = WORK[i]; - for (j = 0; j < n; j++) - v[np * i + j] = V[i + np * j]; - } - - *jstat = JSTAT; - } - - free(A); - free(W); - free(V); - free(WORK); -} - -F77_SUBROUTINE(sla_svdsol) (INTEGER(M), - INTEGER(N), - INTEGER(MP), - INTEGER(NP), - DOUBLE_ARRAY(B), - DOUBLE_ARRAY(U), - DOUBLE_ARRAY(W), - DOUBLE_ARRAY(V), DOUBLE_ARRAY(WORK), DOUBLE_ARRAY(X)); - -void slaSvdsol(int m, int n, int mp, int np, - double *b, double *u, double *w, double *v, double *work, double *x) -{ - - DECLARE_INTEGER(M); - DECLARE_INTEGER(N); - DECLARE_INTEGER(MP); - DECLARE_INTEGER(NP); - F77_DOUBLE_TYPE *B; - F77_DOUBLE_TYPE *U; - F77_DOUBLE_TYPE *W; - F77_DOUBLE_TYPE *V; - F77_DOUBLE_TYPE *WORK; - F77_DOUBLE_TYPE *X; - - int i; - int j; - - B = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) (m)); - U = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) (mp * np)); - W = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) n); - V = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) (np * np)); - WORK = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) n); - X = malloc(sizeof(F77_DOUBLE_TYPE) * (size_t) n); - - if (X) { - M = m; - N = n; - MP = mp; - NP = np; - - for (i = 0; i < m; i++) { - B[i] = b[i]; - for (j = 0; j < n; j++) - U[i + mp * j] = u[np * i + j]; - } - for (i = 0; i < n; i++) { - W[i] = w[i]; - for (j = 0; j < n; j++) - V[i + np * j] = v[np * i + j]; - } - - F77_CALL(sla_svdsol) (INTEGER_ARG(&M), - INTEGER_ARG(&N), - INTEGER_ARG(&MP), - INTEGER_ARG(&NP), - DOUBLE_ARRAY_ARG(B), - DOUBLE_ARRAY_ARG(U), - DOUBLE_ARRAY_ARG(W), - DOUBLE_ARRAY_ARG(V), - DOUBLE_ARRAY_ARG(WORK), DOUBLE_ARRAY_ARG(X)); - - for (i = 0; i < n; i++) { - x[i] = X[i]; - work[i] = WORK[i]; - } - } - - free(B); - free(U); - free(W); - free(V); - free(WORK); - free(X); -} - - - -F77_SUBROUTINE(sla_evp) (DOUBLE(DATE), - DOUBLE(DEQX), - DOUBLE_ARRAY(DVB), - DOUBLE_ARRAY(DPB), DOUBLE_ARRAY(DVH), DOUBLE_ARRAY(DPH)); - -void slaEvp(double date, double deqx, double dvb[3], double dpb[3], - double dvh[3], double dph[3]) -{ - DECLARE_DOUBLE(DATE); - DECLARE_DOUBLE(DEQX); - DECLARE_DOUBLE_ARRAY(DVB, 3); - DECLARE_DOUBLE_ARRAY(DPB, 3); - DECLARE_DOUBLE_ARRAY(DVH, 3); - DECLARE_DOUBLE_ARRAY(DPH, 3); - - int i; - DATE = date; - DEQX = deqx; - F77_CALL(sla_evp) (DOUBLE_ARG(&DATE), - DOUBLE_ARG(&DEQX), - DOUBLE_ARRAY_ARG(DVB), - DOUBLE_ARRAY_ARG(DPB), - DOUBLE_ARRAY_ARG(DVH), DOUBLE_ARRAY_ARG(DPH)); - for (i = 0; i < 3; i++) { - dvb[i] = DVB[i]; - dpb[i] = DPB[i]; - dvh[i] = DVH[i]; - dph[i] = DPH[i]; - } - -} - -F77_SUBROUTINE(sla_fk5hz) (DOUBLE(R5), - DOUBLE(D5), DOUBLE(JEPOCH), DOUBLE(RH), DOUBLE(DH)); - -void slaFk5hz(double r5, double d5, double jepoch, double *rh, double *dh) -{ - DECLARE_DOUBLE(R5); - DECLARE_DOUBLE(D5); - DECLARE_DOUBLE(JEPOCH); - DECLARE_DOUBLE(RH); - DECLARE_DOUBLE(DH); - R5 = r5; - D5 = d5; - JEPOCH = jepoch; - F77_CALL(sla_fk5hz) (DOUBLE_ARG(&R5), - DOUBLE_ARG(&D5), - DOUBLE_ARG(&JEPOCH), DOUBLE_ARG(&RH), DOUBLE_ARG(&DH)); - *rh = RH; - *dh = DH; -} - -F77_SUBROUTINE(sla_hfk5z) (DOUBLE(RH), - DOUBLE(DH), - DOUBLE(JEPOCH), - DOUBLE(R5), DOUBLE(D5), DOUBLE(DR5), DOUBLE(DD5)); - -void slaHfk5z(double rh, double dh, double jepoch, - double *r5, double *d5, double *dr5, double *dd5) -{ - DECLARE_DOUBLE(RH); - DECLARE_DOUBLE(DH); - DECLARE_DOUBLE(JEPOCH); - DECLARE_DOUBLE(R5); - DECLARE_DOUBLE(D5); - DECLARE_DOUBLE(DR5); - DECLARE_DOUBLE(DD5); - RH = rh; - DH = dh; - JEPOCH = jepoch; - F77_CALL(sla_hfk5z) (DOUBLE_ARG(&RH), - DOUBLE_ARG(&DH), - DOUBLE_ARG(&JEPOCH), - DOUBLE_ARG(&R5), - DOUBLE_ARG(&D5), DOUBLE_ARG(&DR5), DOUBLE_ARG(&DD5)); - *r5 = R5; - *d5 = D5; - *dr5 = DR5; - *dd5 = DD5; -} - -F77_SUBROUTINE(sla_geoc) (DOUBLE(P), DOUBLE(H), DOUBLE(R), DOUBLE(Z)); - -void slaGeoc(double p, double h, double *r, double *z) -{ - DECLARE_DOUBLE(P); - DECLARE_DOUBLE(H); - DECLARE_DOUBLE(R); - DECLARE_DOUBLE(Z); - P = p; - H = h; - F77_CALL(sla_geoc) (DOUBLE_ARG(&P), - DOUBLE_ARG(&H), DOUBLE_ARG(&R), DOUBLE_ARG(&Z)); - *r = R; - *z = Z; -} - - -F77_SUBROUTINE(sla_deuler) (CHARACTER(ORDER), - DOUBLE(PHI), - DOUBLE(THETA), DOUBLE(PSI), DOUBLE_ARRAY(RMAT) - TRAIL(ORDER)); - -void slaDeuler(char *order, double phi, double theta, double psi, double rmat[3][3]) -{ - - DECLARE_CHARACTER(ORDER, 4); - DECLARE_DOUBLE(PHI); - DECLARE_DOUBLE(THETA); - DECLARE_DOUBLE(PSI); - DECLARE_DOUBLE_ARRAY(RMAT, 9); - int i, j; - - PHI = phi; - THETA = theta; - PSI = psi; - - slaStringExport(order, ORDER, 4); - - F77_CALL(sla_deuler) (CHARACTER_ARG(ORDER), - DOUBLE_ARG(&PHI), - DOUBLE_ARG(&THETA), - DOUBLE_ARG(&PSI), DOUBLE_ARRAY_ARG(RMAT) - TRAIL_ARG(ORDER)); - - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) - rmat[i][j] = RMAT[i + 3 * j]; - } - -} - - -F77_SUBROUTINE(sla_de2h) (DOUBLE(HA), - DOUBLE(DEC), DOUBLE(PHI), DOUBLE(AZ), DOUBLE(EL)); - -void slaDe2h(double ha, double dec, double phi, double *az, double *el) -{ - DECLARE_DOUBLE(HA); - DECLARE_DOUBLE(DEC); - DECLARE_DOUBLE(PHI); - DECLARE_DOUBLE(AZ); - DECLARE_DOUBLE(EL); - HA = ha; - DEC = dec; - PHI = phi; - F77_CALL(sla_de2h) (DOUBLE_ARG(&HA), - DOUBLE_ARG(&DEC), - DOUBLE_ARG(&PHI), DOUBLE_ARG(&AZ), DOUBLE_ARG(&EL)); - *az = AZ; - *el = EL; -} - -F77_SUBROUTINE(sla_dh2e) (DOUBLE(AZ), - DOUBLE(EL), DOUBLE(PHI), DOUBLE(HA), DOUBLE(DEC)); - -void slaDh2e(double az, double el, double phi, double *ha, double *dec) -{ - DECLARE_DOUBLE(AZ); - DECLARE_DOUBLE(EL); - DECLARE_DOUBLE(PHI); - DECLARE_DOUBLE(HA); - DECLARE_DOUBLE(DEC); - AZ = az; - EL = el; - PHI = phi; - F77_CALL(sla_dh2e) (DOUBLE_ARG(&AZ), - DOUBLE_ARG(&EL), - DOUBLE_ARG(&PHI), DOUBLE_ARG(&HA), DOUBLE_ARG(&DEC)); - *ha = HA; - *dec = DEC; -} - - -F77_SUBROUTINE(sla_oap) (CHARACTER(TYPE), - DOUBLE(OB1), - DOUBLE(OB2), - DOUBLE(DATE), - DOUBLE(DUT), - DOUBLE(ELONGM), - DOUBLE(PHIM), - DOUBLE(HM), - DOUBLE(XP), - DOUBLE(YP), - DOUBLE(TDK), - DOUBLE(PMB), - DOUBLE(RH), - DOUBLE(WL), DOUBLE(TLR), DOUBLE(RAP), DOUBLE(DAP) - TRAIL(TYPE)); - -/* Note that SLA insists that "c" has space for 10 characters + nul - and "name" has space for 40 characters + nul */ - -void -slaOap(char *type, double ob1, double ob2, double date, - double dut, double elongm, double phim, double hm, - double xp, double yp, double tdk, double pmb, - double rh, double wl, double tlr, double *rap, double *dap) -{ - - DECLARE_CHARACTER(TYPE, 1); - DECLARE_DOUBLE(OB1); - DECLARE_DOUBLE(OB2); - DECLARE_DOUBLE(DATE); - DECLARE_DOUBLE(DUT); - DECLARE_DOUBLE(ELONGM); - DECLARE_DOUBLE(PHIM); - DECLARE_DOUBLE(HM); - DECLARE_DOUBLE(XP); - DECLARE_DOUBLE(YP); - DECLARE_DOUBLE(TDK); - DECLARE_DOUBLE(PMB); - DECLARE_DOUBLE(RH); - DECLARE_DOUBLE(WL); - DECLARE_DOUBLE(TLR); - DECLARE_DOUBLE(RAP); - DECLARE_DOUBLE(DAP); - OB1 = ob1; - OB2 = ob2; - DATE = date; - DUT = dut; - ELONGM = elongm; - PHIM = phim; - HM = hm; - XP = xp; - YP = yp; - TDK = tdk; - PMB = pmb; - RH = rh; - WL = wl; - TLR = tlr; - slaStringExport(type, TYPE, 1); - - /* call the routine */ - F77_CALL(sla_oap) (CHARACTER_ARG(TYPE), - DOUBLE_ARG(&OB1), - DOUBLE_ARG(&OB2), - DOUBLE_ARG(&DATE), - DOUBLE_ARG(&DUT), - DOUBLE_ARG(&ELONGM), - DOUBLE_ARG(&PHIM), - DOUBLE_ARG(&HM), - DOUBLE_ARG(&XP), - DOUBLE_ARG(&YP), - DOUBLE_ARG(&TDK), - DOUBLE_ARG(&PMB), - DOUBLE_ARG(&RH), - DOUBLE_ARG(&WL), - DOUBLE_ARG(&TLR), DOUBLE_ARG(&RAP), DOUBLE_ARG(&DAP) - TRAIL_ARG(TYPE)); - *rap = RAP; - *dap = DAP; -} - -F77_SUBROUTINE(sla_obs) (INTEGER(I), - CHARACTER(C), - CHARACTER(NAME), DOUBLE(W), DOUBLE(P), DOUBLE(H) - TRAIL(C) - TRAIL(NAME)); - -/* Note that SLA insists that "c" has space for 10 characters + nul - and "name" has space for 40 characters + nul */ - -void slaObs(int n, char *c, char *name, double *w, double *p, double *h) -{ - - DECLARE_INTEGER(N); - DECLARE_CHARACTER(C, 10); - DECLARE_CHARACTER(NAME, 40); - DECLARE_DOUBLE(W); - DECLARE_DOUBLE(P); - DECLARE_DOUBLE(H); - - if (n < 1) { - /* C needs to be imported */ - slaStringExport(c, C, 10); - } else { - /* initialise C */ - slaStringExport("", C, 10); - } - F77_EXPORT_INTEGER(n, N); - - /* w, p and h are not touched on error but for consistency this means - we copy the current values to Fortran so that we can correctly copy - back the result. */ - F77_EXPORT_DOUBLE(*w, W); - F77_EXPORT_DOUBLE(*p, P); - F77_EXPORT_DOUBLE(*h, H); - - /* call the routine */ - F77_CALL(sla_obs) (INTEGER_ARG(&N), - CHARACTER_ARG(C), - CHARACTER_ARG(NAME), - DOUBLE_ARG(&W), DOUBLE_ARG(&P), DOUBLE_ARG(&H) - TRAIL_ARG(C) - TRAIL_ARG(NAME)); - - /* extract results */ - slaStringImport(NAME, 40, name); - if (n > 0 && name[0] != '?') { - /* only do this if we know we used a numeric input and if the result - for the NAME is not '?' (since we are not allowed to alter the string - in that case). This allows people - to call slaObs with a string constant */ - slaStringImport(C, 10, c); - } - F77_IMPORT_DOUBLE(W, *w); - F77_IMPORT_DOUBLE(P, *p); - F77_IMPORT_DOUBLE(H, *h); - -} - -F77_DOUBLE_FUNCTION(sla_pa) (DOUBLE(HA), DOUBLE(DEC), DOUBLE(PHI)); - -double slaPa(double ha, double dec, double phi) -{ - DECLARE_DOUBLE(HA); - DECLARE_DOUBLE(DEC); - DECLARE_DOUBLE(PHI); - DECLARE_DOUBLE(RETVAL); - double retval; - - F77_EXPORT_DOUBLE(ha, HA); - F77_EXPORT_DOUBLE(dec, DEC); - F77_EXPORT_DOUBLE(phi, PHI); - - RETVAL = F77_CALL(sla_pa) (DOUBLE_ARG(&HA), DOUBLE_ARG(&DEC), DOUBLE_ARG(&PHI)); - - F77_IMPORT_DOUBLE(RETVAL, retval); - return retval; -} - -F77_DOUBLE_FUNCTION(sla_dtt) (DOUBLE(UTC)); - -double slaDtt(double utc) -{ - DECLARE_DOUBLE(UTC); - DECLARE_DOUBLE(RETVAL); - double retval; - - F77_EXPORT_DOUBLE(utc, UTC); - RETVAL = F77_CALL(sla_dtt) (DOUBLE_ARG(&UTC)); - - F77_IMPORT_DOUBLE(RETVAL, retval); - return retval; -} - -F77_DOUBLE_FUNCTION(sla_dat) (DOUBLE(UTC)); - -double slaDat(double utc) -{ - DECLARE_DOUBLE(UTC); - DECLARE_DOUBLE(RETVAL); - double retval; - - F77_EXPORT_DOUBLE(utc, UTC); - RETVAL = F77_CALL(sla_dat) (DOUBLE_ARG(&UTC)); - - F77_IMPORT_DOUBLE(RETVAL, retval); - return retval; -} - -F77_SUBROUTINE(sla_rdplan) (DOUBLE(DATE), INTEGER(I), DOUBLE(ELONG), DOUBLE(PHI), - DOUBLE(RA), DOUBLE(DEC), DOUBLE(DIAM)); - -void -slaRdplan(double date, int i, double elong, double phi, - double *ra, double *dec, double *diam) -{ - DECLARE_DOUBLE(DATE); - DECLARE_INTEGER(I); - DECLARE_DOUBLE(ELONG); - DECLARE_DOUBLE(PHI); - DECLARE_DOUBLE(RA); - DECLARE_DOUBLE(DEC); - DECLARE_DOUBLE(DIAM); - - F77_EXPORT_DOUBLE(date, DATE); - F77_EXPORT_INTEGER(i, I); - F77_EXPORT_DOUBLE(elong, ELONG); - F77_EXPORT_DOUBLE(phi, PHI); - - F77_CALL(sla_rdplan) (DOUBLE_ARG(&DATE), - INTEGER_ARG(&I), - DOUBLE_ARG(&ELONG), - DOUBLE_ARG(&PHI), - DOUBLE_ARG(&RA), DOUBLE_ARG(&DEC), DOUBLE_ARG(&DIAM)); - - F77_IMPORT_DOUBLE(RA, *ra); - F77_IMPORT_DOUBLE(DEC, *dec); - F77_IMPORT_DOUBLE(DIAM, *diam); -} diff --git a/src/slalib/addet.f b/src/slalib/addet.f deleted file mode 100644 index f3d54f1a3..000000000 --- a/src/slalib/addet.f +++ /dev/null @@ -1,84 +0,0 @@ - SUBROUTINE sla_ADDET (RM, DM, EQ, RC, DC) -*+ -* - - - - - - -* A D D E T -* - - - - - - -* -* Add the E-terms (elliptic component of annual aberration) -* to a pre IAU 1976 mean place to conform to the old -* catalogue convention (double precision) -* -* Given: -* RM,DM dp RA,Dec (radians) without E-terms -* EQ dp Besselian epoch of mean equator and equinox -* -* Returned: -* RC,DC dp RA,Dec (radians) with E-terms included -* -* Note: -* -* Most star positions from pre-1984 optical catalogues (or -* derived from astrometry using such stars) embody the -* E-terms. If it is necessary to convert a formal mean -* place (for example a pulsar timing position) to one -* consistent with such a star catalogue, then the RA,Dec -* should be adjusted using this routine. -* -* Reference: -* Explanatory Supplement to the Astronomical Ephemeris, -* section 2D, page 48. -* -* Called: sla_ETRMS, sla_DCS2C, sla_DCC2S, sla_DRANRM, sla_DRANGE -* -* P.T.Wallace Starlink 18 March 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RM,DM,EQ,RC,DC - - DOUBLE PRECISION sla_DRANRM - - DOUBLE PRECISION A(3),V(3) - - INTEGER I - - - -* E-terms vector - CALL sla_ETRMS(EQ,A) - -* Spherical to Cartesian - CALL sla_DCS2C(RM,DM,V) - -* Include the E-terms - DO I=1,3 - V(I)=V(I)+A(I) - END DO - -* Cartesian to spherical - CALL sla_DCC2S(V,RC,DC) - -* Bring RA into conventional range - RC=sla_DRANRM(RC) - - END diff --git a/src/slalib/afin.f b/src/slalib/afin.f deleted file mode 100644 index ba1333fdc..000000000 --- a/src/slalib/afin.f +++ /dev/null @@ -1,119 +0,0 @@ - SUBROUTINE sla_AFIN (STRING, IPTR, A, J) -*+ -* - - - - - -* A F I N -* - - - - - -* -* Sexagesimal character string to angle (single precision) -* -* Given: -* STRING c*(*) string containing deg, arcmin, arcsec fields -* IPTR i pointer to start of decode (1st = 1) -* -* Returned: -* IPTR i advanced past the decoded angle -* A r angle in radians -* J i status: 0 = OK -* +1 = default, A unchanged -* -1 = bad degrees ) -* -2 = bad arcminutes ) (note 3) -* -3 = bad arcseconds ) -* -* Example: -* -* argument before after -* -* STRING '-57 17 44.806 12 34 56.7' unchanged -* IPTR 1 16 (points to 12...) -* A ? -1.00000 -* J ? 0 -* -* A further call to sla_AFIN, without adjustment of IPTR, will -* decode the second angle, 12deg 34min 56.7sec. -* -* Notes: -* -* 1) The first three "fields" in STRING are degrees, arcminutes, -* arcseconds, separated by spaces or commas. The degrees field -* may be signed, but not the others. The decoding is carried -* out by the DFLTIN routine and is free-format. -* -* 2) Successive fields may be absent, defaulting to zero. For -* zero status, the only combinations allowed are degrees alone, -* degrees and arcminutes, and all three fields present. If all -* three fields are omitted, a status of +1 is returned and A is -* unchanged. In all other cases A is changed. -* -* 3) Range checking: -* -* The degrees field is not range checked. However, it is -* expected to be integral unless the other two fields are -* absent. -* -* The arcminutes field is expected to be 0-59, and integral if -* the arcseconds field is present. If the arcseconds field -* is absent, the arcminutes is expected to be 0-59.9999... -* -* The arcseconds field is expected to be 0-59.9999... -* -* 4) Decoding continues even when a check has failed. Under these -* circumstances the field takes the supplied value, defaulting -* to zero, and the result A is computed and returned. -* -* 5) Further fields after the three expected ones are not treated -* as an error. The pointer IPTR is left in the correct state -* for further decoding with the present routine or with DFLTIN -* etc. See the example, above. -* -* 6) If STRING contains hours, minutes, seconds instead of degrees -* etc, or if the required units are turns (or days) instead of -* radians, the result A should be multiplied as follows: -* -* for to obtain multiply -* STRING A in A by -* -* d ' " radians 1 = 1.0 -* d ' " turns 1/2pi = 0.1591549430918953358 -* h m s radians 15 = 15.0 -* h m s days 15/2pi = 2.3873241463784300365 -* -* Called: sla_DAFIN -* -* P.T.Wallace Starlink 13 September 1990 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER IPTR - REAL A - INTEGER J - - DOUBLE PRECISION AD - - - -* Call the double precision version - CALL sla_DAFIN(STRING,IPTR,AD,J) - IF (J.LE.0) A=REAL(AD) - - END diff --git a/src/slalib/airmas.f b/src/slalib/airmas.f deleted file mode 100644 index 945857f22..000000000 --- a/src/slalib/airmas.f +++ /dev/null @@ -1,75 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_AIRMAS (ZD) -*+ -* - - - - - - - -* A I R M A S -* - - - - - - - -* -* Air mass at given zenith distance (double precision) -* -* Given: -* ZD d Observed zenith distance (radians) -* -* The result is an estimate of the air mass, in units of that -* at the zenith. -* -* Notes: -* -* 1) The "observed" zenith distance referred to above means "as -* affected by refraction". -* -* 2) Uses Hardie's (1962) polynomial fit to Bemporad's data for -* the relative air mass, X, in units of thickness at the zenith -* as tabulated by Schoenberg (1929). This is adequate for all -* normal needs as it is accurate to better than 0.1% up to X = -* 6.8 and better than 1% up to X = 10. Bemporad's tabulated -* values are unlikely to be trustworthy to such accuracy -* because of variations in density, pressure and other -* conditions in the atmosphere from those assumed in his work. -* -* 3) The sign of the ZD is ignored. -* -* 4) At zenith distances greater than about ZD = 87 degrees the -* air mass is held constant to avoid arithmetic overflows. -* -* References: -* Hardie, R.H., 1962, in "Astronomical Techniques" -* ed. W.A. Hiltner, University of Chicago Press, p180. -* Schoenberg, E., 1929, Hdb. d. Ap., -* Berlin, Julius Springer, 2, 268. -* -* Original code by P.W.Hill, St Andrews -* -* P.T.Wallace Starlink 18 March 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION ZD - - DOUBLE PRECISION SECZM1 - - - SECZM1 = 1D0/(COS(MIN(1.52D0,ABS(ZD))))-1D0 - sla_AIRMAS = 1D0 + SECZM1*(0.9981833D0 - : - SECZM1*(0.002875D0 + 0.0008083D0*SECZM1)) - - END diff --git a/src/slalib/altaz.f b/src/slalib/altaz.f deleted file mode 100644 index 89cb42fb0..000000000 --- a/src/slalib/altaz.f +++ /dev/null @@ -1,162 +0,0 @@ - SUBROUTINE sla_ALTAZ (HA, DEC, PHI, - : AZ, AZD, AZDD, EL, ELD, ELDD, PA, PAD, PADD) -*+ -* - - - - - - -* A L T A Z -* - - - - - - -* -* Positions, velocities and accelerations for an altazimuth -* telescope mount. -* -* (double precision) -* -* Given: -* HA d hour angle -* DEC d declination -* PHI d observatory latitude -* -* Returned: -* AZ d azimuth -* AZD d " velocity -* AZDD d " acceleration -* EL d elevation -* ELD d " velocity -* ELDD d " acceleration -* PA d parallactic angle -* PAD d " " velocity -* PADD d " " acceleration -* -* Notes: -* -* 1) Natural units are used throughout. HA, DEC, PHI, AZ, EL -* and ZD are in radians. The velocities and accelerations -* assume constant declination and constant rate of change of -* hour angle (as for tracking a star); the units of AZD, ELD -* and PAD are radians per radian of HA, while the units of AZDD, -* ELDD and PADD are radians per radian of HA squared. To -* convert into practical degree- and second-based units: -* -* angles * 360/2pi -> degrees -* velocities * (2pi/86400)*(360/2pi) -> degree/sec -* accelerations * ((2pi/86400)**2)*(360/2pi) -> degree/sec/sec -* -* Note that the seconds here are sidereal rather than SI. One -* sidereal second is about 0.99727 SI seconds. -* -* The velocity and acceleration factors assume the sidereal -* tracking case. Their respective numerical values are (exactly) -* 1/240 and (approximately) 1/3300236.9. -* -* 2) Azimuth is returned in the range 0-2pi; north is zero, -* and east is +pi/2. Elevation and parallactic angle are -* returned in the range +/-pi. Parallactic angle is +ve for -* a star west of the meridian and is the angle NP-star-zenith. -* -* 3) The latitude is geodetic as opposed to geocentric. The -* hour angle and declination are topocentric. Refraction and -* deficiencies in the telescope mounting are ignored. The -* purpose of the routine is to give the general form of the -* quantities. The details of a real telescope could profoundly -* change the results, especially close to the zenith. -* -* 4) No range checking of arguments is carried out. -* -* 5) In applications which involve many such calculations, rather -* than calling the present routine it will be more efficient to -* use inline code, having previously computed fixed terms such -* as sine and cosine of latitude, and (for tracking a star) -* sine and cosine of declination. -* -* This revision: 29 October 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION HA,DEC,PHI,AZ,AZD,AZDD,EL,ELD,ELDD,PA,PAD,PADD - - DOUBLE PRECISION DPI,D2PI,TINY - PARAMETER (DPI=3.1415926535897932384626433832795D0, - : D2PI=6.283185307179586476925286766559D0, - : TINY=1D-30) - - DOUBLE PRECISION SH,CH,SD,CD,SP,CP,CHCD,SDCP,X,Y,Z,RSQ,R,A,E,C,S, - : Q,QD,AD,ED,EDR,ADD,EDD,QDD - - -* Useful functions - SH=SIN(HA) - CH=COS(HA) - SD=SIN(DEC) - CD=COS(DEC) - SP=SIN(PHI) - CP=COS(PHI) - CHCD=CH*CD - SDCP=SD*CP - X=-CHCD*SP+SDCP - Y=-SH*CD - Z=CHCD*CP+SD*SP - RSQ=X*X+Y*Y - R=SQRT(RSQ) - -* Azimuth and elevation - IF (RSQ.EQ.0D0) THEN - A=0D0 - ELSE - A=ATAN2(Y,X) - END IF - IF (A.LT.0D0) A=A+D2PI - E=ATAN2(Z,R) - -* Parallactic angle - C=CD*SP-CH*SDCP - S=SH*CP - IF (C*C+S*S.GT.0) THEN - Q=ATAN2(S,C) - ELSE - Q=DPI-HA - END IF - -* Velocities and accelerations (clamped at zenith/nadir) - IF (RSQ.LT.TINY) THEN - RSQ=TINY - R=SQRT(RSQ) - END IF - QD=-X*CP/RSQ - AD=SP+Z*QD - ED=CP*Y/R - EDR=ED/R - ADD=EDR*(Z*SP+(2D0-RSQ)*QD) - EDD=-R*QD*AD - QDD=EDR*(SP+2D0*Z*QD) - -* Results - AZ=A - AZD=AD - AZDD=ADD - EL=E - ELD=ED - ELDD=EDD - PA=Q - PAD=QD - PADD=QDD - - END diff --git a/src/slalib/amp.f b/src/slalib/amp.f deleted file mode 100644 index 1562cd45d..000000000 --- a/src/slalib/amp.f +++ /dev/null @@ -1,88 +0,0 @@ - SUBROUTINE sla_AMP (RA, DA, DATE, EQ, RM, DM) -*+ -* - - - - -* A M P -* - - - - -* -* Convert star RA,Dec from geocentric apparent to mean place -* -* The mean coordinate system is the post IAU 1976 system, -* loosely called FK5. -* -* Given: -* RA d apparent RA (radians) -* DA d apparent Dec (radians) -* DATE d TDB for apparent place (JD-2400000.5) -* EQ d equinox: Julian epoch of mean place -* -* Returned: -* RM d mean RA (radians) -* DM d mean Dec (radians) -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Notes: -* -* 1) The distinction between the required TDB and TT is always -* negligible. Moreover, for all but the most critical -* applications UTC is adequate. -* -* 2) Iterative techniques are used for the aberration and light -* deflection corrections so that the routines sla_AMP (or -* sla_AMPQK) and sla_MAP (or sla_MAPQK) are accurate inverses; -* even at the edge of the Sun's disc the discrepancy is only -* about 1 nanoarcsecond. -* -* 3) Where multiple apparent places are to be converted to mean -* places, for a fixed date and equinox, it is more efficient to -* use the sla_MAPPA routine to compute the required parameters -* once, followed by one call to sla_AMPQK per star. -* -* 4) The accuracy is sub-milliarcsecond, limited by the -* precession-nutation model (IAU 1976 precession, Shirai & -* Fukushima 2001 forced nutation and precession corrections). -* -* 5) The accuracy is further limited by the routine sla_EVP, called -* by sla_MAPPA, which computes the Earth position and velocity -* using the methods of Stumpff. The maximum error is about -* 0.3 mas. -* -* Called: sla_MAPPA, sla_AMPQK -* -* P.T.Wallace Starlink 17 September 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RA,DA,DATE,EQ,RM,DM - - DOUBLE PRECISION AMPRMS(21) - - - - CALL sla_MAPPA(EQ,DATE,AMPRMS) - CALL sla_AMPQK(RA,DA,AMPRMS,RM,DM) - - END diff --git a/src/slalib/ampqk.f b/src/slalib/ampqk.f deleted file mode 100644 index bc180ceb9..000000000 --- a/src/slalib/ampqk.f +++ /dev/null @@ -1,139 +0,0 @@ - SUBROUTINE sla_AMPQK (RA, DA, AMPRMS, RM, DM) -*+ -* - - - - - - -* A M P Q K -* - - - - - - -* -* Convert star RA,Dec from geocentric apparent to mean place -* -* The mean coordinate system is the post IAU 1976 system, -* loosely called FK5. -* -* Use of this routine is appropriate when efficiency is important -* and where many star positions are all to be transformed for -* one epoch and equinox. The star-independent parameters can be -* obtained by calling the sla_MAPPA routine. -* -* Given: -* RA d apparent RA (radians) -* DA d apparent Dec (radians) -* -* AMPRMS d(21) star-independent mean-to-apparent parameters: -* -* (1) time interval for proper motion (Julian years) -* (2-4) barycentric position of the Earth (AU) -* (5-7) heliocentric direction of the Earth (unit vector) -* (8) (grav rad Sun)*2/(Sun-Earth distance) -* (9-11) ABV: barycentric Earth velocity in units of c -* (12) sqrt(1-v**2) where v=modulus(ABV) -* (13-21) precession/nutation (3,3) matrix -* -* Returned: -* RM d mean RA (radians) -* DM d mean Dec (radians) -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Note: -* -* Iterative techniques are used for the aberration and -* light deflection corrections so that the routines -* sla_AMP (or sla_AMPQK) and sla_MAP (or sla_MAPQK) are -* accurate inverses; even at the edge of the Sun's disc -* the discrepancy is only about 1 nanoarcsecond. -* -* Called: sla_DCS2C, sla_DIMXV, sla_DVDV, sla_DVN, sla_DCC2S, -* sla_DRANRM -* -* P.T.Wallace Starlink 7 May 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RA,DA,AMPRMS(21),RM,DM - - INTEGER I,J - - DOUBLE PRECISION GR2E,AB1,EHN(3),ABV(3),P3(3),P2(3), - : AB1P1,P1DV,P1DVP1,P1(3),W,PDE,PDEP1,P(3) - - DOUBLE PRECISION sla_DVDV,sla_DRANRM - - - -* Unpack scalar and vector parameters - GR2E = AMPRMS(8) - AB1 = AMPRMS(12) - DO I=1,3 - EHN(I) = AMPRMS(I+4) - ABV(I) = AMPRMS(I+8) - END DO - -* Apparent RA,Dec to Cartesian - CALL sla_DCS2C(RA,DA,P3) - -* Precession and nutation - CALL sla_DIMXV(AMPRMS(13),P3,P2) - -* Aberration - AB1P1 = AB1+1D0 - DO I=1,3 - P1(I) = P2(I) - END DO - DO J=1,2 - P1DV = sla_DVDV(P1,ABV) - P1DVP1 = 1D0+P1DV - W = 1D0+P1DV/AB1P1 - DO I=1,3 - P1(I) = (P1DVP1*P2(I)-W*ABV(I))/AB1 - END DO - CALL sla_DVN(P1,P3,W) - DO I=1,3 - P1(I) = P3(I) - END DO - END DO - -* Light deflection - DO I=1,3 - P(I) = P1(I) - END DO - DO J=1,5 - PDE = sla_DVDV(P,EHN) - PDEP1 = 1D0+PDE - W = PDEP1-GR2E*PDE - DO I=1,3 - P(I) = (PDEP1*P1(I)-GR2E*EHN(I))/W - END DO - CALL sla_DVN(P,P2,W) - DO I=1,3 - P(I) = P2(I) - END DO - END DO - -* Mean RA,Dec - CALL sla_DCC2S(P,RM,DM) - RM = sla_DRANRM(RM) - - END diff --git a/src/slalib/aop.f b/src/slalib/aop.f deleted file mode 100644 index 1594f024f..000000000 --- a/src/slalib/aop.f +++ /dev/null @@ -1,191 +0,0 @@ - SUBROUTINE sla_AOP ( RAP, DAP, DATE, DUT, ELONGM, PHIM, HM, - : XP, YP, TDK, PMB, RH, WL, TLR, - : AOB, ZOB, HOB, DOB, ROB ) -*+ -* - - - - -* A O P -* - - - - -* -* Apparent to observed place, for sources distant from the solar -* system. -* -* Given: -* RAP d geocentric apparent right ascension -* DAP d geocentric apparent declination -* DATE d UTC date/time (Modified Julian Date, JD-2400000.5) -* DUT d delta UT: UT1-UTC (UTC seconds) -* ELONGM d mean longitude of the observer (radians, east +ve) -* PHIM d mean geodetic latitude of the observer (radians) -* HM d observer's height above sea level (metres) -* XP d polar motion x-coordinate (radians) -* YP d polar motion y-coordinate (radians) -* TDK d local ambient temperature (K; std=273.15D0) -* PMB d local atmospheric pressure (mb; std=1013.25D0) -* RH d local relative humidity (in the range 0D0-1D0) -* WL d effective wavelength (micron, e.g. 0.55D0) -* TLR d tropospheric lapse rate (K/metre, e.g. 0.0065D0) -* -* Returned: -* AOB d observed azimuth (radians: N=0,E=90) -* ZOB d observed zenith distance (radians) -* HOB d observed Hour Angle (radians) -* DOB d observed Declination (radians) -* ROB d observed Right Ascension (radians) -* -* Notes: -* -* 1) This routine returns zenith distance rather than elevation -* in order to reflect the fact that no allowance is made for -* depression of the horizon. -* -* 2) The accuracy of the result is limited by the corrections for -* refraction. Providing the meteorological parameters are -* known accurately and there are no gross local effects, the -* predicted apparent RA,Dec should be within about 0.1 arcsec -* for a zenith distance of less than 70 degrees. Even at a -* topocentric zenith distance of 90 degrees, the accuracy in -* elevation should be better than 1 arcmin; useful results -* are available for a further 3 degrees, beyond which the -* sla_REFRO routine returns a fixed value of the refraction. -* The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP -* (or sla_OAPQK) are self-consistent to better than 1 micro- -* arcsecond all over the celestial sphere. -* -* 3) It is advisable to take great care with units, as even -* unlikely values of the input parameters are accepted and -* processed in accordance with the models used. -* -* 4) "Apparent" place means the geocentric apparent right ascension -* and declination, which is obtained from a catalogue mean place -* by allowing for space motion, parallax, precession, nutation, -* annual aberration, and the Sun's gravitational lens effect. For -* star positions in the FK5 system (i.e. J2000), these effects can -* be applied by means of the sla_MAP etc routines. Starting from -* other mean place systems, additional transformations will be -* needed; for example, FK4 (i.e. B1950) mean places would first -* have to be converted to FK5, which can be done with the -* sla_FK425 etc routines. -* -* 5) "Observed" Az,El means the position that would be seen by a -* perfect theodolite located at the observer. This is obtained -* from the geocentric apparent RA,Dec by allowing for Earth -* orientation and diurnal aberration, rotating from equator -* to horizon coordinates, and then adjusting for refraction. -* The HA,Dec is obtained by rotating back into equatorial -* coordinates, using the geodetic latitude corrected for polar -* motion, and is the position that would be seen by a perfect -* equatorial located at the observer and with its polar axis -* aligned to the Earth's axis of rotation (n.b. not to the -* refracted pole). Finally, the RA is obtained by subtracting -* the HA from the local apparent ST. -* -* 6) To predict the required setting of a real telescope, the -* observed place produced by this routine would have to be -* adjusted for the tilt of the azimuth or polar axis of the -* mounting (with appropriate corrections for mount flexures), -* for non-perpendicularity between the mounting axes, for the -* position of the rotator axis and the pointing axis relative -* to it, for tube flexure, for gear and encoder errors, and -* finally for encoder zero points. Some telescopes would, of -* course, exhibit other properties which would need to be -* accounted for at the appropriate point in the sequence. -* -* 7) This routine takes time to execute, due mainly to the -* rigorous integration used to evaluate the refraction. -* For processing multiple stars for one location and time, -* call sla_AOPPA once followed by one call per star to sla_AOPQK. -* Where a range of times within a limited period of a few hours -* is involved, and the highest precision is not required, call -* sla_AOPPA once, followed by a call to sla_AOPPAT each time the -* time changes, followed by one call per star to sla_AOPQK. -* -* 8) The DATE argument is UTC expressed as an MJD. This is, -* strictly speaking, wrong, because of leap seconds. However, -* as long as the delta UT and the UTC are consistent there -* are no difficulties, except during a leap second. In this -* case, the start of the 61st second of the final minute should -* begin a new MJD day and the old pre-leap delta UT should -* continue to be used. As the 61st second completes, the MJD -* should revert to the start of the day as, simultaneously, -* the delta UTC changes by one second to its post-leap new value. -* -* 9) The delta UT (UT1-UTC) is tabulated in IERS circulars and -* elsewhere. It increases by exactly one second at the end of -* each UTC leap second, introduced in order to keep delta UT -* within +/- 0.9 seconds. -* -* 10) IMPORTANT -- TAKE CARE WITH THE LONGITUDE SIGN CONVENTION. -* The longitude required by the present routine is east-positive, -* in accordance with geographical convention (and right-handed). -* In particular, note that the longitudes returned by the -* sla_OBS routine are west-positive, following astronomical -* usage, and must be reversed in sign before use in the present -* routine. -* -* 11) The polar coordinates XP,YP can be obtained from IERS -* circulars and equivalent publications. The maximum amplitude -* is about 0.3 arcseconds. If XP,YP values are unavailable, -* use XP=YP=0D0. See page B60 of the 1988 Astronomical Almanac -* for a definition of the two angles. -* -* 12) The height above sea level of the observing station, HM, -* can be obtained from the Astronomical Almanac (Section J -* in the 1988 edition), or via the routine sla_OBS. If P, -* the pressure in millibars, is available, an adequate -* estimate of HM can be obtained from the expression -* -* HM ~ -29.3D0*TSL*LOG(P/1013.25D0). -* -* where TSL is the approximate sea-level air temperature in K -* (see Astrophysical Quantities, C.W.Allen, 3rd edition, -* section 52). Similarly, if the pressure P is not known, -* it can be estimated from the height of the observing -* station, HM, as follows: -* -* P ~ 1013.25D0*EXP(-HM/(29.3D0*TSL)). -* -* Note, however, that the refraction is nearly proportional to the -* pressure and that an accurate P value is important for precise -* work. -* -* 13) The azimuths etc produced by the present routine are with -* respect to the celestial pole. Corrections to the terrestrial -* pole can be computed using sla_POLMO. -* -* Called: sla_AOPPA, sla_AOPQK -* -* Last revision: 2 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RAP,DAP,DATE,DUT,ELONGM,PHIM,HM, - : XP,YP,TDK,PMB,RH,WL,TLR,AOB,ZOB,HOB,DOB,ROB - - DOUBLE PRECISION AOPRMS(14) - - - CALL sla_AOPPA(DATE,DUT,ELONGM,PHIM,HM,XP,YP,TDK,PMB,RH,WL,TLR, - : AOPRMS) - CALL sla_AOPQK(RAP,DAP,AOPRMS,AOB,ZOB,HOB,DOB,ROB) - - END diff --git a/src/slalib/aoppa.f b/src/slalib/aoppa.f deleted file mode 100644 index bce209625..000000000 --- a/src/slalib/aoppa.f +++ /dev/null @@ -1,193 +0,0 @@ - SUBROUTINE sla_AOPPA ( DATE, DUT, ELONGM, PHIM, HM, - : XP, YP, TDK, PMB, RH, WL, TLR, AOPRMS ) -*+ -* - - - - - - -* A O P P A -* - - - - - - -* -* Precompute apparent to observed place parameters required by -* sla_AOPQK and sla_OAPQK. -* -* Given: -* DATE d UTC date/time (modified Julian Date, JD-2400000.5) -* DUT d delta UT: UT1-UTC (UTC seconds) -* ELONGM d mean longitude of the observer (radians, east +ve) -* PHIM d mean geodetic latitude of the observer (radians) -* HM d observer's height above sea level (metres) -* XP d polar motion x-coordinate (radians) -* YP d polar motion y-coordinate (radians) -* TDK d local ambient temperature (K; std=273.15D0) -* PMB d local atmospheric pressure (mb; std=1013.25D0) -* RH d local relative humidity (in the range 0D0-1D0) -* WL d effective wavelength (micron, e.g. 0.55D0) -* TLR d tropospheric lapse rate (K/metre, e.g. 0.0065D0) -* -* Returned: -* AOPRMS d(14) star-independent apparent-to-observed parameters: -* -* (1) geodetic latitude (radians) -* (2,3) sine and cosine of geodetic latitude -* (4) magnitude of diurnal aberration vector -* (5) height (HM) -* (6) ambient temperature (TDK) -* (7) pressure (PMB) -* (8) relative humidity (RH) -* (9) wavelength (WL) -* (10) lapse rate (TLR) -* (11,12) refraction constants A and B (radians) -* (13) longitude + eqn of equinoxes + sidereal DUT (radians) -* (14) local apparent sidereal time (radians) -* -* Notes: -* -* 1) It is advisable to take great care with units, as even -* unlikely values of the input parameters are accepted and -* processed in accordance with the models used. -* -* 2) The DATE argument is UTC expressed as an MJD. This is, -* strictly speaking, improper, because of leap seconds. However, -* as long as the delta UT and the UTC are consistent there -* are no difficulties, except during a leap second. In this -* case, the start of the 61st second of the final minute should -* begin a new MJD day and the old pre-leap delta UT should -* continue to be used. As the 61st second completes, the MJD -* should revert to the start of the day as, simultaneously, -* the delta UTC changes by one second to its post-leap new value. -* -* 3) The delta UT (UT1-UTC) is tabulated in IERS circulars and -* elsewhere. It increases by exactly one second at the end of -* each UTC leap second, introduced in order to keep delta UT -* within +/- 0.9 seconds. -* -* 4) IMPORTANT -- TAKE CARE WITH THE LONGITUDE SIGN CONVENTION. -* The longitude required by the present routine is east-positive, -* in accordance with geographical convention (and right-handed). -* In particular, note that the longitudes returned by the -* sla_OBS routine are west-positive, following astronomical -* usage, and must be reversed in sign before use in the present -* routine. -* -* 5) The polar coordinates XP,YP can be obtained from IERS -* circulars and equivalent publications. The maximum amplitude -* is about 0.3 arcseconds. If XP,YP values are unavailable, -* use XP=YP=0D0. See page B60 of the 1988 Astronomical Almanac -* for a definition of the two angles. -* -* 6) The height above sea level of the observing station, HM, -* can be obtained from the Astronomical Almanac (Section J -* in the 1988 edition), or via the routine sla_OBS. If P, -* the pressure in millibars, is available, an adequate -* estimate of HM can be obtained from the expression -* -* HM ~ -29.3D0*TSL*LOG(P/1013.25D0). -* -* where TSL is the approximate sea-level air temperature in K -* (see Astrophysical Quantities, C.W.Allen, 3rd edition, -* section 52). Similarly, if the pressure P is not known, -* it can be estimated from the height of the observing -* station, HM, as follows: -* -* P ~ 1013.25D0*EXP(-HM/(29.3D0*TSL)). -* -* Note, however, that the refraction is nearly proportional to the -* pressure and that an accurate P value is important for precise -* work. -* -* 7) Repeated, computationally-expensive, calls to sla_AOPPA for -* times that are very close together can be avoided by calling -* sla_AOPPA just once and then using sla_AOPPAT for the subsequent -* times. Fresh calls to sla_AOPPA will be needed only when -* changes in the precession have grown to unacceptable levels or -* when anything affecting the refraction has changed. -* -* Called: sla_GEOC, sla_REFCO, sla_EQEQX, sla_AOPPAT -* -* Last revision: 2 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,DUT,ELONGM,PHIM,HM,XP,YP,TDK,PMB, - : RH,WL,TLR,AOPRMS(14) - - DOUBLE PRECISION sla_EQEQX - -* 2Pi - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925287D0) - -* Seconds of time to radians - DOUBLE PRECISION S2R - PARAMETER (S2R=7.272205216643039903848712D-5) - -* Speed of light (AU per day) - DOUBLE PRECISION C - PARAMETER (C=173.14463331D0) - -* Ratio between solar and sidereal time - DOUBLE PRECISION SOLSID - PARAMETER (SOLSID=1.00273790935D0) - - DOUBLE PRECISION CPHIM,XT,YT,ZT,XC,YC,ZC,ELONG,PHI,UAU,VAU - - - -* Observer's location corrected for polar motion - CPHIM = COS(PHIM) - XT = COS(ELONGM)*CPHIM - YT = SIN(ELONGM)*CPHIM - ZT = SIN(PHIM) - XC = XT-XP*ZT - YC = YT+YP*ZT - ZC = XP*XT-YP*YT+ZT - IF (XC.EQ.0D0.AND.YC.EQ.0D0) THEN - ELONG = 0D0 - ELSE - ELONG = ATAN2(YC,XC) - END IF - PHI = ATAN2(ZC,SQRT(XC*XC+YC*YC)) - AOPRMS(1) = PHI - AOPRMS(2) = SIN(PHI) - AOPRMS(3) = COS(PHI) - -* Magnitude of the diurnal aberration vector - CALL sla_GEOC(PHI,HM,UAU,VAU) - AOPRMS(4) = D2PI*UAU*SOLSID/C - -* Copy the refraction parameters and compute the A & B constants - AOPRMS(5) = HM - AOPRMS(6) = TDK - AOPRMS(7) = PMB - AOPRMS(8) = RH - AOPRMS(9) = WL - AOPRMS(10) = TLR - CALL sla_REFCO(HM,TDK,PMB,RH,WL,PHI,TLR,1D-10, - : AOPRMS(11),AOPRMS(12)) - -* Longitude + equation of the equinoxes + sidereal equivalent of DUT -* (ignoring change in equation of the equinoxes between UTC and TDB) - AOPRMS(13) = ELONG+sla_EQEQX(DATE)+DUT*SOLSID*S2R - -* Sidereal time - CALL sla_AOPPAT(DATE,AOPRMS) - - END diff --git a/src/slalib/aoppat.f b/src/slalib/aoppat.f deleted file mode 100644 index c74b1b324..000000000 --- a/src/slalib/aoppat.f +++ /dev/null @@ -1,62 +0,0 @@ - SUBROUTINE sla_AOPPAT (DATE, AOPRMS) -*+ -* - - - - - - - -* A O P P A T -* - - - - - - - -* -* Recompute the sidereal time in the apparent to observed place -* star-independent parameter block. -* -* Given: -* DATE d UTC date/time (modified Julian Date, JD-2400000.5) -* (see AOPPA source for comments on leap seconds) -* -* AOPRMS d(14) star-independent apparent-to-observed parameters -* -* (1-12) not required -* (13) longitude + eqn of equinoxes + sidereal DUT -* (14) not required -* -* Returned: -* AOPRMS d(14) star-independent apparent-to-observed parameters: -* -* (1-13) not changed -* (14) local apparent sidereal time (radians) -* -* For more information, see sla_AOPPA. -* -* Called: sla_GMST -* -* P.T.Wallace Starlink 1 July 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,AOPRMS(14) - - DOUBLE PRECISION sla_GMST - - - - AOPRMS(14) = sla_GMST(DATE)+AOPRMS(13) - - END diff --git a/src/slalib/aopqk.f b/src/slalib/aopqk.f deleted file mode 100644 index 287fd2298..000000000 --- a/src/slalib/aopqk.f +++ /dev/null @@ -1,259 +0,0 @@ - SUBROUTINE sla_AOPQK (RAP, DAP, AOPRMS, AOB, ZOB, HOB, DOB, ROB) -*+ -* - - - - - - -* A O P Q K -* - - - - - - -* -* Quick apparent to observed place (but see note 8, below, for -* remarks about speed). -* -* Given: -* RAP d geocentric apparent right ascension -* DAP d geocentric apparent declination -* AOPRMS d(14) star-independent apparent-to-observed parameters: -* -* (1) geodetic latitude (radians) -* (2,3) sine and cosine of geodetic latitude -* (4) magnitude of diurnal aberration vector -* (5) height (HM) -* (6) ambient temperature (T) -* (7) pressure (P) -* (8) relative humidity (RH) -* (9) wavelength (WL) -* (10) lapse rate (TLR) -* (11,12) refraction constants A and B (radians) -* (13) longitude + eqn of equinoxes + sidereal DUT (radians) -* (14) local apparent sidereal time (radians) -* -* Returned: -* AOB d observed azimuth (radians: N=0,E=90) -* ZOB d observed zenith distance (radians) -* HOB d observed Hour Angle (radians) -* DOB d observed Declination (radians) -* ROB d observed Right Ascension (radians) -* -* Notes: -* -* 1) This routine returns zenith distance rather than elevation -* in order to reflect the fact that no allowance is made for -* depression of the horizon. -* -* 2) The accuracy of the result is limited by the corrections for -* refraction. Providing the meteorological parameters are -* known accurately and there are no gross local effects, the -* observed RA,Dec predicted by this routine should be within -* about 0.1 arcsec for a zenith distance of less than 70 degrees. -* Even at a topocentric zenith distance of 90 degrees, the -* accuracy in elevation should be better than 1 arcmin; useful -* results are available for a further 3 degrees, beyond which -* the sla_REFRO routine returns a fixed value of the refraction. -* The complementary routines sla_AOP (or sla_AOPQK) and sla_OaAP -* (or sla_OAPQK) are self-consistent to better than 1 micro- -* arcsecond all over the celestial sphere. -* -* 3) It is advisable to take great care with units, as even -* unlikely values of the input parameters are accepted and -* processed in accordance with the models used. -* -* 4) "Apparent" place means the geocentric apparent right ascension -* and declination, which is obtained from a catalogue mean place -* by allowing for space motion, parallax, precession, nutation, -* annual aberration, and the Sun's gravitational lens effect. For -* star positions in the FK5 system (i.e. J2000), these effects can -* be applied by means of the sla_MAP etc routines. Starting from -* other mean place systems, additional transformations will be -* needed; for example, FK4 (i.e. B1950) mean places would first -* have to be converted to FK5, which can be done with the -* sla_FK425 etc routines. -* -* 5) "Observed" Az,El means the position that would be seen by a -* perfect theodolite located at the observer. This is obtained -* from the geocentric apparent RA,Dec by allowing for Earth -* orientation and diurnal aberration, rotating from equator -* to horizon coordinates, and then adjusting for refraction. -* The HA,Dec is obtained by rotating back into equatorial -* coordinates, using the geodetic latitude corrected for polar -* motion, and is the position that would be seen by a perfect -* equatorial located at the observer and with its polar axis -* aligned to the Earth's axis of rotation (n.b. not to the -* refracted pole). Finally, the RA is obtained by subtracting -* the HA from the local apparent ST. -* -* 6) To predict the required setting of a real telescope, the -* observed place produced by this routine would have to be -* adjusted for the tilt of the azimuth or polar axis of the -* mounting (with appropriate corrections for mount flexures), -* for non-perpendicularity between the mounting axes, for the -* position of the rotator axis and the pointing axis relative -* to it, for tube flexure, for gear and encoder errors, and -* finally for encoder zero points. Some telescopes would, of -* course, exhibit other properties which would need to be -* accounted for at the appropriate point in the sequence. -* -* 7) The star-independent apparent-to-observed-place parameters -* in AOPRMS may be computed by means of the sla_AOPPA routine. -* If nothing has changed significantly except the time, the -* sla_AOPPAT routine may be used to perform the requisite -* partial recomputation of AOPRMS. -* -* 8) At zenith distances beyond about 76 degrees, the need for -* special care with the corrections for refraction causes a -* marked increase in execution time. Moreover, the effect -* gets worse with increasing zenith distance. Adroit -* programming in the calling application may allow the -* problem to be reduced. Prepare an alternative AOPRMS array, -* computed for zero air-pressure; this will disable the -* refraction corrections and cause rapid execution. Using -* this AOPRMS array, a preliminary call to the present routine -* will, depending on the application, produce a rough position -* which may be enough to establish whether the full, slow -* calculation (using the real AOPRMS array) is worthwhile. -* For example, there would be no need for the full calculation -* if the preliminary call had already established that the -* source was well below the elevation limits for a particular -* telescope. -* -* 9) The azimuths etc produced by the present routine are with -* respect to the celestial pole. Corrections to the terrestrial -* pole can be computed using sla_POLMO. -* -* Called: sla_DCS2C, sla_REFZ, sla_REFRO, sla_DCC2S, sla_DRANRM -* -* P.T.Wallace Starlink 24 October 2003 -* -* Copyright (C) 2003 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RAP,DAP,AOPRMS(14),AOB,ZOB,HOB,DOB,ROB - -* Breakpoint for fast/slow refraction algorithm: -* ZD greater than arctan(4), (see sla_REFCO routine) -* or vector Z less than cosine(arctan(Z)) = 1/sqrt(17) - DOUBLE PRECISION ZBREAK - PARAMETER (ZBREAK=0.242535625D0) - - INTEGER I - - DOUBLE PRECISION SPHI,CPHI,ST,V(3),XHD,YHD,ZHD,DIURAB,F, - : XHDT,YHDT,ZHDT,XAET,YAET,ZAET,AZOBS, - : ZDT,REFA,REFB,ZDOBS,DZD,DREF,CE, - : XAEO,YAEO,ZAEO,HMOBS,DCOBS,RAOBS - - DOUBLE PRECISION sla_DRANRM - - - -* Sin, cos of latitude - SPHI = AOPRMS(2) - CPHI = AOPRMS(3) - -* Local apparent sidereal time - ST = AOPRMS(14) - -* Apparent RA,Dec to Cartesian -HA,Dec - CALL sla_DCS2C(RAP-ST,DAP,V) - XHD = V(1) - YHD = V(2) - ZHD = V(3) - -* Diurnal aberration - DIURAB = AOPRMS(4) - F = (1D0-DIURAB*YHD) - XHDT = F*XHD - YHDT = F*(YHD+DIURAB) - ZHDT = F*ZHD - -* Cartesian -HA,Dec to Cartesian Az,El (S=0,E=90) - XAET = SPHI*XHDT-CPHI*ZHDT - YAET = YHDT - ZAET = CPHI*XHDT+SPHI*ZHDT - -* Azimuth (N=0,E=90) - IF (XAET.EQ.0D0.AND.YAET.EQ.0D0) THEN - AZOBS = 0D0 - ELSE - AZOBS = ATAN2(YAET,-XAET) - END IF - -* Topocentric zenith distance - ZDT = ATAN2(SQRT(XAET*XAET+YAET*YAET),ZAET) - -* -* Refraction -* ---------- - -* Fast algorithm using two constant model - REFA = AOPRMS(11) - REFB = AOPRMS(12) - CALL sla_REFZ(ZDT,REFA,REFB,ZDOBS) - -* Large zenith distance? - IF (COS(ZDOBS).LT.ZBREAK) THEN - -* Yes: use rigorous algorithm - -* Initialize loop (maximum of 10 iterations) - I = 1 - DZD = 1D1 - DO WHILE (ABS(DZD).GT.1D-10.AND.I.LE.10) - -* Compute refraction using current estimate of observed ZD - CALL sla_REFRO(ZDOBS,AOPRMS(5),AOPRMS(6),AOPRMS(7), - : AOPRMS(8),AOPRMS(9),AOPRMS(1), - : AOPRMS(10),1D-8,DREF) - -* Remaining discrepancy - DZD = ZDOBS+DREF-ZDT - -* Update the estimate - ZDOBS = ZDOBS-DZD - -* Increment the iteration counter - I = I+1 - END DO - END IF - -* To Cartesian Az/ZD - CE = SIN(ZDOBS) - XAEO = -COS(AZOBS)*CE - YAEO = SIN(AZOBS)*CE - ZAEO = COS(ZDOBS) - -* Cartesian Az/ZD to Cartesian -HA,Dec - V(1) = SPHI*XAEO+CPHI*ZAEO - V(2) = YAEO - V(3) = -CPHI*XAEO+SPHI*ZAEO - -* To spherical -HA,Dec - CALL sla_DCC2S(V,HMOBS,DCOBS) - -* Right Ascension - RAOBS = sla_DRANRM(ST+HMOBS) - -* Return the results - AOB = AZOBS - ZOB = ZDOBS - HOB = -HMOBS - DOB = DCOBS - ROB = RAOBS - - END diff --git a/src/slalib/atmdsp.f b/src/slalib/atmdsp.f deleted file mode 100644 index 1831f5583..000000000 --- a/src/slalib/atmdsp.f +++ /dev/null @@ -1,140 +0,0 @@ - SUBROUTINE sla_ATMDSP (TDK, PMB, RH, WL1, A1, B1, WL2, A2, B2) -*+ -* - - - - - - - -* A T M D S P -* - - - - - - - -* -* Apply atmospheric-dispersion adjustments to refraction coefficients. -* -* Given: -* TDK d ambient temperature, K -* PMB d ambient pressure, millibars -* RH d ambient relative humidity, 0-1 -* WL1 d reference wavelength, micrometre (0.4D0 recommended) -* A1 d refraction coefficient A for wavelength WL1 (radians) -* B1 d refraction coefficient B for wavelength WL1 (radians) -* WL2 d wavelength for which adjusted A,B required -* -* Returned: -* A2 d refraction coefficient A for wavelength WL2 (radians) -* B2 d refraction coefficient B for wavelength WL2 (radians) -* -* Notes: -* -* 1 To use this routine, first call sla_REFCO specifying WL1 as the -* wavelength. This yields refraction coefficients A1,B1, correct -* for that wavelength. Subsequently, calls to sla_ATMDSP specifying -* different wavelengths will produce new, slightly adjusted -* refraction coefficients which apply to the specified wavelength. -* -* 2 Most of the atmospheric dispersion happens between 0.7 micrometre -* and the UV atmospheric cutoff, and the effect increases strongly -* towards the UV end. For this reason a blue reference wavelength -* is recommended, for example 0.4 micrometres. -* -* 3 The accuracy, for this set of conditions: -* -* height above sea level 2000 m -* latitude 29 deg -* pressure 793 mb -* temperature 17 degC -* humidity 50% -* lapse rate 0.0065 degC/m -* reference wavelength 0.4 micrometre -* star elevation 15 deg -* -* is about 2.5 mas RMS between 0.3 and 1.0 micrometres, and stays -* within 4 mas for the whole range longward of 0.3 micrometres -* (compared with a total dispersion from 0.3 to 20.0 micrometres -* of about 11 arcsec). These errors are typical for ordinary -* conditions and the given elevation; in extreme conditions values -* a few times this size may occur, while at higher elevations the -* errors become much smaller. -* -* 4 If either wavelength exceeds 100 micrometres, the radio case -* is assumed and the returned refraction coefficients are the -* same as the given ones. Note that radio refraction coefficients -* cannot be turned into optical values using this routine, nor -* vice versa. -* -* 5 The algorithm consists of calculation of the refractivity of the -* air at the observer for the two wavelengths, using the methods -* of the sla_REFRO routine, and then scaling of the two refraction -* coefficients according to classical refraction theory. This -* amounts to scaling the A coefficient in proportion to (n-1) and -* the B coefficient almost in the same ratio (see R.M.Green, -* "Spherical Astronomy", Cambridge University Press, 1985). -* -* Last revision 2 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION TDK,PMB,RH,WL1,A1,B1,WL2,A2,B2 - - DOUBLE PRECISION F,TDKOK,PMBOK,RHOK, - : PSAT,PWO,W1,WLOK,WLSQ,W2,DN1,DN2 - - -* Check for radio wavelengths - IF (WL1.GT.100D0.OR.WL2.GT.100D0) THEN - -* Radio: no dispersion - A2 = A1 - B2 = B1 - ELSE - -* Optical: keep arguments within safe bounds - TDKOK = MIN(MAX(TDK,100D0),500D0) - PMBOK = MIN(MAX(PMB,0D0),10000D0) - RHOK = MIN(MAX(RH,0D0),1D0) - -* Atmosphere parameters at the observer - PSAT = 10D0**(-8.7115D0+0.03477D0*TDKOK) - PWO = RHOK*PSAT - W1 = 11.2684D-6*PWO - -* Refractivity at the observer for first wavelength - WLOK = MAX(WL1,0.1D0) - WLSQ = WLOK*WLOK - W2 = 77.5317D-6+(0.43909D-6+0.00367D-6/WLSQ)/WLSQ - DN1 = (W2*PMBOK-W1)/TDKOK - -* Refractivity at the observer for second wavelength - WLOK = MAX(WL2,0.1D0) - WLSQ = WLOK*WLOK - W2 = 77.5317D-6+(0.43909D-6+0.00367D-6/WLSQ)/WLSQ - DN2 = (W2*PMBOK-W1)/TDKOK - -* Scale the refraction coefficients (see Green 4.31, p93) - IF (DN1.NE.0D0) THEN - F = DN2/DN1 - A2 = A1*F - B2 = B1*F - IF (DN1.NE.A1) B2=B2*(1D0+DN1*(DN1-DN2)/(2D0*(DN1-A1))) - ELSE - A2 = A1 - B2 = B1 - END IF - END IF - - END diff --git a/src/slalib/atms.f b/src/slalib/atms.f deleted file mode 100644 index c6d8ac2e7..000000000 --- a/src/slalib/atms.f +++ /dev/null @@ -1,57 +0,0 @@ - SUBROUTINE sla__ATMS (RT, TT, DNT, GAMAL, R, DN, RDNDR) -*+ -* - - - - - -* A T M S -* - - - - - -* -* Internal routine used by REFRO -* -* Refractive index and derivative with respect to height for the -* stratosphere. -* -* Given: -* RT d height of tropopause from centre of the Earth (metre) -* TT d temperature at the tropopause (K) -* DNT d refractive index at the tropopause -* GAMAL d constant of the atmospheric model = G*MD/R -* R d current distance from the centre of the Earth (metre) -* -* Returned: -* DN d refractive index at R -* RDNDR d R * rate the refractive index is changing at R -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RT,TT,DNT,GAMAL,R,DN,RDNDR - - DOUBLE PRECISION B,W - - - B = GAMAL/TT - W = (DNT-1D0)*EXP(-B*(R-RT)) - DN = 1D0+W - RDNDR = -R*B*W - - END diff --git a/src/slalib/atmt.f b/src/slalib/atmt.f deleted file mode 100644 index 625d8f7c9..000000000 --- a/src/slalib/atmt.f +++ /dev/null @@ -1,71 +0,0 @@ - SUBROUTINE sla__ATMT (R0, T0, ALPHA, GAMM2, DELM2, - : C1, C2, C3, C4, C5, C6, R, T, DN, RDNDR) -*+ -* - - - - - -* A T M T -* - - - - - -* -* Internal routine used by REFRO -* -* Refractive index and derivative with respect to height for the -* troposphere. -* -* Given: -* R0 d height of observer from centre of the Earth (metre) -* T0 d temperature at the observer (K) -* ALPHA d alpha ) -* GAMM2 d gamma minus 2 ) see HMNAO paper -* DELM2 d delta minus 2 ) -* C1 d useful term ) -* C2 d useful term ) -* C3 d useful term ) see source -* C4 d useful term ) of sla_REFRO -* C5 d useful term ) -* C6 d useful term ) -* R d current distance from the centre of the Earth (metre) -* -* Returned: -* T d temperature at R (K) -* DN d refractive index at R -* RDNDR d R * rate the refractive index is changing at R -* -* Note that in the optical case C5 and C6 are zero. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R0,T0,ALPHA,GAMM2,DELM2,C1,C2,C3,C4,C5,C6, - : R,T,DN,RDNDR - - DOUBLE PRECISION TT0,TT0GM2,TT0DM2 - - - T = MAX(MIN(T0-ALPHA*(R-R0),320D0),100D0) - TT0 = T/T0 - TT0GM2 = TT0**GAMM2 - TT0DM2 = TT0**DELM2 - DN = 1D0+(C1*TT0GM2-(C2-C5/T)*TT0DM2)*TT0 - RDNDR = R*(-C3*TT0GM2+(C4-C6/TT0)*TT0DM2) - - END diff --git a/src/slalib/av2m.f b/src/slalib/av2m.f deleted file mode 100644 index 3788b4cfe..000000000 --- a/src/slalib/av2m.f +++ /dev/null @@ -1,84 +0,0 @@ - SUBROUTINE sla_AV2M (AXVEC, RMAT) -*+ -* - - - - - -* A V 2 M -* - - - - - -* -* Form the rotation matrix corresponding to a given axial vector. -* -* (single precision) -* -* A rotation matrix describes a rotation about some arbitrary axis, -* called the Euler axis. The "axial vector" supplied to this routine -* has the same direction as the Euler axis, and its magnitude is the -* amount of rotation in radians. -* -* Given: -* AXVEC r(3) axial vector (radians) -* -* Returned: -* RMAT r(3,3) rotation matrix -* -* If AXVEC is null, the unit matrix is returned. -* -* The reference frame rotates clockwise as seen looking along -* the axial vector from the origin. -* -* Last revision: 26 November 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL AXVEC(3),RMAT(3,3) - - REAL X,Y,Z,PHI,S,C,W - - - -* Rotation angle - magnitude of axial vector - and functions - X = AXVEC(1) - Y = AXVEC(2) - Z = AXVEC(3) - PHI = SQRT(X*X+Y*Y+Z*Z) - S = SIN(PHI) - C = COS(PHI) - W = 1.0-C - -* Euler axis - direction of axial vector (perhaps null) - IF (PHI.NE.0.0) THEN - X = X/PHI - Y = Y/PHI - Z = Z/PHI - END IF - -* Compute the rotation matrix - RMAT(1,1) = X*X*W+C - RMAT(1,2) = X*Y*W+Z*S - RMAT(1,3) = X*Z*W-Y*S - RMAT(2,1) = X*Y*W-Z*S - RMAT(2,2) = Y*Y*W+C - RMAT(2,3) = Y*Z*W+X*S - RMAT(3,1) = X*Z*W+Y*S - RMAT(3,2) = Y*Z*W-X*S - RMAT(3,3) = Z*Z*W+C - - END diff --git a/src/slalib/bear.f b/src/slalib/bear.f deleted file mode 100644 index 09cfbd398..000000000 --- a/src/slalib/bear.f +++ /dev/null @@ -1,59 +0,0 @@ - REAL FUNCTION sla_BEAR (A1, B1, A2, B2) -*+ -* - - - - - -* B E A R -* - - - - - -* -* Bearing (position angle) of one point on a sphere relative to another -* (single precision) -* -* Given: -* A1,B1 r spherical coordinates of one point -* A2,B2 r spherical coordinates of the other point -* -* (The spherical coordinates are RA,Dec, Long,Lat etc, in radians.) -* -* The result is the bearing (position angle), in radians, of point -* A2,B2 as seen from point A1,B1. It is in the range +/- pi. If -* A2,B2 is due east of A1,B1 the bearing is +pi/2. Zero is returned -* if the two points are coincident. -* -* P.T.Wallace Starlink 23 March 1991 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL A1,B1,A2,B2 - - REAL DA,X,Y - - - DA=A2-A1 - Y=SIN(DA)*COS(B2) - X=SIN(B2)*COS(B1)-COS(B2)*SIN(B1)*COS(DA) - IF (X.NE.0.0.OR.Y.NE.0.0) THEN - sla_BEAR=ATAN2(Y,X) - ELSE - sla_BEAR=0.0 - END IF - - END diff --git a/src/slalib/caf2r.f b/src/slalib/caf2r.f deleted file mode 100644 index 1209b4407..000000000 --- a/src/slalib/caf2r.f +++ /dev/null @@ -1,74 +0,0 @@ - SUBROUTINE sla_CAF2R (IDEG, IAMIN, ASEC, RAD, J) -*+ -* - - - - - - -* C A F 2 R -* - - - - - - -* -* Convert degrees, arcminutes, arcseconds to radians -* (single precision) -* -* Given: -* IDEG int degrees -* IAMIN int arcminutes -* ASEC real arcseconds -* -* Returned: -* RAD real angle in radians -* J int status: 0 = OK -* 1 = IDEG outside range 0-359 -* 2 = IAMIN outside range 0-59 -* 3 = ASEC outside range 0-59.999... -* -* Notes: -* -* 1) The result is computed even if any of the range checks -* fail. -* -* 2) The sign must be dealt with outside this routine. -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IDEG,IAMIN - REAL ASEC,RAD - INTEGER J - -* Arc seconds to radians - REAL AS2R - PARAMETER (AS2R=0.484813681109535994E-5) - - - -* Preset status - J=0 - -* Validate arcsec, arcmin, deg - IF (ASEC.LT.0.0.OR.ASEC.GE.60.0) J=3 - IF (IAMIN.LT.0.OR.IAMIN.GT.59) J=2 - IF (IDEG.LT.0.OR.IDEG.GT.359) J=1 - -* Compute angle - RAD=AS2R*(60.0*(60.0*REAL(IDEG)+REAL(IAMIN))+ASEC) - - END diff --git a/src/slalib/caldj.f b/src/slalib/caldj.f deleted file mode 100644 index 9c91a5358..000000000 --- a/src/slalib/caldj.f +++ /dev/null @@ -1,74 +0,0 @@ - SUBROUTINE sla_CALDJ (IY, IM, ID, DJM, J) -*+ -* - - - - - - -* C A L D J -* - - - - - - -* -* Gregorian Calendar to Modified Julian Date -* -* (Includes century default feature: use sla_CLDJ for years -* before 100AD.) -* -* Given: -* IY,IM,ID int year, month, day in Gregorian calendar -* -* Returned: -* DJM dp modified Julian Date (JD-2400000.5) for 0 hrs -* J int status: -* 0 = OK -* 1 = bad year (MJD not computed) -* 2 = bad month (MJD not computed) -* 3 = bad day (MJD computed) -* -* Acceptable years are 00-49, interpreted as 2000-2049, -* 50-99, " " 1950-1999, -* 100 upwards, interpreted literally. -* -* Called: sla_CLDJ -* -* P.T.Wallace Starlink November 1985 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IY,IM,ID - DOUBLE PRECISION DJM - INTEGER J - - INTEGER NY - - - - -* Default century if appropriate - IF (IY.GE.0.AND.IY.LE.49) THEN - NY=IY+2000 - ELSE IF (IY.GE.50.AND.IY.LE.99) THEN - NY=IY+1900 - ELSE - NY=IY - END IF - -* Modified Julian Date - CALL sla_CLDJ(NY,IM,ID,DJM,J) - - END diff --git a/src/slalib/calyd.f b/src/slalib/calyd.f deleted file mode 100644 index 710f04aac..000000000 --- a/src/slalib/calyd.f +++ /dev/null @@ -1,82 +0,0 @@ - SUBROUTINE sla_CALYD (IY, IM, ID, NY, ND, J) -*+ -* - - - - - - -* C A L Y D -* - - - - - - -* -* Gregorian calendar date to year and day in year (in a Julian -* calendar aligned to the 20th/21st century Gregorian calendar). -* -* (Includes century default feature: use sla_CLYD for years -* before 100AD.) -* -* Given: -* IY,IM,ID int year, month, day in Gregorian calendar -* (year may optionally omit the century) -* Returned: -* NY int year (re-aligned Julian calendar) -* ND int day in year (1 = January 1st) -* J int status: -* 0 = OK -* 1 = bad year (before -4711) -* 2 = bad month -* 3 = bad day (but conversion performed) -* -* Notes: -* -* 1 This routine exists to support the low-precision routines -* sla_EARTH, sla_MOON and sla_ECOR. -* -* 2 Between 1900 March 1 and 2100 February 28 it returns answers -* which are consistent with the ordinary Gregorian calendar. -* Outside this range there will be a discrepancy which increases -* by one day for every non-leap century year. -* -* 3 Years in the range 50-99 are interpreted as 1950-1999, and -* years in the range 00-49 are interpreted as 2000-2049. -* -* Called: sla_CLYD -* -* P.T.Wallace Starlink 23 November 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IY,IM,ID,NY,ND,J - - INTEGER I - - - -* Default century if appropriate - IF (IY.GE.0.AND.IY.LE.49) THEN - I=IY+2000 - ELSE IF (IY.GE.50.AND.IY.LE.99) THEN - I=IY+1900 - ELSE - I=IY - END IF - -* Perform the conversion - CALL sla_CLYD(I,IM,ID,NY,ND,J) - - END diff --git a/src/slalib/cc2s.f b/src/slalib/cc2s.f deleted file mode 100644 index d74e4af7b..000000000 --- a/src/slalib/cc2s.f +++ /dev/null @@ -1,69 +0,0 @@ - SUBROUTINE sla_CC2S (V, A, B) -*+ -* - - - - - -* C C 2 S -* - - - - - -* -* Cartesian to spherical coordinates (single precision) -* -* Given: -* V r(3) x,y,z vector -* -* Returned: -* A,B r spherical coordinates in radians -* -* The spherical coordinates are longitude (+ve anticlockwise looking -* from the +ve latitude pole) and latitude. The Cartesian coordinates -* are right handed, with the x axis at zero longitude and latitude, and -* the z axis at the +ve latitude pole. -* -* If V is null, zero A and B are returned. At either pole, zero A is -* returned. -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL V(3),A,B - - REAL X,Y,Z,R - - - X = V(1) - Y = V(2) - Z = V(3) - R = SQRT(X*X+Y*Y) - - IF (R.EQ.0.0) THEN - A = 0.0 - ELSE - A = ATAN2(Y,X) - END IF - - IF (Z.EQ.0.0) THEN - B = 0.0 - ELSE - B = ATAN2(Z,R) - END IF - - END diff --git a/src/slalib/cc62s.f b/src/slalib/cc62s.f deleted file mode 100644 index e5e072c65..000000000 --- a/src/slalib/cc62s.f +++ /dev/null @@ -1,99 +0,0 @@ - SUBROUTINE sla_CC62S (V, A, B, R, AD, BD, RD) -*+ -* - - - - - - -* C C 6 2 S -* - - - - - - -* -* Conversion of position & velocity in Cartesian coordinates -* to spherical coordinates (single precision) -* -* Given: -* V r(6) Cartesian position & velocity vector -* -* Returned: -* A r longitude (radians) -* B r latitude (radians) -* R r radial coordinate -* AD r longitude derivative (radians per unit time) -* BD r latitude derivative (radians per unit time) -* RD r radial derivative -* -* P.T.Wallace Starlink 28 April 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL V(6),A,B,R,AD,BD,RD - - REAL X,Y,Z,XD,YD,ZD,RXY2,RXY,R2,XYP - - - -* Components of position/velocity vector - X=V(1) - Y=V(2) - Z=V(3) - XD=V(4) - YD=V(5) - ZD=V(6) - -* Component of R in XY plane squared - RXY2=X*X+Y*Y - -* Modulus squared - R2=RXY2+Z*Z - -* Protection against null vector - IF (R2.EQ.0.0) THEN - X=XD - Y=YD - Z=ZD - RXY2=X*X+Y*Y - R2=RXY2+Z*Z - END IF - -* Position and velocity in spherical coordinates - RXY=SQRT(RXY2) - XYP=X*XD+Y*YD - IF (RXY2.NE.0.0) THEN - A=ATAN2(Y,X) - B=ATAN2(Z,RXY) - AD=(X*YD-Y*XD)/RXY2 - BD=(ZD*RXY2-Z*XYP)/(R2*RXY) - ELSE - A=0.0 - IF (Z.NE.0.0) THEN - B=ATAN2(Z,RXY) - ELSE - B=0.0 - END IF - AD=0.0 - BD=0.0 - END IF - R=SQRT(R2) - IF (R.NE.0.0) THEN - RD=(XYP+Z*ZD)/R - ELSE - RD=0.0 - END IF - - END diff --git a/src/slalib/cd2tf.f b/src/slalib/cd2tf.f deleted file mode 100644 index 95ed79183..000000000 --- a/src/slalib/cd2tf.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_CD2TF (NDP, DAYS, SIGN, IHMSF) -*+ -* - - - - - - -* C D 2 T F -* - - - - - - -* -* Convert an interval in days into hours, minutes, seconds -* -* (single precision) -* -* Given: -* NDP int number of decimal places of seconds -* DAYS real interval in days -* -* Returned: -* SIGN char '+' or '-' -* IHMSF int(4) hours, minutes, seconds, fraction -* -* Notes: -* -* 1) NDP less than zero is interpreted as zero. -* -* 2) The largest useful value for NDP is determined by the size of -* DAYS, the format of REAL floating-point numbers on the target -* machine, and the risk of overflowing IHMSF(4). On some -* architectures, for DAYS up to 1.0, the available floating- -* point precision corresponds roughly to NDP=3. This is well -* below the ultimate limit of NDP=9 set by the capacity of a -* typical 32-bit IHMSF(4). -* -* 3) The absolute value of DAYS may exceed 1.0. In cases where it -* does not, it is up to the caller to test for and handle the -* case where DAYS is very nearly 1.0 and rounds up to 24 hours, -* by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero. -* -* Called: sla_DD2TF -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - REAL DAYS - CHARACTER SIGN*(*) - INTEGER IHMSF(4) - - - -* Call double precision version - CALL sla_DD2TF(NDP,DBLE(DAYS),SIGN,IHMSF) - - END diff --git a/src/slalib/cldj.f b/src/slalib/cldj.f deleted file mode 100644 index 47aeb01f1..000000000 --- a/src/slalib/cldj.f +++ /dev/null @@ -1,94 +0,0 @@ - SUBROUTINE sla_CLDJ (IY, IM, ID, DJM, J) -*+ -* - - - - - -* C L D J -* - - - - - -* -* Gregorian Calendar to Modified Julian Date -* -* Given: -* IY,IM,ID int year, month, day in Gregorian calendar -* -* Returned: -* DJM dp modified Julian Date (JD-2400000.5) for 0 hrs -* J int status: -* 0 = OK -* 1 = bad year (MJD not computed) -* 2 = bad month (MJD not computed) -* 3 = bad day (MJD computed) -* -* The year must be -4699 (i.e. 4700BC) or later. -* -* The algorithm is adapted from Hatcher 1984 (QJRAS 25, 53-55). -* -* Last revision: 27 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IY,IM,ID - DOUBLE PRECISION DJM - INTEGER J - -* Month lengths in days - INTEGER MTAB(12) - DATA MTAB / 31,28,31,30,31,30,31,31,30,31,30,31 / - - - -* Preset status. - J = 0 - -* Validate year. - IF ( IY .LT. -4699 ) THEN - J = 1 - ELSE - -* Validate month. - IF ( IM.GE.1 .AND. IM.LE.12 ) THEN - -* Allow for leap year. - IF ( MOD(IY,4) .EQ. 0 ) THEN - MTAB(2) = 29 - ELSE - MTAB(2) = 28 - END IF - IF ( MOD(IY,100).EQ.0 .AND. MOD(IY,400).NE.0 ) - : MTAB(2) = 28 - -* Validate day. - IF ( ID.LT.1 .OR. ID.GT.MTAB(IM) ) J=3 - -* Modified Julian Date. - DJM = DBLE ( ( 1461 * ( IY - (12-IM)/10 + 4712 ) ) / 4 - : + ( 306 * MOD ( IM+9, 12 ) + 5 ) / 10 - : - ( 3 * ( ( IY - (12-IM)/10 + 4900 ) / 100 ) ) / 4 - : + ID - 2399904 ) - -* Bad month. - ELSE - J=2 - END IF - - END IF - - END diff --git a/src/slalib/clyd.f b/src/slalib/clyd.f deleted file mode 100644 index 7876753b4..000000000 --- a/src/slalib/clyd.f +++ /dev/null @@ -1,118 +0,0 @@ - SUBROUTINE sla_CLYD (IY, IM, ID, NY, ND, JSTAT) -*+ -* - - - - - -* C L Y D -* - - - - - -* -* Gregorian calendar to year and day in year (in a Julian calendar -* aligned to the 20th/21st century Gregorian calendar). -* -* Given: -* IY,IM,ID i year, month, day in Gregorian calendar -* -* Returned: -* NY i year (re-aligned Julian calendar) -* ND i day in year (1 = January 1st) -* JSTAT i status: -* 0 = OK -* 1 = bad year (before -4711) -* 2 = bad month -* 3 = bad day (but conversion performed) -* -* Notes: -* -* 1 This routine exists to support the low-precision routines -* sla_EARTH, sla_MOON and sla_ECOR. -* -* 2 Between 1900 March 1 and 2100 February 28 it returns answers -* which are consistent with the ordinary Gregorian calendar. -* Outside this range there will be a discrepancy which increases -* by one day for every non-leap century year. -* -* 3 The essence of the algorithm is first to express the Gregorian -* date as a Julian Day Number and then to convert this back to -* a Julian calendar date, with day-in-year instead of month and -* day. See 12.92-1 and 12.95-1 in the reference. -* -* Reference: Explanatory Supplement to the Astronomical Almanac, -* ed P.K.Seidelmann, University Science Books (1992), -* p604-606. -* -* P.T.Wallace Starlink 26 November 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IY,IM,ID,NY,ND,JSTAT - - INTEGER I,J,K,L,N - -* Month lengths in days - INTEGER MTAB(12) - DATA MTAB/31,28,31,30,31,30,31,31,30,31,30,31/ - - - -* Preset status - JSTAT=0 - -* Validate year - IF (IY.GE.-4711) THEN - -* Validate month - IF (IM.GE.1.AND.IM.LE.12) THEN - -* Allow for (Gregorian) leap year - IF (MOD(IY,4).EQ.0.AND. - : (MOD(IY,100).NE.0.OR.MOD(IY,400).EQ.0)) THEN - MTAB(2)=29 - ELSE - MTAB(2)=28 - END IF - -* Validate day - IF (ID.LT.1.OR.ID.GT.MTAB(IM)) JSTAT=3 - -* Perform the conversion - I=(14-IM)/12 - K=IY-I - J=(1461*(K+4800))/4+(367*(IM-2+12*I))/12 - : -(3*((K+4900)/100))/4+ID-30660 - K=(J-1)/1461 - L=J-1461*K - N=(L-1)/365-L/1461 - J=((80*(L-365*N+30))/2447)/11 - I=N+J - ND=59+L-365*I+((4-N)/4)*(1-J) - NY=4*K+I-4716 - -* Bad month - ELSE - JSTAT=2 - END IF - ELSE - -* Bad year - JSTAT=1 - END IF - - END diff --git a/src/slalib/combn.f b/src/slalib/combn.f deleted file mode 100644 index c823495e1..000000000 --- a/src/slalib/combn.f +++ /dev/null @@ -1,159 +0,0 @@ - SUBROUTINE sla_COMBN ( NSEL, NCAND, LIST, J ) -*+ -* - - - - - - -* C O M B N -* - - - - - - -* -* Generate the next combination, a subset of a specified size chosen -* from a specified number of items. -* -* Given: -* NSEL i number of items (subset size) -* NCAND i number of candidates (set size) -* -* Given and returned: -* LIST i(NSEL) latest combination, LIST(1)=0 to initialize -* -* Returned: -* J i status: -1 = illegal NSEL or NCAND -* 0 = OK -* +1 = no more combinations available -* -* Notes: -* -* 1) NSEL and NCAND must both be at least 1, and NSEL must be less -* than or equal to NCAND. -* -* 2) This routine returns, in the LIST array, a subset of NSEL integers -* chosen from the range 1 to NCAND inclusive, in ascending order. -* Before calling the routine for the first time, the caller must set -* the first element of the LIST array to zero (any value less than 1 -* will do) to cause initialization. -* -* 2) The first combination to be generated is: -* -* LIST(1)=1, LIST(2)=2, ..., LIST(NSEL)=NSEL -* -* This is also the combination returned for the "finished" (J=1) -* case. -* -* The final permutation to be generated is: -* -* LIST(1)=NCAND, LIST(2)=NCAND-1, ..., LIST(NSEL)=NCAND-NSEL+1 -* -* 3) If the "finished" (J=1) status is ignored, the routine -* continues to deliver combinations, the pattern repeating -* every NCAND!/(NSEL!*(NCAND-NSEL)!) calls. -* -* 4) The algorithm is by R.F.Warren-Smith (private communication). -* -* P.T.Wallace Starlink 25 August 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NSEL,NCAND,LIST(NSEL),J - - INTEGER I,LISTI,NMAX,M - LOGICAL MORE - - -* Validate, and set status. - IF (NSEL.LT.1.OR.NCAND.LT.1.OR.NSEL.GT.NCAND) THEN - J = -1 - GO TO 9999 - ELSE - J = 0 - END IF - -* Just starting? - IF (LIST(1).LT.1) THEN - -* Yes: return 1,2,3... - DO I=1,NSEL - LIST(I) = I - END DO - - ELSE - -* No: find the first selection that we can increment. - -* Start with the first list item. - I = 1 - -* Loop. - MORE = .TRUE. - DO WHILE (MORE) - -* Current list item. - LISTI = LIST(I) - -* Is this the final list item? - IF (I.GE.NSEL) THEN - -* Yes: comparison value is number of candidates plus one. - NMAX = NCAND+1 - ELSE - -* No: comparison value is next list item. - NMAX = LIST(I+1) - END IF - -* Can the current item be incremented? - IF (NMAX-LISTI.GT.1) THEN - -* Yes: increment it. - LIST(I) = LISTI+1 - -* Reinitialize the preceding items. - DO M=1,I-1 - LIST(M) = M - END DO - -* Break. - MORE = .FALSE. - ELSE - -* Can't increment the current item: is it the final one? - IF (I.GE.NSEL) THEN - -* Yes: set the status. - J = 1 - -* Restart the sequence. - DO I=1,NSEL - LIST(I) = I - END DO - -* Break. - MORE = .FALSE. - ELSE - -* No: next list item. - I = I+1 - END IF - END IF - END DO - END IF - 9999 CONTINUE - - END diff --git a/src/slalib/compile_and_test.txt b/src/slalib/compile_and_test.txt deleted file mode 100644 index 6fe40d5cb..000000000 --- a/src/slalib/compile_and_test.txt +++ /dev/null @@ -1,6 +0,0 @@ -rm *.o -gfortran -fPIC -g -O2 -fno-second-underscore -c -I. *.f *.F -rm sla_test.o -gfortran -shared -o libsla.so -fno-second-underscore -g *.o -gfortran -o sla_test sla_test.f -fno-second-underscore -L. -lsla -./sla_test diff --git a/src/slalib/cr2af.f b/src/slalib/cr2af.f deleted file mode 100644 index 1e621442c..000000000 --- a/src/slalib/cr2af.f +++ /dev/null @@ -1,75 +0,0 @@ - SUBROUTINE sla_CR2AF (NDP, ANGLE, SIGN, IDMSF) -*+ -* - - - - - - -* C R 2 A F -* - - - - - - -* -* Convert an angle in radians into degrees, arcminutes, arcseconds -* (single precision) -* -* Given: -* NDP int number of decimal places of arcseconds -* ANGLE real angle in radians -* -* Returned: -* SIGN char '+' or '-' -* IDMSF int(4) degrees, arcminutes, arcseconds, fraction -* -* Notes: -* -* 1) NDP less than zero is interpreted as zero. -* -* 2) The largest useful value for NDP is determined by the size of -* ANGLE, the format of REAL floating-point numbers on the target -* machine, and the risk of overflowing IDMSF(4). On some -* architectures, for ANGLE up to 2pi, the available floating- -* point precision corresponds roughly to NDP=3. This is well -* below the ultimate limit of NDP=9 set by the capacity of a -* typical 32-bit IDMSF(4). -* -* 3) The absolute value of ANGLE may exceed 2pi. In cases where it -* does not, it is up to the caller to test for and handle the -* case where ANGLE is very nearly 2pi and rounds up to 360 deg, -* by testing for IDMSF(1)=360 and setting IDMSF(1-4) to zero. -* -* Called: sla_CD2TF -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - REAL ANGLE - CHARACTER SIGN*(*) - INTEGER IDMSF(4) - -* Hours to degrees * radians to turns - REAL F - PARAMETER (F=15.0/6.283185307179586476925287) - - - -* Scale then use days to h,m,s routine - CALL sla_CD2TF(NDP,ANGLE*F,SIGN,IDMSF) - - END diff --git a/src/slalib/cr2tf.f b/src/slalib/cr2tf.f deleted file mode 100644 index e0d7ec212..000000000 --- a/src/slalib/cr2tf.f +++ /dev/null @@ -1,75 +0,0 @@ - SUBROUTINE sla_CR2TF (NDP, ANGLE, SIGN, IHMSF) -*+ -* - - - - - - -* C R 2 T F -* - - - - - - -* -* Convert an angle in radians into hours, minutes, seconds -* (single precision) -* -* Given: -* NDP int number of decimal places of seconds -* ANGLE real angle in radians -* -* Returned: -* SIGN char '+' or '-' -* IHMSF int(4) hours, minutes, seconds, fraction -* -* Notes: -* -* 1) NDP less than zero is interpreted as zero. -* -* 2) The largest useful value for NDP is determined by the size of -* ANGLE, the format of REAL floating-point numbers on the target -* machine, and the risk of overflowing IHMSF(4). On some -* architectures, for ANGLE up to 2pi, the available floating-point -* precision corresponds roughly to NDP=3. This is well below -* the ultimate limit of NDP=9 set by the capacity of a typical -* 32-bit IHMSF(4). -* -* 3) The absolute value of ANGLE may exceed 2pi. In cases where it -* does not, it is up to the caller to test for and handle the -* case where ANGLE is very nearly 2pi and rounds up to 24 hours, -* by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero. -* -* Called: sla_CD2TF -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - REAL ANGLE - CHARACTER SIGN*(*) - INTEGER IHMSF(4) - -* Turns to radians - REAL T2R - PARAMETER (T2R=6.283185307179586476925287) - - - -* Scale then use days to h,m,s routine - CALL sla_CD2TF(NDP,ANGLE/T2R,SIGN,IHMSF) - - END diff --git a/src/slalib/cs2c.f b/src/slalib/cs2c.f deleted file mode 100644 index ab210214d..000000000 --- a/src/slalib/cs2c.f +++ /dev/null @@ -1,57 +0,0 @@ - SUBROUTINE sla_CS2C (A, B, V) -*+ -* - - - - - -* C S 2 C -* - - - - - -* -* Spherical coordinates to direction cosines (single precision) -* -* Given: -* A,B real spherical coordinates in radians -* (RA,Dec), (long,lat) etc. -* -* Returned: -* V real(3) x,y,z unit vector -* -* The spherical coordinates are longitude (+ve anticlockwise looking -* from the +ve latitude pole) and latitude. The Cartesian coordinates -* are right handed, with the x axis at zero longitude and latitude, and -* the z axis at the +ve latitude pole. -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL A,B,V(3) - - REAL COSB - - - - COSB = COS(B) - - V(1) = COS(A)*COSB - V(2) = SIN(A)*COSB - V(3) = SIN(B) - - END diff --git a/src/slalib/cs2c6.f b/src/slalib/cs2c6.f deleted file mode 100644 index 5b714d41b..000000000 --- a/src/slalib/cs2c6.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_CS2C6 ( A, B, R, AD, BD, RD, V ) -*+ -* - - - - - - -* C S 2 C 6 -* - - - - - - -* -* Conversion of position & velocity in spherical coordinates -* to Cartesian coordinates (single precision) -* -* Given: -* A r longitude (radians) -* B r latitude (radians) -* R r radial coordinate -* AD r longitude derivative (radians per unit time) -* BD r latitude derivative (radians per unit time) -* RD r radial derivative -* -* Returned: -* V r(6) Cartesian position & velocity vector -* -* Last revision: 11 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL A, B, R, AD, BD, RD, V(6) - - REAL SA, CA, SB, CB, RCB, X, Y, RBD, W - - - -* Useful functions. - SA = SIN(A) - CA = COS(A) - SB = SIN(B) - CB = COS(B) - RCB = R*CB - X = RCB*CA - Y = RCB*SA - RBD = R*BD - W = RBD*SB-CB*RD - -* Position. - V(1) = X - V(2) = Y - V(3) = R*SB - -* Velocity. - V(4) = -Y*AD-W*CA - V(5) = X*AD-W*SA - V(6) = RBD*CB+SB*RD - - END diff --git a/src/slalib/ctf2d.f b/src/slalib/ctf2d.f deleted file mode 100644 index 9de8fef23..000000000 --- a/src/slalib/ctf2d.f +++ /dev/null @@ -1,73 +0,0 @@ - SUBROUTINE sla_CTF2D (IHOUR, IMIN, SEC, DAYS, J) -*+ -* - - - - - - -* C T F 2 D -* - - - - - - -* -* Convert hours, minutes, seconds to days (single precision) -* -* Given: -* IHOUR int hours -* IMIN int minutes -* SEC real seconds -* -* Returned: -* DAYS real interval in days -* J int status: 0 = OK -* 1 = IHOUR outside range 0-23 -* 2 = IMIN outside range 0-59 -* 3 = SEC outside range 0-59.999... -* -* Notes: -* -* 1) The result is computed even if any of the range checks -* fail. -* -* 2) The sign must be dealt with outside this routine. -* -* P.T.Wallace Starlink November 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IHOUR,IMIN - REAL SEC,DAYS - INTEGER J - -* Seconds per day - REAL D2S - PARAMETER (D2S=86400.0) - - - -* Preset status - J=0 - -* Validate sec, min, hour - IF (SEC.LT.0.0.OR.SEC.GE.60.0) J=3 - IF (IMIN.LT.0.OR.IMIN.GT.59) J=2 - IF (IHOUR.LT.0.OR.IHOUR.GT.23) J=1 - -* Compute interval - DAYS=(60.0*(60.0*REAL(IHOUR)+REAL(IMIN))+SEC)/D2S - - END diff --git a/src/slalib/ctf2r.f b/src/slalib/ctf2r.f deleted file mode 100644 index 83ecb5df4..000000000 --- a/src/slalib/ctf2r.f +++ /dev/null @@ -1,71 +0,0 @@ - SUBROUTINE sla_CTF2R (IHOUR, IMIN, SEC, RAD, J) -*+ -* - - - - - - -* C T F 2 R -* - - - - - - -* -* Convert hours, minutes, seconds to radians (single precision) -* -* Given: -* IHOUR int hours -* IMIN int minutes -* SEC real seconds -* -* Returned: -* RAD real angle in radians -* J int status: 0 = OK -* 1 = IHOUR outside range 0-23 -* 2 = IMIN outside range 0-59 -* 3 = SEC outside range 0-59.999... -* -* Called: -* sla_CTF2D -* -* Notes: -* -* 1) The result is computed even if any of the range checks -* fail. -* -* 2) The sign must be dealt with outside this routine. -* -* P.T.Wallace Starlink November 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IHOUR,IMIN - REAL SEC,RAD - INTEGER J - - REAL TURNS - -* Turns to radians - REAL T2R - PARAMETER (T2R=6.283185307179586476925287) - - - -* Convert to turns then radians - CALL sla_CTF2D(IHOUR,IMIN,SEC,TURNS,J) - RAD=T2R*TURNS - - END diff --git a/src/slalib/daf2r.f b/src/slalib/daf2r.f deleted file mode 100644 index f13f0a3e0..000000000 --- a/src/slalib/daf2r.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_DAF2R (IDEG, IAMIN, ASEC, RAD, J) -*+ -* - - - - - - -* D A F 2 R -* - - - - - - -* -* Convert degrees, arcminutes, arcseconds to radians -* (double precision) -* -* Given: -* IDEG int degrees -* IAMIN int arcminutes -* ASEC dp arcseconds -* -* Returned: -* RAD dp angle in radians -* J int status: 0 = OK -* 1 = IDEG outside range 0-359 -* 2 = IAMIN outside range 0-59 -* 3 = ASEC outside range 0-59.999... -* -* Notes: -* 1) The result is computed even if any of the range checks -* fail. -* 2) The sign must be dealt with outside this routine. -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IDEG,IAMIN - DOUBLE PRECISION ASEC,RAD - INTEGER J - -* Arc seconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - - - -* Preset status - J=0 - -* Validate arcsec, arcmin, deg - IF (ASEC.LT.0D0.OR.ASEC.GE.60D0) J=3 - IF (IAMIN.LT.0.OR.IAMIN.GT.59) J=2 - IF (IDEG.LT.0.OR.IDEG.GT.359) J=1 - -* Compute angle - RAD=AS2R*(60D0*(60D0*DBLE(IDEG)+DBLE(IAMIN))+ASEC) - - END diff --git a/src/slalib/dafin.f b/src/slalib/dafin.f deleted file mode 100644 index 05969d7b0..000000000 --- a/src/slalib/dafin.f +++ /dev/null @@ -1,180 +0,0 @@ - SUBROUTINE sla_DAFIN (STRING, IPTR, A, J) -*+ -* - - - - - - -* D A F I N -* - - - - - - -* -* Sexagesimal character string to angle (double precision) -* -* Given: -* STRING c*(*) string containing deg, arcmin, arcsec fields -* IPTR i pointer to start of decode (1st = 1) -* -* Returned: -* IPTR i advanced past the decoded angle -* A d angle in radians -* J i status: 0 = OK -* +1 = default, A unchanged -* -1 = bad degrees ) -* -2 = bad arcminutes ) (note 3) -* -3 = bad arcseconds ) -* -* Example: -* -* argument before after -* -* STRING '-57 17 44.806 12 34 56.7' unchanged -* IPTR 1 16 (points to 12...) -* A ? -1.00000D0 -* J ? 0 -* -* A further call to sla_DAFIN, without adjustment of IPTR, will -* decode the second angle, 12deg 34min 56.7sec. -* -* Notes: -* -* 1) The first three "fields" in STRING are degrees, arcminutes, -* arcseconds, separated by spaces or commas. The degrees field -* may be signed, but not the others. The decoding is carried -* out by the DFLTIN routine and is free-format. -* -* 2) Successive fields may be absent, defaulting to zero. For -* zero status, the only combinations allowed are degrees alone, -* degrees and arcminutes, and all three fields present. If all -* three fields are omitted, a status of +1 is returned and A is -* unchanged. In all other cases A is changed. -* -* 3) Range checking: -* -* The degrees field is not range checked. However, it is -* expected to be integral unless the other two fields are absent. -* -* The arcminutes field is expected to be 0-59, and integral if -* the arcseconds field is present. If the arcseconds field -* is absent, the arcminutes is expected to be 0-59.9999... -* -* The arcseconds field is expected to be 0-59.9999... -* -* 4) Decoding continues even when a check has failed. Under these -* circumstances the field takes the supplied value, defaulting -* to zero, and the result A is computed and returned. -* -* 5) Further fields after the three expected ones are not treated -* as an error. The pointer IPTR is left in the correct state -* for further decoding with the present routine or with DFLTIN -* etc. See the example, above. -* -* 6) If STRING contains hours, minutes, seconds instead of degrees -* etc, or if the required units are turns (or days) instead of -* radians, the result A should be multiplied as follows: -* -* for to obtain multiply -* STRING A in A by -* -* d ' " radians 1 = 1D0 -* d ' " turns 1/2pi = 0.1591549430918953358D0 -* h m s radians 15 = 15D0 -* h m s days 15/2pi = 2.3873241463784300365D0 -* -* Called: sla_DFLTIN -* -* P.T.Wallace Starlink 1 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER IPTR - DOUBLE PRECISION A - INTEGER J - - DOUBLE PRECISION AS2R - PARAMETER (AS2R=4.84813681109535993589914102358D-6) - INTEGER JF,JD,JM,JS - DOUBLE PRECISION DEG,ARCMIN,ARCSEC - - - -* Preset the status to OK - JF=0 - -* Defaults - DEG=0D0 - ARCMIN=0D0 - ARCSEC=0D0 - -* Decode degrees, arcminutes, arcseconds - CALL sla_DFLTIN(STRING,IPTR,DEG,JD) - IF (JD.GT.1) THEN - JF=-1 - ELSE - CALL sla_DFLTIN(STRING,IPTR,ARCMIN,JM) - IF (JM.LT.0.OR.JM.GT.1) THEN - JF=-2 - ELSE - CALL sla_DFLTIN(STRING,IPTR,ARCSEC,JS) - IF (JS.LT.0.OR.JS.GT.1) THEN - JF=-3 - -* See if the combination of fields is credible - ELSE IF (JD.GT.0) THEN -* No degrees: arcmin, arcsec ought also to be absent - IF (JM.EQ.0) THEN -* Suspect arcmin - JF=-2 - ELSE IF (JS.EQ.0) THEN -* Suspect arcsec - JF=-3 - ELSE -* All three fields absent - JF=1 - END IF -* Degrees present: if arcsec present so ought arcmin to be - ELSE IF (JM.NE.0.AND.JS.EQ.0) THEN - JF=-3 - -* Tests for range and integrality - -* Degrees - ELSE IF (JM.EQ.0.AND.DINT(DEG).NE.DEG) THEN - JF=-1 -* Arcminutes - ELSE IF ((JS.EQ.0.AND.DINT(ARCMIN).NE.ARCMIN).OR. - : ARCMIN.GE.60D0) THEN - JF=-2 -* Arcseconds - ELSE IF (ARCSEC.GE.60D0) THEN - JF=-3 - END IF - END IF - END IF - -* Unless all three fields absent, compute angle value - IF (JF.LE.0) THEN - A=AS2R*(60D0*(60D0*ABS(DEG)+ARCMIN)+ARCSEC) - IF (JD.LT.0) A=-A - END IF - -* Return the status - J=JF - - END diff --git a/src/slalib/dat.f b/src/slalib/dat.f deleted file mode 100644 index 21a6eedbc..000000000 --- a/src/slalib/dat.f +++ /dev/null @@ -1,252 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DAT (UTC) -*+ -* - - - - -* D A T -* - - - - -* -* Increment to be applied to Coordinated Universal Time UTC to give -* International Atomic Time TAI (double precision) -* -* Given: -* UTC d UTC date as a modified JD (JD-2400000.5) -* -* Result: TAI-UTC in seconds -* -* Notes: -* -* 1 The UTC is specified to be a date rather than a time to indicate -* that care needs to be taken not to specify an instant which lies -* within a leap second. Though in most cases UTC can include the -* fractional part, correct behaviour on the day of a leap second -* can only be guaranteed up to the end of the second 23:59:59. -* -* 2 For epochs from 1961 January 1 onwards, the expressions from the -* file ftp://maia.usno.navy.mil/ser7/tai-utc.dat are used. -* -* 3 The 5ms time step at 1961 January 1 is taken from 2.58.1 (p87) of -* the 1992 Explanatory Supplement. -* -* 4 UTC began at 1960 January 1.0 (JD 2436934.5) and it is improper -* to call the routine with an earlier epoch. However, if this -* is attempted, the TAI-UTC expression for the year 1960 is used. -* -* -* :-----------------------------------------: -* : : -* : IMPORTANT : -* : : -* : This routine must be updated on each : -* : occasion that a leap second is : -* : announced : -* : : -* : Latest leap second: 2015 July 1 : -* : : -* :-----------------------------------------: -* -* Last revision: 31 January 2015 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION UTC - - DOUBLE PRECISION DT - - - - IF (.FALSE.) THEN - -* - - - - - - - - - - - - - - - - - - - - - - * -* Add new code here on each occasion that a * -* leap second is announced, and update the * -* preamble comments appropriately. * -* - - - - - - - - - - - - - - - - - - - - - - * - -* 2015 July 1 - ELSE IF (UTC.GE.57204D0) THEN - DT=36D0 - -* 2012 July 1 - ELSE IF (UTC.GE.56109D0) THEN - DT=35D0 - -* 2009 January 1 - ELSE IF (UTC.GE.54832D0) THEN - DT=34D0 - -* 2006 January 1 - ELSE IF (UTC.GE.53736D0) THEN - DT=33D0 - -* 1999 January 1 - ELSE IF (UTC.GE.51179D0) THEN - DT=32D0 - -* 1997 July 1 - ELSE IF (UTC.GE.50630D0) THEN - DT=31D0 - -* 1996 January 1 - ELSE IF (UTC.GE.50083D0) THEN - DT=30D0 - -* 1994 July 1 - ELSE IF (UTC.GE.49534D0) THEN - DT=29D0 - -* 1993 July 1 - ELSE IF (UTC.GE.49169D0) THEN - DT=28D0 - -* 1992 July 1 - ELSE IF (UTC.GE.48804D0) THEN - DT=27D0 - -* 1991 January 1 - ELSE IF (UTC.GE.48257D0) THEN - DT=26D0 - -* 1990 January 1 - ELSE IF (UTC.GE.47892D0) THEN - DT=25D0 - -* 1988 January 1 - ELSE IF (UTC.GE.47161D0) THEN - DT=24D0 - -* 1985 July 1 - ELSE IF (UTC.GE.46247D0) THEN - DT=23D0 - -* 1983 July 1 - ELSE IF (UTC.GE.45516D0) THEN - DT=22D0 - -* 1982 July 1 - ELSE IF (UTC.GE.45151D0) THEN - DT=21D0 - -* 1981 July 1 - ELSE IF (UTC.GE.44786D0) THEN - DT=20D0 - -* 1980 January 1 - ELSE IF (UTC.GE.44239D0) THEN - DT=19D0 - -* 1979 January 1 - ELSE IF (UTC.GE.43874D0) THEN - DT=18D0 - -* 1978 January 1 - ELSE IF (UTC.GE.43509D0) THEN - DT=17D0 - -* 1977 January 1 - ELSE IF (UTC.GE.43144D0) THEN - DT=16D0 - -* 1976 January 1 - ELSE IF (UTC.GE.42778D0) THEN - DT=15D0 - -* 1975 January 1 - ELSE IF (UTC.GE.42413D0) THEN - DT=14D0 - -* 1974 January 1 - ELSE IF (UTC.GE.42048D0) THEN - DT=13D0 - -* 1973 January 1 - ELSE IF (UTC.GE.41683D0) THEN - DT=12D0 - -* 1972 July 1 - ELSE IF (UTC.GE.41499D0) THEN - DT=11D0 - -* 1972 January 1 - ELSE IF (UTC.GE.41317D0) THEN - DT=10D0 - -* 1968 February 1 - ELSE IF (UTC.GE.39887D0) THEN - DT=4.2131700D0+(UTC-39126D0)*0.002592D0 - -* 1966 January 1 - ELSE IF (UTC.GE.39126D0) THEN - DT=4.3131700D0+(UTC-39126D0)*0.002592D0 - -* 1965 September 1 - ELSE IF (UTC.GE.39004D0) THEN - DT=3.8401300D0+(UTC-38761D0)*0.001296D0 - -* 1965 July 1 - ELSE IF (UTC.GE.38942D0) THEN - DT=3.7401300D0+(UTC-38761D0)*0.001296D0 - -* 1965 March 1 - ELSE IF (UTC.GE.38820D0) THEN - DT=3.6401300D0+(UTC-38761D0)*0.001296D0 - -* 1965 January 1 - ELSE IF (UTC.GE.38761D0) THEN - DT=3.5401300D0+(UTC-38761D0)*0.001296D0 - -* 1964 September 1 - ELSE IF (UTC.GE.38639D0) THEN - DT=3.4401300D0+(UTC-38761D0)*0.001296D0 - -* 1964 April 1 - ELSE IF (UTC.GE.38486D0) THEN - DT=3.3401300D0+(UTC-38761D0)*0.001296D0 - -* 1964 January 1 - ELSE IF (UTC.GE.38395D0) THEN - DT=3.2401300D0+(UTC-38761D0)*0.001296D0 - -* 1963 November 1 - ELSE IF (UTC.GE.38334D0) THEN - DT=1.9458580D0+(UTC-37665D0)*0.0011232D0 - -* 1962 January 1 - ELSE IF (UTC.GE.37665D0) THEN - DT=1.8458580D0+(UTC-37665D0)*0.0011232D0 - -* 1961 August 1 - ELSE IF (UTC.GE.37512D0) THEN - DT=1.3728180D0+(UTC-37300D0)*0.001296D0 - -* 1961 January 1 - ELSE IF (UTC.GE.37300D0) THEN - DT=1.4228180D0+(UTC-37300D0)*0.001296D0 - -* Before that - ELSE - DT=1.4178180D0+(UTC-37300D0)*0.001296D0 - - END IF - - sla_DAT=DT - - END diff --git a/src/slalib/dav2m.f b/src/slalib/dav2m.f deleted file mode 100644 index 994d4ff91..000000000 --- a/src/slalib/dav2m.f +++ /dev/null @@ -1,83 +0,0 @@ - SUBROUTINE sla_DAV2M (AXVEC, RMAT) -*+ -* - - - - - - -* D A V 2 M -* - - - - - - -* -* Form the rotation matrix corresponding to a given axial vector. -* (double precision) -* -* A rotation matrix describes a rotation about some arbitrary axis, -* called the Euler axis. The "axial vector" supplied to this routine -* has the same direction as the Euler axis, and its magnitude is the -* amount of rotation in radians. -* -* Given: -* AXVEC d(3) axial vector (radians) -* -* Returned: -* RMAT d(3,3) rotation matrix -* -* If AXVEC is null, the unit matrix is returned. -* -* The reference frame rotates clockwise as seen looking along -* the axial vector from the origin. -* -* Last revision: 26 November 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION AXVEC(3),RMAT(3,3) - - DOUBLE PRECISION X,Y,Z,PHI,S,C,W - - - -* Rotation angle - magnitude of axial vector - and functions - X = AXVEC(1) - Y = AXVEC(2) - Z = AXVEC(3) - PHI = SQRT(X*X+Y*Y+Z*Z) - S = SIN(PHI) - C = COS(PHI) - W = 1D0-C - -* Euler axis - direction of axial vector (perhaps null) - IF (PHI.NE.0D0) THEN - X = X/PHI - Y = Y/PHI - Z = Z/PHI - END IF - -* Compute the rotation matrix - RMAT(1,1) = X*X*W+C - RMAT(1,2) = X*Y*W+Z*S - RMAT(1,3) = X*Z*W-Y*S - RMAT(2,1) = X*Y*W-Z*S - RMAT(2,2) = Y*Y*W+C - RMAT(2,3) = Y*Z*W+X*S - RMAT(3,1) = X*Z*W+Y*S - RMAT(3,2) = Y*Z*W-X*S - RMAT(3,3) = Z*Z*W+C - - END diff --git a/src/slalib/dbear.f b/src/slalib/dbear.f deleted file mode 100644 index b452f7895..000000000 --- a/src/slalib/dbear.f +++ /dev/null @@ -1,59 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DBEAR (A1, B1, A2, B2) -*+ -* - - - - - - -* D B E A R -* - - - - - - -* -* Bearing (position angle) of one point on a sphere relative to another -* (double precision) -* -* Given: -* A1,B1 d spherical coordinates of one point -* A2,B2 d spherical coordinates of the other point -* -* (The spherical coordinates are RA,Dec, Long,Lat etc, in radians.) -* -* The result is the bearing (position angle), in radians, of point -* A2,B2 as seen from point A1,B1. It is in the range +/- pi. If -* A2,B2 is due east of A1,B1 the bearing is +pi/2. Zero is returned -* if the two points are coincident. -* -* P.T.Wallace Starlink 23 March 1991 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION A1,B1,A2,B2 - - DOUBLE PRECISION DA,X,Y - - - DA=A2-A1 - Y=SIN(DA)*COS(B2) - X=SIN(B2)*COS(B1)-COS(B2)*SIN(B1)*COS(DA) - IF (X.NE.0D0.OR.Y.NE.0D0) THEN - sla_DBEAR=ATAN2(Y,X) - ELSE - sla_DBEAR=0D0 - END IF - - END diff --git a/src/slalib/dbjin.f b/src/slalib/dbjin.f deleted file mode 100644 index 6e319ad75..000000000 --- a/src/slalib/dbjin.f +++ /dev/null @@ -1,130 +0,0 @@ - SUBROUTINE sla_DBJIN (STRING, NSTRT, DRESLT, J1, J2) -*+ -* - - - - - - -* D B J I N -* - - - - - - -* -* Convert free-format input into double precision floating point, -* using DFLTIN but with special syntax extensions. -* -* The purpose of the syntax extensions is to help cope with mixed -* FK4 and FK5 data. In addition to the syntax accepted by DFLTIN, -* the following two extensions are recognized by DBJIN: -* -* 1) A valid non-null field preceded by the character 'B' -* (or 'b') is accepted. -* -* 2) A valid non-null field preceded by the character 'J' -* (or 'j') is accepted. -* -* The calling program is notified of the incidence of either of these -* extensions through an supplementary status argument. The rest of -* the arguments are as for DFLTIN. -* -* Given: -* STRING char string containing field to be decoded -* NSTRT int pointer to 1st character of field in string -* -* Returned: -* NSTRT int incremented -* DRESLT double result -* J1 int DFLTIN status: -1 = -OK -* 0 = +OK -* +1 = null field -* +2 = error -* J2 int syntax flag: 0 = normal DFLTIN syntax -* +1 = 'B' or 'b' -* +2 = 'J' or 'j' -* -* Called: sla_DFLTIN -* -* For details of the basic syntax, see sla_DFLTIN. -* -* P.T.Wallace Starlink 23 November 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER NSTRT - DOUBLE PRECISION DRESLT - INTEGER J1,J2 - - INTEGER J2A,LENSTR,NA,J1A,NB,J1B - CHARACTER C - - - -* Preset syntax flag - J2A=0 - -* Length of string - LENSTR=LEN(STRING) - -* Pointer to current character - NA=NSTRT - -* Attempt normal decode - CALL sla_DFLTIN(STRING,NA,DRESLT,J1A) - -* Proceed only if pointer still within string - IF (NA.GE.1.AND.NA.LE.LENSTR) THEN - -* See if DFLTIN reported a null field - IF (J1A.EQ.1) THEN - -* It did: examine character it stuck on - C=STRING(NA:NA) - IF (C.EQ.'B'.OR.C.EQ.'b') THEN -* 'B' - provisionally note - J2A=1 - ELSE IF (C.EQ.'J'.OR.C.EQ.'j') THEN -* 'J' - provisionally note - J2A=2 - END IF - -* Following B or J, attempt to decode a number - IF (J2A.EQ.1.OR.J2A.EQ.2) THEN - NB=NA+1 - CALL sla_DFLTIN(STRING,NB,DRESLT,J1B) - -* If successful, copy pointer and status - IF (J1B.LE.0) THEN - NA=NB - J1A=J1B -* If not, forget about the B or J - ELSE - J2A=0 - END IF - - END IF - - END IF - - END IF - -* Return argument values and exit - NSTRT=NA - J1=J1A - J2=J2A - - END diff --git a/src/slalib/dc62s.f b/src/slalib/dc62s.f deleted file mode 100644 index f2f4c8b2e..000000000 --- a/src/slalib/dc62s.f +++ /dev/null @@ -1,99 +0,0 @@ - SUBROUTINE sla_DC62S (V, A, B, R, AD, BD, RD) -*+ -* - - - - - - -* D C 6 2 S -* - - - - - - -* -* Conversion of position & velocity in Cartesian coordinates -* to spherical coordinates (double precision) -* -* Given: -* V d(6) Cartesian position & velocity vector -* -* Returned: -* A d longitude (radians) -* B d latitude (radians) -* R d radial coordinate -* AD d longitude derivative (radians per unit time) -* BD d latitude derivative (radians per unit time) -* RD d radial derivative -* -* P.T.Wallace Starlink 28 April 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION V(6),A,B,R,AD,BD,RD - - DOUBLE PRECISION X,Y,Z,XD,YD,ZD,RXY2,RXY,R2,XYP - - - -* Components of position/velocity vector - X=V(1) - Y=V(2) - Z=V(3) - XD=V(4) - YD=V(5) - ZD=V(6) - -* Component of R in XY plane squared - RXY2=X*X+Y*Y - -* Modulus squared - R2=RXY2+Z*Z - -* Protection against null vector - IF (R2.EQ.0D0) THEN - X=XD - Y=YD - Z=ZD - RXY2=X*X+Y*Y - R2=RXY2+Z*Z - END IF - -* Position and velocity in spherical coordinates - RXY=SQRT(RXY2) - XYP=X*XD+Y*YD - IF (RXY2.NE.0D0) THEN - A=ATAN2(Y,X) - B=ATAN2(Z,RXY) - AD=(X*YD-Y*XD)/RXY2 - BD=(ZD*RXY2-Z*XYP)/(R2*RXY) - ELSE - A=0D0 - IF (Z.NE.0D0) THEN - B=ATAN2(Z,RXY) - ELSE - B=0D0 - END IF - AD=0D0 - BD=0D0 - END IF - R=SQRT(R2) - IF (R.NE.0D0) THEN - RD=(XYP+Z*ZD)/R - ELSE - RD=0D0 - END IF - - END diff --git a/src/slalib/dcc2s.f b/src/slalib/dcc2s.f deleted file mode 100644 index 7752a6705..000000000 --- a/src/slalib/dcc2s.f +++ /dev/null @@ -1,69 +0,0 @@ - SUBROUTINE sla_DCC2S (V, A, B) -*+ -* - - - - - - -* D C C 2 S -* - - - - - - -* -* Cartesian to spherical coordinates (double precision) -* -* Given: -* V d(3) x,y,z vector -* -* Returned: -* A,B d spherical coordinates in radians -* -* The spherical coordinates are longitude (+ve anticlockwise looking -* from the +ve latitude pole) and latitude. The Cartesian coordinates -* are right handed, with the x axis at zero longitude and latitude, and -* the z axis at the +ve latitude pole. -* -* If V is null, zero A and B are returned. At either pole, zero A is -* returned. -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION V(3),A,B - - DOUBLE PRECISION X,Y,Z,R - - - X = V(1) - Y = V(2) - Z = V(3) - R = SQRT(X*X+Y*Y) - - IF (R.EQ.0D0) THEN - A = 0D0 - ELSE - A = ATAN2(Y,X) - END IF - - IF (Z.EQ.0D0) THEN - B = 0D0 - ELSE - B = ATAN2(Z,R) - END IF - - END diff --git a/src/slalib/dcmpf.f b/src/slalib/dcmpf.f deleted file mode 100644 index d6013b5b8..000000000 --- a/src/slalib/dcmpf.f +++ /dev/null @@ -1,159 +0,0 @@ - SUBROUTINE sla_DCMPF (COEFFS,XZ,YZ,XS,YS,PERP,ORIENT) -*+ -* - - - - - - -* D C M P F -* - - - - - - -* -* Decompose an [X,Y] linear fit into its constituent parameters: -* zero points, scales, nonperpendicularity and orientation. -* -* Given: -* COEFFS d(6) transformation coefficients (see note) -* -* Returned: -* XZ d x zero point -* YZ d y zero point -* XS d x scale -* YS d y scale -* PERP d nonperpendicularity (radians) -* ORIENT d orientation (radians) -* -* Called: sla_DRANGE -* -* The model relates two sets of [X,Y] coordinates as follows. -* Naming the elements of COEFFS: -* -* COEFFS(1) = A -* COEFFS(2) = B -* COEFFS(3) = C -* COEFFS(4) = D -* COEFFS(5) = E -* COEFFS(6) = F -* -* the model transforms coordinates [X1,Y1] into coordinates -* [X2,Y2] as follows: -* -* X2 = A + B*X1 + C*Y1 -* Y2 = D + E*X1 + F*Y1 -* -* The transformation can be decomposed into four steps: -* -* 1) Zero points: -* -* x' = XZ + X1 -* y' = YZ + Y1 -* -* 2) Scales: -* -* x'' = XS*x' -* y'' = YS*y' -* -* 3) Nonperpendicularity: -* -* x''' = cos(PERP/2)*x'' + sin(PERP/2)*y'' -* y''' = sin(PERP/2)*x'' + cos(PERP/2)*y'' -* -* 4) Orientation: -* -* X2 = cos(ORIENT)*x''' + sin(ORIENT)*y''' -* Y2 =-sin(ORIENT)*y''' + cos(ORIENT)*y''' -* -* See also sla_FITXY, sla_PXY, sla_INVF, sla_XY2XY -* -* P.T.Wallace Starlink 19 December 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION COEFFS(6),XZ,YZ,XS,YS,PERP,ORIENT - - DOUBLE PRECISION A,B,C,D,E,F,RB2E2,RC2F2,XSC,YSC,P1,P2,P,WS,WC, - : OR,HP,SHP,CHP,SOR,COR,DET,X0,Y0,sla_DRANGE - - - -* Copy the six coefficients. - A = COEFFS(1) - B = COEFFS(2) - C = COEFFS(3) - D = COEFFS(4) - E = COEFFS(5) - F = COEFFS(6) - -* Scales. - RB2E2 = SQRT(B*B+E*E) - RC2F2 = SQRT(C*C+F*F) - IF (B*F-C*E.GE.0D0) THEN - XSC = RB2E2 - ELSE - B = -B - E = -E - XSC = -RB2E2 - END IF - YSC = RC2F2 - -* Non-perpendicularity. - IF (C.NE.0D0.OR.F.NE.0D0) THEN - P1 = ATAN2(C,F) - ELSE - P1 = 0D0 - END IF - IF (E.NE.0D0.OR.B.NE.0D0) THEN - P2 = ATAN2(E,B) - ELSE - P2 = 0D0 - END IF - P = sla_DRANGE(P1+P2) - -* Orientation. - WS = C*RB2E2-E*RC2F2 - WC = B*RC2F2+F*RB2E2 - IF (WS.NE.0D0.OR.WC.NE.0D0) THEN - OR = ATAN2(WS,WC) - ELSE - OR = 0D0 - END IF - -* Zero points. - HP = P/2D0 - SHP = SIN(HP) - CHP = COS(HP) - SOR = SIN(OR) - COR = COS(OR) - DET = XSC*YSC*(CHP+SHP)*(CHP-SHP) - IF (ABS(DET).GT.0D0) THEN - X0 = YSC*(A*(CHP*COR-SHP*SOR)-D*(CHP*SOR+SHP*COR))/DET - Y0 = XSC*(A*(CHP*SOR-SHP*COR)+D*(CHP*COR+SHP*SOR))/DET - ELSE - X0 = 0D0 - Y0 = 0D0 - END IF - -* Results. - XZ = X0 - YZ = Y0 - XS = XSC - YS = YSC - PERP = P - ORIENT = OR - - END diff --git a/src/slalib/dcs2c.f b/src/slalib/dcs2c.f deleted file mode 100644 index 5b02c6fd3..000000000 --- a/src/slalib/dcs2c.f +++ /dev/null @@ -1,56 +0,0 @@ - SUBROUTINE sla_DCS2C (A, B, V) -*+ -* - - - - - - -* D C S 2 C -* - - - - - - -* -* Spherical coordinates to direction cosines (double precision) -* -* Given: -* A,B d spherical coordinates in radians -* (RA,Dec), (long,lat) etc. -* -* Returned: -* V d(3) x,y,z unit vector -* -* The spherical coordinates are longitude (+ve anticlockwise looking -* from the +ve latitude pole) and latitude. The Cartesian coordinates -* are right handed, with the x axis at zero longitude and latitude, and -* the z axis at the +ve latitude pole. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION A,B,V(3) - - DOUBLE PRECISION COSB - - - COSB = COS(B) - - V(1) = COS(A)*COSB - V(2) = SIN(A)*COSB - V(3) = SIN(B) - - END diff --git a/src/slalib/dd2tf.f b/src/slalib/dd2tf.f deleted file mode 100644 index 596ff5b4c..000000000 --- a/src/slalib/dd2tf.f +++ /dev/null @@ -1,106 +0,0 @@ - SUBROUTINE sla_DD2TF (NDP, DAYS, SIGN, IHMSF) -*+ -* - - - - - - -* D D 2 T F -* - - - - - - -* -* Convert an interval in days into hours, minutes, seconds -* (double precision) -* -* Given: -* NDP i number of decimal places of seconds -* DAYS d interval in days -* -* Returned: -* SIGN c '+' or '-' -* IHMSF i(4) hours, minutes, seconds, fraction -* -* Notes: -* -* 1) NDP less than zero is interpreted as zero. -* -* 2) The largest useful value for NDP is determined by the size -* of DAYS, the format of DOUBLE PRECISION floating-point numbers -* on the target machine, and the risk of overflowing IHMSF(4). -* On some architectures, for DAYS up to 1D0, the available -* floating-point precision corresponds roughly to NDP=12. -* However, the practical limit is NDP=9, set by the capacity of -* a typical 32-bit IHMSF(4). -* -* 3) The absolute value of DAYS may exceed 1D0. In cases where it -* does not, it is up to the caller to test for and handle the -* case where DAYS is very nearly 1D0 and rounds up to 24 hours, -* by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - DOUBLE PRECISION DAYS - CHARACTER SIGN*(*) - INTEGER IHMSF(4) - -* Days to seconds - DOUBLE PRECISION D2S - PARAMETER (D2S=86400D0) - - INTEGER NRS,N - DOUBLE PRECISION RS,RM,RH,A,AH,AM,AS,AF - - - -* Handle sign - IF (DAYS.GE.0D0) THEN - SIGN='+' - ELSE - SIGN='-' - END IF - -* Field units in terms of least significant figure - NRS=1 - DO N=1,NDP - NRS=NRS*10 - END DO - RS=DBLE(NRS) - RM=RS*60D0 - RH=RM*60D0 - -* Round interval and express in smallest units required - A=ANINT(RS*D2S*ABS(DAYS)) - -* Separate into fields - AH=AINT(A/RH) - A=A-AH*RH - AM=AINT(A/RM) - A=A-AM*RM - AS=AINT(A/RS) - AF=A-AS*RS - -* Return results - IHMSF(1)=MAX(NINT(AH),0) - IHMSF(2)=MAX(MIN(NINT(AM),59),0) - IHMSF(3)=MAX(MIN(NINT(AS),59),0) - IHMSF(4)=MAX(NINT(MIN(AF,RS-1D0)),0) - - END diff --git a/src/slalib/de2h.f b/src/slalib/de2h.f deleted file mode 100644 index 523e7b40f..000000000 --- a/src/slalib/de2h.f +++ /dev/null @@ -1,106 +0,0 @@ - SUBROUTINE sla_DE2H (HA, DEC, PHI, AZ, EL) -*+ -* - - - - - -* D E 2 H -* - - - - - -* -* Equatorial to horizon coordinates: HA,Dec to Az,El -* -* (double precision) -* -* Given: -* HA d hour angle -* DEC d declination -* PHI d observatory latitude -* -* Returned: -* AZ d azimuth -* EL d elevation -* -* Notes: -* -* 1) All the arguments are angles in radians. -* -* 2) Azimuth is returned in the range 0-2pi; north is zero, -* and east is +pi/2. Elevation is returned in the range -* +/-pi/2. -* -* 3) The latitude must be geodetic. In critical applications, -* corrections for polar motion should be applied. -* -* 4) In some applications it will be important to specify the -* correct type of hour angle and declination in order to -* produce the required type of azimuth and elevation. In -* particular, it may be important to distinguish between -* elevation as affected by refraction, which would -* require the "observed" HA,Dec, and the elevation -* in vacuo, which would require the "topocentric" HA,Dec. -* If the effects of diurnal aberration can be neglected, the -* "apparent" HA,Dec may be used instead of the topocentric -* HA,Dec. -* -* 5) No range checking of arguments is carried out. -* -* 6) In applications which involve many such calculations, rather -* than calling the present routine it will be more efficient to -* use inline code, having previously computed fixed terms such -* as sine and cosine of latitude, and (for tracking a star) -* sine and cosine of declination. -* -* P.T.Wallace Starlink 9 July 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION HA,DEC,PHI,AZ,EL - - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925286766559D0) - - DOUBLE PRECISION SH,CH,SD,CD,SP,CP,X,Y,Z,R,A - - -* Useful trig functions - SH=SIN(HA) - CH=COS(HA) - SD=SIN(DEC) - CD=COS(DEC) - SP=SIN(PHI) - CP=COS(PHI) - -* Az,El as x,y,z - X=-CH*CD*SP+SD*CP - Y=-SH*CD - Z=CH*CD*CP+SD*SP - -* To spherical - R=SQRT(X*X+Y*Y) - IF (R.EQ.0D0) THEN - A=0D0 - ELSE - A=ATAN2(Y,X) - END IF - IF (A.LT.0D0) A=A+D2PI - AZ=A - EL=ATAN2(Z,R) - - END diff --git a/src/slalib/deuler.f b/src/slalib/deuler.f deleted file mode 100644 index 7f67f317b..000000000 --- a/src/slalib/deuler.f +++ /dev/null @@ -1,180 +0,0 @@ - SUBROUTINE sla_DEULER (ORDER, PHI, THETA, PSI, RMAT) -*+ -* - - - - - - - -* D E U L E R -* - - - - - - - -* -* Form a rotation matrix from the Euler angles - three successive -* rotations about specified Cartesian axes (double precision) -* -* Given: -* ORDER c*(*) specifies about which axes the rotations occur -* PHI d 1st rotation (radians) -* THETA d 2nd rotation ( " ) -* PSI d 3rd rotation ( " ) -* -* Returned: -* RMAT d(3,3) rotation matrix -* -* A rotation is positive when the reference frame rotates -* anticlockwise as seen looking towards the origin from the -* positive region of the specified axis. -* -* The characters of ORDER define which axes the three successive -* rotations are about. A typical value is 'ZXZ', indicating that -* RMAT is to become the direction cosine matrix corresponding to -* rotations of the reference frame through PHI radians about the -* old Z-axis, followed by THETA radians about the resulting X-axis, -* then PSI radians about the resulting Z-axis. -* -* The axis names can be any of the following, in any order or -* combination: X, Y, Z, uppercase or lowercase, 1, 2, 3. Normal -* axis labelling/numbering conventions apply; the xyz (=123) -* triad is right-handed. Thus, the 'ZXZ' example given above -* could be written 'zxz' or '313' (or even 'ZxZ' or '3xZ'). ORDER -* is terminated by length or by the first unrecognized character. -* -* Fewer than three rotations are acceptable, in which case the later -* angle arguments are ignored. If all rotations are zero, the -* identity matrix is produced. -* -* P.T.Wallace Starlink 23 May 1997 -* -* Copyright (C) 1997 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) ORDER - DOUBLE PRECISION PHI,THETA,PSI,RMAT(3,3) - - INTEGER J,I,L,N,K - DOUBLE PRECISION RESULT(3,3),ROTN(3,3),ANGLE,S,C,W,WM(3,3) - CHARACTER AXIS - - - -* Initialize result matrix - DO J=1,3 - DO I=1,3 - IF (I.NE.J) THEN - RESULT(I,J) = 0D0 - ELSE - RESULT(I,J) = 1D0 - END IF - END DO - END DO - -* Establish length of axis string - L = LEN(ORDER) - -* Look at each character of axis string until finished - DO N=1,3 - IF (N.LE.L) THEN - -* Initialize rotation matrix for the current rotation - DO J=1,3 - DO I=1,3 - IF (I.NE.J) THEN - ROTN(I,J) = 0D0 - ELSE - ROTN(I,J) = 1D0 - END IF - END DO - END DO - -* Pick up the appropriate Euler angle and take sine & cosine - IF (N.EQ.1) THEN - ANGLE = PHI - ELSE IF (N.EQ.2) THEN - ANGLE = THETA - ELSE - ANGLE = PSI - END IF - S = SIN(ANGLE) - C = COS(ANGLE) - -* Identify the axis - AXIS = ORDER(N:N) - IF (AXIS.EQ.'X'.OR. - : AXIS.EQ.'x'.OR. - : AXIS.EQ.'1') THEN - -* Matrix for x-rotation - ROTN(2,2) = C - ROTN(2,3) = S - ROTN(3,2) = -S - ROTN(3,3) = C - - ELSE IF (AXIS.EQ.'Y'.OR. - : AXIS.EQ.'y'.OR. - : AXIS.EQ.'2') THEN - -* Matrix for y-rotation - ROTN(1,1) = C - ROTN(1,3) = -S - ROTN(3,1) = S - ROTN(3,3) = C - - ELSE IF (AXIS.EQ.'Z'.OR. - : AXIS.EQ.'z'.OR. - : AXIS.EQ.'3') THEN - -* Matrix for z-rotation - ROTN(1,1) = C - ROTN(1,2) = S - ROTN(2,1) = -S - ROTN(2,2) = C - - ELSE - -* Unrecognized character - fake end of string - L = 0 - - END IF - -* Apply the current rotation (matrix ROTN x matrix RESULT) - DO I=1,3 - DO J=1,3 - W = 0D0 - DO K=1,3 - W = W+ROTN(I,K)*RESULT(K,J) - END DO - WM(I,J) = W - END DO - END DO - DO J=1,3 - DO I=1,3 - RESULT(I,J) = WM(I,J) - END DO - END DO - - END IF - - END DO - -* Copy the result - DO J=1,3 - DO I=1,3 - RMAT(I,J) = RESULT(I,J) - END DO - END DO - - END diff --git a/src/slalib/dfltin.f b/src/slalib/dfltin.f deleted file mode 100644 index 1bad6ed77..000000000 --- a/src/slalib/dfltin.f +++ /dev/null @@ -1,297 +0,0 @@ - SUBROUTINE sla_DFLTIN (STRING, NSTRT, DRESLT, JFLAG) -*+ -* - - - - - - - -* D F L T I N -* - - - - - - - -* -* Convert free-format input into double precision floating point -* -* Given: -* STRING c string containing number to be decoded -* NSTRT i pointer to where decoding is to start -* DRESLT d current value of result -* -* Returned: -* NSTRT i advanced to next number -* DRESLT d result -* JFLAG i status: -1 = -OK, 0 = +OK, 1 = null, 2 = error -* -* Notes: -* -* 1 The reason DFLTIN has separate OK status values for + -* and - is to enable minus zero to be detected. This is -* of crucial importance when decoding mixed-radix numbers. -* For example, an angle expressed as deg, arcmin, arcsec -* may have a leading minus sign but a zero degrees field. -* -* 2 A TAB is interpreted as a space, and lowercase characters -* are interpreted as uppercase. -* -* 3 The basic format is the sequence of fields #^.^@#^, where -* # is a sign character + or -, ^ means a string of decimal -* digits, and @, which indicates an exponent, means D or E. -* Various combinations of these fields can be omitted, and -* embedded blanks are permissible in certain places. -* -* 4 Spaces: -* -* . Leading spaces are ignored. -* -* . Embedded spaces are allowed only after +, -, D or E, -* and after the decomal point if the first sequence of -* digits is absent. -* -* . Trailing spaces are ignored; the first signifies -* end of decoding and subsequent ones are skipped. -* -* 5 Delimiters: -* -* . Any character other than +,-,0-9,.,D,E or space may be -* used to signal the end of the number and terminate -* decoding. -* -* . Comma is recognized by DFLTIN as a special case; it -* is skipped, leaving the pointer on the next character. -* See 13, below. -* -* 6 Both signs are optional. The default is +. -* -* 7 The mantissa ^.^ defaults to 1. -* -* 8 The exponent @#^ defaults to D0. -* -* 9 The strings of decimal digits may be of any length. -* -* 10 The decimal point is optional for whole numbers. -* -* 11 A "null result" occurs when the string of characters being -* decoded does not begin with +,-,0-9,.,D or E, or consists -* entirely of spaces. When this condition is detected, JFLAG -* is set to 1 and DRESLT is left untouched. -* -* 12 NSTRT = 1 for the first character in the string. -* -* 13 On return from DFLTIN, NSTRT is set ready for the next -* decode - following trailing blanks and any comma. If a -* delimiter other than comma is being used, NSTRT must be -* incremented before the next call to DFLTIN, otherwise -* all subsequent calls will return a null result. -* -* 14 Errors (JFLAG=2) occur when: -* -* . a +, -, D or E is left unsatisfied; or -* -* . the decimal point is present without at least -* one decimal digit before or after it; or -* -* . an exponent more than 100 has been presented. -* -* 15 When an error has been detected, NSTRT is left -* pointing to the character following the last -* one used before the error came to light. This -* may be after the point at which a more sophisticated -* program could have detected the error. For example, -* DFLTIN does not detect that '1D999' is unacceptable -* (on a computer where this is so) until the entire number -* has been decoded. -* -* 16 Certain highly unlikely combinations of mantissa & -* exponent can cause arithmetic faults during the -* decode, in some cases despite the fact that they -* together could be construed as a valid number. -* -* 17 Decoding is left to right, one pass. -* -* 18 See also FLOTIN and INTIN -* -* Called: sla__IDCHF -* -* P.T.Wallace Starlink 18 March 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER NSTRT - DOUBLE PRECISION DRESLT - INTEGER JFLAG - - INTEGER NPTR,MSIGN,NEXP,NDP,NVEC,NDIGIT,ISIGNX,J - DOUBLE PRECISION DMANT,DIGIT - - - -* Current character - NPTR=NSTRT - -* Set defaults: mantissa & sign, exponent & sign, decimal place count - DMANT=0D0 - MSIGN=1 - NEXP=0 - ISIGNX=1 - NDP=0 - -* Look for sign - 100 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO ( 400, 100, 800, 500, 300, 200, 9110, 9100, 9110),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Negative - 200 CONTINUE - MSIGN=-1 - -* Look for first leading decimal - 300 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO ( 400, 300, 800, 500, 9200, 9200, 9200, 9200, 9210),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Accept leading decimals - 400 CONTINUE - DMANT=DMANT*1D1+DIGIT - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO ( 400, 1310, 900, 600, 1300, 1300, 1300, 1300, 1310),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Look for decimal when none preceded the point - 500 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO ( 700, 500, 9200, 9200, 9200, 9200, 9200, 9200, 9210),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Look for trailing decimals - 600 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO ( 700, 1310, 900, 1300, 1300, 1300, 1300, 1300, 1310),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Accept trailing decimals - 700 CONTINUE - NDP=NDP+1 - DMANT=DMANT*1D1+DIGIT - GO TO 600 - -* Exponent symbol first in field: default mantissa to 1 - 800 CONTINUE - DMANT=1D0 - -* Look for sign of exponent - 900 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO (1200, 900, 9200, 9200, 1100, 1000, 9200, 9200, 9210),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Exponent negative - 1000 CONTINUE - ISIGNX=-1 - -* Look for first digit of exponent - 1100 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO (1200, 1100, 9200, 9200, 9200, 9200, 9200, 9200, 9210),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Use exponent digit - 1200 CONTINUE - NEXP=NEXP*10+NDIGIT - IF (NEXP.GT.100) GO TO 9200 - -* Look for subsequent digits of exponent - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO (1200, 1310, 1300, 1300, 1300, 1300, 1300, 1300, 1310),NVEC -* 0-9 SP D/E . + - , ELSE END - -* Combine exponent and decimal place count - 1300 CONTINUE - NPTR=NPTR-1 - 1310 CONTINUE - NEXP=NEXP*ISIGNX-NDP - -* Skip if net exponent negative - IF (NEXP.LT.0) GO TO 1500 - -* Positive exponent: scale up - 1400 CONTINUE - IF (NEXP.LT.10) GO TO 1410 - DMANT=DMANT*1D10 - NEXP=NEXP-10 - GO TO 1400 - 1410 CONTINUE - IF (NEXP.LT.1) GO TO 1600 - DMANT=DMANT*1D1 - NEXP=NEXP-1 - GO TO 1410 - -* Negative exponent: scale down - 1500 CONTINUE - IF (NEXP.GT.-10) GO TO 1510 - DMANT=DMANT/1D10 - NEXP=NEXP+10 - GO TO 1500 - 1510 CONTINUE - IF (NEXP.GT.-1) GO TO 1600 - DMANT=DMANT/1D1 - NEXP=NEXP+1 - GO TO 1510 - -* Get result & status - 1600 CONTINUE - J=0 - IF (MSIGN.EQ.1) GO TO 1610 - J=-1 - DMANT=-DMANT - 1610 CONTINUE - DRESLT=DMANT - -* Skip to end of field - 1620 CONTINUE - CALL sla__IDCHF(STRING,NPTR,NVEC,NDIGIT,DIGIT) - GO TO (1720, 1620, 1720, 1720, 1720, 1720, 9900, 1720, 9900),NVEC -* 0-9 SP D/E . + - , ELSE END - - 1720 CONTINUE - NPTR=NPTR-1 - GO TO 9900 - - -* Exits - -* Null field - 9100 CONTINUE - NPTR=NPTR-1 - 9110 CONTINUE - J=1 - GO TO 9900 - -* Errors - 9200 CONTINUE - NPTR=NPTR-1 - 9210 CONTINUE - J=2 - -* Return - 9900 CONTINUE - NSTRT=NPTR - JFLAG=J - - END diff --git a/src/slalib/dh2e.f b/src/slalib/dh2e.f deleted file mode 100644 index 24c0f5603..000000000 --- a/src/slalib/dh2e.f +++ /dev/null @@ -1,100 +0,0 @@ - SUBROUTINE sla_DH2E (AZ, EL, PHI, HA, DEC) -*+ -* - - - - - -* D E 2 H -* - - - - - -* -* Horizon to equatorial coordinates: Az,El to HA,Dec -* -* (double precision) -* -* Given: -* AZ d azimuth -* EL d elevation -* PHI d observatory latitude -* -* Returned: -* HA d hour angle -* DEC d declination -* -* Notes: -* -* 1) All the arguments are angles in radians. -* -* 2) The sign convention for azimuth is north zero, east +pi/2. -* -* 3) HA is returned in the range +/-pi. Declination is returned -* in the range +/-pi/2. -* -* 4) The latitude is (in principle) geodetic. In critical -* applications, corrections for polar motion should be applied. -* -* 5) In some applications it will be important to specify the -* correct type of elevation in order to produce the required -* type of HA,Dec. In particular, it may be important to -* distinguish between the elevation as affected by refraction, -* which will yield the "observed" HA,Dec, and the elevation -* in vacuo, which will yield the "topocentric" HA,Dec. If the -* effects of diurnal aberration can be neglected, the -* topocentric HA,Dec may be used as an approximation to the -* "apparent" HA,Dec. -* -* 6) No range checking of arguments is done. -* -* 7) In applications which involve many such calculations, rather -* than calling the present routine it will be more efficient to -* use inline code, having previously computed fixed terms such -* as sine and cosine of latitude. -* -* P.T.Wallace Starlink 21 February 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION AZ,EL,PHI,HA,DEC - - DOUBLE PRECISION SA,CA,SE,CE,SP,CP,X,Y,Z,R - - -* Useful trig functions - SA=SIN(AZ) - CA=COS(AZ) - SE=SIN(EL) - CE=COS(EL) - SP=SIN(PHI) - CP=COS(PHI) - -* HA,Dec as x,y,z - X=-CA*CE*SP+SE*CP - Y=-SA*CE - Z=CA*CE*CP+SE*SP - -* To HA,Dec - R=SQRT(X*X+Y*Y) - IF (R.EQ.0D0) THEN - HA=0D0 - ELSE - HA=ATAN2(Y,X) - END IF - DEC=ATAN2(Z,R) - - END diff --git a/src/slalib/dimxv.f b/src/slalib/dimxv.f deleted file mode 100644 index 8442144e4..000000000 --- a/src/slalib/dimxv.f +++ /dev/null @@ -1,68 +0,0 @@ - SUBROUTINE sla_DIMXV (DM, VA, VB) -*+ -* - - - - - - -* D I M X V -* - - - - - - -* -* Performs the 3-D backward unitary transformation: -* -* vector VB = (inverse of matrix DM) * vector VA -* -* (double precision) -* -* (n.b. the matrix must be unitary, as this routine assumes that -* the inverse and transpose are identical) -* -* Given: -* DM dp(3,3) matrix -* VA dp(3) vector -* -* Returned: -* VB dp(3) result vector -* -* P.T.Wallace Starlink March 1986 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DM(3,3),VA(3),VB(3) - - INTEGER I,J - DOUBLE PRECISION W,VW(3) - - - -* Inverse of matrix DM * vector VA -> vector VW - DO J=1,3 - W=0D0 - DO I=1,3 - W=W+DM(I,J)*VA(I) - END DO - VW(J)=W - END DO - -* Vector VW -> vector VB - DO J=1,3 - VB(J)=VW(J) - END DO - - END diff --git a/src/slalib/djcal.f b/src/slalib/djcal.f deleted file mode 100644 index 3cd7d2e59..000000000 --- a/src/slalib/djcal.f +++ /dev/null @@ -1,92 +0,0 @@ - SUBROUTINE sla_DJCAL (NDP, DJM, IYMDF, J) -*+ -* - - - - - - -* D J C A L -* - - - - - - -* -* Modified Julian Date to Gregorian Calendar, expressed -* in a form convenient for formatting messages (namely -* rounded to a specified precision, and with the fields -* stored in a single array) -* -* Given: -* NDP i number of decimal places of days in fraction -* DJM d modified Julian Date (JD-2400000.5) -* -* Returned: -* IYMDF i(4) year, month, day, fraction in Gregorian -* calendar -* J i status: nonzero = out of range -* -* Any date after 4701BC March 1 is accepted. -* -* NDP should be 4 or less if internal overflows are to be avoided -* on machines which use 32-bit integers. -* -* The algorithm is adapted from Hatcher 1984 (QJRAS 25, 53-55). -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - DOUBLE PRECISION DJM - INTEGER IYMDF(4),J - - INTEGER NFD - DOUBLE PRECISION FD,DF,F,D - INTEGER JD,N4,ND10 - - -* Validate. - IF ( DJM.LE.-2395520D0 .OR. DJM.GE.1D9 ) THEN - J = -1 - ELSE - J = 0 - -* Denominator of fraction. - NFD = 10**MAX(NDP,0) - FD = DBLE(NFD) - -* Round date and express in units of fraction. - DF = ANINT(DJM*FD) - -* Separate day and fraction. - F = MOD(DF,FD) - IF (F.LT.0D0) F = F+FD - D = (DF-F)/FD - -* Express day in Gregorian calendar. - JD = NINT(D)+2400001 - - N4 = 4*(JD+((2*((4*JD-17918)/146097)*3)/4+1)/2-37) - ND10 = 10*(MOD(N4-237,1461)/4)+5 - - IYMDF(1) = N4/1461-4712 - IYMDF(2) = MOD(ND10/306+2,12)+1 - IYMDF(3) = MOD(ND10,306)/10+1 - IYMDF(4) = NINT(F) - - END IF - - END diff --git a/src/slalib/djcl.f b/src/slalib/djcl.f deleted file mode 100644 index 91561e6bd..000000000 --- a/src/slalib/djcl.f +++ /dev/null @@ -1,83 +0,0 @@ - SUBROUTINE sla_DJCL (DJM, IY, IM, ID, FD, J) -*+ -* - - - - - -* D J C L -* - - - - - -* -* Modified Julian Date to Gregorian year, month, day, -* and fraction of a day. -* -* Given: -* DJM dp modified Julian Date (JD-2400000.5) -* -* Returned: -* IY int year -* IM int month -* ID int day -* FD dp fraction of day -* J int status: -* 0 = OK -* -1 = unacceptable date (before 4701BC March 1) -* -* The algorithm is adapted from Hatcher 1984 (QJRAS 25, 53-55). -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DJM - INTEGER IY,IM,ID - DOUBLE PRECISION FD - INTEGER J - - DOUBLE PRECISION F,D - INTEGER JD,N4,ND10 - - -* Check if date is acceptable. - IF ( DJM.LE.-2395520D0 .OR. DJM.GE.1D9 ) THEN - J = -1 - ELSE - J = 0 - -* Separate day and fraction. - F = MOD(DJM,1D0) - IF (F.LT.0D0) F = F+1D0 - D = ANINT(DJM-F) - -* Express day in Gregorian calendar. - JD = NINT(D)+2400001 - - N4 = 4*(JD+((6*((4*JD-17918)/146097))/4+1)/2-37) - ND10 = 10*(MOD(N4-237,1461)/4)+5 - - IY = N4/1461-4712 - IM = MOD(ND10/306+2,12)+1 - ID = MOD(ND10,306)/10+1 - FD = F - - J=0 - - END IF - - END diff --git a/src/slalib/dm2av.f b/src/slalib/dm2av.f deleted file mode 100644 index 32bf074fc..000000000 --- a/src/slalib/dm2av.f +++ /dev/null @@ -1,74 +0,0 @@ - SUBROUTINE sla_DM2AV (RMAT, AXVEC) -*+ -* - - - - - - -* D M 2 A V -* - - - - - - -* -* From a rotation matrix, determine the corresponding axial vector. -* (double precision) -* -* A rotation matrix describes a rotation about some arbitrary axis, -* called the Euler axis. The "axial vector" returned by this routine -* has the same direction as the Euler axis, and its magnitude is the -* amount of rotation in radians. (The magnitude and direction can be -* separated by means of the routine sla_DVN.) -* -* Given: -* RMAT d(3,3) rotation matrix -* -* Returned: -* AXVEC d(3) axial vector (radians) -* -* The reference frame rotates clockwise as seen looking along -* the axial vector from the origin. -* -* If RMAT is null, so is the result. -* -* Last revision: 26 November 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RMAT(3,3),AXVEC(3) - - DOUBLE PRECISION X,Y,Z,S2,C2,PHI,F - - - - X = RMAT(2,3)-RMAT(3,2) - Y = RMAT(3,1)-RMAT(1,3) - Z = RMAT(1,2)-RMAT(2,1) - S2 = SQRT(X*X+Y*Y+Z*Z) - IF (S2.NE.0D0) THEN - C2 = RMAT(1,1)+RMAT(2,2)+RMAT(3,3)-1D0 - PHI = ATAN2(S2,C2) - F = PHI/S2 - AXVEC(1) = X*F - AXVEC(2) = Y*F - AXVEC(3) = Z*F - ELSE - AXVEC(1) = 0D0 - AXVEC(2) = 0D0 - AXVEC(3) = 0D0 - END IF - - END diff --git a/src/slalib/dmat.f b/src/slalib/dmat.f deleted file mode 100644 index d2cfa87bf..000000000 --- a/src/slalib/dmat.f +++ /dev/null @@ -1,157 +0,0 @@ - SUBROUTINE sla_DMAT (N, A, Y, D, JF, IW) -*+ -* - - - - - -* D M A T -* - - - - - -* -* Matrix inversion & solution of simultaneous equations -* (double precision) -* -* For the set of n simultaneous equations in n unknowns: -* A.Y = X -* -* where: -* A is a non-singular N x N matrix -* Y is the vector of N unknowns -* X is the known vector -* -* DMATRX computes: -* the inverse of matrix A -* the determinant of matrix A -* the vector of N unknowns -* -* Arguments: -* -* symbol type dimension before after -* -* N i no. of unknowns unchanged -* A d (N,N) matrix inverse -* Y d (N) known vector solution vector -* D d - determinant -* * JF i - singularity flag -* IW i (N) - workspace -* -* * JF is the singularity flag. If the matrix is non-singular, JF=0 -* is returned. If the matrix is singular, JF=-1 & D=0D0 are -* returned. In the latter case, the contents of array A on return -* are undefined. -* -* Algorithm: -* Gaussian elimination with partial pivoting. -* -* Speed: -* Very fast. -* -* Accuracy: -* Fairly accurate - errors 1 to 4 times those of routines optimized -* for accuracy. -* -* P.T.Wallace Starlink 4 December 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER N - DOUBLE PRECISION A(N,N),Y(N),D - INTEGER JF - INTEGER IW(N) - - DOUBLE PRECISION SFA - PARAMETER (SFA=1D-20) - - INTEGER K,IMX,I,J,NP1MK,KI - DOUBLE PRECISION AMX,T,AKK,YK,AIK - - - JF=0 - D=1D0 - DO K=1,N - AMX=DABS(A(K,K)) - IMX=K - IF (K.NE.N) THEN - DO I=K+1,N - T=DABS(A(I,K)) - IF (T.GT.AMX) THEN - AMX=T - IMX=I - END IF - END DO - END IF - IF (AMX.LT.SFA) THEN - JF=-1 - ELSE - IF (IMX.NE.K) THEN - DO J=1,N - T=A(K,J) - A(K,J)=A(IMX,J) - A(IMX,J)=T - END DO - T=Y(K) - Y(K)=Y(IMX) - Y(IMX)=T - D=-D - END IF - IW(K)=IMX - AKK=A(K,K) - D=D*AKK - IF (DABS(D).LT.SFA) THEN - JF=-1 - ELSE - AKK=1D0/AKK - A(K,K)=AKK - DO J=1,N - IF (J.NE.K) A(K,J)=A(K,J)*AKK - END DO - YK=Y(K)*AKK - Y(K)=YK - DO I=1,N - AIK=A(I,K) - IF (I.NE.K) THEN - DO J=1,N - IF (J.NE.K) A(I,J)=A(I,J)-AIK*A(K,J) - END DO - Y(I)=Y(I)-AIK*YK - END IF - END DO - DO I=1,N - IF (I.NE.K) A(I,K)=-A(I,K)*AKK - END DO - END IF - END IF - END DO - IF (JF.NE.0) THEN - D=0D0 - ELSE - DO K=1,N - NP1MK=N+1-K - KI=IW(NP1MK) - IF (NP1MK.NE.KI) THEN - DO I=1,N - T=A(I,NP1MK) - A(I,NP1MK)=A(I,KI) - A(I,KI)=T - END DO - END IF - END DO - END IF - - END diff --git a/src/slalib/dmoon.f b/src/slalib/dmoon.f deleted file mode 100644 index dc6819b37..000000000 --- a/src/slalib/dmoon.f +++ /dev/null @@ -1,658 +0,0 @@ - SUBROUTINE sla_DMOON (DATE, PV) -*+ -* - - - - - - -* D M O O N -* - - - - - - -* -* Approximate geocentric position and velocity of the Moon -* (double precision) -* -* Given: -* DATE D TDB (loosely ET) as a Modified Julian Date -* (JD-2400000.5) -* -* Returned: -* PV D(6) Moon x,y,z,xdot,ydot,zdot, mean equator and -* equinox of date (AU, AU/s) -* -* Notes: -* -* 1 This routine is a full implementation of the algorithm -* published by Meeus (see reference). -* -* 2 Meeus quotes accuracies of 10 arcsec in longitude, 3 arcsec in -* latitude and 0.2 arcsec in HP (equivalent to about 20 km in -* distance). Comparison with JPL DE200 over the interval -* 1960-2025 gives RMS errors of 3.7 arcsec and 83 mas/hour in -* longitude, 2.3 arcsec and 48 mas/hour in latitude, 11 km -* and 81 mm/s in distance. The maximum errors over the same -* interval are 18 arcsec and 0.50 arcsec/hour in longitude, -* 11 arcsec and 0.24 arcsec/hour in latitude, 40 km and 0.29 m/s -* in distance. -* -* 3 The original algorithm is expressed in terms of the obsolete -* timescale Ephemeris Time. Either TDB or TT can be used, but -* not UT without incurring significant errors (30 arcsec at -* the present time) due to the Moon's 0.5 arcsec/sec movement. -* -* 4 The algorithm is based on pre IAU 1976 standards. However, -* the result has been moved onto the new (FK5) equinox, an -* adjustment which is in any case much smaller than the -* intrinsic accuracy of the procedure. -* -* 5 Velocity is obtained by a complete analytical differentiation -* of the Meeus model. -* -* Reference: -* Meeus, l'Astronomie, June 1984, p348. -* -* P.T.Wallace Starlink 22 January 1998 -* -* Copyright (C) 1998 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,PV(6) - -* Degrees, arcseconds and seconds of time to radians - DOUBLE PRECISION D2R,DAS2R,DS2R - PARAMETER (D2R=0.0174532925199432957692369D0, - : DAS2R=4.848136811095359935899141D-6, - : DS2R=7.272205216643039903848712D-5) - -* Seconds per Julian century (86400*36525) - DOUBLE PRECISION CJ - PARAMETER (CJ=3155760000D0) - -* Julian epoch of B1950 - DOUBLE PRECISION B1950 - PARAMETER (B1950=1949.9997904423D0) - -* Earth equatorial radius in AU ( = 6378.137 / 149597870 ) - DOUBLE PRECISION ERADAU - PARAMETER (ERADAU=4.2635212653763D-5) - - DOUBLE PRECISION T,THETA,SINOM,COSOM,DOMCOM,WA,DWA,WB,DWB,WOM, - : DWOM,SINWOM,COSWOM,V,DV,COEFF,EMN,EMPN,DN,FN,EN, - : DEN,DTHETA,FTHETA,EL,DEL,B,DB,BF,DBF,P,DP,SP,R, - : DR,X,Y,Z,XD,YD,ZD,SEL,CEL,SB,CB,RCB,RBD,W,EPJ, - : EQCOR,EPS,SINEPS,COSEPS,ES,EC - INTEGER N,I - -* -* Coefficients for fundamental arguments -* -* at J1900: T**0, T**1, T**2, T**3 -* at epoch: T**0, T**1 -* -* Units are degrees for position and Julian centuries for time -* - -* Moon's mean longitude - DOUBLE PRECISION ELP0,ELP1,ELP2,ELP3,ELP,DELP - PARAMETER (ELP0=270.434164D0, - : ELP1=481267.8831D0, - : ELP2=-0.001133D0, - : ELP3=0.0000019D0) - -* Sun's mean anomaly - DOUBLE PRECISION EM0,EM1,EM2,EM3,EM,DEM - PARAMETER (EM0=358.475833D0, - : EM1=35999.0498D0, - : EM2=-0.000150D0, - : EM3=-0.0000033D0) - -* Moon's mean anomaly - DOUBLE PRECISION EMP0,EMP1,EMP2,EMP3,EMP,DEMP - PARAMETER (EMP0=296.104608D0, - : EMP1=477198.8491D0, - : EMP2=0.009192D0, - : EMP3=0.0000144D0) - -* Moon's mean elongation - DOUBLE PRECISION D0,D1,D2,D3,D,DD - PARAMETER (D0=350.737486D0, - : D1=445267.1142D0, - : D2=-0.001436D0, - : D3=0.0000019D0) - -* Mean distance of the Moon from its ascending node - DOUBLE PRECISION F0,F1,F2,F3,F,DF - PARAMETER (F0=11.250889D0, - : F1=483202.0251D0, - : F2=-0.003211D0, - : F3=-0.0000003D0) - -* Longitude of the Moon's ascending node - DOUBLE PRECISION OM0,OM1,OM2,OM3,OM,DOM - PARAMETER (OM0=259.183275D0, - : OM1=-1934.1420D0, - : OM2=0.002078D0, - : OM3=0.0000022D0) - -* Coefficients for (dimensionless) E factor - DOUBLE PRECISION E1,E2,E,DE,ESQ,DESQ - PARAMETER (E1=-0.002495D0,E2=-0.00000752D0) - -* Coefficients for periodic variations etc - DOUBLE PRECISION PAC,PA0,PA1 - PARAMETER (PAC=0.000233D0,PA0=51.2D0,PA1=20.2D0) - DOUBLE PRECISION PBC - PARAMETER (PBC=-0.001778D0) - DOUBLE PRECISION PCC - PARAMETER (PCC=0.000817D0) - DOUBLE PRECISION PDC - PARAMETER (PDC=0.002011D0) - DOUBLE PRECISION PEC,PE0,PE1,PE2 - PARAMETER (PEC=0.003964D0, - : PE0=346.560D0,PE1=132.870D0,PE2=-0.0091731D0) - DOUBLE PRECISION PFC - PARAMETER (PFC=0.001964D0) - DOUBLE PRECISION PGC - PARAMETER (PGC=0.002541D0) - DOUBLE PRECISION PHC - PARAMETER (PHC=0.001964D0) - DOUBLE PRECISION PIC - PARAMETER (PIC=-0.024691D0) - DOUBLE PRECISION PJC,PJ0,PJ1 - PARAMETER (PJC=-0.004328D0,PJ0=275.05D0,PJ1=-2.30D0) - DOUBLE PRECISION CW1 - PARAMETER (CW1=0.0004664D0) - DOUBLE PRECISION CW2 - PARAMETER (CW2=0.0000754D0) - -* -* Coefficients for Moon position -* -* Tx(N) = coefficient of L, B or P term (deg) -* ITx(N,1-5) = coefficients of M, M', D, F, E**n in argument -* - INTEGER NL,NB,NP - PARAMETER (NL=50,NB=45,NP=31) - DOUBLE PRECISION TL(NL),TB(NB),TP(NP) - INTEGER ITL(5,NL),ITB(5,NB),ITP(5,NP) -* -* Longitude -* M M' D F n - DATA TL( 1)/ +6.288750D0 /, - : (ITL(I, 1),I=1,5)/ +0, +1, +0, +0, 0 / - DATA TL( 2)/ +1.274018D0 /, - : (ITL(I, 2),I=1,5)/ +0, -1, +2, +0, 0 / - DATA TL( 3)/ +0.658309D0 /, - : (ITL(I, 3),I=1,5)/ +0, +0, +2, +0, 0 / - DATA TL( 4)/ +0.213616D0 /, - : (ITL(I, 4),I=1,5)/ +0, +2, +0, +0, 0 / - DATA TL( 5)/ -0.185596D0 /, - : (ITL(I, 5),I=1,5)/ +1, +0, +0, +0, 1 / - DATA TL( 6)/ -0.114336D0 /, - : (ITL(I, 6),I=1,5)/ +0, +0, +0, +2, 0 / - DATA TL( 7)/ +0.058793D0 /, - : (ITL(I, 7),I=1,5)/ +0, -2, +2, +0, 0 / - DATA TL( 8)/ +0.057212D0 /, - : (ITL(I, 8),I=1,5)/ -1, -1, +2, +0, 1 / - DATA TL( 9)/ +0.053320D0 /, - : (ITL(I, 9),I=1,5)/ +0, +1, +2, +0, 0 / - DATA TL(10)/ +0.045874D0 /, - : (ITL(I,10),I=1,5)/ -1, +0, +2, +0, 1 / - DATA TL(11)/ +0.041024D0 /, - : (ITL(I,11),I=1,5)/ -1, +1, +0, +0, 1 / - DATA TL(12)/ -0.034718D0 /, - : (ITL(I,12),I=1,5)/ +0, +0, +1, +0, 0 / - DATA TL(13)/ -0.030465D0 /, - : (ITL(I,13),I=1,5)/ +1, +1, +0, +0, 1 / - DATA TL(14)/ +0.015326D0 /, - : (ITL(I,14),I=1,5)/ +0, +0, +2, -2, 0 / - DATA TL(15)/ -0.012528D0 /, - : (ITL(I,15),I=1,5)/ +0, +1, +0, +2, 0 / - DATA TL(16)/ -0.010980D0 /, - : (ITL(I,16),I=1,5)/ +0, -1, +0, +2, 0 / - DATA TL(17)/ +0.010674D0 /, - : (ITL(I,17),I=1,5)/ +0, -1, +4, +0, 0 / - DATA TL(18)/ +0.010034D0 /, - : (ITL(I,18),I=1,5)/ +0, +3, +0, +0, 0 / - DATA TL(19)/ +0.008548D0 /, - : (ITL(I,19),I=1,5)/ +0, -2, +4, +0, 0 / - DATA TL(20)/ -0.007910D0 /, - : (ITL(I,20),I=1,5)/ +1, -1, +2, +0, 1 / - DATA TL(21)/ -0.006783D0 /, - : (ITL(I,21),I=1,5)/ +1, +0, +2, +0, 1 / - DATA TL(22)/ +0.005162D0 /, - : (ITL(I,22),I=1,5)/ +0, +1, -1, +0, 0 / - DATA TL(23)/ +0.005000D0 /, - : (ITL(I,23),I=1,5)/ +1, +0, +1, +0, 1 / - DATA TL(24)/ +0.004049D0 /, - : (ITL(I,24),I=1,5)/ -1, +1, +2, +0, 1 / - DATA TL(25)/ +0.003996D0 /, - : (ITL(I,25),I=1,5)/ +0, +2, +2, +0, 0 / - DATA TL(26)/ +0.003862D0 /, - : (ITL(I,26),I=1,5)/ +0, +0, +4, +0, 0 / - DATA TL(27)/ +0.003665D0 /, - : (ITL(I,27),I=1,5)/ +0, -3, +2, +0, 0 / - DATA TL(28)/ +0.002695D0 /, - : (ITL(I,28),I=1,5)/ -1, +2, +0, +0, 1 / - DATA TL(29)/ +0.002602D0 /, - : (ITL(I,29),I=1,5)/ +0, +1, -2, -2, 0 / - DATA TL(30)/ +0.002396D0 /, - : (ITL(I,30),I=1,5)/ -1, -2, +2, +0, 1 / - DATA TL(31)/ -0.002349D0 /, - : (ITL(I,31),I=1,5)/ +0, +1, +1, +0, 0 / - DATA TL(32)/ +0.002249D0 /, - : (ITL(I,32),I=1,5)/ -2, +0, +2, +0, 2 / - DATA TL(33)/ -0.002125D0 /, - : (ITL(I,33),I=1,5)/ +1, +2, +0, +0, 1 / - DATA TL(34)/ -0.002079D0 /, - : (ITL(I,34),I=1,5)/ +2, +0, +0, +0, 2 / - DATA TL(35)/ +0.002059D0 /, - : (ITL(I,35),I=1,5)/ -2, -1, +2, +0, 2 / - DATA TL(36)/ -0.001773D0 /, - : (ITL(I,36),I=1,5)/ +0, +1, +2, -2, 0 / - DATA TL(37)/ -0.001595D0 /, - : (ITL(I,37),I=1,5)/ +0, +0, +2, +2, 0 / - DATA TL(38)/ +0.001220D0 /, - : (ITL(I,38),I=1,5)/ -1, -1, +4, +0, 1 / - DATA TL(39)/ -0.001110D0 /, - : (ITL(I,39),I=1,5)/ +0, +2, +0, +2, 0 / - DATA TL(40)/ +0.000892D0 /, - : (ITL(I,40),I=1,5)/ +0, +1, -3, +0, 0 / - DATA TL(41)/ -0.000811D0 /, - : (ITL(I,41),I=1,5)/ +1, +1, +2, +0, 1 / - DATA TL(42)/ +0.000761D0 /, - : (ITL(I,42),I=1,5)/ -1, -2, +4, +0, 1 / - DATA TL(43)/ +0.000717D0 /, - : (ITL(I,43),I=1,5)/ -2, +1, +0, +0, 2 / - DATA TL(44)/ +0.000704D0 /, - : (ITL(I,44),I=1,5)/ -2, +1, -2, +0, 2 / - DATA TL(45)/ +0.000693D0 /, - : (ITL(I,45),I=1,5)/ +1, -2, +2, +0, 1 / - DATA TL(46)/ +0.000598D0 /, - : (ITL(I,46),I=1,5)/ -1, +0, +2, -2, 1 / - DATA TL(47)/ +0.000550D0 /, - : (ITL(I,47),I=1,5)/ +0, +1, +4, +0, 0 / - DATA TL(48)/ +0.000538D0 /, - : (ITL(I,48),I=1,5)/ +0, +4, +0, +0, 0 / - DATA TL(49)/ +0.000521D0 /, - : (ITL(I,49),I=1,5)/ -1, +0, +4, +0, 1 / - DATA TL(50)/ +0.000486D0 /, - : (ITL(I,50),I=1,5)/ +0, +2, -1, +0, 0 / -* -* Latitude -* M M' D F n - DATA TB( 1)/ +5.128189D0 /, - : (ITB(I, 1),I=1,5)/ +0, +0, +0, +1, 0 / - DATA TB( 2)/ +0.280606D0 /, - : (ITB(I, 2),I=1,5)/ +0, +1, +0, +1, 0 / - DATA TB( 3)/ +0.277693D0 /, - : (ITB(I, 3),I=1,5)/ +0, +1, +0, -1, 0 / - DATA TB( 4)/ +0.173238D0 /, - : (ITB(I, 4),I=1,5)/ +0, +0, +2, -1, 0 / - DATA TB( 5)/ +0.055413D0 /, - : (ITB(I, 5),I=1,5)/ +0, -1, +2, +1, 0 / - DATA TB( 6)/ +0.046272D0 /, - : (ITB(I, 6),I=1,5)/ +0, -1, +2, -1, 0 / - DATA TB( 7)/ +0.032573D0 /, - : (ITB(I, 7),I=1,5)/ +0, +0, +2, +1, 0 / - DATA TB( 8)/ +0.017198D0 /, - : (ITB(I, 8),I=1,5)/ +0, +2, +0, +1, 0 / - DATA TB( 9)/ +0.009267D0 /, - : (ITB(I, 9),I=1,5)/ +0, +1, +2, -1, 0 / - DATA TB(10)/ +0.008823D0 /, - : (ITB(I,10),I=1,5)/ +0, +2, +0, -1, 0 / - DATA TB(11)/ +0.008247D0 /, - : (ITB(I,11),I=1,5)/ -1, +0, +2, -1, 1 / - DATA TB(12)/ +0.004323D0 /, - : (ITB(I,12),I=1,5)/ +0, -2, +2, -1, 0 / - DATA TB(13)/ +0.004200D0 /, - : (ITB(I,13),I=1,5)/ +0, +1, +2, +1, 0 / - DATA TB(14)/ +0.003372D0 /, - : (ITB(I,14),I=1,5)/ -1, +0, -2, +1, 1 / - DATA TB(15)/ +0.002472D0 /, - : (ITB(I,15),I=1,5)/ -1, -1, +2, +1, 1 / - DATA TB(16)/ +0.002222D0 /, - : (ITB(I,16),I=1,5)/ -1, +0, +2, +1, 1 / - DATA TB(17)/ +0.002072D0 /, - : (ITB(I,17),I=1,5)/ -1, -1, +2, -1, 1 / - DATA TB(18)/ +0.001877D0 /, - : (ITB(I,18),I=1,5)/ -1, +1, +0, +1, 1 / - DATA TB(19)/ +0.001828D0 /, - : (ITB(I,19),I=1,5)/ +0, -1, +4, -1, 0 / - DATA TB(20)/ -0.001803D0 /, - : (ITB(I,20),I=1,5)/ +1, +0, +0, +1, 1 / - DATA TB(21)/ -0.001750D0 /, - : (ITB(I,21),I=1,5)/ +0, +0, +0, +3, 0 / - DATA TB(22)/ +0.001570D0 /, - : (ITB(I,22),I=1,5)/ -1, +1, +0, -1, 1 / - DATA TB(23)/ -0.001487D0 /, - : (ITB(I,23),I=1,5)/ +0, +0, +1, +1, 0 / - DATA TB(24)/ -0.001481D0 /, - : (ITB(I,24),I=1,5)/ +1, +1, +0, +1, 1 / - DATA TB(25)/ +0.001417D0 /, - : (ITB(I,25),I=1,5)/ -1, -1, +0, +1, 1 / - DATA TB(26)/ +0.001350D0 /, - : (ITB(I,26),I=1,5)/ -1, +0, +0, +1, 1 / - DATA TB(27)/ +0.001330D0 /, - : (ITB(I,27),I=1,5)/ +0, +0, -1, +1, 0 / - DATA TB(28)/ +0.001106D0 /, - : (ITB(I,28),I=1,5)/ +0, +3, +0, +1, 0 / - DATA TB(29)/ +0.001020D0 /, - : (ITB(I,29),I=1,5)/ +0, +0, +4, -1, 0 / - DATA TB(30)/ +0.000833D0 /, - : (ITB(I,30),I=1,5)/ +0, -1, +4, +1, 0 / - DATA TB(31)/ +0.000781D0 /, - : (ITB(I,31),I=1,5)/ +0, +1, +0, -3, 0 / - DATA TB(32)/ +0.000670D0 /, - : (ITB(I,32),I=1,5)/ +0, -2, +4, +1, 0 / - DATA TB(33)/ +0.000606D0 /, - : (ITB(I,33),I=1,5)/ +0, +0, +2, -3, 0 / - DATA TB(34)/ +0.000597D0 /, - : (ITB(I,34),I=1,5)/ +0, +2, +2, -1, 0 / - DATA TB(35)/ +0.000492D0 /, - : (ITB(I,35),I=1,5)/ -1, +1, +2, -1, 1 / - DATA TB(36)/ +0.000450D0 /, - : (ITB(I,36),I=1,5)/ +0, +2, -2, -1, 0 / - DATA TB(37)/ +0.000439D0 /, - : (ITB(I,37),I=1,5)/ +0, +3, +0, -1, 0 / - DATA TB(38)/ +0.000423D0 /, - : (ITB(I,38),I=1,5)/ +0, +2, +2, +1, 0 / - DATA TB(39)/ +0.000422D0 /, - : (ITB(I,39),I=1,5)/ +0, -3, +2, -1, 0 / - DATA TB(40)/ -0.000367D0 /, - : (ITB(I,40),I=1,5)/ +1, -1, +2, +1, 1 / - DATA TB(41)/ -0.000353D0 /, - : (ITB(I,41),I=1,5)/ +1, +0, +2, +1, 1 / - DATA TB(42)/ +0.000331D0 /, - : (ITB(I,42),I=1,5)/ +0, +0, +4, +1, 0 / - DATA TB(43)/ +0.000317D0 /, - : (ITB(I,43),I=1,5)/ -1, +1, +2, +1, 1 / - DATA TB(44)/ +0.000306D0 /, - : (ITB(I,44),I=1,5)/ -2, +0, +2, -1, 2 / - DATA TB(45)/ -0.000283D0 /, - : (ITB(I,45),I=1,5)/ +0, +1, +0, +3, 0 / -* -* Parallax -* M M' D F n - DATA TP( 1)/ +0.950724D0 /, - : (ITP(I, 1),I=1,5)/ +0, +0, +0, +0, 0 / - DATA TP( 2)/ +0.051818D0 /, - : (ITP(I, 2),I=1,5)/ +0, +1, +0, +0, 0 / - DATA TP( 3)/ +0.009531D0 /, - : (ITP(I, 3),I=1,5)/ +0, -1, +2, +0, 0 / - DATA TP( 4)/ +0.007843D0 /, - : (ITP(I, 4),I=1,5)/ +0, +0, +2, +0, 0 / - DATA TP( 5)/ +0.002824D0 /, - : (ITP(I, 5),I=1,5)/ +0, +2, +0, +0, 0 / - DATA TP( 6)/ +0.000857D0 /, - : (ITP(I, 6),I=1,5)/ +0, +1, +2, +0, 0 / - DATA TP( 7)/ +0.000533D0 /, - : (ITP(I, 7),I=1,5)/ -1, +0, +2, +0, 1 / - DATA TP( 8)/ +0.000401D0 /, - : (ITP(I, 8),I=1,5)/ -1, -1, +2, +0, 1 / - DATA TP( 9)/ +0.000320D0 /, - : (ITP(I, 9),I=1,5)/ -1, +1, +0, +0, 1 / - DATA TP(10)/ -0.000271D0 /, - : (ITP(I,10),I=1,5)/ +0, +0, +1, +0, 0 / - DATA TP(11)/ -0.000264D0 /, - : (ITP(I,11),I=1,5)/ +1, +1, +0, +0, 1 / - DATA TP(12)/ -0.000198D0 /, - : (ITP(I,12),I=1,5)/ +0, -1, +0, +2, 0 / - DATA TP(13)/ +0.000173D0 /, - : (ITP(I,13),I=1,5)/ +0, +3, +0, +0, 0 / - DATA TP(14)/ +0.000167D0 /, - : (ITP(I,14),I=1,5)/ +0, -1, +4, +0, 0 / - DATA TP(15)/ -0.000111D0 /, - : (ITP(I,15),I=1,5)/ +1, +0, +0, +0, 1 / - DATA TP(16)/ +0.000103D0 /, - : (ITP(I,16),I=1,5)/ +0, -2, +4, +0, 0 / - DATA TP(17)/ -0.000084D0 /, - : (ITP(I,17),I=1,5)/ +0, +2, -2, +0, 0 / - DATA TP(18)/ -0.000083D0 /, - : (ITP(I,18),I=1,5)/ +1, +0, +2, +0, 1 / - DATA TP(19)/ +0.000079D0 /, - : (ITP(I,19),I=1,5)/ +0, +2, +2, +0, 0 / - DATA TP(20)/ +0.000072D0 /, - : (ITP(I,20),I=1,5)/ +0, +0, +4, +0, 0 / - DATA TP(21)/ +0.000064D0 /, - : (ITP(I,21),I=1,5)/ -1, +1, +2, +0, 1 / - DATA TP(22)/ -0.000063D0 /, - : (ITP(I,22),I=1,5)/ +1, -1, +2, +0, 1 / - DATA TP(23)/ +0.000041D0 /, - : (ITP(I,23),I=1,5)/ +1, +0, +1, +0, 1 / - DATA TP(24)/ +0.000035D0 /, - : (ITP(I,24),I=1,5)/ -1, +2, +0, +0, 1 / - DATA TP(25)/ -0.000033D0 /, - : (ITP(I,25),I=1,5)/ +0, +3, -2, +0, 0 / - DATA TP(26)/ -0.000030D0 /, - : (ITP(I,26),I=1,5)/ +0, +1, +1, +0, 0 / - DATA TP(27)/ -0.000029D0 /, - : (ITP(I,27),I=1,5)/ +0, +0, -2, +2, 0 / - DATA TP(28)/ -0.000029D0 /, - : (ITP(I,28),I=1,5)/ +1, +2, +0, +0, 1 / - DATA TP(29)/ +0.000026D0 /, - : (ITP(I,29),I=1,5)/ -2, +0, +2, +0, 2 / - DATA TP(30)/ -0.000023D0 /, - : (ITP(I,30),I=1,5)/ +0, +1, -2, +2, 0 / - DATA TP(31)/ +0.000019D0 /, - : (ITP(I,31),I=1,5)/ -1, -1, +4, +0, 1 / - - - -* Centuries since J1900 - T=(DATE-15019.5D0)/36525D0 - -* -* Fundamental arguments (radians) and derivatives (radians per -* Julian century) for the current epoch -* - -* Moon's mean longitude - ELP=D2R*MOD(ELP0+(ELP1+(ELP2+ELP3*T)*T)*T,360D0) - DELP=D2R*(ELP1+(2D0*ELP2+3D0*ELP3*T)*T) - -* Sun's mean anomaly - EM=D2R*MOD(EM0+(EM1+(EM2+EM3*T)*T)*T,360D0) - DEM=D2R*(EM1+(2D0*EM2+3D0*EM3*T)*T) - -* Moon's mean anomaly - EMP=D2R*MOD(EMP0+(EMP1+(EMP2+EMP3*T)*T)*T,360D0) - DEMP=D2R*(EMP1+(2D0*EMP2+3D0*EMP3*T)*T) - -* Moon's mean elongation - D=D2R*MOD(D0+(D1+(D2+D3*T)*T)*T,360D0) - DD=D2R*(D1+(2D0*D2+3D0*D3*T)*T) - -* Mean distance of the Moon from its ascending node - F=D2R*MOD(F0+(F1+(F2+F3*T)*T)*T,360D0) - DF=D2R*(F1+(2D0*F2+3D0*F3*T)*T) - -* Longitude of the Moon's ascending node - OM=D2R*MOD(OM0+(OM1+(OM2+OM3*T)*T)*T,360D0) - DOM=D2R*(OM1+(2D0*OM2+3D0*OM3*T)*T) - SINOM=SIN(OM) - COSOM=COS(OM) - DOMCOM=DOM*COSOM - -* Add the periodic variations - THETA=D2R*(PA0+PA1*T) - WA=SIN(THETA) - DWA=D2R*PA1*COS(THETA) - THETA=D2R*(PE0+(PE1+PE2*T)*T) - WB=PEC*SIN(THETA) - DWB=D2R*PEC*(PE1+2D0*PE2*T)*COS(THETA) - ELP=ELP+D2R*(PAC*WA+WB+PFC*SINOM) - DELP=DELP+D2R*(PAC*DWA+DWB+PFC*DOMCOM) - EM=EM+D2R*PBC*WA - DEM=DEM+D2R*PBC*DWA - EMP=EMP+D2R*(PCC*WA+WB+PGC*SINOM) - DEMP=DEMP+D2R*(PCC*DWA+DWB+PGC*DOMCOM) - D=D+D2R*(PDC*WA+WB+PHC*SINOM) - DD=DD+D2R*(PDC*DWA+DWB+PHC*DOMCOM) - WOM=OM+D2R*(PJ0+PJ1*T) - DWOM=DOM+D2R*PJ1 - SINWOM=SIN(WOM) - COSWOM=COS(WOM) - F=F+D2R*(WB+PIC*SINOM+PJC*SINWOM) - DF=DF+D2R*(DWB+PIC*DOMCOM+PJC*DWOM*COSWOM) - -* E-factor, and square - E=1D0+(E1+E2*T)*T - DE=E1+2D0*E2*T - ESQ=E*E - DESQ=2D0*E*DE - -* -* Series expansions -* - -* Longitude - V=0D0 - DV=0D0 - DO N=NL,1,-1 - COEFF=TL(N) - EMN=DBLE(ITL(1,N)) - EMPN=DBLE(ITL(2,N)) - DN=DBLE(ITL(3,N)) - FN=DBLE(ITL(4,N)) - I=ITL(5,N) - IF (I.EQ.0) THEN - EN=1D0 - DEN=0D0 - ELSE IF (I.EQ.1) THEN - EN=E - DEN=DE - ELSE - EN=ESQ - DEN=DESQ - END IF - THETA=EMN*EM+EMPN*EMP+DN*D+FN*F - DTHETA=EMN*DEM+EMPN*DEMP+DN*DD+FN*DF - FTHETA=SIN(THETA) - V=V+COEFF*FTHETA*EN - DV=DV+COEFF*(COS(THETA)*DTHETA*EN+FTHETA*DEN) - END DO - EL=ELP+D2R*V - DEL=(DELP+D2R*DV)/CJ - -* Latitude - V=0D0 - DV=0D0 - DO N=NB,1,-1 - COEFF=TB(N) - EMN=DBLE(ITB(1,N)) - EMPN=DBLE(ITB(2,N)) - DN=DBLE(ITB(3,N)) - FN=DBLE(ITB(4,N)) - I=ITB(5,N) - IF (I.EQ.0) THEN - EN=1D0 - DEN=0D0 - ELSE IF (I.EQ.1) THEN - EN=E - DEN=DE - ELSE - EN=ESQ - DEN=DESQ - END IF - THETA=EMN*EM+EMPN*EMP+DN*D+FN*F - DTHETA=EMN*DEM+EMPN*DEMP+DN*DD+FN*DF - FTHETA=SIN(THETA) - V=V+COEFF*FTHETA*EN - DV=DV+COEFF*(COS(THETA)*DTHETA*EN+FTHETA*DEN) - END DO - BF=1D0-CW1*COSOM-CW2*COSWOM - DBF=CW1*DOM*SINOM+CW2*DWOM*SINWOM - B=D2R*V*BF - DB=D2R*(DV*BF+V*DBF)/CJ - -* Parallax - V=0D0 - DV=0D0 - DO N=NP,1,-1 - COEFF=TP(N) - EMN=DBLE(ITP(1,N)) - EMPN=DBLE(ITP(2,N)) - DN=DBLE(ITP(3,N)) - FN=DBLE(ITP(4,N)) - I=ITP(5,N) - IF (I.EQ.0) THEN - EN=1D0 - DEN=0D0 - ELSE IF (I.EQ.1) THEN - EN=E - DEN=DE - ELSE - EN=ESQ - DEN=DESQ - END IF - THETA=EMN*EM+EMPN*EMP+DN*D+FN*F - DTHETA=EMN*DEM+EMPN*DEMP+DN*DD+FN*DF - FTHETA=COS(THETA) - V=V+COEFF*FTHETA*EN - DV=DV+COEFF*(-SIN(THETA)*DTHETA*EN+FTHETA*DEN) - END DO - P=D2R*V - DP=D2R*DV/CJ - -* -* Transformation into final form -* - -* Parallax to distance (AU, AU/sec) - SP=SIN(P) - R=ERADAU/SP - DR=-R*DP*COS(P)/SP - -* Longitude, latitude to x,y,z (AU) - SEL=SIN(EL) - CEL=COS(EL) - SB=SIN(B) - CB=COS(B) - RCB=R*CB - RBD=R*DB - W=RBD*SB-CB*DR - X=RCB*CEL - Y=RCB*SEL - Z=R*SB - XD=-Y*DEL-W*CEL - YD=X*DEL-W*SEL - ZD=RBD*CB+SB*DR - -* Julian centuries since J2000 - T=(DATE-51544.5D0)/36525D0 - -* Fricke equinox correction - EPJ=2000D0+T*100D0 - EQCOR=DS2R*(0.035D0+0.00085D0*(EPJ-B1950)) - -* Mean obliquity (IAU 1976) - EPS=DAS2R*(84381.448D0+(-46.8150D0+(-0.00059D0+0.001813D0*T)*T)*T) - -* To the equatorial system, mean of date, FK5 system - SINEPS=SIN(EPS) - COSEPS=COS(EPS) - ES=EQCOR*SINEPS - EC=EQCOR*COSEPS - PV(1)=X-EC*Y+ES*Z - PV(2)=EQCOR*X+Y*COSEPS-Z*SINEPS - PV(3)=Y*SINEPS+Z*COSEPS - PV(4)=XD-EC*YD+ES*ZD - PV(5)=EQCOR*XD+YD*COSEPS-ZD*SINEPS - PV(6)=YD*SINEPS+ZD*COSEPS - - END diff --git a/src/slalib/dmxm.f b/src/slalib/dmxm.f deleted file mode 100644 index 3409d2a23..000000000 --- a/src/slalib/dmxm.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_DMXM (A, B, C) -*+ -* - - - - - -* D M X M -* - - - - - -* -* Product of two 3x3 matrices: -* -* matrix C = matrix A x matrix B -* -* (double precision) -* -* Given: -* A dp(3,3) matrix -* B dp(3,3) matrix -* -* Returned: -* C dp(3,3) matrix result -* -* To comply with the ANSI Fortran 77 standard, A, B and C must -* be different arrays. However, the routine is coded so as to -* work properly on many platforms even if this rule is violated. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION A(3,3),B(3,3),C(3,3) - - INTEGER I,J,K - DOUBLE PRECISION W,WM(3,3) - - -* Multiply into scratch matrix - DO I=1,3 - DO J=1,3 - W=0D0 - DO K=1,3 - W=W+A(I,K)*B(K,J) - END DO - WM(I,J)=W - END DO - END DO - -* Return the result - DO J=1,3 - DO I=1,3 - C(I,J)=WM(I,J) - END DO - END DO - - END diff --git a/src/slalib/dmxv.f b/src/slalib/dmxv.f deleted file mode 100644 index c4a918663..000000000 --- a/src/slalib/dmxv.f +++ /dev/null @@ -1,68 +0,0 @@ - SUBROUTINE sla_DMXV (DM, VA, VB) -*+ -* - - - - - -* D M X V -* - - - - - -* -* Performs the 3-D forward unitary transformation: -* -* vector VB = matrix DM * vector VA -* -* (double precision) -* -* Given: -* DM dp(3,3) matrix -* VA dp(3) vector -* -* Returned: -* VB dp(3) result vector -* -* To comply with the ANSI Fortran 77 standard, VA and VB must be -* different arrays. However, the routine is coded so as to work -* properly on many platforms even if this rule is violated. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DM(3,3),VA(3),VB(3) - - INTEGER I,J - DOUBLE PRECISION W,VW(3) - - -* Matrix DM * vector VA -> vector VW - DO J=1,3 - W=0D0 - DO I=1,3 - W=W+DM(J,I)*VA(I) - END DO - VW(J)=W - END DO - -* Vector VW -> vector VB - DO J=1,3 - VB(J)=VW(J) - END DO - - END diff --git a/src/slalib/dpav.f b/src/slalib/dpav.f deleted file mode 100644 index 5407ba2f0..000000000 --- a/src/slalib/dpav.f +++ /dev/null @@ -1,81 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DPAV ( V1, V2 ) -*+ -* - - - - - -* D P A V -* - - - - - -* -* Position angle of one celestial direction with respect to another. -* -* (double precision) -* -* Given: -* V1 d(3) direction cosines of one point -* V2 d(3) direction cosines of the other point -* -* (The coordinate frames correspond to RA,Dec, Long,Lat etc.) -* -* The result is the bearing (position angle), in radians, of point -* V2 with respect to point V1. It is in the range +/- pi. The -* sense is such that if V2 is a small distance east of V1, the -* bearing is about +pi/2. Zero is returned if the two points -* are coincident. -* -* V1 and V2 need not be unit vectors. -* -* The routine sla_DBEAR performs an equivalent function except -* that the points are specified in the form of spherical -* coordinates. -* -* Last revision: 16 March 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION V1(3),V2(3) - - DOUBLE PRECISION X1,Y1,Z1,W,X2,Y2,Z2,SQ,CQ - - - -* The unit vector to point 1. - X1 = V1(1) - Y1 = V1(2) - Z1 = V1(3) - W = SQRT(X1*X1+Y1*Y1+Z1*Z1) - IF (W.NE.0D0) THEN - X1 = X1/W - Y1 = Y1/W - Z1 = Z1/W - END IF - -* The vector to point 2. - X2 = V2(1) - Y2 = V2(2) - Z2 = V2(3) - -* Position angle. - SQ = Y2*X1-X2*Y1 - CQ = Z2*(X1*X1+Y1*Y1)-Z1*(X2*X1+Y2*Y1) - IF (SQ.EQ.0D0.AND.CQ.EQ.0D0) CQ=1D0 - sla_DPAV = ATAN2(SQ,CQ) - - END diff --git a/src/slalib/dr2af.f b/src/slalib/dr2af.f deleted file mode 100644 index 9d09c918c..000000000 --- a/src/slalib/dr2af.f +++ /dev/null @@ -1,75 +0,0 @@ - SUBROUTINE sla_DR2AF (NDP, ANGLE, SIGN, IDMSF) -*+ -* - - - - - - -* D R 2 A F -* - - - - - - -* -* Convert an angle in radians to degrees, arcminutes, arcseconds -* (double precision) -* -* Given: -* NDP i number of decimal places of arcseconds -* ANGLE d angle in radians -* -* Returned: -* SIGN c '+' or '-' -* IDMSF i(4) degrees, arcminutes, arcseconds, fraction -* -* Notes: -* -* 1) NDP less than zero is interpreted as zero. -* -* 2) The largest useful value for NDP is determined by the size -* of ANGLE, the format of DOUBLE PRECISION floating-point -* numbers on the target machine, and the risk of overflowing -* IDMSF(4). On some architectures, for ANGLE up to 2pi, the -* available floating-point precision corresponds roughly to -* NDP=12. However, the practical limit is NDP=9, set by the -* capacity of a typical 32-bit IDMSF(4). -* -* 3) The absolute value of ANGLE may exceed 2pi. In cases where it -* does not, it is up to the caller to test for and handle the -* case where ANGLE is very nearly 2pi and rounds up to 360 deg, -* by testing for IDMSF(1)=360 and setting IDMSF(1-4) to zero. -* -* Called: sla_DD2TF -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - DOUBLE PRECISION ANGLE - CHARACTER SIGN*(*) - INTEGER IDMSF(4) - -* Hours to degrees * radians to turns - DOUBLE PRECISION F - PARAMETER (F=15D0/6.283185307179586476925287D0) - - - -* Scale then use days to h,m,s routine - CALL sla_DD2TF(NDP,ANGLE*F,SIGN,IDMSF) - - END diff --git a/src/slalib/dr2tf.f b/src/slalib/dr2tf.f deleted file mode 100644 index d610797cb..000000000 --- a/src/slalib/dr2tf.f +++ /dev/null @@ -1,75 +0,0 @@ - SUBROUTINE sla_DR2TF (NDP, ANGLE, SIGN, IHMSF) -*+ -* - - - - - - -* D R 2 T F -* - - - - - - -* -* Convert an angle in radians to hours, minutes, seconds -* (double precision) -* -* Given: -* NDP i number of decimal places of seconds -* ANGLE d angle in radians -* -* Returned: -* SIGN c '+' or '-' -* IHMSF i(4) hours, minutes, seconds, fraction -* -* Notes: -* -* 1) NDP less than zero is interpreted as zero. -* -* 2) The largest useful value for NDP is determined by the size -* of ANGLE, the format of DOUBLE PRECISION floating-point -* numbers on the target machine, and the risk of overflowing -* IHMSF(4). On some architectures, for ANGLE up to 2pi, the -* available floating-point precision corresponds roughly to -* NDP=12. However, the practical limit is NDP=9, set by the -* capacity of a typical 32-bit IHMSF(4). -* -* 3) The absolute value of ANGLE may exceed 2pi. In cases where it -* does not, it is up to the caller to test for and handle the -* case where ANGLE is very nearly 2pi and rounds up to 24 hours, -* by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero. -* -* Called: sla_DD2TF -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NDP - DOUBLE PRECISION ANGLE - CHARACTER SIGN*(*) - INTEGER IHMSF(4) - -* Turns to radians - DOUBLE PRECISION T2R - PARAMETER (T2R=6.283185307179586476925287D0) - - - -* Scale then use days to h,m,s routine - CALL sla_DD2TF(NDP,ANGLE/T2R,SIGN,IHMSF) - - END diff --git a/src/slalib/drange.f b/src/slalib/drange.f deleted file mode 100644 index 43312ba6d..000000000 --- a/src/slalib/drange.f +++ /dev/null @@ -1,49 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DRANGE (ANGLE) -*+ -* - - - - - - - -* D R A N G E -* - - - - - - - -* -* Normalize angle into range +/- pi (double precision) -* -* Given: -* ANGLE dp the angle in radians -* -* The result (double precision) is ANGLE expressed in the range +/- pi. -* -* P.T.Wallace Starlink 23 November 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION ANGLE - - DOUBLE PRECISION DPI,D2PI - PARAMETER (DPI=3.141592653589793238462643D0) - PARAMETER (D2PI=6.283185307179586476925287D0) - - - sla_DRANGE=MOD(ANGLE,D2PI) - IF (ABS(sla_DRANGE).GE.DPI) - : sla_DRANGE=sla_DRANGE-SIGN(D2PI,ANGLE) - - END diff --git a/src/slalib/dranrm.f b/src/slalib/dranrm.f deleted file mode 100644 index 6f9ed6571..000000000 --- a/src/slalib/dranrm.f +++ /dev/null @@ -1,47 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DRANRM (ANGLE) -*+ -* - - - - - - - -* D R A N R M -* - - - - - - - -* -* Normalize angle into range 0-2 pi (double precision) -* -* Given: -* ANGLE dp the angle in radians -* -* The result is ANGLE expressed in the range 0-2 pi. -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION ANGLE - - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925286766559D0) - - - sla_DRANRM = MOD(ANGLE,D2PI) - IF (sla_DRANRM.LT.0D0) sla_DRANRM = sla_DRANRM+D2PI - - END diff --git a/src/slalib/ds2c6.f b/src/slalib/ds2c6.f deleted file mode 100644 index da2726bb0..000000000 --- a/src/slalib/ds2c6.f +++ /dev/null @@ -1,74 +0,0 @@ - SUBROUTINE sla_DS2C6 (A, B, R, AD, BD, RD, V) -*+ -* - - - - - - -* D S 2 C 6 -* - - - - - - -* -* Conversion of position & velocity in spherical coordinates -* to Cartesian coordinates -* -* (double precision) -* -* Given: -* A dp longitude (radians) -* B dp latitude (radians) -* R dp radial coordinate -* AD dp longitude derivative (radians per unit time) -* BD dp latitude derivative (radians per unit time) -* RD dp radial derivative -* -* Returned: -* V dp(6) Cartesian position & velocity vector -* -* P.T.Wallace Starlink 10 July 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION A,B,R,AD,BD,RD,V(6) - - DOUBLE PRECISION SA,CA,SB,CB,RCB,X,Y,RBD,W - - - -* Useful functions - SA=SIN(A) - CA=COS(A) - SB=SIN(B) - CB=COS(B) - RCB=R*CB - X=RCB*CA - Y=RCB*SA - RBD=R*BD - W=RBD*SB-CB*RD - -* Position - V(1)=X - V(2)=Y - V(3)=R*SB - -* Velocity - V(4)=-Y*AD-W*CA - V(5)=X*AD-W*SA - V(6)=RBD*CB+SB*RD - - END diff --git a/src/slalib/ds2tp.f b/src/slalib/ds2tp.f deleted file mode 100644 index b54e7fa70..000000000 --- a/src/slalib/ds2tp.f +++ /dev/null @@ -1,84 +0,0 @@ - SUBROUTINE sla_DS2TP (RA, DEC, RAZ, DECZ, XI, ETA, J) -*+ -* - - - - - - -* D S 2 T P -* - - - - - - -* -* Projection of spherical coordinates onto tangent plane: -* "gnomonic" projection - "standard coordinates" (double precision) -* -* Given: -* RA,DEC dp spherical coordinates of point to be projected -* RAZ,DECZ dp spherical coordinates of tangent point -* -* Returned: -* XI,ETA dp rectangular coordinates on tangent plane -* J int status: 0 = OK, star on tangent plane -* 1 = error, star too far from axis -* 2 = error, antistar on tangent plane -* 3 = error, antistar too far from axis -* -* P.T.Wallace Starlink 18 July 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RA,DEC,RAZ,DECZ,XI,ETA - INTEGER J - - DOUBLE PRECISION SDECZ,SDEC,CDECZ,CDEC, - : RADIF,SRADIF,CRADIF,DENOM - - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-6) - - -* Trig functions - SDECZ=SIN(DECZ) - SDEC=SIN(DEC) - CDECZ=COS(DECZ) - CDEC=COS(DEC) - RADIF=RA-RAZ - SRADIF=SIN(RADIF) - CRADIF=COS(RADIF) - -* Reciprocal of star vector length to tangent plane - DENOM=SDEC*SDECZ+CDEC*CDECZ*CRADIF - -* Handle vectors too far from axis - IF (DENOM.GT.TINY) THEN - J=0 - ELSE IF (DENOM.GE.0D0) THEN - J=1 - DENOM=TINY - ELSE IF (DENOM.GT.-TINY) THEN - J=2 - DENOM=-TINY - ELSE - J=3 - END IF - -* Compute tangent plane coordinates (even in dubious cases) - XI=CDEC*SRADIF/DENOM - ETA=(SDEC*CDECZ-CDEC*SDECZ*CRADIF)/DENOM - - END diff --git a/src/slalib/dsep.f b/src/slalib/dsep.f deleted file mode 100644 index 5a0928e44..000000000 --- a/src/slalib/dsep.f +++ /dev/null @@ -1,60 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DSEP (A1, B1, A2, B2) -*+ -* - - - - - -* D S E P -* - - - - - -* -* Angle between two points on a sphere. -* -* (double precision) -* -* Given: -* A1,B1 d spherical coordinates of one point -* A2,B2 d spherical coordinates of the other point -* -* (The spherical coordinates are [RA,Dec], [Long,Lat] etc, in radians.) -* -* The result is the angle, in radians, between the two points. It -* is always positive. -* -* Called: sla_DCS2C, sla_DSEPV -* -* Last revision: 7 May 2000 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION A1,B1,A2,B2 - - DOUBLE PRECISION V1(3),V2(3) - DOUBLE PRECISION sla_DSEPV - - - -* Convert coordinates from spherical to Cartesian. - CALL sla_DCS2C(A1,B1,V1) - CALL sla_DCS2C(A2,B2,V2) - -* Angle between the vectors. - sla_DSEP = sla_DSEPV(V1,V2) - - END diff --git a/src/slalib/dsepv.f b/src/slalib/dsepv.f deleted file mode 100644 index b73b2e462..000000000 --- a/src/slalib/dsepv.f +++ /dev/null @@ -1,76 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DSEPV (V1, V2) -*+ -* - - - - - - -* D S E P V -* - - - - - - -* -* Angle between two vectors. -* -* (double precision) -* -* Given: -* V1 d(3) first vector -* V2 d(3) second vector -* -* The result is the angle, in radians, between the two vectors. It -* is always positive. -* -* Notes: -* -* 1 There is no requirement for the vectors to be unit length. -* -* 2 If either vector is null, zero is returned. -* -* 3 The simplest formulation would use dot product alone. However, -* this would reduce the accuracy for angles near zero and pi. The -* algorithm uses both cross product and dot product, which maintains -* accuracy for all sizes of angle. -* -* Called: sla_DVXV, sla_DVN, sla_DVDV -* -* Last revision: 14 June 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION V1(3),V2(3) - - DOUBLE PRECISION V1XV2(3),WV(3),S,C - DOUBLE PRECISION sla_DVDV - - - -* Modulus of cross product = sine multiplied by the two moduli. - CALL sla_DVXV(V1,V2,V1XV2) - CALL sla_DVN(V1XV2,WV,S) - -* Dot product = cosine multiplied by the two moduli. - C = sla_DVDV(V1,V2) - -* Angle between the vectors. - IF ( S.NE.0D0 .OR. C.NE.0D0 ) THEN - sla_DSEPV = ATAN2(S,C) - ELSE - sla_DSEPV = 0D0 - END IF - - END diff --git a/src/slalib/dt.f b/src/slalib/dt.f deleted file mode 100644 index ba9e2a606..000000000 --- a/src/slalib/dt.f +++ /dev/null @@ -1,96 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DT (EPOCH) -*+ -* - - - -* D T -* - - - -* -* Estimate the offset between dynamical time and Universal Time -* for a given historical epoch. -* -* Given: -* EPOCH d (Julian) epoch (e.g. 1850D0) -* -* The result is a rough estimate of ET-UT (after 1984, TT-UT) at -* the given epoch, in seconds. -* -* Notes: -* -* 1 Depending on the epoch, one of three parabolic approximations -* is used: -* -* before 979 Stephenson & Morrison's 390 BC to AD 948 model -* 979 to 1708 Stephenson & Morrison's 948 to 1600 model -* after 1708 McCarthy & Babcock's post-1650 model -* -* The breakpoints are chosen to ensure continuity: they occur -* at places where the adjacent models give the same answer as -* each other. -* -* 2 The accuracy is modest, with errors of up to 20 sec during -* the interval since 1650, rising to perhaps 30 min by 1000 BC. -* Comparatively accurate values from AD 1600 are tabulated in -* the Astronomical Almanac (see section K8 of the 1995 AA). -* -* 3 The use of double-precision for both argument and result is -* purely for compatibility with other SLALIB time routines. -* -* 4 The models used are based on a lunar tidal acceleration value -* of -26.00 arcsec per century. -* -* Reference: Explanatory Supplement to the Astronomical Almanac, -* ed P.K.Seidelmann, University Science Books (1992), -* section 2.553, p83. This contains references to -* the Stephenson & Morrison and McCarthy & Babcock -* papers. -* -* P.T.Wallace Starlink 1 March 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EPOCH - DOUBLE PRECISION T,W,S - - -* Centuries since 1800 - T=(EPOCH-1800D0)/100D0 - -* Select model - IF (EPOCH.GE.1708.185161980887D0) THEN - -* Post-1708: use McCarthy & Babcock - W=T-0.19D0 - S=5.156D0+13.3066D0*W*W - ELSE IF (EPOCH.GE.979.0258204760233D0) THEN - -* 979-1708: use Stephenson & Morrison's 948-1600 model - S=25.5D0*T*T - ELSE - -* Pre-979: use Stephenson & Morrison's 390 BC to AD 948 model - S=1360.0D0+(320D0+44.3D0*T)*T - END IF - -* Result - sla_DT=S - - END diff --git a/src/slalib/dtf2d.f b/src/slalib/dtf2d.f deleted file mode 100644 index 315eae6f6..000000000 --- a/src/slalib/dtf2d.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_DTF2D (IHOUR, IMIN, SEC, DAYS, J) -*+ -* - - - - - - -* D T F 2 D -* - - - - - - -* -* Convert hours, minutes, seconds to days (double precision) -* -* Given: -* IHOUR int hours -* IMIN int minutes -* SEC dp seconds -* -* Returned: -* DAYS dp interval in days -* J int status: 0 = OK -* 1 = IHOUR outside range 0-23 -* 2 = IMIN outside range 0-59 -* 3 = SEC outside range 0-59.999... -* -* Notes: -* -* 1) The result is computed even if any of the range checks fail. -* -* 2) The sign must be dealt with outside this routine. -* -* P.T.Wallace Starlink July 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IHOUR,IMIN - DOUBLE PRECISION SEC,DAYS - INTEGER J - -* Seconds per day - DOUBLE PRECISION D2S - PARAMETER (D2S=86400D0) - - - -* Preset status - J=0 - -* Validate sec, min, hour - IF (SEC.LT.0D0.OR.SEC.GE.60D0) J=3 - IF (IMIN.LT.0.OR.IMIN.GT.59) J=2 - IF (IHOUR.LT.0.OR.IHOUR.GT.23) J=1 - -* Compute interval - DAYS=(60D0*(60D0*DBLE(IHOUR)+DBLE(IMIN))+SEC)/D2S - - END diff --git a/src/slalib/dtf2r.f b/src/slalib/dtf2r.f deleted file mode 100644 index d13a66551..000000000 --- a/src/slalib/dtf2r.f +++ /dev/null @@ -1,70 +0,0 @@ - SUBROUTINE sla_DTF2R (IHOUR, IMIN, SEC, RAD, J) -*+ -* - - - - - - -* D T F 2 R -* - - - - - - -* -* Convert hours, minutes, seconds to radians (double precision) -* -* Given: -* IHOUR int hours -* IMIN int minutes -* SEC dp seconds -* -* Returned: -* RAD dp angle in radians -* J int status: 0 = OK -* 1 = IHOUR outside range 0-23 -* 2 = IMIN outside range 0-59 -* 3 = SEC outside range 0-59.999... -* -* Called: -* sla_DTF2D -* -* Notes: -* -* 1) The result is computed even if any of the range checks fail. -* -* 2) The sign must be dealt with outside this routine. -* -* P.T.Wallace Starlink July 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IHOUR,IMIN - DOUBLE PRECISION SEC,RAD - INTEGER J - - DOUBLE PRECISION TURNS - -* Turns to radians - DOUBLE PRECISION T2R - PARAMETER (T2R=6.283185307179586476925287D0) - - - -* Convert to turns then radians - CALL sla_DTF2D(IHOUR,IMIN,SEC,TURNS,J) - RAD=T2R*TURNS - - END diff --git a/src/slalib/dtp2s.f b/src/slalib/dtp2s.f deleted file mode 100644 index e51183054..000000000 --- a/src/slalib/dtp2s.f +++ /dev/null @@ -1,59 +0,0 @@ - SUBROUTINE sla_DTP2S (XI, ETA, RAZ, DECZ, RA, DEC) -*+ -* - - - - - - -* D T P 2 S -* - - - - - - -* -* Transform tangent plane coordinates into spherical -* (double precision) -* -* Given: -* XI,ETA dp tangent plane rectangular coordinates -* RAZ,DECZ dp spherical coordinates of tangent point -* -* Returned: -* RA,DEC dp spherical coordinates (0-2pi,+/-pi/2) -* -* Called: sla_DRANRM -* -* P.T.Wallace Starlink 24 July 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION XI,ETA,RAZ,DECZ,RA,DEC - - DOUBLE PRECISION sla_DRANRM - - DOUBLE PRECISION SDECZ,CDECZ,DENOM - - - - SDECZ=SIN(DECZ) - CDECZ=COS(DECZ) - - DENOM=CDECZ-ETA*SDECZ - - RA=sla_DRANRM(ATAN2(XI,DENOM)+RAZ) - DEC=ATAN2(SDECZ+ETA*CDECZ,SQRT(XI*XI+DENOM*DENOM)) - - END diff --git a/src/slalib/dtp2v.f b/src/slalib/dtp2v.f deleted file mode 100644 index 234b5df3f..000000000 --- a/src/slalib/dtp2v.f +++ /dev/null @@ -1,73 +0,0 @@ - SUBROUTINE sla_DTP2V (XI, ETA, V0, V) -*+ -* - - - - - - -* D T P 2 V -* - - - - - - -* -* Given the tangent-plane coordinates of a star and the direction -* cosines of the tangent point, determine the direction cosines -* of the star. -* -* (double precision) -* -* Given: -* XI,ETA d tangent plane coordinates of star -* V0 d(3) direction cosines of tangent point -* -* Returned: -* V d(3) direction cosines of star -* -* Notes: -* -* 1 If vector V0 is not of unit length, the returned vector V will -* be wrong. -* -* 2 If vector V0 points at a pole, the returned vector V will be -* based on the arbitrary assumption that the RA of the tangent -* point is zero. -* -* 3 This routine is the Cartesian equivalent of the routine sla_DTP2S. -* -* P.T.Wallace Starlink 11 February 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION XI,ETA,V0(3),V(3) - - DOUBLE PRECISION X,Y,Z,F,R - - - X=V0(1) - Y=V0(2) - Z=V0(3) - F=SQRT(1D0+XI*XI+ETA*ETA) - R=SQRT(X*X+Y*Y) - IF (R.EQ.0D0) THEN - R=1D-20 - X=R - END IF - V(1)=(X-(XI*Y+ETA*X*Z)/R)/F - V(2)=(Y+(XI*X-ETA*Y*Z)/R)/F - V(3)=(Z+ETA*R)/F - - END diff --git a/src/slalib/dtps2c.f b/src/slalib/dtps2c.f deleted file mode 100644 index edb43783f..000000000 --- a/src/slalib/dtps2c.f +++ /dev/null @@ -1,108 +0,0 @@ - SUBROUTINE sla_DTPS2C (XI, ETA, RA, DEC, RAZ1, DECZ1, - : RAZ2, DECZ2, N) -*+ -* - - - - - - - -* D T P S 2 C -* - - - - - - - -* -* From the tangent plane coordinates of a star of known RA,Dec, -* determine the RA,Dec of the tangent point. -* -* (double precision) -* -* Given: -* XI,ETA d tangent plane rectangular coordinates -* RA,DEC d spherical coordinates -* -* Returned: -* RAZ1,DECZ1 d spherical coordinates of tangent point, solution 1 -* RAZ2,DECZ2 d spherical coordinates of tangent point, solution 2 -* N i number of solutions: -* 0 = no solutions returned (note 2) -* 1 = only the first solution is useful (note 3) -* 2 = both solutions are useful (note 3) -* -* Notes: -* -* 1 The RAZ1 and RAZ2 values are returned in the range 0-2pi. -* -* 2 Cases where there is no solution can only arise near the poles. -* For example, it is clearly impossible for a star at the pole -* itself to have a non-zero XI value, and hence it is -* meaningless to ask where the tangent point would have to be -* to bring about this combination of XI and DEC. -* -* 3 Also near the poles, cases can arise where there are two useful -* solutions. The argument N indicates whether the second of the -* two solutions returned is useful. N=1 indicates only one useful -* solution, the usual case; under these circumstances, the second -* solution corresponds to the "over-the-pole" case, and this is -* reflected in the values of RAZ2 and DECZ2 which are returned. -* -* 4 The DECZ1 and DECZ2 values are returned in the range +/-pi, but -* in the usual, non-pole-crossing, case, the range is +/-pi/2. -* -* 5 This routine is the spherical equivalent of the routine sla_DTPV2C. -* -* Called: sla_DRANRM -* -* P.T.Wallace Starlink 5 June 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION XI,ETA,RA,DEC,RAZ1,DECZ1,RAZ2,DECZ2 - INTEGER N - - DOUBLE PRECISION X2,Y2,SD,CD,SDF,R2,R,S,C - - DOUBLE PRECISION sla_DRANRM - - - X2=XI*XI - Y2=ETA*ETA - SD=SIN(DEC) - CD=COS(DEC) - SDF=SD*SQRT(1D0+X2+Y2) - R2=CD*CD*(1D0+Y2)-SD*SD*X2 - IF (R2.GE.0D0) THEN - R=SQRT(R2) - S=SDF-ETA*R - C=SDF*ETA+R - IF (XI.EQ.0D0.AND.R.EQ.0D0) R=1D0 - RAZ1=sla_DRANRM(RA-ATAN2(XI,R)) - DECZ1=ATAN2(S,C) - R=-R - S=SDF-ETA*R - C=SDF*ETA+R - RAZ2=sla_DRANRM(RA-ATAN2(XI,R)) - DECZ2=ATAN2(S,C) - IF (ABS(SDF).LT.1D0) THEN - N=1 - ELSE - N=2 - END IF - ELSE - N=0 - END IF - - END diff --git a/src/slalib/dtpv2c.f b/src/slalib/dtpv2c.f deleted file mode 100644 index 8cb7f2e85..000000000 --- a/src/slalib/dtpv2c.f +++ /dev/null @@ -1,100 +0,0 @@ - SUBROUTINE sla_DTPV2C (XI, ETA, V, V01, V02, N) -*+ -* - - - - - - - -* D T P V 2 C -* - - - - - - - -* -* Given the tangent-plane coordinates of a star and its direction -* cosines, determine the direction cosines of the tangent-point. -* -* (double precision) -* -* Given: -* XI,ETA d tangent plane coordinates of star -* V d(3) direction cosines of star -* -* Returned: -* V01 d(3) direction cosines of tangent point, solution 1 -* V02 d(3) direction cosines of tangent point, solution 2 -* N i number of solutions: -* 0 = no solutions returned (note 2) -* 1 = only the first solution is useful (note 3) -* 2 = both solutions are useful (note 3) -* -* Notes: -* -* 1 The vector V must be of unit length or the result will be wrong. -* -* 2 Cases where there is no solution can only arise near the poles. -* For example, it is clearly impossible for a star at the pole -* itself to have a non-zero XI value, and hence it is meaningless -* to ask where the tangent point would have to be. -* -* 3 Also near the poles, cases can arise where there are two useful -* solutions. The argument N indicates whether the second of the -* two solutions returned is useful. N=1 indicates only one useful -* solution, the usual case; under these circumstances, the second -* solution can be regarded as valid if the vector V02 is interpreted -* as the "over-the-pole" case. -* -* 4 This routine is the Cartesian equivalent of the routine sla_DTPS2C. -* -* P.T.Wallace Starlink 5 June 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION XI,ETA,V(3),V01(3),V02(3) - INTEGER N - - DOUBLE PRECISION X,Y,Z,RXY2,XI2,ETA2P1,SDF,R2,R,C - - - X=V(1) - Y=V(2) - Z=V(3) - RXY2=X*X+Y*Y - XI2=XI*XI - ETA2P1=ETA*ETA+1D0 - SDF=Z*SQRT(XI2+ETA2P1) - R2=RXY2*ETA2P1-Z*Z*XI2 - IF (R2.GT.0D0) THEN - R=SQRT(R2) - C=(SDF*ETA+R)/(ETA2P1*SQRT(RXY2*(R2+XI2))) - V01(1)=C*(X*R+Y*XI) - V01(2)=C*(Y*R-X*XI) - V01(3)=(SDF-ETA*R)/ETA2P1 - R=-R - C=(SDF*ETA+R)/(ETA2P1*SQRT(RXY2*(R2+XI2))) - V02(1)=C*(X*R+Y*XI) - V02(2)=C*(Y*R-X*XI) - V02(3)=(SDF-ETA*R)/ETA2P1 - IF (ABS(SDF).LT.1D0) THEN - N=1 - ELSE - N=2 - END IF - ELSE - N=0 - END IF - - END diff --git a/src/slalib/dtt.f b/src/slalib/dtt.f deleted file mode 100644 index a084db6bd..000000000 --- a/src/slalib/dtt.f +++ /dev/null @@ -1,63 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DTT (UTC) -*+ -* - - - - -* D T T -* - - - - -* -* Increment to be applied to Coordinated Universal Time UTC to give -* Terrestrial Time TT (formerly Ephemeris Time ET) -* -* (double precision) -* -* Given: -* UTC d UTC date as a modified JD (JD-2400000.5) -* -* Result: TT-UTC in seconds -* -* Notes: -* -* 1 The UTC is specified to be a date rather than a time to indicate -* that care needs to be taken not to specify an instant which lies -* within a leap second. Though in most cases UTC can include the -* fractional part, correct behaviour on the day of a leap second -* can only be guaranteed up to the end of the second 23:59:59. -* -* 2 Pre 1972 January 1 a fixed value of 10 + ET-TAI is returned. -* -* 3 See also the routine sla_DT, which roughly estimates ET-UT for -* historical epochs. -* -* Called: sla_DAT -* -* P.T.Wallace Starlink 6 December 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION UTC - - DOUBLE PRECISION sla_DAT - - - sla_DTT=32.184D0+sla_DAT(UTC) - - END diff --git a/src/slalib/dv2tp.f b/src/slalib/dv2tp.f deleted file mode 100644 index 4a0caecb1..000000000 --- a/src/slalib/dv2tp.f +++ /dev/null @@ -1,95 +0,0 @@ - SUBROUTINE sla_DV2TP (V, V0, XI, ETA, J) -*+ -* - - - - - - -* D V 2 T P -* - - - - - - -* -* Given the direction cosines of a star and of the tangent point, -* determine the star's tangent-plane coordinates. -* -* (double precision) -* -* Given: -* V d(3) direction cosines of star -* V0 d(3) direction cosines of tangent point -* -* Returned: -* XI,ETA d tangent plane coordinates of star -* J i status: 0 = OK -* 1 = error, star too far from axis -* 2 = error, antistar on tangent plane -* 3 = error, antistar too far from axis -* -* Notes: -* -* 1 If vector V0 is not of unit length, or if vector V is of zero -* length, the results will be wrong. -* -* 2 If V0 points at a pole, the returned XI,ETA will be based on the -* arbitrary assumption that the RA of the tangent point is zero. -* -* 3 This routine is the Cartesian equivalent of the routine sla_DS2TP. -* -* P.T.Wallace Starlink 27 November 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION V(3),V0(3),XI,ETA - INTEGER J - - DOUBLE PRECISION X,Y,Z,X0,Y0,Z0,R2,R,W,D - - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-6) - - - X=V(1) - Y=V(2) - Z=V(3) - X0=V0(1) - Y0=V0(2) - Z0=V0(3) - R2=X0*X0+Y0*Y0 - R=SQRT(R2) - IF (R.EQ.0D0) THEN - R=1D-20 - X0=R - END IF - W=X*X0+Y*Y0 - D=W+Z*Z0 - IF (D.GT.TINY) THEN - J=0 - ELSE IF (D.GE.0D0) THEN - J=1 - D=TINY - ELSE IF (D.GT.-TINY) THEN - J=2 - D=-TINY - ELSE - J=3 - END IF - D=D*R - XI=(Y*X0-X*Y0)/D - ETA=(Z*R2-Z0*W)/D - - END diff --git a/src/slalib/dvdv.f b/src/slalib/dvdv.f deleted file mode 100644 index b90545f03..000000000 --- a/src/slalib/dvdv.f +++ /dev/null @@ -1,44 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_DVDV (VA, VB) -*+ -* - - - - - -* D V D V -* - - - - - -* -* Scalar product of two 3-vectors (double precision) -* -* Given: -* VA dp(3) first vector -* VB dp(3) second vector -* -* The result is the scalar product VA.VB (double precision) -* -* P.T.Wallace Starlink November 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION VA(3),VB(3) - - - sla_DVDV=VA(1)*VB(1)+VA(2)*VB(2)+VA(3)*VB(3) - - END diff --git a/src/slalib/dvn.f b/src/slalib/dvn.f deleted file mode 100644 index 5bfc40262..000000000 --- a/src/slalib/dvn.f +++ /dev/null @@ -1,69 +0,0 @@ - SUBROUTINE sla_DVN (V, UV, VM) -*+ -* - - - - -* D V N -* - - - - -* -* Normalizes a 3-vector also giving the modulus (double precision) -* -* Given: -* V d(3) vector -* -* Returned: -* UV d(3) unit vector in direction of V -* VM d modulus of V -* -* Notes: -* -* 1 If the modulus of V is zero, UV is set to zero as well. -* -* 2 To comply with the ANSI Fortran 77 standard, V and UV must be -* different arrays. However, the routine is coded so as to work -* properly on most platforms even if this rule is violated. -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION V(3),UV(3),VM - - INTEGER I - DOUBLE PRECISION W1,W2 - - -* Modulus. - W1 = 0D0 - DO I=1,3 - W2 = V(I) - W1 = W1+W2*W2 - END DO - W1 = SQRT(W1) - VM = W1 - -* Normalize the vector. - IF (W1.LE.0D0) W1 = 1D0 - DO I=1,3 - UV(I) = V(I)/W1 - END DO - - END diff --git a/src/slalib/dvxv.f b/src/slalib/dvxv.f deleted file mode 100644 index 1d2bafa6b..000000000 --- a/src/slalib/dvxv.f +++ /dev/null @@ -1,56 +0,0 @@ - SUBROUTINE sla_DVXV (VA, VB, VC) -*+ -* - - - - - -* D V X V -* - - - - - -* -* Vector product of two 3-vectors (double precision) -* -* Given: -* VA dp(3) first vector -* VB dp(3) second vector -* -* Returned: -* VC dp(3) vector result -* -* P.T.Wallace Starlink March 1986 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION VA(3),VB(3),VC(3) - - DOUBLE PRECISION VW(3) - INTEGER I - - -* Form the vector product VA cross VB - VW(1)=VA(2)*VB(3)-VA(3)*VB(2) - VW(2)=VA(3)*VB(1)-VA(1)*VB(3) - VW(3)=VA(1)*VB(2)-VA(2)*VB(1) - -* Return the result - DO I=1,3 - VC(I)=VW(I) - END DO - - END diff --git a/src/slalib/e2h.f b/src/slalib/e2h.f deleted file mode 100644 index 8ae8f6e7b..000000000 --- a/src/slalib/e2h.f +++ /dev/null @@ -1,106 +0,0 @@ - SUBROUTINE sla_E2H (HA, DEC, PHI, AZ, EL) -*+ -* - - - - -* E 2 H -* - - - - -* -* Equatorial to horizon coordinates: HA,Dec to Az,El -* -* (single precision) -* -* Given: -* HA r hour angle -* DEC r declination -* PHI r observatory latitude -* -* Returned: -* AZ r azimuth -* EL r elevation -* -* Notes: -* -* 1) All the arguments are angles in radians. -* -* 2) Azimuth is returned in the range 0-2pi; north is zero, -* and east is +pi/2. Elevation is returned in the range -* +/-pi/2. -* -* 3) The latitude must be geodetic. In critical applications, -* corrections for polar motion should be applied. -* -* 4) In some applications it will be important to specify the -* correct type of hour angle and declination in order to -* produce the required type of azimuth and elevation. In -* particular, it may be important to distinguish between -* elevation as affected by refraction, which would -* require the "observed" HA,Dec, and the elevation -* in vacuo, which would require the "topocentric" HA,Dec. -* If the effects of diurnal aberration can be neglected, the -* "apparent" HA,Dec may be used instead of the topocentric -* HA,Dec. -* -* 5) No range checking of arguments is carried out. -* -* 6) In applications which involve many such calculations, rather -* than calling the present routine it will be more efficient to -* use inline code, having previously computed fixed terms such -* as sine and cosine of latitude, and (for tracking a star) -* sine and cosine of declination. -* -* P.T.Wallace Starlink 9 July 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL HA,DEC,PHI,AZ,EL - - REAL R2PI - PARAMETER (R2PI=6.283185307179586476925286766559) - - REAL SH,CH,SD,CD,SP,CP,X,Y,Z,R,A - - -* Useful trig functions - SH=SIN(HA) - CH=COS(HA) - SD=SIN(DEC) - CD=COS(DEC) - SP=SIN(PHI) - CP=COS(PHI) - -* Az,El as x,y,z - X=-CH*CD*SP+SD*CP - Y=-SH*CD - Z=CH*CD*CP+SD*SP - -* To spherical - R=SQRT(X*X+Y*Y) - IF (R.EQ.0.0) THEN - A=0.0 - ELSE - A=ATAN2(Y,X) - END IF - IF (A.LT.0.0) A=A+R2PI - AZ=A - EL=ATAN2(Z,R) - - END diff --git a/src/slalib/earth.f b/src/slalib/earth.f deleted file mode 100644 index a434e5494..000000000 --- a/src/slalib/earth.f +++ /dev/null @@ -1,129 +0,0 @@ - SUBROUTINE sla_EARTH (IY, ID, FD, PV) -*+ -* - - - - - - -* E A R T H -* - - - - - - -* -* Approximate heliocentric position and velocity of the Earth -* -* Given: -* IY I year -* ID I day in year (1 = Jan 1st) -* FD R fraction of day -* -* Returned: -* PV R(6) Earth position & velocity vector -* -* Notes: -* -* 1 The date and time is TDB (loosely ET) in a Julian calendar -* which has been aligned to the ordinary Gregorian -* calendar for the interval 1900 March 1 to 2100 February 28. -* The year and day can be obtained by calling sla_CALYD or -* sla_CLYD. -* -* 2 The Earth heliocentric 6-vector is mean equator and equinox -* of date. Position part, PV(1-3), is in AU; velocity part, -* PV(4-6), is in AU/sec. -* -* 3 Max/RMS errors 1950-2050: -* 13/5 E-5 AU = 19200/7600 km in position -* 47/26 E-10 AU/s = 0.0070/0.0039 km/s in speed -* -* 4 More accurate results are obtainable with the routines sla_EVP -* and sla_EPV. -* -* Last revision: 5 April 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IY,ID - REAL FD,PV(6) - - INTEGER IY4 - REAL TWOPI,SPEED,REMB,SEMB,YI,YF,T,ELM,GAMMA,EM,ELT,EPS0, - : E,ESQ,V,R,ELMM,COSELT,SINEPS,COSEPS,W1,W2,SELMM,CELMM - - PARAMETER (TWOPI=6.28318530718) - -* Mean orbital speed of Earth, AU/s - PARAMETER (SPEED=1.9913E-7) - -* Mean Earth:EMB distance and speed, AU and AU/s - PARAMETER (REMB=3.12E-5,SEMB=8.31E-11) - - - -* Whole years & fraction of year, and years since J1900.0 - YI=FLOAT(IY-1900) - IY4=MOD(MOD(IY,4)+4,4) - YF=(FLOAT(4*(ID-1/(IY4+1))-IY4-2)+4.0*FD)/1461.0 - T=YI+YF - -* Geometric mean longitude of Sun -* (cf 4.881627938+6.283319509911*T MOD 2PI) - ELM=MOD(4.881628+TWOPI*YF+0.00013420*T,TWOPI) - -* Mean longitude of perihelion - GAMMA=4.908230+3.0005E-4*T - -* Mean anomaly - EM=ELM-GAMMA - -* Mean obliquity - EPS0=0.40931975-2.27E-6*T - -* Eccentricity - E=0.016751-4.2E-7*T - ESQ=E*E - -* True anomaly - V=EM+2.0*E*SIN(EM)+1.25*ESQ*SIN(2.0*EM) - -* True ecliptic longitude - ELT=V+GAMMA - -* True distance - R=(1.0-ESQ)/(1.0+E*COS(V)) - -* Moon's mean longitude - ELMM=MOD(4.72+83.9971*T,TWOPI) - -* Useful functions - COSELT=COS(ELT) - SINEPS=SIN(EPS0) - COSEPS=COS(EPS0) - W1=-R*SIN(ELT) - W2=-SPEED*(COSELT+E*COS(GAMMA)) - SELMM=SIN(ELMM) - CELMM=COS(ELMM) - -* Earth position and velocity - PV(1)=-R*COSELT-REMB*CELMM - PV(2)=(W1-REMB*SELMM)*COSEPS - PV(3)=W1*SINEPS - PV(4)=SPEED*(SIN(ELT)+E*SIN(GAMMA))+SEMB*SELMM - PV(5)=(W2-SEMB*CELMM)*COSEPS - PV(6)=W2*SINEPS - - END diff --git a/src/slalib/ecleq.f b/src/slalib/ecleq.f deleted file mode 100644 index a5e8ae10b..000000000 --- a/src/slalib/ecleq.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_ECLEQ (DL, DB, DATE, DR, DD) -*+ -* - - - - - - -* E C L E Q -* - - - - - - -* -* Transformation from ecliptic coordinates to -* J2000.0 equatorial coordinates (double precision) -* -* Given: -* DL,DB dp ecliptic longitude and latitude -* (mean of date, IAU 1980 theory, radians) -* DATE dp TDB (loosely ET) as Modified Julian Date -* (JD-2400000.5) -* Returned: -* DR,DD dp J2000.0 mean RA,Dec (radians) -* -* Called: -* sla_DCS2C, sla_ECMAT, sla_DIMXV, sla_PREC, sla_EPJ, sla_DCC2S, -* sla_DRANRM, sla_DRANGE -* -* P.T.Wallace Starlink March 1986 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DL,DB,DATE,DR,DD - - DOUBLE PRECISION sla_EPJ,sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION RMAT(3,3),V1(3),V2(3) - - - -* Spherical to Cartesian - CALL sla_DCS2C(DL,DB,V1) - -* Ecliptic to equatorial - CALL sla_ECMAT(DATE,RMAT) - CALL sla_DIMXV(RMAT,V1,V2) - -* Mean of date to J2000 - CALL sla_PREC(2000D0,sla_EPJ(DATE),RMAT) - CALL sla_DIMXV(RMAT,V2,V1) - -* Cartesian to spherical - CALL sla_DCC2S(V1,DR,DD) - -* Express in conventional ranges - DR=sla_DRANRM(DR) - DD=sla_DRANGE(DD) - - END diff --git a/src/slalib/ecmat.f b/src/slalib/ecmat.f deleted file mode 100644 index b30bee591..000000000 --- a/src/slalib/ecmat.f +++ /dev/null @@ -1,69 +0,0 @@ - SUBROUTINE sla_ECMAT (DATE, RMAT) -*+ -* - - - - - - -* E C M A T -* - - - - - - -* -* Form the equatorial to ecliptic rotation matrix - IAU 1980 theory -* (double precision) -* -* Given: -* DATE dp TDB (loosely ET) as Modified Julian Date -* (JD-2400000.5) -* Returned: -* RMAT dp(3,3) matrix -* -* Reference: -* Murray,C.A., Vectorial Astrometry, section 4.3. -* -* Note: -* The matrix is in the sense V(ecl) = RMAT * V(equ); the -* equator, equinox and ecliptic are mean of date. -* -* Called: sla_DEULER -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,RMAT(3,3) - -* Arc seconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - - DOUBLE PRECISION T,EPS0 - - - -* Interval between basic epoch J2000.0 and current epoch (JC) - T = (DATE-51544.5D0)/36525D0 - -* Mean obliquity - EPS0 = AS2R* - : (84381.448D0+(-46.8150D0+(-0.00059D0+0.001813D0*T)*T)*T) - -* Matrix - CALL sla_DEULER('X',EPS0,0D0,0D0,RMAT) - - END diff --git a/src/slalib/ecor.f b/src/slalib/ecor.f deleted file mode 100644 index 4bc55554c..000000000 --- a/src/slalib/ecor.f +++ /dev/null @@ -1,95 +0,0 @@ - SUBROUTINE sla_ECOR (RM, DM, IY, ID, FD, RV, TL) -*+ -* - - - - - -* E C O R -* - - - - - -* -* Component of Earth orbit velocity and heliocentric -* light time in a given direction (single precision) -* -* Given: -* RM,DM real mean RA, Dec of date (radians) -* IY int year -* ID int day in year (1 = Jan 1st) -* FD real fraction of day -* -* Returned: -* RV real component of Earth orbital velocity (km/sec) -* TL real component of heliocentric light time (sec) -* -* Notes: -* -* 1 The date and time is TDB (loosely ET) in a Julian calendar -* which has been aligned to the ordinary Gregorian -* calendar for the interval 1900 March 1 to 2100 February 28. -* The year and day can be obtained by calling sla_CALYD or -* sla_CLYD. -* -* 2 Sign convention: -* -* The velocity component is +ve when the Earth is receding from -* the given point on the sky. The light time component is +ve -* when the Earth lies between the Sun and the given point on -* the sky. -* -* 3 Accuracy: -* -* The velocity component is usually within 0.004 km/s of the -* correct value and is never in error by more than 0.007 km/s. -* The error in light time correction is about 0.03s at worst, -* but is usually better than 0.01s. For applications requiring -* higher accuracy, see the sla_EVP and sla_EPV routines. -* -* Called: sla_EARTH, sla_CS2C, sla_VDV -* -* Last revision: 5 April 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL RM,DM - INTEGER IY,ID - REAL FD,RV,TL - - REAL sla_VDV - - REAL PV(6),V(3),AUKM,AUSEC - -* AU to km and light sec (1985 Almanac) - PARAMETER (AUKM=1.4959787066E8, - : AUSEC=499.0047837) - - - -* Sun:Earth position & velocity vector - CALL sla_EARTH(IY,ID,FD,PV) - -* Star position vector - CALL sla_CS2C(RM,DM,V) - -* Velocity component - RV=-AUKM*sla_VDV(PV(4),V) - -* Light time component - TL=AUSEC*sla_VDV(PV(1),V) - - END diff --git a/src/slalib/eg50.f b/src/slalib/eg50.f deleted file mode 100644 index d03ce728e..000000000 --- a/src/slalib/eg50.f +++ /dev/null @@ -1,107 +0,0 @@ - SUBROUTINE sla_EG50 (DR, DD, DL, DB) -*+ -* - - - - - -* E G 5 0 -* - - - - - -* -* Transformation from B1950.0 'FK4' equatorial coordinates to -* IAU 1958 galactic coordinates (double precision) -* -* Given: -* DR,DD dp B1950.0 'FK4' RA,Dec -* -* Returned: -* DL,DB dp galactic longitude and latitude L2,B2 -* -* (all arguments are radians) -* -* Called: -* sla_DCS2C, sla_DMXV, sla_DCC2S, sla_SUBET, sla_DRANRM, sla_DRANGE -* -* Note: -* The equatorial coordinates are B1950.0 'FK4'. Use the -* routine sla_EQGAL if conversion from J2000.0 coordinates -* is required. -* -* Reference: -* Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960) -* -* P.T.Wallace Starlink 5 September 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DR,DD,DL,DB - - DOUBLE PRECISION sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION V1(3),V2(3),R,D - -* -* L2,B2 system of galactic coordinates -* -* P = 192.25 RA of galactic north pole (mean B1950.0) -* Q = 62.6 inclination of galactic to mean B1950.0 equator -* R = 33 longitude of ascending node -* -* P,Q,R are degrees -* -* -* Equatorial to galactic rotation matrix -* -* The Euler angles are P, Q, 90-R, about the z then y then -* z axes. -* -* +CP.CQ.SR-SP.CR +SP.CQ.SR+CP.CR -SQ.SR -* -* -CP.CQ.CR-SP.SR -SP.CQ.CR+CP.SR +SQ.CR -* -* +CP.SQ +SP.SQ +CQ -* - - DOUBLE PRECISION RMAT(3,3) - DATA RMAT(1,1),RMAT(1,2),RMAT(1,3), - : RMAT(2,1),RMAT(2,2),RMAT(2,3), - : RMAT(3,1),RMAT(3,2),RMAT(3,3) / - : -0.066988739415D0,-0.872755765852D0,-0.483538914632D0, - : +0.492728466075D0,-0.450346958020D0,+0.744584633283D0, - : -0.867600811151D0,-0.188374601723D0,+0.460199784784D0 / - - - -* Remove E-terms - CALL sla_SUBET(DR,DD,1950D0,R,D) - -* Spherical to Cartesian - CALL sla_DCS2C(R,D,V1) - -* Rotate to galactic - CALL sla_DMXV(RMAT,V1,V2) - -* Cartesian to spherical - CALL sla_DCC2S(V2,DL,DB) - -* Express angles in conventional ranges - DL=sla_DRANRM(DL) - DB=sla_DRANGE(DB) - - END diff --git a/src/slalib/el2ue.f b/src/slalib/el2ue.f deleted file mode 100644 index 8d3925a02..000000000 --- a/src/slalib/el2ue.f +++ /dev/null @@ -1,328 +0,0 @@ - SUBROUTINE sla_EL2UE (DATE, JFORM, EPOCH, ORBINC, ANODE, - : PERIH, AORQ, E, AORL, DM, - : U, JSTAT) -*+ -* - - - - - - -* E L 2 U E -* - - - - - - -* -* Transform conventional osculating orbital elements into "universal" -* form. -* -* Given: -* DATE d epoch (TT MJD) of osculation (Note 3) -* JFORM i choice of element set (1-3, Note 6) -* EPOCH d epoch (TT MJD) of the elements -* ORBINC d inclination (radians) -* ANODE d longitude of the ascending node (radians) -* PERIH d longitude or argument of perihelion (radians) -* AORQ d mean distance or perihelion distance (AU) -* E d eccentricity -* AORL d mean anomaly or longitude (radians, JFORM=1,2 only) -* DM d daily motion (radians, JFORM=1 only) -* -* Returned: -* U d(13) universal orbital elements (Note 1) -* -* (1) combined mass (M+m) -* (2) total energy of the orbit (alpha) -* (3) reference (osculating) epoch (t0) -* (4-6) position at reference epoch (r0) -* (7-9) velocity at reference epoch (v0) -* (10) heliocentric distance at reference epoch -* (11) r0.v0 -* (12) date (t) -* (13) universal eccentric anomaly (psi) of date, approx -* -* JSTAT i status: 0 = OK -* -1 = illegal JFORM -* -2 = illegal E -* -3 = illegal AORQ -* -4 = illegal DM -* -5 = numerical error -* -* Called: sla_UE2PV, sla_PV2UE -* -* Notes -* -* 1 The "universal" elements are those which define the orbit for the -* purposes of the method of universal variables (see reference). -* They consist of the combined mass of the two bodies, an epoch, -* and the position and velocity vectors (arbitrary reference frame) -* at that epoch. The parameter set used here includes also various -* quantities that can, in fact, be derived from the other -* information. This approach is taken to avoiding unnecessary -* computation and loss of accuracy. The supplementary quantities -* are (i) alpha, which is proportional to the total energy of the -* orbit, (ii) the heliocentric distance at epoch, (iii) the -* outwards component of the velocity at the given epoch, (iv) an -* estimate of psi, the "universal eccentric anomaly" at a given -* date and (v) that date. -* -* 2 The companion routine is sla_UE2PV. This takes the set of numbers -* that the present routine outputs and uses them to derive the -* object's position and velocity. A single prediction requires one -* call to the present routine followed by one call to sla_UE2PV; -* for convenience, the two calls are packaged as the routine -* sla_PLANEL. Multiple predictions may be made by again calling the -* present routine once, but then calling sla_UE2PV multiple times, -* which is faster than multiple calls to sla_PLANEL. -* -* 3 DATE is the epoch of osculation. It is in the TT timescale -* (formerly Ephemeris Time, ET) and is a Modified Julian Date -* (JD-2400000.5). -* -* 4 The supplied orbital elements are with respect to the J2000 -* ecliptic and equinox. The position and velocity parameters -* returned in the array U are with respect to the mean equator and -* equinox of epoch J2000, and are for the perihelion prior to the -* specified epoch. -* -* 5 The universal elements returned in the array U are in canonical -* units (solar masses, AU and canonical days). -* -* 6 Three different element-format options are available: -* -* Option JFORM=1, suitable for the major planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = longitude of perihelion, curly pi (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e (range 0 to <1) -* AORL = mean longitude L (radians) -* DM = daily motion (radians) -* -* Option JFORM=2, suitable for minor planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e (range 0 to <1) -* AORL = mean anomaly M (radians) -* -* Option JFORM=3, suitable for comets: -* -* EPOCH = epoch of perihelion (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = perihelion distance, q (AU) -* E = eccentricity, e (range 0 to 10) -* -* 7 Unused elements (DM for JFORM=2, AORL and DM for JFORM=3) are -* not accessed. -* -* 8 The algorithm was originally adapted from the EPHSLA program of -* D.H.P.Jones (private communication, 1996). The method is based -* on Stumpff's Universal Variables. -* -* Reference: Everhart & Pitkin, Am.J.Phys. 51, 712 (1983). -* -* Last revision: 8 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - INTEGER JFORM - DOUBLE PRECISION EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM,U(13) - INTEGER JSTAT - -* Gaussian gravitational constant (exact) - DOUBLE PRECISION GCON - PARAMETER (GCON=0.01720209895D0) - -* Sin and cos of J2000 mean obliquity (IAU 1976) - DOUBLE PRECISION SE,CE - PARAMETER (SE=0.3977771559319137D0, - : CE=0.9174820620691818D0) - - INTEGER J - - DOUBLE PRECISION PHT,ARGPH,Q,W,CM,ALPHA,PHS,SW,CW,SI,CI,SO,CO, - : X,Y,Z,PX,PY,PZ,VX,VY,VZ,DT,FC,FP,PSI, - : UL(13),PV(6) - - - -* Validate arguments. - IF (JFORM.LT.1.OR.JFORM.GT.3) THEN - JSTAT = -1 - GO TO 9999 - END IF - IF (E.LT.0D0.OR.E.GT.10D0.OR.(E.GE.1D0.AND.JFORM.NE.3)) THEN - JSTAT = -2 - GO TO 9999 - END IF - IF (AORQ.LE.0D0) THEN - JSTAT = -3 - GO TO 9999 - END IF - IF (JFORM.EQ.1.AND.DM.LE.0D0) THEN - JSTAT = -4 - GO TO 9999 - END IF - -* -* Transform elements into standard form: -* -* PHT = epoch of perihelion passage -* ARGPH = argument of perihelion (little omega) -* Q = perihelion distance (q) -* CM = combined mass, M+m (mu) - - IF (JFORM.EQ.1) THEN - -* Major planet. - PHT = EPOCH-(AORL-PERIH)/DM - ARGPH = PERIH-ANODE - Q = AORQ*(1D0-E) - W = DM/GCON - CM = W*W*AORQ*AORQ*AORQ - - ELSE IF (JFORM.EQ.2) THEN - -* Minor planet. - PHT = EPOCH-AORL*SQRT(AORQ*AORQ*AORQ)/GCON - ARGPH = PERIH - Q = AORQ*(1D0-E) - CM = 1D0 - - ELSE - -* Comet. - PHT = EPOCH - ARGPH = PERIH - Q = AORQ - CM = 1D0 - - END IF - -* The universal variable alpha. This is proportional to the total -* energy of the orbit: -ve for an ellipse, zero for a parabola, -* +ve for a hyperbola. - - ALPHA = CM*(E-1D0)/Q - -* Speed at perihelion. - - PHS = SQRT(ALPHA+2D0*CM/Q) - -* In a Cartesian coordinate system which has the x-axis pointing -* to perihelion and the z-axis normal to the orbit (such that the -* object orbits counter-clockwise as seen from +ve z), the -* perihelion position and velocity vectors are: -* -* position [Q,0,0] -* velocity [0,PHS,0] -* -* To express the results in J2000 equatorial coordinates we make a -* series of four rotations of the Cartesian axes: -* -* axis Euler angle -* -* 1 z argument of perihelion (little omega) -* 2 x inclination (i) -* 3 z longitude of the ascending node (big omega) -* 4 x J2000 obliquity (epsilon) -* -* In each case the rotation is clockwise as seen from the +ve end of -* the axis concerned. - -* Functions of the Euler angles. - SW = SIN(ARGPH) - CW = COS(ARGPH) - SI = SIN(ORBINC) - CI = COS(ORBINC) - SO = SIN(ANODE) - CO = COS(ANODE) - -* Position at perihelion (AU). - X = Q*CW - Y = Q*SW - Z = Y*SI - Y = Y*CI - PX = X*CO-Y*SO - Y = X*SO+Y*CO - PY = Y*CE-Z*SE - PZ = Y*SE+Z*CE - -* Velocity at perihelion (AU per canonical day). - X = -PHS*SW - Y = PHS*CW - Z = Y*SI - Y = Y*CI - VX = X*CO-Y*SO - Y = X*SO+Y*CO - VY = Y*CE-Z*SE - VZ = Y*SE+Z*CE - -* Time from perihelion to date (in Canonical Days: a canonical day -* is 58.1324409... days, defined as 1/GCON). - - DT = (DATE-PHT)*GCON - -* First approximation to the Universal Eccentric Anomaly, PSI, -* based on the circle (FC) and parabola (FP) values. - - FC = DT/Q - W = (3D0*DT+SQRT(9D0*DT*DT+8D0*Q*Q*Q))**(1D0/3D0) - FP = W-2D0*Q/W - PSI = (1D0-E)*FC+E*FP - -* Assemble local copy of element set. - UL(1) = CM - UL(2) = ALPHA - UL(3) = PHT - UL(4) = PX - UL(5) = PY - UL(6) = PZ - UL(7) = VX - UL(8) = VY - UL(9) = VZ - UL(10) = Q - UL(11) = 0D0 - UL(12) = DATE - UL(13) = PSI - -* Predict position+velocity at epoch of osculation. - CALL sla_UE2PV(DATE,UL,PV,J) - IF (J.NE.0) GO TO 9010 - -* Convert back to universal elements. - CALL sla_PV2UE(PV,DATE,CM-1D0,U,J) - IF (J.NE.0) GO TO 9010 - -* OK exit. - JSTAT = 0 - GO TO 9999 - -* Quasi-impossible numerical errors. - 9010 CONTINUE - JSTAT = -5 - - 9999 CONTINUE - END diff --git a/src/slalib/epb.f b/src/slalib/epb.f deleted file mode 100644 index 29db30ef0..000000000 --- a/src/slalib/epb.f +++ /dev/null @@ -1,47 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_EPB (DATE) -*+ -* - - - - -* E P B -* - - - - -* -* Conversion of Modified Julian Date to Besselian Epoch -* (double precision) -* -* Given: -* DATE dp Modified Julian Date (JD - 2400000.5) -* -* The result is the Besselian Epoch. -* -* Reference: -* Lieske,J.H., 1979. Astron.Astrophys.,73,282. -* -* P.T.Wallace Starlink February 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - - - sla_EPB = 1900D0 + (DATE-15019.81352D0)/365.242198781D0 - - END diff --git a/src/slalib/epb2d.f b/src/slalib/epb2d.f deleted file mode 100644 index 13b3e031d..000000000 --- a/src/slalib/epb2d.f +++ /dev/null @@ -1,47 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_EPB2D (EPB) -*+ -* - - - - - - -* E P B 2 D -* - - - - - - -* -* Conversion of Besselian Epoch to Modified Julian Date -* (double precision) -* -* Given: -* EPB dp Besselian Epoch -* -* The result is the Modified Julian Date (JD - 2400000.5). -* -* Reference: -* Lieske,J.H., 1979. Astron.Astrophys.,73,282. -* -* P.T.Wallace Starlink February 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EPB - - - sla_EPB2D = 15019.81352D0 + (EPB-1900D0)*365.242198781D0 - - END diff --git a/src/slalib/epco.f b/src/slalib/epco.f deleted file mode 100644 index f3e5e82e6..000000000 --- a/src/slalib/epco.f +++ /dev/null @@ -1,68 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_EPCO (K0, K, E) -*+ -* - - - - - -* E P C O -* - - - - - -* -* Convert an epoch into the appropriate form - 'B' or 'J' -* -* Given: -* K0 char form of result: 'B'=Besselian, 'J'=Julian -* K char form of given epoch: 'B' or 'J' -* E dp epoch -* -* Called: sla_EPB, sla_EPJ2D, sla_EPJ, sla_EPB2D -* -* Notes: -* -* 1) The result is always either equal to or very close to -* the given epoch E. The routine is required only in -* applications where punctilious treatment of heterogeneous -* mixtures of star positions is necessary. -* -* 2) K0 and K are not validated. They are interpreted as follows: -* -* o If K0 and K are the same the result is E. -* o If K0 is 'B' or 'b' and K isn't, the conversion is J to B. -* o In all other cases, the conversion is B to J. -* -* Note that K0 and K won't match if their cases differ. -* -* P.T.Wallace Starlink 5 September 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) K0,K - DOUBLE PRECISION E - DOUBLE PRECISION sla_EPB,sla_EPJ2D,sla_EPJ,sla_EPB2D - - - IF (K.EQ.K0) THEN - sla_EPCO=E - ELSE IF (K0.EQ.'B'.OR.K0.EQ.'b') THEN - sla_EPCO=sla_EPB(sla_EPJ2D(E)) - ELSE - sla_EPCO=sla_EPJ(sla_EPB2D(E)) - END IF - - END diff --git a/src/slalib/epj.f b/src/slalib/epj.f deleted file mode 100644 index 7cffaf905..000000000 --- a/src/slalib/epj.f +++ /dev/null @@ -1,46 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_EPJ (DATE) -*+ -* - - - - -* E P J -* - - - - -* -* Conversion of Modified Julian Date to Julian Epoch (double precision) -* -* Given: -* DATE dp Modified Julian Date (JD - 2400000.5) -* -* The result is the Julian Epoch. -* -* Reference: -* Lieske,J.H., 1979. Astron.Astrophys.,73,282. -* -* P.T.Wallace Starlink February 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - - - sla_EPJ = 2000D0 + (DATE-51544.5D0)/365.25D0 - - END diff --git a/src/slalib/epj2d.f b/src/slalib/epj2d.f deleted file mode 100644 index b2683a030..000000000 --- a/src/slalib/epj2d.f +++ /dev/null @@ -1,46 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_EPJ2D (EPJ) -*+ -* - - - - - - -* E P J 2 D -* - - - - - - -* -* Conversion of Julian Epoch to Modified Julian Date (double precision) -* -* Given: -* EPJ dp Julian Epoch -* -* The result is the Modified Julian Date (JD - 2400000.5). -* -* Reference: -* Lieske,J.H., 1979. Astron.Astrophys.,73,282. -* -* P.T.Wallace Starlink February 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EPJ - - - sla_EPJ2D = 51544.5D0 + (EPJ-2000D0)*365.25D0 - - END diff --git a/src/slalib/epv.f b/src/slalib/epv.f deleted file mode 100644 index 95ab788a8..000000000 --- a/src/slalib/epv.f +++ /dev/null @@ -1,2508 +0,0 @@ - SUBROUTINE sla_EPV ( DATE, PH, VH, PB, VB ) -*+ -* - - - - -* E P V -* - - - - -* -* Earth position and velocity, heliocentric and barycentric, with -* respect to the Barycentric Celestial Reference System. -* -* Given: -* DATE d date, TDB Modified Julian Date (Note 1) -* -* Returned: -* PH d(3) heliocentric Earth position (AU) -* VH d(3) heliocentric Earth velocity (AU,AU/day) -* PB d(3) barycentric Earth position (AU) -* VB d(3) barycentric Earth velocity (AU/day) -* -* Notes: -* -* 1) The date is TDB as an MJD (=JD-2400000.5). TT can be used instead -* of TDB in most applications. -* -* 2) On return, the arrays PH, VH, PV, PB contain the following: -* -* PH(1) x } -* PH(2) y } heliocentric position, AU -* PH(3) z } -* -* VH(1) xdot } -* VH(2) ydot } heliocentric velocity, AU/d -* VH(3) zdot } -* -* PB(1) x } -* PB(2) y } barycentric position, AU -* PB(3) z } -* -* VB(1) xdot } -* VB(2) ydot } barycentric velocity, AU/d -* VB(3) zdot } -* -* The vectors are with respect to the Barycentric Celestial -* Reference System (BCRS); velocities are in AU per TDB day. -* -* 3) The routine is a SIMPLIFIED SOLUTION from the planetary theory -* VSOP2000 (X. Moisson, P. Bretagnon, 2001, Celes. Mechanics & -* Dyn. Astron., 80, 3/4, 205-213) and is an adaptation of original -* Fortran code supplied by P. Bretagnon (private comm., 2000). -* -* 4) Comparisons over the time span 1900-2100 with this simplified -* solution and the JPL DE405 ephemeris give the following results: -* -* RMS max -* Heliocentric: -* position error 3.7 11.2 km -* velocity error 1.4 5.0 mm/s -* -* Barycentric: -* position error 4.6 13.4 km -* velocity error 1.4 4.9 mm/s -* -* The results deteriorate outside this time span. -* -* 5) The routine sla_EVP is faster but less accurate. The present -* routine targets the case where high accuracy is more important -* than CPU time, yet the extra complication of reading a pre- -* computed ephemeris is not justified. -* -* Last revision: 7 April 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*----------------------------------------------------------------------- - - IMPLICIT NONE - - DOUBLE PRECISION DATE, PH(3), VH(3), PB(3), VB(3) - - DOUBLE PRECISION T, T2, XYZ, XYZD, A, B, C, CT, P, CP, - : HP(3), HV(3), BP(3), BV(3), X, Y, Z - - INTEGER I, J, K - -* Days per Julian year - DOUBLE PRECISION DJY - PARAMETER ( DJY = 365.25D0 ) - -* Reference epoch (J2000), MJD - DOUBLE PRECISION DJM0 - PARAMETER ( DJM0 = 51544.5D0 ) -* -* Matrix elements for orienting the analytical model to DE405/ICRF. -* -* The corresponding Euler angles are: -* -* d ' " -* 1st rotation - 23 26 21.4091 about the x-axis (obliquity) -* 2nd rotation + 0.0475 about the z-axis (RA offset) -* -* These were obtained empirically, by comparisons with DE405 over -* 1900-2100. -* - DOUBLE PRECISION AM12, AM13, AM21, AM22, AM23, AM32, AM33 - PARAMETER ( AM12 = +0.000000211284D0, - : AM13 = -0.000000091603D0, - : AM21 = -0.000000230286D0, - : AM22 = +0.917482137087D0, - : AM23 = -0.397776982902D0, - : AM32 = +0.397776982902D0, - : AM33 = +0.917482137087D0 ) - -* ---------------------- -* Ephemeris Coefficients -* ---------------------- -* -* The coefficients are stored in arrays of dimension (3,n,3). There -* are separate sets of arrays for (i) the Sun to Earth vector and -* (ii) the Solar-System barycenter to Sun vector. Each of these two -* sets contains separate arrays for the terms (n in number) in each -* power of time (in Julian years since J2000): T^0, T^1 and T^2. -* Within each array, all the Cartesian x-components, elements (i,j,1), -* appear first, followed by all the y-components, elements (i,j,2) and -* finally all the z-components, elements (i,j,3). At the lowest level -* are groups of three coefficients. The first coefficient in each -* group, element (1,j,k), is the amplitude of the term, the second, -* element (2,j,k), is the phase and the third, element (3,j,k), is the -* frequency. -* -* The naming scheme is such that a block -* -* DOUBLE PRECISION bn(3,Mbn,3) -* -* applies to body b and time exponent n: -* -* . b can be either E (Earth with respect to Sun) or S (Sun with -* respect to Solar-System Barycenter) -* -* . n can be 0, 1 or 2, for T^0, T^1 or T^2 -* -* For example, array E2(3,ME2,3) contains the coefficients for -* the T^2 terms for the Sun-to-Earth vector. -* -* There is no requirement for the X, Y and Z models for a particular -* block to use the same number of coefficients. The number actually -* used is parameterized, the number of terms being used called NbnX, -* NbnY, and NbnZ respectively. The parameter Mbn is the biggest of -* the three, and defines the array size. Unused elements are not -* initialized and are never accessed. -* - - INTEGER NE0(3), NE0X, NE0Y, NE0Z, ME0, - : NE1(3), NE1X, NE1Y, NE1Z, ME1, - : NE2(3), NE2X, NE2Y, NE2Z, ME2, - : NS0(3), NS0X, NS0Y, NS0Z, MS0, - : NS1(3), NS1X, NS1Y, NS1Z, MS1, - : NS2(3), NS2X, NS2Y, NS2Z, MS2 - - PARAMETER ( NE0X = 501, NE0Y = 501, NE0Z = 137, ME0 = NE0X, - : NE1X = 79, NE1Y = 80, NE1Z = 12, ME1 = NE1Y, - : NE2X = 5, NE2Y = 5, NE2Z = 3, ME2 = NE2X, - : NS0X = 212, NS0Y = 213, NS0Z = 69, MS0 = NS0Y, - : NS1X = 50, NS1Y = 50, NS1Z = 14, MS1 = NS1X, - : NS2X = 9, NS2Y = 9, NS2Z = 2, MS2 = NS2X ) - - DOUBLE PRECISION E0(3,ME0,3), E1(3,ME1,3), E2(3,ME2,3), - : S0(3,MS0,3), S1(3,MS1,3), S2(3,MS2,3) - - DATA NE0 / NE0X, NE0Y, NE0Z / - DATA NE1 / NE1X, NE1Y, NE1Z / - DATA NE2 / NE2X, NE2Y, NE2Z / - DATA NS0 / NS0X, NS0Y, NS0Z / - DATA NS1 / NS1X, NS1Y, NS1Z / - DATA NS2 / NS2X, NS2Y, NS2Z / - -* Sun-to-Earth, T^0, X - DATA ((E0(I,J,1),I=1,3),J= 1, 10) / - : 0.9998292878132D+00, 0.1753485171504D+01, 0.6283075850446D+01, - : 0.8352579567414D-02, 0.1710344404582D+01, 0.1256615170089D+02, - : 0.5611445335148D-02, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.1046664295572D-03, 0.1667225416770D+01, 0.1884922755134D+02, - : 0.3110842534677D-04, 0.6687513390251D+00, 0.8399684731857D+02, - : 0.2552413503550D-04, 0.5830637358413D+00, 0.5296909721118D+00, - : 0.2137207845781D-04, 0.1092330954011D+01, 0.1577343543434D+01, - : 0.1680240182951D-04, 0.4955366134987D+00, 0.6279552690824D+01, - : 0.1679012370795D-04, 0.6153014091901D+01, 0.6286599010068D+01, - : 0.1445526946777D-04, 0.3472744100492D+01, 0.2352866153506D+01 / - DATA ((E0(I,J,1),I=1,3),J= 11, 20) / - : 0.1091038246184D-04, 0.3689845786119D+01, 0.5223693906222D+01, - : 0.9344399733932D-05, 0.6073934645672D+01, 0.1203646072878D+02, - : 0.8993182910652D-05, 0.3175705249069D+01, 0.1021328554739D+02, - : 0.5665546034116D-05, 0.2152484672246D+01, 0.1059381944224D+01, - : 0.6844146703035D-05, 0.1306964099750D+01, 0.5753384878334D+01, - : 0.7346610905565D-05, 0.4354980070466D+01, 0.3981490189893D+00, - : 0.6815396474414D-05, 0.2218229211267D+01, 0.4705732307012D+01, - : 0.6112787253053D-05, 0.5384788425458D+01, 0.6812766822558D+01, - : 0.4518120711239D-05, 0.6087604012291D+01, 0.5884926831456D+01, - : 0.4521963430706D-05, 0.1279424524906D+01, 0.6256777527156D+01 / - DATA ((E0(I,J,1),I=1,3),J= 21, 30) / - : 0.4497426764085D-05, 0.5369129144266D+01, 0.6309374173736D+01, - : 0.4062190566959D-05, 0.5436473303367D+00, 0.6681224869435D+01, - : 0.5412193480192D-05, 0.7867838528395D+00, 0.7755226100720D+00, - : 0.5469839049386D-05, 0.1461440311134D+01, 0.1414349524433D+02, - : 0.5205264083477D-05, 0.4432944696116D+01, 0.7860419393880D+01, - : 0.2149759935455D-05, 0.4502237496846D+01, 0.1150676975667D+02, - : 0.2279109618501D-05, 0.1239441308815D+01, 0.7058598460518D+01, - : 0.2259282939683D-05, 0.3272430985331D+01, 0.4694002934110D+01, - : 0.2558950271319D-05, 0.2265471086404D+01, 0.1216800268190D+02, - : 0.2561581447555D-05, 0.1454740653245D+01, 0.7099330490126D+00 / - DATA ((E0(I,J,1),I=1,3),J= 31, 40) / - : 0.1781441115440D-05, 0.2962068630206D+01, 0.7962980379786D+00, - : 0.1612005874644D-05, 0.1473255041006D+01, 0.5486777812467D+01, - : 0.1818630667105D-05, 0.3743903293447D+00, 0.6283008715021D+01, - : 0.1818601377529D-05, 0.6274174354554D+01, 0.6283142985870D+01, - : 0.1554475925257D-05, 0.1624110906816D+01, 0.2513230340178D+02, - : 0.2090948029241D-05, 0.5852052276256D+01, 0.1179062909082D+02, - : 0.2000176345460D-05, 0.4072093298513D+01, 0.1778984560711D+02, - : 0.1289535917759D-05, 0.5217019331069D+01, 0.7079373888424D+01, - : 0.1281135307881D-05, 0.4802054538934D+01, 0.3738761453707D+01, - : 0.1518229005692D-05, 0.8691914742502D+00, 0.2132990797783D+00 / - DATA ((E0(I,J,1),I=1,3),J= 41, 50) / - : 0.9450128579027D-06, 0.4601859529950D+01, 0.1097707878456D+02, - : 0.7781119494996D-06, 0.1844352816694D+01, 0.8827390247185D+01, - : 0.7733407759912D-06, 0.3582790154750D+01, 0.5507553240374D+01, - : 0.7350644318120D-06, 0.2695277788230D+01, 0.1589072916335D+01, - : 0.6535928827023D-06, 0.3651327986142D+01, 0.1176985366291D+02, - : 0.6324624183656D-06, 0.2241302375862D+01, 0.6262300422539D+01, - : 0.6298565300557D-06, 0.4407122406081D+01, 0.6303851278352D+01, - : 0.8587037089179D-06, 0.3024307223119D+01, 0.1672837615881D+03, - : 0.8299954491035D-06, 0.6192539428237D+01, 0.3340612434717D+01, - : 0.6311263503401D-06, 0.2014758795416D+01, 0.7113454667900D-02 / - DATA ((E0(I,J,1),I=1,3),J= 51, 60) / - : 0.6005646745452D-06, 0.3399500503397D+01, 0.4136910472696D+01, - : 0.7917715109929D-06, 0.2493386877837D+01, 0.6069776770667D+01, - : 0.7556958099685D-06, 0.4159491740143D+01, 0.6496374930224D+01, - : 0.6773228244949D-06, 0.4034162934230D+01, 0.9437762937313D+01, - : 0.5370708577847D-06, 0.1562219163734D+01, 0.1194447056968D+01, - : 0.5710804266203D-06, 0.2662730803386D+01, 0.6282095334605D+01, - : 0.5709824583726D-06, 0.3985828430833D+01, 0.6284056366286D+01, - : 0.5143950896447D-06, 0.1308144688689D+01, 0.6290189305114D+01, - : 0.5088010604546D-06, 0.5352817214804D+01, 0.6275962395778D+01, - : 0.4960369085172D-06, 0.2644267922349D+01, 0.6127655567643D+01 / - DATA ((E0(I,J,1),I=1,3),J= 61, 70) / - : 0.4803137891183D-06, 0.4008844192080D+01, 0.6438496133249D+01, - : 0.5731747768225D-06, 0.3794550174597D+01, 0.3154687086868D+01, - : 0.4735947960579D-06, 0.6107118308982D+01, 0.3128388763578D+01, - : 0.4808348796625D-06, 0.4771458618163D+01, 0.8018209333619D+00, - : 0.4115073743137D-06, 0.3327111335159D+01, 0.8429241228195D+01, - : 0.5230575889287D-06, 0.5305708551694D+01, 0.1336797263425D+02, - : 0.5133977889215D-06, 0.5784230738814D+01, 0.1235285262111D+02, - : 0.5065815825327D-06, 0.2052064793679D+01, 0.1185621865188D+02, - : 0.4339831593868D-06, 0.3644994195830D+01, 0.1726015463500D+02, - : 0.3952928638953D-06, 0.4930376436758D+01, 0.5481254917084D+01 / - DATA ((E0(I,J,1),I=1,3),J= 71, 80) / - : 0.4898498111942D-06, 0.4542084219731D+00, 0.9225539266174D+01, - : 0.4757490209328D-06, 0.3161126388878D+01, 0.5856477690889D+01, - : 0.4727701669749D-06, 0.6214993845446D+00, 0.2544314396739D+01, - : 0.3800966681863D-06, 0.3040132339297D+01, 0.4265981595566D+00, - : 0.3257301077939D-06, 0.8064977360087D+00, 0.3930209696940D+01, - : 0.3255810528674D-06, 0.1974147981034D+01, 0.2146165377750D+01, - : 0.3252029748187D-06, 0.2845924913135D+01, 0.4164311961999D+01, - : 0.3255505635308D-06, 0.3017900824120D+01, 0.5088628793478D+01, - : 0.2801345211990D-06, 0.6109717793179D+01, 0.1256967486051D+02, - : 0.3688987740970D-06, 0.2911550235289D+01, 0.1807370494127D+02 / - DATA ((E0(I,J,1),I=1,3),J= 81, 90) / - : 0.2475153429458D-06, 0.2179146025856D+01, 0.2629832328990D-01, - : 0.3033457749150D-06, 0.1994161050744D+01, 0.4535059491685D+01, - : 0.2186743763110D-06, 0.5125687237936D+01, 0.1137170464392D+02, - : 0.2764777032774D-06, 0.4822646860252D+00, 0.1256262854127D+02, - : 0.2199028768592D-06, 0.4637633293831D+01, 0.1255903824622D+02, - : 0.2046482824760D-06, 0.1467038733093D+01, 0.7084896783808D+01, - : 0.2611209147507D-06, 0.3044718783485D+00, 0.7143069561767D+02, - : 0.2286079656818D-06, 0.4764220356805D+01, 0.8031092209206D+01, - : 0.1855071202587D-06, 0.3383637774428D+01, 0.1748016358760D+01, - : 0.2324669506784D-06, 0.6189088449251D+01, 0.1831953657923D+02 / - DATA ((E0(I,J,1),I=1,3),J= 91,100) / - : 0.1709528015688D-06, 0.5874966729774D+00, 0.4933208510675D+01, - : 0.2168156875828D-06, 0.4302994009132D+01, 0.1044738781244D+02, - : 0.2106675556535D-06, 0.3800475419891D+01, 0.7477522907414D+01, - : 0.1430213830465D-06, 0.1294660846502D+01, 0.2942463415728D+01, - : 0.1388396901944D-06, 0.4594797202114D+01, 0.8635942003952D+01, - : 0.1922258844190D-06, 0.4943044543591D+00, 0.1729818233119D+02, - : 0.1888460058292D-06, 0.2426943912028D+01, 0.1561374759853D+03, - : 0.1789449386107D-06, 0.1582973303499D+00, 0.1592596075957D+01, - : 0.1360803685374D-06, 0.5197240440504D+01, 0.1309584267300D+02, - : 0.1504038014709D-06, 0.3120360916217D+01, 0.1649636139783D+02 / - DATA ((E0(I,J,1),I=1,3),J=101,110) / - : 0.1382769533389D-06, 0.6164702888205D+01, 0.7632943190217D+01, - : 0.1438059769079D-06, 0.1437423770979D+01, 0.2042657109477D+02, - : 0.1326303260037D-06, 0.3609688799679D+01, 0.1213955354133D+02, - : 0.1159244950540D-06, 0.5463018167225D+01, 0.5331357529664D+01, - : 0.1433118149136D-06, 0.6028909912097D+01, 0.7342457794669D+01, - : 0.1234623148594D-06, 0.3109645574997D+01, 0.6279485555400D+01, - : 0.1233949875344D-06, 0.3539359332866D+01, 0.6286666145492D+01, - : 0.9927196061299D-07, 0.1259321569772D+01, 0.7234794171227D+01, - : 0.1242302191316D-06, 0.1065949392609D+01, 0.1511046609763D+02, - : 0.1098402195201D-06, 0.2192508743837D+01, 0.1098880815746D+02 / - DATA ((E0(I,J,1),I=1,3),J=111,120) / - : 0.1158191395315D-06, 0.4054411278650D+01, 0.5729506548653D+01, - : 0.9048475596241D-07, 0.5429764748518D+01, 0.9623688285163D+01, - : 0.8889853269023D-07, 0.5046586206575D+01, 0.6148010737701D+01, - : 0.1048694242164D-06, 0.2628858030806D+01, 0.6836645152238D+01, - : 0.1112308378646D-06, 0.4177292719907D+01, 0.1572083878776D+02, - : 0.8631729709901D-07, 0.1601345232557D+01, 0.6418140963190D+01, - : 0.8527816951664D-07, 0.2463888997513D+01, 0.1471231707864D+02, - : 0.7892139456991D-07, 0.3154022088718D+01, 0.2118763888447D+01, - : 0.1051782905236D-06, 0.4795035816088D+01, 0.1349867339771D+01, - : 0.1048219943164D-06, 0.2952983395230D+01, 0.5999216516294D+01 / - DATA ((E0(I,J,1),I=1,3),J=121,130) / - : 0.7435760775143D-07, 0.5420547991464D+01, 0.6040347114260D+01, - : 0.9869574106949D-07, 0.3695646753667D+01, 0.6566935184597D+01, - : 0.9156886364226D-07, 0.3922675306609D+01, 0.5643178611111D+01, - : 0.7006834356188D-07, 0.1233968624861D+01, 0.6525804586632D+01, - : 0.9806170182601D-07, 0.1919542280684D+01, 0.2122839202813D+02, - : 0.9052289673607D-07, 0.4615902724369D+01, 0.4690479774488D+01, - : 0.7554200867893D-07, 0.1236863719072D+01, 0.1253985337760D+02, - : 0.8215741286498D-07, 0.3286800101559D+00, 0.1097355562493D+02, - : 0.7185178575397D-07, 0.5880942158367D+01, 0.6245048154254D+01, - : 0.7130726476180D-07, 0.7674871987661D+00, 0.6321103546637D+01 / - DATA ((E0(I,J,1),I=1,3),J=131,140) / - : 0.6650894461162D-07, 0.6987129150116D+00, 0.5327476111629D+01, - : 0.7396888823688D-07, 0.3576824794443D+01, 0.5368044267797D+00, - : 0.7420588884775D-07, 0.5033615245369D+01, 0.2354323048545D+02, - : 0.6141181642908D-07, 0.9449927045673D+00, 0.1296430071988D+02, - : 0.6373557924058D-07, 0.6206342280341D+01, 0.9517183207817D+00, - : 0.6359474329261D-07, 0.5036079095757D+01, 0.1990745094947D+01, - : 0.5740173582646D-07, 0.6105106371350D+01, 0.9555997388169D+00, - : 0.7019864084602D-07, 0.7237747359018D+00, 0.5225775174439D+00, - : 0.6398054487042D-07, 0.3976367969666D+01, 0.2407292145756D+02, - : 0.7797092650498D-07, 0.4305423910623D+01, 0.2200391463820D+02 / - DATA ((E0(I,J,1),I=1,3),J=141,150) / - : 0.6466760000900D-07, 0.3500136825200D+01, 0.5230807360890D+01, - : 0.7529417043890D-07, 0.3514779246100D+01, 0.1842262939178D+02, - : 0.6924571140892D-07, 0.2743457928679D+01, 0.1554202828031D+00, - : 0.6220798650222D-07, 0.2242598118209D+01, 0.1845107853235D+02, - : 0.5870209391853D-07, 0.2332832707527D+01, 0.6398972393349D+00, - : 0.6263953473888D-07, 0.2191105358956D+01, 0.6277552955062D+01, - : 0.6257781390012D-07, 0.4457559396698D+01, 0.6288598745829D+01, - : 0.5697304945123D-07, 0.3499234761404D+01, 0.1551045220144D+01, - : 0.6335438746791D-07, 0.6441691079251D+00, 0.5216580451554D+01, - : 0.6377258441152D-07, 0.2252599151092D+01, 0.5650292065779D+01 / - DATA ((E0(I,J,1),I=1,3),J=151,160) / - : 0.6484841818165D-07, 0.1992812417646D+01, 0.1030928125552D+00, - : 0.4735551485250D-07, 0.3744672082942D+01, 0.1431416805965D+02, - : 0.4628595996170D-07, 0.1334226211745D+01, 0.5535693017924D+00, - : 0.6258152336933D-07, 0.4395836159154D+01, 0.2608790314060D+02, - : 0.6196171366594D-07, 0.2587043007997D+01, 0.8467247584405D+02, - : 0.6159556952126D-07, 0.4782499769128D+01, 0.2394243902548D+03, - : 0.4987741172394D-07, 0.7312257619924D+00, 0.7771377146812D+02, - : 0.5459280703142D-07, 0.3001376372532D+01, 0.6179983037890D+01, - : 0.4863461189999D-07, 0.3767222128541D+01, 0.9027992316901D+02, - : 0.5349912093158D-07, 0.3663594450273D+01, 0.6386168663001D+01 / - DATA ((E0(I,J,1),I=1,3),J=161,170) / - : 0.5673725607806D-07, 0.4331187919049D+01, 0.6915859635113D+01, - : 0.4745485060512D-07, 0.5816195745518D+01, 0.6282970628506D+01, - : 0.4745379005326D-07, 0.8323672435672D+00, 0.6283181072386D+01, - : 0.4049002796321D-07, 0.3785023976293D+01, 0.6254626709878D+01, - : 0.4247084014515D-07, 0.2378220728783D+01, 0.7875671926403D+01, - : 0.4026912363055D-07, 0.2864103423269D+01, 0.6311524991013D+01, - : 0.4062935011774D-07, 0.2415408595975D+01, 0.3634620989887D+01, - : 0.5347771048509D-07, 0.3343479309801D+01, 0.2515860172507D+02, - : 0.4829494136505D-07, 0.2821742398262D+01, 0.5760498333002D+01, - : 0.4342554404599D-07, 0.5624662458712D+01, 0.7238675589263D+01 / - DATA ((E0(I,J,1),I=1,3),J=171,180) / - : 0.4021599184361D-07, 0.5557250275009D+00, 0.1101510648075D+02, - : 0.4104900474558D-07, 0.3296691780005D+01, 0.6709674010002D+01, - : 0.4376532905131D-07, 0.3814443999443D+01, 0.6805653367890D+01, - : 0.3314590480650D-07, 0.3560229189250D+01, 0.1259245002418D+02, - : 0.3232421839643D-07, 0.5185389180568D+01, 0.1066495398892D+01, - : 0.3541176318876D-07, 0.3921381909679D+01, 0.9917696840332D+01, - : 0.3689831242681D-07, 0.4190658955386D+01, 0.1192625446156D+02, - : 0.3890605376774D-07, 0.5546023371097D+01, 0.7478166569050D-01, - : 0.3038559339780D-07, 0.6231032794494D+01, 0.1256621883632D+02, - : 0.3137083969782D-07, 0.6207063419190D+01, 0.4292330755499D+01 / - DATA ((E0(I,J,1),I=1,3),J=181,190) / - : 0.4024004081854D-07, 0.1195257375713D+01, 0.1334167431096D+02, - : 0.3300234879283D-07, 0.1804694240998D+01, 0.1057540660594D+02, - : 0.3635399155575D-07, 0.5597811343500D+01, 0.6208294184755D+01, - : 0.3032668691356D-07, 0.3191059366530D+01, 0.1805292951336D+02, - : 0.2809652069058D-07, 0.4094348032570D+01, 0.3523159621801D-02, - : 0.3696955383823D-07, 0.5219282738794D+01, 0.5966683958112D+01, - : 0.3562894142503D-07, 0.1037247544554D+01, 0.6357857516136D+01, - : 0.3510598524148D-07, 0.1430020816116D+01, 0.6599467742779D+01, - : 0.3617736142953D-07, 0.3002911403677D+01, 0.6019991944201D+01, - : 0.2624524910730D-07, 0.2437046757292D+01, 0.6702560555334D+01 / - DATA ((E0(I,J,1),I=1,3),J=191,200) / - : 0.2535824204490D-07, 0.1581594689647D+01, 0.3141537925223D+02, - : 0.3519787226257D-07, 0.5379863121521D+01, 0.2505706758577D+03, - : 0.2578406709982D-07, 0.4904222639329D+01, 0.1673046366289D+02, - : 0.3423887981473D-07, 0.3646448997315D+01, 0.6546159756691D+01, - : 0.2776083886467D-07, 0.3307829300144D+01, 0.1272157198369D+02, - : 0.3379592818379D-07, 0.1747541251125D+01, 0.1494531617769D+02, - : 0.3050255426284D-07, 0.1784689432607D-01, 0.4732030630302D+01, - : 0.2652378350236D-07, 0.4420055276260D+01, 0.5863591145557D+01, - : 0.2374498173768D-07, 0.3629773929208D+01, 0.2388894113936D+01, - : 0.2716451255140D-07, 0.3079623706780D+01, 0.1202934727411D+02 / - DATA ((E0(I,J,1),I=1,3),J=201,210) / - : 0.3038583699229D-07, 0.3312487903507D+00, 0.1256608456547D+02, - : 0.2220681228760D-07, 0.5265520401774D+01, 0.1336244973887D+02, - : 0.3044156540912D-07, 0.4766664081250D+01, 0.2908881142201D+02, - : 0.2731859923561D-07, 0.5069146530691D+01, 0.1391601904066D+02, - : 0.2285603018171D-07, 0.5954935112271D+01, 0.6076890225335D+01, - : 0.2025006454555D-07, 0.4061789589267D+01, 0.4701116388778D+01, - : 0.2012597519804D-07, 0.2485047705241D+01, 0.6262720680387D+01, - : 0.2003406962258D-07, 0.4163779209320D+01, 0.6303431020504D+01, - : 0.2207863441371D-07, 0.6923839133828D+00, 0.6489261475556D+01, - : 0.2481374305624D-07, 0.5944173595676D+01, 0.1204357418345D+02 / - DATA ((E0(I,J,1),I=1,3),J=211,220) / - : 0.2130923288870D-07, 0.4641013671967D+01, 0.5746271423666D+01, - : 0.2446370543391D-07, 0.6125796518757D+01, 0.1495633313810D+00, - : 0.1932492759052D-07, 0.2234572324504D+00, 0.1352175143971D+02, - : 0.2600122568049D-07, 0.4281012405440D+01, 0.4590910121555D+01, - : 0.2431754047488D-07, 0.1429943874870D+00, 0.1162474756779D+01, - : 0.1875902869209D-07, 0.9781803816948D+00, 0.6279194432410D+01, - : 0.1874381139426D-07, 0.5670368130173D+01, 0.6286957268481D+01, - : 0.2156696047173D-07, 0.2008985006833D+01, 0.1813929450232D+02, - : 0.1965076182484D-07, 0.2566186202453D+00, 0.4686889479442D+01, - : 0.2334816372359D-07, 0.4408121891493D+01, 0.1002183730415D+02 / - DATA ((E0(I,J,1),I=1,3),J=221,230) / - : 0.1869937408802D-07, 0.5272745038656D+01, 0.2427287361862D+00, - : 0.2436236460883D-07, 0.4407720479029D+01, 0.9514313292143D+02, - : 0.1761365216611D-07, 0.1943892315074D+00, 0.1351787002167D+02, - : 0.2156289480503D-07, 0.1418570924545D+01, 0.6037244212485D+01, - : 0.2164748979255D-07, 0.4724603439430D+01, 0.2301353951334D+02, - : 0.2222286670853D-07, 0.2400266874598D+01, 0.1266924451345D+02, - : 0.2070901414929D-07, 0.5230348028732D+01, 0.6528907488406D+01, - : 0.1792745177020D-07, 0.2099190328945D+01, 0.6819880277225D+01, - : 0.1841802068445D-07, 0.3467527844848D+00, 0.6514761976723D+02, - : 0.1578401631718D-07, 0.7098642356340D+00, 0.2077542790660D-01 / - DATA ((E0(I,J,1),I=1,3),J=231,240) / - : 0.1561690152531D-07, 0.5943349620372D+01, 0.6272439236156D+01, - : 0.1558591045463D-07, 0.7040653478980D+00, 0.6293712464735D+01, - : 0.1737356469576D-07, 0.4487064760345D+01, 0.1765478049437D+02, - : 0.1434755619991D-07, 0.2993391570995D+01, 0.1102062672231D+00, - : 0.1482187806654D-07, 0.2278049198251D+01, 0.1052268489556D+01, - : 0.1424812827089D-07, 0.1682114725827D+01, 0.1311972100268D+02, - : 0.1380282448623D-07, 0.3262668602579D+01, 0.1017725758696D+02, - : 0.1811481244566D-07, 0.3187771221777D+01, 0.1887552587463D+02, - : 0.1504446185696D-07, 0.5650162308647D+01, 0.7626583626240D-01, - : 0.1740776154137D-07, 0.5487068607507D+01, 0.1965104848470D+02 / - DATA ((E0(I,J,1),I=1,3),J=241,250) / - : 0.1374339536251D-07, 0.5745688172201D+01, 0.6016468784579D+01, - : 0.1761377477704D-07, 0.5748060203659D+01, 0.2593412433514D+02, - : 0.1535138225795D-07, 0.6226848505790D+01, 0.9411464614024D+01, - : 0.1788140543676D-07, 0.6189318878563D+01, 0.3301902111895D+02, - : 0.1375002807996D-07, 0.5371812884394D+01, 0.6327837846670D+00, - : 0.1242115758632D-07, 0.1471687569712D+01, 0.3894181736510D+01, - : 0.1450977333938D-07, 0.4143836662127D+01, 0.1277945078067D+02, - : 0.1297579575023D-07, 0.9003477661957D+00, 0.6549682916313D+01, - : 0.1462667934821D-07, 0.5760505536428D+01, 0.1863592847156D+02, - : 0.1381774374799D-07, 0.1085471729463D+01, 0.2379164476796D+01 / - DATA ((E0(I,J,1),I=1,3),J=251,260) / - : 0.1682333169307D-07, 0.5409870870133D+01, 0.1620077269078D+02, - : 0.1190812918837D-07, 0.1397205174601D+01, 0.1149965630200D+02, - : 0.1221434762106D-07, 0.9001804809095D+00, 0.1257326515556D+02, - : 0.1549934644860D-07, 0.4262528275544D+01, 0.1820933031200D+02, - : 0.1252138953050D-07, 0.1411642012027D+01, 0.6993008899458D+01, - : 0.1237078905387D-07, 0.2844472403615D+01, 0.2435678079171D+02, - : 0.1446953389615D-07, 0.5295835522223D+01, 0.3813291813120D-01, - : 0.1388446457170D-07, 0.4969428135497D+01, 0.2458316379602D+00, - : 0.1019339179228D-07, 0.2491369561806D+01, 0.6112403035119D+01, - : 0.1258880815343D-07, 0.4679426248976D+01, 0.5429879531333D+01 / - DATA ((E0(I,J,1),I=1,3),J=261,270) / - : 0.1297768238261D-07, 0.1074509953328D+01, 0.1249137003520D+02, - : 0.9913505718094D-08, 0.4735097918224D+01, 0.6247047890016D+01, - : 0.9830453155969D-08, 0.4158649187338D+01, 0.6453748665772D+01, - : 0.1192615865309D-07, 0.3438208613699D+01, 0.6290122169689D+01, - : 0.9835874798277D-08, 0.1913300781229D+01, 0.6319103810876D+01, - : 0.9639087569277D-08, 0.9487683644125D+00, 0.8273820945392D+01, - : 0.1175716107001D-07, 0.3228141664287D+01, 0.6276029531202D+01, - : 0.1018926508678D-07, 0.2216607854300D+01, 0.1254537627298D+02, - : 0.9500087869225D-08, 0.2625116459733D+01, 0.1256517118505D+02, - : 0.9664192916575D-08, 0.5860562449214D+01, 0.6259197520765D+01 / - DATA ((E0(I,J,1),I=1,3),J=271,280) / - : 0.9612858712203D-08, 0.7885682917381D+00, 0.6306954180126D+01, - : 0.1117645675413D-07, 0.3932148831189D+01, 0.1779695906178D+02, - : 0.1158864052160D-07, 0.9995605521691D+00, 0.1778273215245D+02, - : 0.9021043467028D-08, 0.5263769742673D+01, 0.6172869583223D+01, - : 0.8836134773563D-08, 0.1496843220365D+01, 0.1692165728891D+01, - : 0.1045872200691D-07, 0.7009039517214D+00, 0.2204125344462D+00, - : 0.1211463487798D-07, 0.4041544938511D+01, 0.8257698122054D+02, - : 0.8541990804094D-08, 0.1447586692316D+01, 0.6393282117669D+01, - : 0.1038720703636D-07, 0.4594249718112D+00, 0.1550861511662D+02, - : 0.1126722351445D-07, 0.3925550579036D+01, 0.2061856251104D+00 / - DATA ((E0(I,J,1),I=1,3),J=281,290) / - : 0.8697373859631D-08, 0.4411341856037D+01, 0.9491756770005D+00, - : 0.8869380028441D-08, 0.2402659724813D+01, 0.3903911373650D+01, - : 0.9247014693258D-08, 0.1401579743423D+01, 0.6267823317922D+01, - : 0.9205062930950D-08, 0.5245978000814D+01, 0.6298328382969D+01, - : 0.8000745038049D-08, 0.3590803356945D+01, 0.2648454860559D+01, - : 0.9168973650819D-08, 0.2470150501679D+01, 0.1498544001348D+03, - : 0.1075444949238D-07, 0.1328606161230D+01, 0.3694923081589D+02, - : 0.7817298525817D-08, 0.6162256225998D+01, 0.4804209201333D+01, - : 0.9541469226356D-08, 0.3942568967039D+01, 0.1256713221673D+02, - : 0.9821910122027D-08, 0.2360246287233D+00, 0.1140367694411D+02 / - DATA ((E0(I,J,1),I=1,3),J=291,300) / - : 0.9897822023777D-08, 0.4619805634280D+01, 0.2280573557157D+02, - : 0.7737289283765D-08, 0.3784727847451D+01, 0.7834121070590D+01, - : 0.9260204034710D-08, 0.2223352487601D+01, 0.2787043132925D+01, - : 0.7320252888486D-08, 0.1288694636874D+01, 0.6282655592598D+01, - : 0.7319785780946D-08, 0.5359869567774D+01, 0.6283496108294D+01, - : 0.7147219933778D-08, 0.5516616675856D+01, 0.1725663147538D+02, - : 0.7946502829878D-08, 0.2630459984567D+01, 0.1241073141809D+02, - : 0.9001711808932D-08, 0.2849815827227D+01, 0.6281591679874D+01, - : 0.8994041507257D-08, 0.3795244450750D+01, 0.6284560021018D+01, - : 0.8298582787358D-08, 0.5236413127363D+00, 0.1241658836951D+02 / - DATA ((E0(I,J,1),I=1,3),J=301,310) / - : 0.8526596520710D-08, 0.4794605424426D+01, 0.1098419223922D+02, - : 0.8209822103197D-08, 0.1578752370328D+01, 0.1096996532989D+02, - : 0.6357049861094D-08, 0.5708926113761D+01, 0.1596186371003D+01, - : 0.7370473179049D-08, 0.3842402530241D+01, 0.4061219149443D+01, - : 0.7232154664726D-08, 0.3067548981535D+01, 0.1610006857377D+03, - : 0.6328765494903D-08, 0.1313930030069D+01, 0.1193336791622D+02, - : 0.8030064908595D-08, 0.3488500408886D+01, 0.8460828644453D+00, - : 0.6275464259232D-08, 0.1532061626198D+01, 0.8531963191132D+00, - : 0.7051897446325D-08, 0.3285859929993D+01, 0.5849364236221D+01, - : 0.6161593705428D-08, 0.1477341999464D+01, 0.5573142801433D+01 / - DATA ((E0(I,J,1),I=1,3),J=311,320) / - : 0.7754683957278D-08, 0.1586118663096D+01, 0.8662240327241D+01, - : 0.5889928990701D-08, 0.1304887868803D+01, 0.1232342296471D+02, - : 0.5705756047075D-08, 0.4555333589350D+01, 0.1258692712880D+02, - : 0.5964178808332D-08, 0.3001762842062D+01, 0.5333900173445D+01, - : 0.6712446027467D-08, 0.4886780007595D+01, 0.1171295538178D+02, - : 0.5941809275464D-08, 0.4701509603824D+01, 0.9779108567966D+01, - : 0.5466993627395D-08, 0.4588357817278D+01, 0.1884211409667D+02, - : 0.6340512090980D-08, 0.1164543038893D+01, 0.5217580628120D+02, - : 0.6325505710045D-08, 0.3919171259645D+01, 0.1041998632314D+02, - : 0.6164789509685D-08, 0.2143828253542D+01, 0.6151533897323D+01 / - DATA ((E0(I,J,1),I=1,3),J=321,330) / - : 0.5263330812430D-08, 0.6066564434241D+01, 0.1885275071096D+02, - : 0.5597087780221D-08, 0.2926316429472D+01, 0.4337116142245D+00, - : 0.5396556236817D-08, 0.3244303591505D+01, 0.6286362197481D+01, - : 0.5396615148223D-08, 0.3404304703662D+01, 0.6279789503410D+01, - : 0.7091832443341D-08, 0.8532377803192D+00, 0.4907302013889D+01, - : 0.6572352589782D-08, 0.4901966774419D+01, 0.1176433076753D+02, - : 0.5960236060795D-08, 0.1874672315797D+01, 0.1422690933580D-01, - : 0.5125480043511D-08, 0.3735726064334D+01, 0.1245594543367D+02, - : 0.5928241866410D-08, 0.4502033899935D+01, 0.6414617803568D+01, - : 0.5249600357424D-08, 0.4372334799878D+01, 0.1151388321134D+02 / - DATA ((E0(I,J,1),I=1,3),J=331,340) / - : 0.6059171276087D-08, 0.2581617302908D+01, 0.6062663316000D+01, - : 0.5295235081662D-08, 0.2974811513158D+01, 0.3496032717521D+01, - : 0.5820561875933D-08, 0.1796073748244D+00, 0.2838593341516D+00, - : 0.4754696606440D-08, 0.1981998136973D+01, 0.3104930017775D+01, - : 0.6385053548955D-08, 0.2559174171605D+00, 0.6133512519065D+01, - : 0.6589828273941D-08, 0.2750967106776D+01, 0.4087944051283D+02, - : 0.5383376567189D-08, 0.6325947523578D+00, 0.2248384854122D+02, - : 0.5928941683538D-08, 0.1672304519067D+01, 0.1581959461667D+01, - : 0.4816060709794D-08, 0.3512566172575D+01, 0.9388005868221D+01, - : 0.6003381586512D-08, 0.5610932219189D+01, 0.5326786718777D+01 / - DATA ((E0(I,J,1),I=1,3),J=341,350) / - : 0.5504225393105D-08, 0.4037501131256D+01, 0.6503488384892D+01, - : 0.5353772620129D-08, 0.6122774968240D+01, 0.1735668374386D+03, - : 0.5786253768544D-08, 0.5527984999515D+01, 0.1350651127443D+00, - : 0.5065706702002D-08, 0.9980765573624D+00, 0.1248988586463D+02, - : 0.5972838885276D-08, 0.6044489493203D+01, 0.2673594526851D+02, - : 0.5323585877961D-08, 0.3924265998147D+01, 0.4171425416666D+01, - : 0.5210772682858D-08, 0.6220111376901D+01, 0.2460261242967D+02, - : 0.4726549040535D-08, 0.3716043206862D+01, 0.7232251527446D+01, - : 0.6029425105059D-08, 0.8548704071116D+00, 0.3227113045244D+03, - : 0.4481542826513D-08, 0.1426925072829D+01, 0.5547199253223D+01 / - DATA ((E0(I,J,1),I=1,3),J=351,360) / - : 0.5836024505068D-08, 0.7135651752625D-01, 0.7285056171570D+02, - : 0.4137046613272D-08, 0.5330767643283D+01, 0.1087398597200D+02, - : 0.5171977473924D-08, 0.4494262335353D+00, 0.1884570439172D+02, - : 0.5694429833732D-08, 0.2952369582215D+01, 0.9723862754494D+02, - : 0.4009158925298D-08, 0.3500003416535D+01, 0.6244942932314D+01, - : 0.4784939596873D-08, 0.6196709413181D+01, 0.2929661536378D+02, - : 0.3983725022610D-08, 0.5103690031897D+01, 0.4274518229222D+01, - : 0.3870535232462D-08, 0.3187569587401D+01, 0.6321208768577D+01, - : 0.5140501213951D-08, 0.1668924357457D+01, 0.1232032006293D+02, - : 0.3849034819355D-08, 0.4445722510309D+01, 0.1726726808967D+02 / - DATA ((E0(I,J,1),I=1,3),J=361,370) / - : 0.4002383075060D-08, 0.5226224152423D+01, 0.7018952447668D+01, - : 0.3890719543549D-08, 0.4371166550274D+01, 0.1491901785440D+02, - : 0.4887084607881D-08, 0.5973556689693D+01, 0.1478866649112D+01, - : 0.3739939287592D-08, 0.2089084714600D+01, 0.6922973089781D+01, - : 0.5031925918209D-08, 0.4658371936827D+01, 0.1715706182245D+02, - : 0.4387748764954D-08, 0.4825580552819D+01, 0.2331413144044D+03, - : 0.4147398098865D-08, 0.3739003524998D+01, 0.1376059875786D+02, - : 0.3719089993586D-08, 0.1148941386536D+01, 0.6297302759782D+01, - : 0.3934238461056D-08, 0.1559893008343D+01, 0.7872148766781D+01, - : 0.3672471375622D-08, 0.5516145383612D+01, 0.6268848941110D+01 / - DATA ((E0(I,J,1),I=1,3),J=371,380) / - : 0.3768911277583D-08, 0.6116053700563D+01, 0.4157198507331D+01, - : 0.4033388417295D-08, 0.5076821746017D+01, 0.1567108171867D+02, - : 0.3764194617832D-08, 0.8164676232075D+00, 0.3185192151914D+01, - : 0.4840628226284D-08, 0.1360479453671D+01, 0.1252801878276D+02, - : 0.4949443923785D-08, 0.2725622229926D+01, 0.1617106187867D+03, - : 0.4117393089971D-08, 0.6054459628492D+00, 0.5642198095270D+01, - : 0.3925754020428D-08, 0.8570462135210D+00, 0.2139354194808D+02, - : 0.3630551757923D-08, 0.3552067338279D+01, 0.6294805223347D+01, - : 0.3627274802357D-08, 0.3096565085313D+01, 0.6271346477544D+01, - : 0.3806143885093D-08, 0.6367751709777D+00, 0.1725304118033D+02 / - DATA ((E0(I,J,1),I=1,3),J=381,390) / - : 0.4433254641565D-08, 0.4848461503937D+01, 0.7445550607224D+01, - : 0.3712319846576D-08, 0.1331950643655D+01, 0.4194847048887D+00, - : 0.3849847534783D-08, 0.4958368297746D+00, 0.9562891316684D+00, - : 0.3483955430165D-08, 0.2237215515707D+01, 0.1161697602389D+02, - : 0.3961912730982D-08, 0.3332402188575D+01, 0.2277943724828D+02, - : 0.3419978244481D-08, 0.5785600576016D+01, 0.1362553364512D+02, - : 0.3329417758177D-08, 0.9812676559709D-01, 0.1685848245639D+02, - : 0.4207206893193D-08, 0.9494780468236D+00, 0.2986433403208D+02, - : 0.3268548976410D-08, 0.1739332095686D+00, 0.5749861718712D+01, - : 0.3321880082685D-08, 0.1423354800666D+01, 0.6279143387820D+01 / - DATA ((E0(I,J,1),I=1,3),J=391,400) / - : 0.4503173010852D-08, 0.2314972675293D+00, 0.1385561574497D+01, - : 0.4316599090954D-08, 0.1012646782616D+00, 0.4176041334900D+01, - : 0.3283493323850D-08, 0.5233306881265D+01, 0.6287008313071D+01, - : 0.3164033542343D-08, 0.4005597257511D+01, 0.2099539292909D+02, - : 0.4159720956725D-08, 0.5365676242020D+01, 0.5905702259363D+01, - : 0.3565176892217D-08, 0.4284440620612D+01, 0.3932462625300D-02, - : 0.3514440950221D-08, 0.4270562636575D+01, 0.7335344340001D+01, - : 0.3540596871909D-08, 0.5953553201060D+01, 0.1234573916645D+02, - : 0.2960769905118D-08, 0.1115180417718D+01, 0.2670964694522D+02, - : 0.2962213739684D-08, 0.3863811918186D+01, 0.6408777551755D+00 / - DATA ((E0(I,J,1),I=1,3),J=401,410) / - : 0.3883556700251D-08, 0.1268617928302D+01, 0.6660449441528D+01, - : 0.2919225516346D-08, 0.4908605223265D+01, 0.1375773836557D+01, - : 0.3115158863370D-08, 0.3744519976885D+01, 0.3802769619140D-01, - : 0.4099438144212D-08, 0.4173244670532D+01, 0.4480965020977D+02, - : 0.2899531858964D-08, 0.5910601428850D+01, 0.2059724391010D+02, - : 0.3289733429855D-08, 0.2488050078239D+01, 0.1081813534213D+02, - : 0.3933075612875D-08, 0.1122363652883D+01, 0.3773735910827D+00, - : 0.3021403764467D-08, 0.4951973724904D+01, 0.2982630633589D+02, - : 0.2798598949757D-08, 0.5117057845513D+01, 0.1937891852345D+02, - : 0.3397421302707D-08, 0.6104159180476D+01, 0.6923953605621D+01 / - DATA ((E0(I,J,1),I=1,3),J=411,420) / - : 0.3720398002179D-08, 0.1184933429829D+01, 0.3066615496545D+02, - : 0.3598484186267D-08, 0.3505282086105D+01, 0.6147450479709D+01, - : 0.3694594027310D-08, 0.2286651088141D+01, 0.2636725487657D+01, - : 0.2680444152969D-08, 0.1871816775482D+00, 0.6816289982179D+01, - : 0.3497574865641D-08, 0.3143251755431D+01, 0.6418701221183D+01, - : 0.3130274129494D-08, 0.2462167316018D+01, 0.1235996607578D+02, - : 0.3241119069551D-08, 0.4256374004686D+01, 0.1652265972112D+02, - : 0.2601960842061D-08, 0.4970362941425D+01, 0.1045450126711D+02, - : 0.2690601527504D-08, 0.2372657824898D+01, 0.3163918923335D+00, - : 0.2908688152664D-08, 0.4232652627721D+01, 0.2828699048865D+02 / - DATA ((E0(I,J,1),I=1,3),J=421,430) / - : 0.3120456131875D-08, 0.3925747001137D+00, 0.2195415756911D+02, - : 0.3148855423384D-08, 0.3093478330445D+01, 0.1172006883645D+02, - : 0.3051044261017D-08, 0.5560948248212D+01, 0.6055599646783D+01, - : 0.2826006876660D-08, 0.5072790310072D+01, 0.5120601093667D+01, - : 0.3100034191711D-08, 0.4998530231096D+01, 0.1799603123222D+02, - : 0.2398771640101D-08, 0.2561739802176D+01, 0.6255674361143D+01, - : 0.2384002842728D-08, 0.4087420284111D+01, 0.6310477339748D+01, - : 0.2842146517568D-08, 0.2515048217955D+01, 0.5469525544182D+01, - : 0.2847674371340D-08, 0.5235326497443D+01, 0.1034429499989D+02, - : 0.2903722140764D-08, 0.1088200795797D+01, 0.6510552054109D+01 / - DATA ((E0(I,J,1),I=1,3),J=431,440) / - : 0.3187610710605D-08, 0.4710624424816D+01, 0.1693792562116D+03, - : 0.3048869992813D-08, 0.2857975896445D+00, 0.8390110365991D+01, - : 0.2860216950984D-08, 0.2241619020815D+01, 0.2243449970715D+00, - : 0.2701117683113D-08, 0.6651573305272D-01, 0.6129297044991D+01, - : 0.2509891590152D-08, 0.1285135324585D+01, 0.1044027435778D+02, - : 0.2623200252223D-08, 0.2981229834530D+00, 0.6436854655901D+01, - : 0.2622541669202D-08, 0.6122470726189D+01, 0.9380959548977D+01, - : 0.2818435667099D-08, 0.4251087148947D+01, 0.5934151399930D+01, - : 0.2365196797465D-08, 0.3465070460790D+01, 0.2470570524223D+02, - : 0.2358704646143D-08, 0.5791603815350D+01, 0.8671969964381D+01 / - DATA ((E0(I,J,1),I=1,3),J=441,450) / - : 0.2388299481390D-08, 0.4142483772941D+01, 0.7096626156709D+01, - : 0.1996041217224D-08, 0.2101901889496D+01, 0.1727188400790D+02, - : 0.2687593060336D-08, 0.1526689456959D+01, 0.7075506709219D+02, - : 0.2618913670810D-08, 0.2397684236095D+01, 0.6632000300961D+01, - : 0.2571523050364D-08, 0.5751929456787D+00, 0.6206810014183D+01, - : 0.2582135006946D-08, 0.5595464352926D+01, 0.4873985990671D+02, - : 0.2372530190361D-08, 0.5092689490655D+01, 0.1590676413561D+02, - : 0.2357178484712D-08, 0.4444363527851D+01, 0.3097883698531D+01, - : 0.2451590394723D-08, 0.3108251687661D+01, 0.6612329252343D+00, - : 0.2370045949608D-08, 0.2608133861079D+01, 0.3459636466239D+02 / - DATA ((E0(I,J,1),I=1,3),J=451,460) / - : 0.2268997267358D-08, 0.3639717753384D+01, 0.2844914056730D-01, - : 0.1731432137906D-08, 0.1741898445707D+00, 0.2019909489111D+02, - : 0.1629869741622D-08, 0.3902225646724D+01, 0.3035599730800D+02, - : 0.2206215801974D-08, 0.4971131250731D+01, 0.6281667977667D+01, - : 0.2205469554680D-08, 0.1677462357110D+01, 0.6284483723224D+01, - : 0.2148792362509D-08, 0.4236259604006D+01, 0.1980482729015D+02, - : 0.1873733657847D-08, 0.5926814998687D+01, 0.2876692439167D+02, - : 0.2026573758959D-08, 0.4349643351962D+01, 0.2449240616245D+02, - : 0.1807770325110D-08, 0.5700940482701D+01, 0.2045286941806D+02, - : 0.1881174408581D-08, 0.6601286363430D+00, 0.2358125818164D+02 / - DATA ((E0(I,J,1),I=1,3),J=461,470) / - : 0.1368023671690D-08, 0.2211098592752D+01, 0.2473415438279D+02, - : 0.1720017916280D-08, 0.4942488551129D+01, 0.1679593901136D+03, - : 0.1702427665131D-08, 0.1452233856386D+01, 0.3338575901272D+03, - : 0.1414032510054D-08, 0.5525357721439D+01, 0.1624205518357D+03, - : 0.1652626045364D-08, 0.4108794283624D+01, 0.8956999012000D+02, - : 0.1642957769686D-08, 0.7344335209984D+00, 0.5267006960365D+02, - : 0.1614952403624D-08, 0.3541213951363D+01, 0.3332657872986D+02, - : 0.1535988291188D-08, 0.4031094072151D+01, 0.3852657435933D+02, - : 0.1593193738177D-08, 0.4185136203609D+01, 0.2282781046519D+03, - : 0.1074569126382D-08, 0.1720485636868D+01, 0.8397383534231D+02 / - DATA ((E0(I,J,1),I=1,3),J=471,480) / - : 0.1074408214509D-08, 0.2758613420318D+01, 0.8401985929482D+02, - : 0.9700199670465D-09, 0.4216686842097D+01, 0.7826370942180D+02, - : 0.1258433517061D-08, 0.2575068876639D+00, 0.3115650189215D+03, - : 0.1240303229539D-08, 0.4800844956756D+00, 0.1784300471910D+03, - : 0.9018345948127D-09, 0.3896756361552D+00, 0.5886454391678D+02, - : 0.1135301432805D-08, 0.3700805023550D+00, 0.7842370451713D+02, - : 0.9215887951370D-09, 0.4364579276638D+01, 0.1014262087719D+03, - : 0.1055401054147D-08, 0.2156564222111D+01, 0.5660027930059D+02, - : 0.1008725979831D-08, 0.5454015785234D+01, 0.4245678405627D+02, - : 0.7217398104321D-09, 0.1597772562175D+01, 0.2457074661053D+03 / - DATA ((E0(I,J,1),I=1,3),J=481,490) / - : 0.6912033134447D-09, 0.5824090621461D+01, 0.1679936946371D+03, - : 0.6833881523549D-09, 0.3578778482835D+01, 0.6053048899753D+02, - : 0.4887304205142D-09, 0.3724362812423D+01, 0.9656299901946D+02, - : 0.5173709754788D-09, 0.5422427507933D+01, 0.2442876000072D+03, - : 0.4671353097145D-09, 0.2396106924439D+01, 0.1435713242844D+03, - : 0.5652608439480D-09, 0.2804028838685D+01, 0.8365903305582D+02, - : 0.5604061331253D-09, 0.1638816006247D+01, 0.8433466158131D+02, - : 0.4712723365400D-09, 0.8979003224474D+00, 0.3164282286739D+03, - : 0.4909967465112D-09, 0.3210426725516D+01, 0.4059982187939D+03, - : 0.4771358267658D-09, 0.5308027211629D+01, 0.1805255418145D+03 / - DATA ((E0(I,J,1),I=1,3),J=491,500) / - : 0.3943451445989D-09, 0.2195145341074D+01, 0.2568537517081D+03, - : 0.3952109120244D-09, 0.5081189491586D+01, 0.2449975330562D+03, - : 0.3788134594789D-09, 0.4345171264441D+01, 0.1568131045107D+03, - : 0.3738330190479D-09, 0.2613062847997D+01, 0.3948519331910D+03, - : 0.3099866678136D-09, 0.2846760817689D+01, 0.1547176098872D+03, - : 0.2002962716768D-09, 0.4921360989412D+01, 0.2268582385539D+03, - : 0.2198291338754D-09, 0.1130360117454D+00, 0.1658638954901D+03, - : 0.1491958330784D-09, 0.4228195232278D+01, 0.2219950288015D+03, - : 0.1475384076173D-09, 0.3005721811604D+00, 0.3052819430710D+03, - : 0.1661626624624D-09, 0.7830125621203D+00, 0.2526661704812D+03 / - DATA ((E0(I,J,1),I=1,3),J=501,NE0X) / - : 0.9015823460025D-10, 0.3807792942715D+01, 0.4171445043968D+03 / - -* Sun-to-Earth, T^1, X - DATA ((E1(I,J,1),I=1,3),J= 1, 10) / - : 0.1234046326004D-05, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.5150068824701D-06, 0.6002664557501D+01, 0.1256615170089D+02, - : 0.1290743923245D-07, 0.5959437664199D+01, 0.1884922755134D+02, - : 0.1068615564952D-07, 0.2015529654209D+01, 0.6283075850446D+01, - : 0.2079619142538D-08, 0.1732960531432D+01, 0.6279552690824D+01, - : 0.2078009243969D-08, 0.4915604476996D+01, 0.6286599010068D+01, - : 0.6206330058856D-09, 0.3616457953824D+00, 0.4705732307012D+01, - : 0.5989335313746D-09, 0.3802607304474D+01, 0.6256777527156D+01, - : 0.5958495663840D-09, 0.2845866560031D+01, 0.6309374173736D+01, - : 0.4866923261539D-09, 0.5213203771824D+01, 0.7755226100720D+00 / - DATA ((E1(I,J,1),I=1,3),J= 11, 20) / - : 0.4267785823142D-09, 0.4368189727818D+00, 0.1059381944224D+01, - : 0.4610675141648D-09, 0.1837249181372D-01, 0.7860419393880D+01, - : 0.3626989993973D-09, 0.2161590545326D+01, 0.5753384878334D+01, - : 0.3563071194389D-09, 0.1452631954746D+01, 0.5884926831456D+01, - : 0.3557015642807D-09, 0.4470593393054D+01, 0.6812766822558D+01, - : 0.3210412089122D-09, 0.5195926078314D+01, 0.6681224869435D+01, - : 0.2875473577986D-09, 0.5916256610193D+01, 0.2513230340178D+02, - : 0.2842913681629D-09, 0.1149902426047D+01, 0.6127655567643D+01, - : 0.2751248215916D-09, 0.5502088574662D+01, 0.6438496133249D+01, - : 0.2481432881127D-09, 0.2921989846637D+01, 0.5486777812467D+01 / - DATA ((E1(I,J,1),I=1,3),J= 21, 30) / - : 0.2059885976560D-09, 0.3718070376585D+01, 0.7079373888424D+01, - : 0.2015522342591D-09, 0.5979395259740D+01, 0.6290189305114D+01, - : 0.1995364084253D-09, 0.6772087985494D+00, 0.6275962395778D+01, - : 0.1957436436943D-09, 0.2899210654665D+01, 0.5507553240374D+01, - : 0.1651609818948D-09, 0.6228206482192D+01, 0.1150676975667D+02, - : 0.1822980550699D-09, 0.1469348746179D+01, 0.1179062909082D+02, - : 0.1675223159760D-09, 0.3813910555688D+01, 0.7058598460518D+01, - : 0.1706491764745D-09, 0.3004380506684D+00, 0.7113454667900D-02, - : 0.1392952362615D-09, 0.1440393973406D+01, 0.7962980379786D+00, - : 0.1209868266342D-09, 0.4150425791727D+01, 0.4694002934110D+01 / - DATA ((E1(I,J,1),I=1,3),J= 31, 40) / - : 0.1009827202611D-09, 0.3290040429843D+01, 0.3738761453707D+01, - : 0.1047261388602D-09, 0.4229590090227D+01, 0.6282095334605D+01, - : 0.1047006652004D-09, 0.2418967680575D+01, 0.6284056366286D+01, - : 0.9609993143095D-10, 0.4627943659201D+01, 0.6069776770667D+01, - : 0.9590900593873D-10, 0.1894393939924D+01, 0.4136910472696D+01, - : 0.9146249188071D-10, 0.2010647519562D+01, 0.6496374930224D+01, - : 0.8545274480290D-10, 0.5529846956226D-01, 0.1194447056968D+01, - : 0.8224377881194D-10, 0.1254304102174D+01, 0.1589072916335D+01, - : 0.6183529510410D-10, 0.3360862168815D+01, 0.8827390247185D+01, - : 0.6259255147141D-10, 0.4755628243179D+01, 0.8429241228195D+01 / - DATA ((E1(I,J,1),I=1,3),J= 41, 50) / - : 0.5539291694151D-10, 0.5371746955142D+01, 0.4933208510675D+01, - : 0.7328259466314D-10, 0.4927699613906D+00, 0.4535059491685D+01, - : 0.6017835843560D-10, 0.5776682001734D-01, 0.1255903824622D+02, - : 0.7079827775243D-10, 0.4395059432251D+01, 0.5088628793478D+01, - : 0.5170358878213D-10, 0.5154062619954D+01, 0.1176985366291D+02, - : 0.4872301838682D-10, 0.6289611648973D+00, 0.6040347114260D+01, - : 0.5249869411058D-10, 0.5617272046949D+01, 0.3154687086868D+01, - : 0.4716172354411D-10, 0.3965901800877D+01, 0.5331357529664D+01, - : 0.4871214940964D-10, 0.4627507050093D+01, 0.1256967486051D+02, - : 0.4598076850751D-10, 0.6023631226459D+01, 0.6525804586632D+01 / - DATA ((E1(I,J,1),I=1,3),J= 51, 60) / - : 0.4562196089485D-10, 0.4138562084068D+01, 0.3930209696940D+01, - : 0.4325493872224D-10, 0.1330845906564D+01, 0.7632943190217D+01, - : 0.5673781176748D-10, 0.2558752615657D+01, 0.5729506548653D+01, - : 0.3961436642503D-10, 0.2728071734630D+01, 0.7234794171227D+01, - : 0.5101868209058D-10, 0.4113444965144D+01, 0.6836645152238D+01, - : 0.5257043167676D-10, 0.6195089830590D+01, 0.8031092209206D+01, - : 0.5076613989393D-10, 0.2305124132918D+01, 0.7477522907414D+01, - : 0.3342169352778D-10, 0.5415998155071D+01, 0.1097707878456D+02, - : 0.3545881983591D-10, 0.3727160564574D+01, 0.4164311961999D+01, - : 0.3364063738599D-10, 0.2901121049204D+00, 0.1137170464392D+02 / - DATA ((E1(I,J,1),I=1,3),J= 61, 70) / - : 0.3357039670776D-10, 0.1652229354331D+01, 0.5223693906222D+01, - : 0.4307412268687D-10, 0.4938909587445D+01, 0.1592596075957D+01, - : 0.3405769115435D-10, 0.2408890766511D+01, 0.3128388763578D+01, - : 0.3001926198480D-10, 0.4862239006386D+01, 0.1748016358760D+01, - : 0.2778264787325D-10, 0.5241168661353D+01, 0.7342457794669D+01, - : 0.2676159480666D-10, 0.3423593942199D+01, 0.2146165377750D+01, - : 0.2954273399939D-10, 0.1881721265406D+01, 0.5368044267797D+00, - : 0.3309362888795D-10, 0.1931525677349D+01, 0.8018209333619D+00, - : 0.2810283608438D-10, 0.2414659495050D+01, 0.5225775174439D+00, - : 0.3378045637764D-10, 0.4238019163430D+01, 0.1554202828031D+00 / - DATA ((E1(I,J,1),I=1,3),J= 71,NE1X) / - : 0.2558134979840D-10, 0.1828225235805D+01, 0.5230807360890D+01, - : 0.2273755578447D-10, 0.5858184283998D+01, 0.7084896783808D+01, - : 0.2294176037690D-10, 0.4514589779057D+01, 0.1726015463500D+02, - : 0.2533506099435D-10, 0.2355717851551D+01, 0.5216580451554D+01, - : 0.2716685375812D-10, 0.2221003625100D+01, 0.8635942003952D+01, - : 0.2419043435198D-10, 0.5955704951635D+01, 0.4690479774488D+01, - : 0.2521232544812D-10, 0.1395676848521D+01, 0.5481254917084D+01, - : 0.2630195021491D-10, 0.5727468918743D+01, 0.2629832328990D-01, - : 0.2548395840944D-10, 0.2628351859400D-03, 0.1349867339771D+01 / - -* Sun-to-Earth, T^2, X - DATA ((E2(I,J,1),I=1,3),J= 1,NE2X) / - : -0.4143818297913D-10, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.2171497694435D-10, 0.4398225628264D+01, 0.1256615170089D+02, - : 0.9845398442516D-11, 0.2079720838384D+00, 0.6283075850446D+01, - : 0.9256833552682D-12, 0.4191264694361D+01, 0.1884922755134D+02, - : 0.1022049384115D-12, 0.5381133195658D+01, 0.8399684731857D+02 / - -* Sun-to-Earth, T^0, Y - DATA ((E0(I,J,2),I=1,3),J= 1, 10) / - : 0.9998921098898D+00, 0.1826583913846D+00, 0.6283075850446D+01, - : -0.2442700893735D-01, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.8352929742915D-02, 0.1395277998680D+00, 0.1256615170089D+02, - : 0.1046697300177D-03, 0.9641423109763D-01, 0.1884922755134D+02, - : 0.3110841876663D-04, 0.5381140401712D+01, 0.8399684731857D+02, - : 0.2570269094593D-04, 0.5301016407128D+01, 0.5296909721118D+00, - : 0.2147389623610D-04, 0.2662510869850D+01, 0.1577343543434D+01, - : 0.1680344384050D-04, 0.5207904119704D+01, 0.6279552690824D+01, - : 0.1679117312193D-04, 0.4582187486968D+01, 0.6286599010068D+01, - : 0.1440512068440D-04, 0.1900688517726D+01, 0.2352866153506D+01 / - DATA ((E0(I,J,2),I=1,3),J= 11, 20) / - : 0.1135139664999D-04, 0.5273108538556D+01, 0.5223693906222D+01, - : 0.9345482571018D-05, 0.4503047687738D+01, 0.1203646072878D+02, - : 0.9007418719568D-05, 0.1605621059637D+01, 0.1021328554739D+02, - : 0.5671536712314D-05, 0.5812849070861D+00, 0.1059381944224D+01, - : 0.7451401861666D-05, 0.2807346794836D+01, 0.3981490189893D+00, - : 0.6393470057114D-05, 0.6029224133855D+01, 0.5753384878334D+01, - : 0.6814275881697D-05, 0.6472990145974D+00, 0.4705732307012D+01, - : 0.6113705628887D-05, 0.3813843419700D+01, 0.6812766822558D+01, - : 0.4503851367273D-05, 0.4527804370996D+01, 0.5884926831456D+01, - : 0.4522249141926D-05, 0.5991783029224D+01, 0.6256777527156D+01 / - DATA ((E0(I,J,2),I=1,3),J= 21, 30) / - : 0.4501794307018D-05, 0.3798703844397D+01, 0.6309374173736D+01, - : 0.5514927480180D-05, 0.3961257833388D+01, 0.5507553240374D+01, - : 0.4062862799995D-05, 0.5256247296369D+01, 0.6681224869435D+01, - : 0.5414900429712D-05, 0.5499032014097D+01, 0.7755226100720D+00, - : 0.5463153987424D-05, 0.6173092454097D+01, 0.1414349524433D+02, - : 0.5071611859329D-05, 0.2870244247651D+01, 0.7860419393880D+01, - : 0.2195112094455D-05, 0.2952338617201D+01, 0.1150676975667D+02, - : 0.2279139233919D-05, 0.5951775132933D+01, 0.7058598460518D+01, - : 0.2278386100876D-05, 0.4845456398785D+01, 0.4694002934110D+01, - : 0.2559088003308D-05, 0.6945321117311D+00, 0.1216800268190D+02 / - DATA ((E0(I,J,2),I=1,3),J= 31, 40) / - : 0.2561079286856D-05, 0.6167224608301D+01, 0.7099330490126D+00, - : 0.1792755796387D-05, 0.1400122509632D+01, 0.7962980379786D+00, - : 0.1818715656502D-05, 0.4703347611830D+01, 0.6283142985870D+01, - : 0.1818744924791D-05, 0.5086748900237D+01, 0.6283008715021D+01, - : 0.1554518791390D-05, 0.5331008042713D-01, 0.2513230340178D+02, - : 0.2063265737239D-05, 0.4283680484178D+01, 0.1179062909082D+02, - : 0.1497613520041D-05, 0.6074207826073D+01, 0.5486777812467D+01, - : 0.2000617940427D-05, 0.2501426281450D+01, 0.1778984560711D+02, - : 0.1289731195580D-05, 0.3646340599536D+01, 0.7079373888424D+01, - : 0.1282657998934D-05, 0.3232864804902D+01, 0.3738761453707D+01 / - DATA ((E0(I,J,2),I=1,3),J= 41, 50) / - : 0.1528915968658D-05, 0.5581433416669D+01, 0.2132990797783D+00, - : 0.1187304098432D-05, 0.5453576453694D+01, 0.9437762937313D+01, - : 0.7842782928118D-06, 0.2823953922273D+00, 0.8827390247185D+01, - : 0.7352892280868D-06, 0.1124369580175D+01, 0.1589072916335D+01, - : 0.6570189360797D-06, 0.2089154042840D+01, 0.1176985366291D+02, - : 0.6324967590410D-06, 0.6704855581230D+00, 0.6262300422539D+01, - : 0.6298289872283D-06, 0.2836414855840D+01, 0.6303851278352D+01, - : 0.6476686465855D-06, 0.4852433866467D+00, 0.7113454667900D-02, - : 0.8587034651234D-06, 0.1453511005668D+01, 0.1672837615881D+03, - : 0.8068948788113D-06, 0.9224087798609D+00, 0.6069776770667D+01 / - DATA ((E0(I,J,2),I=1,3),J= 51, 60) / - : 0.8353786011661D-06, 0.4631707184895D+01, 0.3340612434717D+01, - : 0.6009324532132D-06, 0.1829498827726D+01, 0.4136910472696D+01, - : 0.7558158559566D-06, 0.2588596800317D+01, 0.6496374930224D+01, - : 0.5809279504503D-06, 0.5516818853476D+00, 0.1097707878456D+02, - : 0.5374131950254D-06, 0.6275674734960D+01, 0.1194447056968D+01, - : 0.5711160507326D-06, 0.1091905956872D+01, 0.6282095334605D+01, - : 0.5710183170746D-06, 0.2415001635090D+01, 0.6284056366286D+01, - : 0.5144373590610D-06, 0.6020336443438D+01, 0.6290189305114D+01, - : 0.5103108927267D-06, 0.3775634564605D+01, 0.6275962395778D+01, - : 0.4960654697891D-06, 0.1073450946756D+01, 0.6127655567643D+01 / - DATA ((E0(I,J,2),I=1,3),J= 61, 70) / - : 0.4786385689280D-06, 0.2431178012310D+01, 0.6438496133249D+01, - : 0.6109911263665D-06, 0.5343356157914D+01, 0.3154687086868D+01, - : 0.4839898944024D-06, 0.5830833594047D-01, 0.8018209333619D+00, - : 0.4734822623919D-06, 0.4536080134821D+01, 0.3128388763578D+01, - : 0.4834741473290D-06, 0.2585090489754D+00, 0.7084896783808D+01, - : 0.5134858581156D-06, 0.4213317172603D+01, 0.1235285262111D+02, - : 0.5064004264978D-06, 0.4814418806478D+00, 0.1185621865188D+02, - : 0.3753476772761D-06, 0.1599953399788D+01, 0.8429241228195D+01, - : 0.4935264014283D-06, 0.2157417556873D+01, 0.2544314396739D+01, - : 0.3950929600897D-06, 0.3359394184254D+01, 0.5481254917084D+01 / - DATA ((E0(I,J,2),I=1,3),J= 71, 80) / - : 0.4895849789777D-06, 0.5165704376558D+01, 0.9225539266174D+01, - : 0.4215241688886D-06, 0.2065368800993D+01, 0.1726015463500D+02, - : 0.3796773731132D-06, 0.1468606346612D+01, 0.4265981595566D+00, - : 0.3114178142515D-06, 0.3615638079474D+01, 0.2146165377750D+01, - : 0.3260664220838D-06, 0.4417134922435D+01, 0.4164311961999D+01, - : 0.3976996123008D-06, 0.4700866883004D+01, 0.5856477690889D+01, - : 0.2801459672924D-06, 0.4538902060922D+01, 0.1256967486051D+02, - : 0.3638931868861D-06, 0.1334197991475D+01, 0.1807370494127D+02, - : 0.2487013269476D-06, 0.3749275558275D+01, 0.2629832328990D-01, - : 0.3034165481994D-06, 0.4236622030873D+00, 0.4535059491685D+01 / - DATA ((E0(I,J,2),I=1,3),J= 81, 90) / - : 0.2676278825586D-06, 0.5970848007811D+01, 0.3930209696940D+01, - : 0.2764903818918D-06, 0.5194636754501D+01, 0.1256262854127D+02, - : 0.2485149930507D-06, 0.1002434207846D+01, 0.5088628793478D+01, - : 0.2199305540941D-06, 0.3066773098403D+01, 0.1255903824622D+02, - : 0.2571106500435D-06, 0.7588312459063D+00, 0.1336797263425D+02, - : 0.2049751817158D-06, 0.3444977434856D+01, 0.1137170464392D+02, - : 0.2599707296297D-06, 0.1873128542205D+01, 0.7143069561767D+02, - : 0.1785018072217D-06, 0.5015891306615D+01, 0.1748016358760D+01, - : 0.2324833891115D-06, 0.4618271239730D+01, 0.1831953657923D+02, - : 0.1709711119545D-06, 0.5300003455669D+01, 0.4933208510675D+01 / - DATA ((E0(I,J,2),I=1,3),J= 91,100) / - : 0.2107159351716D-06, 0.2229819815115D+01, 0.7477522907414D+01, - : 0.1750333080295D-06, 0.6161485880008D+01, 0.1044738781244D+02, - : 0.2000598210339D-06, 0.2967357299999D+01, 0.8031092209206D+01, - : 0.1380920248681D-06, 0.3027007923917D+01, 0.8635942003952D+01, - : 0.1412460470299D-06, 0.6037597163798D+01, 0.2942463415728D+01, - : 0.1888459803001D-06, 0.8561476243374D+00, 0.1561374759853D+03, - : 0.1788370542585D-06, 0.4869736290209D+01, 0.1592596075957D+01, - : 0.1360893296167D-06, 0.3626411886436D+01, 0.1309584267300D+02, - : 0.1506846530160D-06, 0.1550975377427D+01, 0.1649636139783D+02, - : 0.1800913376176D-06, 0.2075826033190D+01, 0.1729818233119D+02 / - DATA ((E0(I,J,2),I=1,3),J=101,110) / - : 0.1436261390649D-06, 0.6148876420255D+01, 0.2042657109477D+02, - : 0.1220227114151D-06, 0.4382583879906D+01, 0.7632943190217D+01, - : 0.1337883603592D-06, 0.2036644327361D+01, 0.1213955354133D+02, - : 0.1159326650738D-06, 0.3892276994687D+01, 0.5331357529664D+01, - : 0.1352853128569D-06, 0.1447950649744D+01, 0.1673046366289D+02, - : 0.1433408296083D-06, 0.4457854692961D+01, 0.7342457794669D+01, - : 0.1234701666518D-06, 0.1538818147151D+01, 0.6279485555400D+01, - : 0.1234027192007D-06, 0.1968523220760D+01, 0.6286666145492D+01, - : 0.1244024091797D-06, 0.5779803499985D+01, 0.1511046609763D+02, - : 0.1097934945516D-06, 0.6210975221388D+00, 0.1098880815746D+02 / - DATA ((E0(I,J,2),I=1,3),J=111,120) / - : 0.1254611329856D-06, 0.2591963807998D+01, 0.1572083878776D+02, - : 0.1158247286784D-06, 0.2483612812670D+01, 0.5729506548653D+01, - : 0.9039078252960D-07, 0.3857554579796D+01, 0.9623688285163D+01, - : 0.9108024978836D-07, 0.5826368512984D+01, 0.7234794171227D+01, - : 0.8887068108436D-07, 0.3475694573987D+01, 0.6148010737701D+01, - : 0.8632374035438D-07, 0.3059070488983D-01, 0.6418140963190D+01, - : 0.7893186992967D-07, 0.1583194837728D+01, 0.2118763888447D+01, - : 0.8297650201172D-07, 0.8519770534637D+00, 0.1471231707864D+02, - : 0.1019759578988D-06, 0.1319598738732D+00, 0.1349867339771D+01, - : 0.1010037696236D-06, 0.9937860115618D+00, 0.6836645152238D+01 / - DATA ((E0(I,J,2),I=1,3),J=121,130) / - : 0.1047727548266D-06, 0.1382138405399D+01, 0.5999216516294D+01, - : 0.7351993881086D-07, 0.3833397851735D+01, 0.6040347114260D+01, - : 0.9868771092341D-07, 0.2124913814390D+01, 0.6566935184597D+01, - : 0.7007321959390D-07, 0.5946305343763D+01, 0.6525804586632D+01, - : 0.6861411679709D-07, 0.4574654977089D+01, 0.7238675589263D+01, - : 0.7554519809614D-07, 0.5949232686844D+01, 0.1253985337760D+02, - : 0.9541880448335D-07, 0.3495242990564D+01, 0.2122839202813D+02, - : 0.7185606722155D-07, 0.4310113471661D+01, 0.6245048154254D+01, - : 0.7131360871710D-07, 0.5480309323650D+01, 0.6321103546637D+01, - : 0.6651142021039D-07, 0.5411097713654D+01, 0.5327476111629D+01 / - DATA ((E0(I,J,2),I=1,3),J=131,140) / - : 0.8538618213667D-07, 0.1827849973951D+01, 0.1101510648075D+02, - : 0.8634954288044D-07, 0.5443584943349D+01, 0.5643178611111D+01, - : 0.7449415051484D-07, 0.2011535459060D+01, 0.5368044267797D+00, - : 0.7421047599169D-07, 0.3464562529249D+01, 0.2354323048545D+02, - : 0.6140694354424D-07, 0.5657556228815D+01, 0.1296430071988D+02, - : 0.6353525143033D-07, 0.3463816593821D+01, 0.1990745094947D+01, - : 0.6221964013447D-07, 0.1532259498697D+01, 0.9517183207817D+00, - : 0.5852480257244D-07, 0.1375396598875D+01, 0.9555997388169D+00, - : 0.6398637498911D-07, 0.2405645801972D+01, 0.2407292145756D+02, - : 0.7039744069878D-07, 0.5397541799027D+01, 0.5225775174439D+00 / - DATA ((E0(I,J,2),I=1,3),J=141,150) / - : 0.6977997694382D-07, 0.4762347105419D+01, 0.1097355562493D+02, - : 0.7460629558396D-07, 0.2711944692164D+01, 0.2200391463820D+02, - : 0.5376577536101D-07, 0.2352980430239D+01, 0.1431416805965D+02, - : 0.7530607893556D-07, 0.1943940180699D+01, 0.1842262939178D+02, - : 0.6822928971605D-07, 0.4337651846959D+01, 0.1554202828031D+00, - : 0.6220772380094D-07, 0.6716871369278D+00, 0.1845107853235D+02, - : 0.6586950799043D-07, 0.2229714460505D+01, 0.5216580451554D+01, - : 0.5873800565771D-07, 0.7627013920580D+00, 0.6398972393349D+00, - : 0.6264346929745D-07, 0.6202785478961D+00, 0.6277552955062D+01, - : 0.6257929115669D-07, 0.2886775596668D+01, 0.6288598745829D+01 / - DATA ((E0(I,J,2),I=1,3),J=151,160) / - : 0.5343536033409D-07, 0.1977241012051D+01, 0.4690479774488D+01, - : 0.5587849781714D-07, 0.1922923484825D+01, 0.1551045220144D+01, - : 0.6905100845603D-07, 0.3570757164631D+01, 0.1030928125552D+00, - : 0.6178957066649D-07, 0.5197558947765D+01, 0.5230807360890D+01, - : 0.6187270224331D-07, 0.8193497368922D+00, 0.5650292065779D+01, - : 0.5385664291426D-07, 0.5406336665586D+01, 0.7771377146812D+02, - : 0.6329363917926D-07, 0.2837760654536D+01, 0.2608790314060D+02, - : 0.4546018761604D-07, 0.2933580297050D+01, 0.5535693017924D+00, - : 0.6196091049375D-07, 0.4157871494377D+01, 0.8467247584405D+02, - : 0.6159555108218D-07, 0.3211703561703D+01, 0.2394243902548D+03 / - DATA ((E0(I,J,2),I=1,3),J=161,170) / - : 0.4995340539317D-07, 0.1459098102922D+01, 0.4732030630302D+01, - : 0.5457031243572D-07, 0.1430457676136D+01, 0.6179983037890D+01, - : 0.4863461418397D-07, 0.2196425916730D+01, 0.9027992316901D+02, - : 0.5342947626870D-07, 0.2086612890268D+01, 0.6386168663001D+01, - : 0.5674296648439D-07, 0.2760204966535D+01, 0.6915859635113D+01, - : 0.4745783120161D-07, 0.4245368971862D+01, 0.6282970628506D+01, - : 0.4745676961198D-07, 0.5544725787016D+01, 0.6283181072386D+01, - : 0.4049796869973D-07, 0.2213984363586D+01, 0.6254626709878D+01, - : 0.4248333596940D-07, 0.8075781952896D+00, 0.7875671926403D+01, - : 0.4027178070205D-07, 0.1293268540378D+01, 0.6311524991013D+01 / - DATA ((E0(I,J,2),I=1,3),J=171,180) / - : 0.4066543943476D-07, 0.3986141175804D+01, 0.3634620989887D+01, - : 0.4858863787880D-07, 0.1276112738231D+01, 0.5760498333002D+01, - : 0.5277398263530D-07, 0.4916111741527D+01, 0.2515860172507D+02, - : 0.4105635656559D-07, 0.1725805864426D+01, 0.6709674010002D+01, - : 0.4376781925772D-07, 0.2243642442106D+01, 0.6805653367890D+01, - : 0.3235827894693D-07, 0.3614135118271D+01, 0.1066495398892D+01, - : 0.3073244740308D-07, 0.2460873393460D+01, 0.5863591145557D+01, - : 0.3088609271373D-07, 0.5678431771790D+01, 0.9917696840332D+01, - : 0.3393022279836D-07, 0.3814017477291D+01, 0.1391601904066D+02, - : 0.3038686508802D-07, 0.4660216229171D+01, 0.1256621883632D+02 / - DATA ((E0(I,J,2),I=1,3),J=181,190) / - : 0.4019677752497D-07, 0.5906906243735D+01, 0.1334167431096D+02, - : 0.3288834998232D-07, 0.9536146445882D+00, 0.1620077269078D+02, - : 0.3889973794631D-07, 0.3942205097644D+01, 0.7478166569050D-01, - : 0.3050438987141D-07, 0.1624810271286D+01, 0.1805292951336D+02, - : 0.3601142564638D-07, 0.4030467142575D+01, 0.6208294184755D+01, - : 0.3689015557141D-07, 0.3648878818694D+01, 0.5966683958112D+01, - : 0.3563471893565D-07, 0.5749584017096D+01, 0.6357857516136D+01, - : 0.2776183170667D-07, 0.2630124187070D+01, 0.3523159621801D-02, - : 0.2922350530341D-07, 0.1790346403629D+01, 0.1272157198369D+02, - : 0.3511076917302D-07, 0.6142198301611D+01, 0.6599467742779D+01 / - DATA ((E0(I,J,2),I=1,3),J=191,200) / - : 0.3619351007632D-07, 0.1432421386492D+01, 0.6019991944201D+01, - : 0.2561254711098D-07, 0.2302822475792D+01, 0.1259245002418D+02, - : 0.2626903942920D-07, 0.8660470994571D+00, 0.6702560555334D+01, - : 0.2550187397083D-07, 0.6069721995383D+01, 0.1057540660594D+02, - : 0.2535873526138D-07, 0.1079020331795D-01, 0.3141537925223D+02, - : 0.3519786153847D-07, 0.3809066902283D+01, 0.2505706758577D+03, - : 0.3424651492873D-07, 0.2075435114417D+01, 0.6546159756691D+01, - : 0.2372676630861D-07, 0.2057803120154D+01, 0.2388894113936D+01, - : 0.2710980779541D-07, 0.1510068488010D+01, 0.1202934727411D+02, - : 0.3038710889704D-07, 0.5043617528901D+01, 0.1256608456547D+02 / - DATA ((E0(I,J,2),I=1,3),J=201,210) / - : 0.2220364130585D-07, 0.3694793218205D+01, 0.1336244973887D+02, - : 0.3025880825460D-07, 0.5450618999049D-01, 0.2908881142201D+02, - : 0.2784493486864D-07, 0.3381164084502D+01, 0.1494531617769D+02, - : 0.2294414142438D-07, 0.4382309025210D+01, 0.6076890225335D+01, - : 0.2012723294724D-07, 0.9142212256518D+00, 0.6262720680387D+01, - : 0.2036357831958D-07, 0.5676172293154D+01, 0.4701116388778D+01, - : 0.2003474823288D-07, 0.2592767977625D+01, 0.6303431020504D+01, - : 0.2207144900109D-07, 0.5404976271180D+01, 0.6489261475556D+01, - : 0.2481664905135D-07, 0.4373284587027D+01, 0.1204357418345D+02, - : 0.2674949182295D-07, 0.5859182188482D+01, 0.4590910121555D+01 / - DATA ((E0(I,J,2),I=1,3),J=211,220) / - : 0.2450554720322D-07, 0.4555381557451D+01, 0.1495633313810D+00, - : 0.2601975986457D-07, 0.3933165584959D+01, 0.1965104848470D+02, - : 0.2199860022848D-07, 0.5227977189087D+01, 0.1351787002167D+02, - : 0.2448121172316D-07, 0.4858060353949D+01, 0.1162474756779D+01, - : 0.1876014864049D-07, 0.5690546553605D+01, 0.6279194432410D+01, - : 0.1874513219396D-07, 0.4099539297446D+01, 0.6286957268481D+01, - : 0.2156380842559D-07, 0.4382594769913D+00, 0.1813929450232D+02, - : 0.1981691240061D-07, 0.1829784152444D+01, 0.4686889479442D+01, - : 0.2329992648539D-07, 0.2836254278973D+01, 0.1002183730415D+02, - : 0.1765184135302D-07, 0.2803494925833D+01, 0.4292330755499D+01 / - DATA ((E0(I,J,2),I=1,3),J=221,230) / - : 0.2436368366085D-07, 0.2836897959677D+01, 0.9514313292143D+02, - : 0.2164089203889D-07, 0.6127522446024D+01, 0.6037244212485D+01, - : 0.1847755034221D-07, 0.3683163635008D+01, 0.2427287361862D+00, - : 0.1674798769966D-07, 0.3316993867246D+00, 0.1311972100268D+02, - : 0.2222542124356D-07, 0.8294097805480D+00, 0.1266924451345D+02, - : 0.2071074505925D-07, 0.3659492220261D+01, 0.6528907488406D+01, - : 0.1608224471835D-07, 0.4774492067182D+01, 0.1352175143971D+02, - : 0.1857583439071D-07, 0.2873120597682D+01, 0.8662240327241D+01, - : 0.1793018836159D-07, 0.5282441177929D+00, 0.6819880277225D+01, - : 0.1575391221692D-07, 0.1320789654258D+01, 0.1102062672231D+00 / - DATA ((E0(I,J,2),I=1,3),J=231,240) / - : 0.1840132009557D-07, 0.1917110916256D+01, 0.6514761976723D+02, - : 0.1760917288281D-07, 0.2972635937132D+01, 0.5746271423666D+01, - : 0.1561779518516D-07, 0.4372569261981D+01, 0.6272439236156D+01, - : 0.1558687885205D-07, 0.5416424926425D+01, 0.6293712464735D+01, - : 0.1951359382579D-07, 0.3094448898752D+01, 0.2301353951334D+02, - : 0.1569144275614D-07, 0.2802103689808D+01, 0.1765478049437D+02, - : 0.1479130389462D-07, 0.2136435020467D+01, 0.2077542790660D-01, - : 0.1467828510764D-07, 0.7072627435674D+00, 0.1052268489556D+01, - : 0.1627627337440D-07, 0.3947607143237D+01, 0.6327837846670D+00, - : 0.1503498479758D-07, 0.4079248909190D+01, 0.7626583626240D-01 / - DATA ((E0(I,J,2),I=1,3),J=241,250) / - : 0.1297967708237D-07, 0.6269637122840D+01, 0.1149965630200D+02, - : 0.1374416896634D-07, 0.4175657970702D+01, 0.6016468784579D+01, - : 0.1783812325219D-07, 0.1476540547560D+01, 0.3301902111895D+02, - : 0.1525884228756D-07, 0.4653477715241D+01, 0.9411464614024D+01, - : 0.1451067396763D-07, 0.2573001128225D+01, 0.1277945078067D+02, - : 0.1297713111950D-07, 0.5612799618771D+01, 0.6549682916313D+01, - : 0.1462784012820D-07, 0.4189661623870D+01, 0.1863592847156D+02, - : 0.1384185980007D-07, 0.2656915472196D+01, 0.2379164476796D+01, - : 0.1221497599801D-07, 0.5612515760138D+01, 0.1257326515556D+02, - : 0.1560574525896D-07, 0.4783414317919D+01, 0.1887552587463D+02 / - DATA ((E0(I,J,2),I=1,3),J=251,260) / - : 0.1544598372036D-07, 0.2694431138063D+01, 0.1820933031200D+02, - : 0.1531678928696D-07, 0.4105103489666D+01, 0.2593412433514D+02, - : 0.1349321503795D-07, 0.3082437194015D+00, 0.5120601093667D+01, - : 0.1252030290917D-07, 0.6124072334087D+01, 0.6993008899458D+01, - : 0.1459243816687D-07, 0.3733103981697D+01, 0.3813291813120D-01, - : 0.1226103625262D-07, 0.1267127706817D+01, 0.2435678079171D+02, - : 0.1019449641504D-07, 0.4367790112269D+01, 0.1725663147538D+02, - : 0.1380789433607D-07, 0.3387201768700D+01, 0.2458316379602D+00, - : 0.1019453421658D-07, 0.9204143073737D+00, 0.6112403035119D+01, - : 0.1297929434405D-07, 0.5786874896426D+01, 0.1249137003520D+02 / - DATA ((E0(I,J,2),I=1,3),J=261,270) / - : 0.9912677786097D-08, 0.3164232870746D+01, 0.6247047890016D+01, - : 0.9829386098599D-08, 0.2586762413351D+01, 0.6453748665772D+01, - : 0.1226807746104D-07, 0.6239068436607D+01, 0.5429879531333D+01, - : 0.1192691755997D-07, 0.1867380051424D+01, 0.6290122169689D+01, - : 0.9836499227081D-08, 0.3424716293727D+00, 0.6319103810876D+01, - : 0.9642862564285D-08, 0.5661372990657D+01, 0.8273820945392D+01, - : 0.1165184404862D-07, 0.5768367239093D+01, 0.1778273215245D+02, - : 0.1175794418818D-07, 0.1657351222943D+01, 0.6276029531202D+01, - : 0.1018948635601D-07, 0.6458292350865D+00, 0.1254537627298D+02, - : 0.9500383606676D-08, 0.1054306140741D+01, 0.1256517118505D+02 / - DATA ((E0(I,J,2),I=1,3),J=271,280) / - : 0.1227512202906D-07, 0.2505278379114D+01, 0.2248384854122D+02, - : 0.9664792009993D-08, 0.4289737277000D+01, 0.6259197520765D+01, - : 0.9613285666331D-08, 0.5500597673141D+01, 0.6306954180126D+01, - : 0.1117906736211D-07, 0.2361405953468D+01, 0.1779695906178D+02, - : 0.9611378640782D-08, 0.2851310576269D+01, 0.2061856251104D+00, - : 0.8845354852370D-08, 0.6208777705343D+01, 0.1692165728891D+01, - : 0.1054046966600D-07, 0.5413091423934D+01, 0.2204125344462D+00, - : 0.1215539124483D-07, 0.5613969479755D+01, 0.8257698122054D+02, - : 0.9932460955209D-08, 0.1106124877015D+01, 0.1017725758696D+02, - : 0.8785804715043D-08, 0.2869224476477D+01, 0.9491756770005D+00 / - DATA ((E0(I,J,2),I=1,3),J=281,290) / - : 0.8538084097562D-08, 0.6159640899344D+01, 0.6393282117669D+01, - : 0.8648994369529D-08, 0.1374901198784D+01, 0.4804209201333D+01, - : 0.1039063219067D-07, 0.5171080641327D+01, 0.1550861511662D+02, - : 0.8867983926439D-08, 0.8317320304902D+00, 0.3903911373650D+01, - : 0.8327495955244D-08, 0.3605591969180D+01, 0.6172869583223D+01, - : 0.9243088356133D-08, 0.6114299196843D+01, 0.6267823317922D+01, - : 0.9205657357835D-08, 0.3675153683737D+01, 0.6298328382969D+01, - : 0.1033269714606D-07, 0.3313328813024D+01, 0.5573142801433D+01, - : 0.8001706275552D-08, 0.2019980960053D+01, 0.2648454860559D+01, - : 0.9171858254191D-08, 0.8992015524177D+00, 0.1498544001348D+03 / - DATA ((E0(I,J,2),I=1,3),J=291,300) / - : 0.1075327150242D-07, 0.2898669963648D+01, 0.3694923081589D+02, - : 0.9884866689828D-08, 0.4946715904478D+01, 0.1140367694411D+02, - : 0.9541835576677D-08, 0.2371787888469D+01, 0.1256713221673D+02, - : 0.7739903376237D-08, 0.2213775190612D+01, 0.7834121070590D+01, - : 0.7311962684106D-08, 0.3429378787739D+01, 0.1192625446156D+02, - : 0.9724904869624D-08, 0.6195878564404D+01, 0.2280573557157D+02, - : 0.9251628983612D-08, 0.6511509527390D+00, 0.2787043132925D+01, - : 0.7320763787842D-08, 0.6001083639421D+01, 0.6282655592598D+01, - : 0.7320296650962D-08, 0.3789073265087D+01, 0.6283496108294D+01, - : 0.7947032271039D-08, 0.1059659582204D+01, 0.1241073141809D+02 / - DATA ((E0(I,J,2),I=1,3),J=301,310) / - : 0.9005277053115D-08, 0.1280315624361D+01, 0.6281591679874D+01, - : 0.8995601652048D-08, 0.2224439106766D+01, 0.6284560021018D+01, - : 0.8288040568796D-08, 0.5234914433867D+01, 0.1241658836951D+02, - : 0.6359381347255D-08, 0.4137989441490D+01, 0.1596186371003D+01, - : 0.8699572228626D-08, 0.1758411009497D+01, 0.6133512519065D+01, - : 0.6456797542736D-08, 0.5919285089994D+01, 0.1685848245639D+02, - : 0.7424573475452D-08, 0.5414616938827D+01, 0.4061219149443D+01, - : 0.7235671196168D-08, 0.1496516557134D+01, 0.1610006857377D+03, - : 0.8104015182733D-08, 0.1919918242764D+01, 0.8460828644453D+00, - : 0.8098576535937D-08, 0.3819615855458D+01, 0.3894181736510D+01 / - DATA ((E0(I,J,2),I=1,3),J=311,320) / - : 0.6275292346625D-08, 0.6244264115141D+01, 0.8531963191132D+00, - : 0.6052432989112D-08, 0.5037731872610D+00, 0.1567108171867D+02, - : 0.5705651535817D-08, 0.2984557271995D+01, 0.1258692712880D+02, - : 0.5789650115138D-08, 0.6087038140697D+01, 0.1193336791622D+02, - : 0.5512132153377D-08, 0.5855668994076D+01, 0.1232342296471D+02, - : 0.7388890819102D-08, 0.2443128574740D+01, 0.4907302013889D+01, - : 0.5467593991798D-08, 0.3017561234194D+01, 0.1884211409667D+02, - : 0.6388519802999D-08, 0.5887386712935D+01, 0.5217580628120D+02, - : 0.6106777149944D-08, 0.3483461059895D+00, 0.1422690933580D-01, - : 0.7383420275489D-08, 0.5417387056707D+01, 0.2358125818164D+02 / - DATA ((E0(I,J,2),I=1,3),J=321,330) / - : 0.5505208141738D-08, 0.2848193644783D+01, 0.1151388321134D+02, - : 0.6310757462877D-08, 0.2349882520828D+01, 0.1041998632314D+02, - : 0.6166904929691D-08, 0.5728575944077D+00, 0.6151533897323D+01, - : 0.5263442042754D-08, 0.4495796125937D+01, 0.1885275071096D+02, - : 0.5591828082629D-08, 0.1355441967677D+01, 0.4337116142245D+00, - : 0.5397051680497D-08, 0.1673422864307D+01, 0.6286362197481D+01, - : 0.5396992745159D-08, 0.1833502206373D+01, 0.6279789503410D+01, - : 0.6572913000726D-08, 0.3331122065824D+01, 0.1176433076753D+02, - : 0.5123421866413D-08, 0.2165327142679D+01, 0.1245594543367D+02, - : 0.5930495725999D-08, 0.2931146089284D+01, 0.6414617803568D+01 / - DATA ((E0(I,J,2),I=1,3),J=331,340) / - : 0.6431797403933D-08, 0.4134407994088D+01, 0.1350651127443D+00, - : 0.5003182207604D-08, 0.3805420303749D+01, 0.1096996532989D+02, - : 0.5587731032504D-08, 0.1082469260599D+01, 0.6062663316000D+01, - : 0.5935263407816D-08, 0.8384333678401D+00, 0.5326786718777D+01, - : 0.4756019827760D-08, 0.3552588749309D+01, 0.3104930017775D+01, - : 0.6599951172637D-08, 0.4320826409528D+01, 0.4087944051283D+02, - : 0.5902606868464D-08, 0.4811879454445D+01, 0.5849364236221D+01, - : 0.5921147809031D-08, 0.9942628922396D-01, 0.1581959461667D+01, - : 0.5505382581266D-08, 0.2466557607764D+01, 0.6503488384892D+01, - : 0.5353771071862D-08, 0.4551978748683D+01, 0.1735668374386D+03 / - DATA ((E0(I,J,2),I=1,3),J=341,350) / - : 0.5063282210946D-08, 0.5710812312425D+01, 0.1248988586463D+02, - : 0.5926120403383D-08, 0.1333998428358D+01, 0.2673594526851D+02, - : 0.5211016176149D-08, 0.4649315360760D+01, 0.2460261242967D+02, - : 0.5347075084894D-08, 0.5512754081205D+01, 0.4171425416666D+01, - : 0.4872609773574D-08, 0.1308025299938D+01, 0.5333900173445D+01, - : 0.4727711321420D-08, 0.2144908368062D+01, 0.7232251527446D+01, - : 0.6029426018652D-08, 0.5567259412084D+01, 0.3227113045244D+03, - : 0.4321485284369D-08, 0.5230667156451D+01, 0.9388005868221D+01, - : 0.4476406760553D-08, 0.6134081115303D+01, 0.5547199253223D+01, - : 0.5835268277420D-08, 0.4783808492071D+01, 0.7285056171570D+02 / - DATA ((E0(I,J,2),I=1,3),J=351,360) / - : 0.5172183602748D-08, 0.5161817911099D+01, 0.1884570439172D+02, - : 0.5693571465184D-08, 0.1381646203111D+01, 0.9723862754494D+02, - : 0.4060634965349D-08, 0.3876705259495D+00, 0.4274518229222D+01, - : 0.3967398770473D-08, 0.5029491776223D+01, 0.3496032717521D+01, - : 0.3943754005255D-08, 0.1923162955490D+01, 0.6244942932314D+01, - : 0.4781323427824D-08, 0.4633332586423D+01, 0.2929661536378D+02, - : 0.3871483781204D-08, 0.1616650009743D+01, 0.6321208768577D+01, - : 0.5141741733997D-08, 0.9817316704659D-01, 0.1232032006293D+02, - : 0.4002385978497D-08, 0.3656161212139D+01, 0.7018952447668D+01, - : 0.4901092604097D-08, 0.4404098713092D+01, 0.1478866649112D+01 / - DATA ((E0(I,J,2),I=1,3),J=361,370) / - : 0.3740932630345D-08, 0.5181188732639D+00, 0.6922973089781D+01, - : 0.4387283718538D-08, 0.3254859566869D+01, 0.2331413144044D+03, - : 0.5019197802033D-08, 0.3086773224677D+01, 0.1715706182245D+02, - : 0.3834931695175D-08, 0.2797882673542D+01, 0.1491901785440D+02, - : 0.3760413942497D-08, 0.2892676280217D+01, 0.1726726808967D+02, - : 0.3719717204628D-08, 0.5861046025739D+01, 0.6297302759782D+01, - : 0.4145623530149D-08, 0.2168239627033D+01, 0.1376059875786D+02, - : 0.3932788425380D-08, 0.6271811124181D+01, 0.7872148766781D+01, - : 0.3686377476857D-08, 0.3936853151404D+01, 0.6268848941110D+01, - : 0.3779077950339D-08, 0.1404148734043D+01, 0.4157198507331D+01 / - DATA ((E0(I,J,2),I=1,3),J=371,380) / - : 0.4091334550598D-08, 0.2452436180854D+01, 0.9779108567966D+01, - : 0.3926694536146D-08, 0.6102292739040D+01, 0.1098419223922D+02, - : 0.4841000253289D-08, 0.6072760457276D+01, 0.1252801878276D+02, - : 0.4949340130240D-08, 0.1154832815171D+01, 0.1617106187867D+03, - : 0.3761557737360D-08, 0.5527545321897D+01, 0.3185192151914D+01, - : 0.3647396268188D-08, 0.1525035688629D+01, 0.6271346477544D+01, - : 0.3932405074189D-08, 0.5570681040569D+01, 0.2139354194808D+02, - : 0.3631322501141D-08, 0.1981240601160D+01, 0.6294805223347D+01, - : 0.4130007425139D-08, 0.2050060880201D+01, 0.2195415756911D+02, - : 0.4433905965176D-08, 0.3277477970321D+01, 0.7445550607224D+01 / - DATA ((E0(I,J,2),I=1,3),J=381,390) / - : 0.3851814176947D-08, 0.5210690074886D+01, 0.9562891316684D+00, - : 0.3485807052785D-08, 0.6653274904611D+00, 0.1161697602389D+02, - : 0.3979772816991D-08, 0.1767941436148D+01, 0.2277943724828D+02, - : 0.3402607460500D-08, 0.3421746306465D+01, 0.1087398597200D+02, - : 0.4049993000926D-08, 0.1127144787547D+01, 0.3163918923335D+00, - : 0.3420511182382D-08, 0.4214794779161D+01, 0.1362553364512D+02, - : 0.3640772365012D-08, 0.5324905497687D+01, 0.1725304118033D+02, - : 0.3323037987501D-08, 0.6135761838271D+01, 0.6279143387820D+01, - : 0.4503141663637D-08, 0.1802305450666D+01, 0.1385561574497D+01, - : 0.4314560055588D-08, 0.4812299731574D+01, 0.4176041334900D+01 / - DATA ((E0(I,J,2),I=1,3),J=391,400) / - : 0.3294226949110D-08, 0.3657547059723D+01, 0.6287008313071D+01, - : 0.3215657197281D-08, 0.4866676894425D+01, 0.5749861718712D+01, - : 0.4129362656266D-08, 0.3809342558906D+01, 0.5905702259363D+01, - : 0.3137762976388D-08, 0.2494635174443D+01, 0.2099539292909D+02, - : 0.3514010952384D-08, 0.2699961831678D+01, 0.7335344340001D+01, - : 0.3327607571530D-08, 0.3318457714816D+01, 0.5436992986000D+01, - : 0.3541066946675D-08, 0.4382703582466D+01, 0.1234573916645D+02, - : 0.3216179847052D-08, 0.5271066317054D+01, 0.3802769619140D-01, - : 0.2959045059570D-08, 0.5819591585302D+01, 0.2670964694522D+02, - : 0.3884040326665D-08, 0.5980934960428D+01, 0.6660449441528D+01 / - DATA ((E0(I,J,2),I=1,3),J=401,410) / - : 0.2922027539886D-08, 0.3337290282483D+01, 0.1375773836557D+01, - : 0.4110846382042D-08, 0.5742978187327D+01, 0.4480965020977D+02, - : 0.2934508411032D-08, 0.2278075804200D+01, 0.6408777551755D+00, - : 0.3966896193000D-08, 0.5835747858477D+01, 0.3773735910827D+00, - : 0.3286695827610D-08, 0.5838898193902D+01, 0.3932462625300D-02, - : 0.3720643094196D-08, 0.1122212337858D+01, 0.1646033343740D+02, - : 0.3285508906174D-08, 0.9182250996416D+00, 0.1081813534213D+02, - : 0.3753880575973D-08, 0.5174761973266D+01, 0.5642198095270D+01, - : 0.3022129385587D-08, 0.3381611020639D+01, 0.2982630633589D+02, - : 0.2798569205621D-08, 0.3546193723922D+01, 0.1937891852345D+02 / - DATA ((E0(I,J,2),I=1,3),J=411,420) / - : 0.3397872070505D-08, 0.4533203197934D+01, 0.6923953605621D+01, - : 0.3708099772977D-08, 0.2756168198616D+01, 0.3066615496545D+02, - : 0.3599283541510D-08, 0.1934395469918D+01, 0.6147450479709D+01, - : 0.3688702753059D-08, 0.7149920971109D+00, 0.2636725487657D+01, - : 0.2681084724003D-08, 0.4899819493154D+01, 0.6816289982179D+01, - : 0.3495993460759D-08, 0.1572418915115D+01, 0.6418701221183D+01, - : 0.3130770324995D-08, 0.8912190180489D+00, 0.1235996607578D+02, - : 0.2744353821941D-08, 0.3800821940055D+01, 0.2059724391010D+02, - : 0.2842732906341D-08, 0.2644717440029D+01, 0.2828699048865D+02, - : 0.3046882682154D-08, 0.3987793020179D+01, 0.6055599646783D+01 / - DATA ((E0(I,J,2),I=1,3),J=421,430) / - : 0.2399072455143D-08, 0.9908826440764D+00, 0.6255674361143D+01, - : 0.2384306274204D-08, 0.2516149752220D+01, 0.6310477339748D+01, - : 0.2977324500559D-08, 0.5849195642118D+01, 0.1652265972112D+02, - : 0.3062835258972D-08, 0.1681660100162D+01, 0.1172006883645D+02, - : 0.3109682589231D-08, 0.5804143987737D+00, 0.2751146787858D+02, - : 0.2903920355299D-08, 0.5800768280123D+01, 0.6510552054109D+01, - : 0.2823221989212D-08, 0.9241118370216D+00, 0.5469525544182D+01, - : 0.3187949696649D-08, 0.3139776445735D+01, 0.1693792562116D+03, - : 0.2922559771655D-08, 0.3549440782984D+01, 0.2630839062450D+00, - : 0.2436302066603D-08, 0.4735540696319D+01, 0.3946258593675D+00 / - DATA ((E0(I,J,2),I=1,3),J=431,440) / - : 0.3049473043606D-08, 0.4998289124561D+01, 0.8390110365991D+01, - : 0.2863682575784D-08, 0.6709515671102D+00, 0.2243449970715D+00, - : 0.2641750517966D-08, 0.5410978257284D+01, 0.2986433403208D+02, - : 0.2704093466243D-08, 0.4778317207821D+01, 0.6129297044991D+01, - : 0.2445522177011D-08, 0.6009020662222D+01, 0.1171295538178D+02, - : 0.2623608810230D-08, 0.5010449777147D+01, 0.6436854655901D+01, - : 0.2079259704053D-08, 0.5980943768809D+01, 0.2019909489111D+02, - : 0.2820225596771D-08, 0.2679965110468D+01, 0.5934151399930D+01, - : 0.2365221950927D-08, 0.1894231148810D+01, 0.2470570524223D+02, - : 0.2359682077149D-08, 0.4220752950780D+01, 0.8671969964381D+01 / - DATA ((E0(I,J,2),I=1,3),J=441,450) / - : 0.2387577137206D-08, 0.2571783940617D+01, 0.7096626156709D+01, - : 0.1982102089816D-08, 0.5169765997119D+00, 0.1727188400790D+02, - : 0.2687502389925D-08, 0.6239078264579D+01, 0.7075506709219D+02, - : 0.2207751669135D-08, 0.2031184412677D+01, 0.4377611041777D+01, - : 0.2618370214274D-08, 0.8266079985979D+00, 0.6632000300961D+01, - : 0.2591951887361D-08, 0.8819350522008D+00, 0.4873985990671D+02, - : 0.2375055656248D-08, 0.3520944177789D+01, 0.1590676413561D+02, - : 0.2472019978911D-08, 0.1551431908671D+01, 0.6612329252343D+00, - : 0.2368157127199D-08, 0.4178610147412D+01, 0.3459636466239D+02, - : 0.1764846605693D-08, 0.1506764000157D+01, 0.1980094587212D+02 / - DATA ((E0(I,J,2),I=1,3),J=451,460) / - : 0.2291769608798D-08, 0.2118250611782D+01, 0.2844914056730D-01, - : 0.2209997316943D-08, 0.3363255261678D+01, 0.2666070658668D+00, - : 0.2292699097923D-08, 0.4200423956460D+00, 0.1484170571900D-02, - : 0.1629683015329D-08, 0.2331362582487D+01, 0.3035599730800D+02, - : 0.2206492862426D-08, 0.3400274026992D+01, 0.6281667977667D+01, - : 0.2205746568257D-08, 0.1066051230724D+00, 0.6284483723224D+01, - : 0.2026310767991D-08, 0.2779066487979D+01, 0.2449240616245D+02, - : 0.1762977622163D-08, 0.9951450691840D+00, 0.2045286941806D+02, - : 0.1368535049606D-08, 0.6402447365817D+00, 0.2473415438279D+02, - : 0.1720598775450D-08, 0.2303524214705D+00, 0.1679593901136D+03 / - DATA ((E0(I,J,2),I=1,3),J=461,470) / - : 0.1702429015449D-08, 0.6164622655048D+01, 0.3338575901272D+03, - : 0.1414033197685D-08, 0.3954561185580D+01, 0.1624205518357D+03, - : 0.1573768958043D-08, 0.2028286308984D+01, 0.3144167757552D+02, - : 0.1650705184447D-08, 0.2304040666128D+01, 0.5267006960365D+02, - : 0.1651087618855D-08, 0.2538461057280D+01, 0.8956999012000D+02, - : 0.1616409518983D-08, 0.5111054348152D+01, 0.3332657872986D+02, - : 0.1537175173581D-08, 0.5601130666603D+01, 0.3852657435933D+02, - : 0.1593191980553D-08, 0.2614340453411D+01, 0.2282781046519D+03, - : 0.1499480170643D-08, 0.3624721577264D+01, 0.2823723341956D+02, - : 0.1493807843235D-08, 0.4214569879008D+01, 0.2876692439167D+02 / - DATA ((E0(I,J,2),I=1,3),J=471,480) / - : 0.1074571199328D-08, 0.1496911744704D+00, 0.8397383534231D+02, - : 0.1074406983417D-08, 0.1187817671922D+01, 0.8401985929482D+02, - : 0.9757576855851D-09, 0.2655703035858D+01, 0.7826370942180D+02, - : 0.1258432887565D-08, 0.4969896184844D+01, 0.3115650189215D+03, - : 0.1240336343282D-08, 0.5192460776926D+01, 0.1784300471910D+03, - : 0.9016107005164D-09, 0.1960356923057D+01, 0.5886454391678D+02, - : 0.1135392360918D-08, 0.5082427809068D+01, 0.7842370451713D+02, - : 0.9216046089565D-09, 0.2793775037273D+01, 0.1014262087719D+03, - : 0.1061276615030D-08, 0.3726144311409D+01, 0.5660027930059D+02, - : 0.1010110596263D-08, 0.7404080708937D+00, 0.4245678405627D+02 / - DATA ((E0(I,J,2),I=1,3),J=481,490) / - : 0.7217424756199D-09, 0.2697449980577D-01, 0.2457074661053D+03, - : 0.6912003846756D-09, 0.4253296276335D+01, 0.1679936946371D+03, - : 0.6871814664847D-09, 0.5148072412354D+01, 0.6053048899753D+02, - : 0.4887158016343D-09, 0.2153581148294D+01, 0.9656299901946D+02, - : 0.5161802866314D-09, 0.3852750634351D+01, 0.2442876000072D+03, - : 0.5652599559057D-09, 0.1233233356270D+01, 0.8365903305582D+02, - : 0.4710812608586D-09, 0.5610486976767D+01, 0.3164282286739D+03, - : 0.4909977500324D-09, 0.1639629524123D+01, 0.4059982187939D+03, - : 0.4772641839378D-09, 0.3737100368583D+01, 0.1805255418145D+03, - : 0.4487562567153D-09, 0.1158417054478D+00, 0.8433466158131D+02 / - DATA ((E0(I,J,2),I=1,3),J=491,500) / - : 0.3943441230497D-09, 0.6243502862796D+00, 0.2568537517081D+03, - : 0.3952236913598D-09, 0.3510377382385D+01, 0.2449975330562D+03, - : 0.3788898363417D-09, 0.5916128302299D+01, 0.1568131045107D+03, - : 0.3738329328831D-09, 0.1042266763456D+01, 0.3948519331910D+03, - : 0.2451199165151D-09, 0.1166788435700D+01, 0.1435713242844D+03, - : 0.2436734402904D-09, 0.3254726114901D+01, 0.2268582385539D+03, - : 0.2213605274325D-09, 0.1687210598530D+01, 0.1658638954901D+03, - : 0.1491521204829D-09, 0.2657541786794D+01, 0.2219950288015D+03, - : 0.1474995329744D-09, 0.5013089805819D+01, 0.3052819430710D+03, - : 0.1661939475656D-09, 0.5495315428418D+01, 0.2526661704812D+03 / - DATA ((E0(I,J,2),I=1,3),J=501,NE0Y) / - : 0.9015946748003D-10, 0.2236989966505D+01, 0.4171445043968D+03 / - -* Sun-to-Earth, T^1, Y - DATA ((E1(I,J,2),I=1,3),J= 1, 10) / - : 0.9304690546528D-06, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.5150715570663D-06, 0.4431807116294D+01, 0.1256615170089D+02, - : 0.1290825411056D-07, 0.4388610039678D+01, 0.1884922755134D+02, - : 0.4645466665386D-08, 0.5827263376034D+01, 0.6283075850446D+01, - : 0.2079625310718D-08, 0.1621698662282D+00, 0.6279552690824D+01, - : 0.2078189850907D-08, 0.3344713435140D+01, 0.6286599010068D+01, - : 0.6207190138027D-09, 0.5074049319576D+01, 0.4705732307012D+01, - : 0.5989826532569D-09, 0.2231842216620D+01, 0.6256777527156D+01, - : 0.5961360812618D-09, 0.1274975769045D+01, 0.6309374173736D+01, - : 0.4874165471016D-09, 0.3642277426779D+01, 0.7755226100720D+00 / - DATA ((E1(I,J,2),I=1,3),J= 11, 20) / - : 0.4283834034360D-09, 0.5148765510106D+01, 0.1059381944224D+01, - : 0.4652389287529D-09, 0.4715794792175D+01, 0.7860419393880D+01, - : 0.3751707476401D-09, 0.6617207370325D+00, 0.5753384878334D+01, - : 0.3559998806198D-09, 0.6155548875404D+01, 0.5884926831456D+01, - : 0.3558447558857D-09, 0.2898827297664D+01, 0.6812766822558D+01, - : 0.3211116927106D-09, 0.3625813502509D+01, 0.6681224869435D+01, - : 0.2875609914672D-09, 0.4345435813134D+01, 0.2513230340178D+02, - : 0.2843109704069D-09, 0.5862263940038D+01, 0.6127655567643D+01, - : 0.2744676468427D-09, 0.3926419475089D+01, 0.6438496133249D+01, - : 0.2481285237789D-09, 0.1351976572828D+01, 0.5486777812467D+01 / - DATA ((E1(I,J,2),I=1,3),J= 21, 30) / - : 0.2060338481033D-09, 0.2147556998591D+01, 0.7079373888424D+01, - : 0.2015822358331D-09, 0.4408358972216D+01, 0.6290189305114D+01, - : 0.2001195944195D-09, 0.5385829822531D+01, 0.6275962395778D+01, - : 0.1953667642377D-09, 0.1304933746120D+01, 0.5507553240374D+01, - : 0.1839744078713D-09, 0.6173567228835D+01, 0.1179062909082D+02, - : 0.1643334294845D-09, 0.4635942997523D+01, 0.1150676975667D+02, - : 0.1768051018652D-09, 0.5086283558874D+01, 0.7113454667900D-02, - : 0.1674874205489D-09, 0.2243332137241D+01, 0.7058598460518D+01, - : 0.1421445397609D-09, 0.6186899771515D+01, 0.7962980379786D+00, - : 0.1255163958267D-09, 0.5730238465658D+01, 0.4694002934110D+01 / - DATA ((E1(I,J,2),I=1,3),J= 31, 40) / - : 0.1013945281961D-09, 0.1726055228402D+01, 0.3738761453707D+01, - : 0.1047294335852D-09, 0.2658801228129D+01, 0.6282095334605D+01, - : 0.1047103879392D-09, 0.8481047835035D+00, 0.6284056366286D+01, - : 0.9530343962826D-10, 0.3079267149859D+01, 0.6069776770667D+01, - : 0.9604637611690D-10, 0.3258679792918D+00, 0.4136910472696D+01, - : 0.9153518537177D-10, 0.4398599886584D+00, 0.6496374930224D+01, - : 0.8562458214922D-10, 0.4772686794145D+01, 0.1194447056968D+01, - : 0.8232525360654D-10, 0.5966220721679D+01, 0.1589072916335D+01, - : 0.6150223411438D-10, 0.1780985591923D+01, 0.8827390247185D+01, - : 0.6272087858000D-10, 0.3184305429012D+01, 0.8429241228195D+01 / - DATA ((E1(I,J,2),I=1,3),J= 41, 50) / - : 0.5540476311040D-10, 0.3801260595433D+01, 0.4933208510675D+01, - : 0.7331901699361D-10, 0.5205948591865D+01, 0.4535059491685D+01, - : 0.6018528702791D-10, 0.4770139083623D+01, 0.1255903824622D+02, - : 0.5150530724804D-10, 0.3574796899585D+01, 0.1176985366291D+02, - : 0.6471933741811D-10, 0.2679787266521D+01, 0.5088628793478D+01, - : 0.5317460644174D-10, 0.9528763345494D+00, 0.3154687086868D+01, - : 0.4832187748783D-10, 0.5329322498232D+01, 0.6040347114260D+01, - : 0.4716763555110D-10, 0.2395235316466D+01, 0.5331357529664D+01, - : 0.4871509139861D-10, 0.3056663648823D+01, 0.1256967486051D+02, - : 0.4598417696768D-10, 0.4452762609019D+01, 0.6525804586632D+01 / - DATA ((E1(I,J,2),I=1,3),J= 51, 60) / - : 0.5674189533175D-10, 0.9879680872193D+00, 0.5729506548653D+01, - : 0.4073560328195D-10, 0.5939127696986D+01, 0.7632943190217D+01, - : 0.5040994945359D-10, 0.4549875824510D+01, 0.8031092209206D+01, - : 0.5078185134679D-10, 0.7346659893982D+00, 0.7477522907414D+01, - : 0.3769343537061D-10, 0.1071317188367D+01, 0.7234794171227D+01, - : 0.4980331365299D-10, 0.2500345341784D+01, 0.6836645152238D+01, - : 0.3458236594757D-10, 0.3825159450711D+01, 0.1097707878456D+02, - : 0.3578859493602D-10, 0.5299664791549D+01, 0.4164311961999D+01, - : 0.3370504646419D-10, 0.5002316301593D+01, 0.1137170464392D+02, - : 0.3299873338428D-10, 0.2526123275282D+01, 0.3930209696940D+01 / - DATA ((E1(I,J,2),I=1,3),J= 61, 70) / - : 0.4304917318409D-10, 0.3368078557132D+01, 0.1592596075957D+01, - : 0.3402418753455D-10, 0.8385495425800D+00, 0.3128388763578D+01, - : 0.2778460572146D-10, 0.3669905203240D+01, 0.7342457794669D+01, - : 0.2782710128902D-10, 0.2691664812170D+00, 0.1748016358760D+01, - : 0.2711725179646D-10, 0.4707487217718D+01, 0.5296909721118D+00, - : 0.2981760946340D-10, 0.3190260867816D+00, 0.5368044267797D+00, - : 0.2811672977772D-10, 0.3196532315372D+01, 0.7084896783808D+01, - : 0.2863454474467D-10, 0.2263240324780D+00, 0.5223693906222D+01, - : 0.3333464634051D-10, 0.3498451685065D+01, 0.8018209333619D+00, - : 0.3312991747609D-10, 0.5839154477412D+01, 0.1554202828031D+00 / - DATA ((E1(I,J,2),I=1,3),J= 71,NE1Y) / - : 0.2813255564006D-10, 0.8268044346621D+00, 0.5225775174439D+00, - : 0.2665098083966D-10, 0.3934021725360D+01, 0.5216580451554D+01, - : 0.2349795705216D-10, 0.5197620913779D+01, 0.2146165377750D+01, - : 0.2330352293961D-10, 0.2984999231807D+01, 0.1726015463500D+02, - : 0.2728001683419D-10, 0.6521679638544D+00, 0.8635942003952D+01, - : 0.2484061007669D-10, 0.3468955561097D+01, 0.5230807360890D+01, - : 0.2646328768427D-10, 0.1013724533516D+01, 0.2629832328990D-01, - : 0.2518630264831D-10, 0.6108081057122D+01, 0.5481254917084D+01, - : 0.2421901455384D-10, 0.1651097776260D+01, 0.1349867339771D+01, - : 0.6348533267831D-11, 0.3220226560321D+01, 0.8433466158131D+02 / - -* Sun-to-Earth, T^2, Y - DATA ((E2(I,J,2),I=1,3),J= 1,NE2Y) / - : 0.5063375872532D-10, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.2173815785980D-10, 0.2827805833053D+01, 0.1256615170089D+02, - : 0.1010231999920D-10, 0.4634612377133D+01, 0.6283075850446D+01, - : 0.9259745317636D-12, 0.2620612076189D+01, 0.1884922755134D+02, - : 0.1022202095812D-12, 0.3809562326066D+01, 0.8399684731857D+02 / - -* Sun-to-Earth, T^0, Z - DATA ((E0(I,J,3),I=1,3),J= 1, 10) / - : 0.2796207639075D-05, 0.3198701560209D+01, 0.8433466158131D+02, - : 0.1016042198142D-05, 0.5422360395913D+01, 0.5507553240374D+01, - : 0.8044305033647D-06, 0.3880222866652D+01, 0.5223693906222D+01, - : 0.4385347909274D-06, 0.3704369937468D+01, 0.2352866153506D+01, - : 0.3186156414906D-06, 0.3999639363235D+01, 0.1577343543434D+01, - : 0.2272412285792D-06, 0.3984738315952D+01, 0.1047747311755D+01, - : 0.1645620103007D-06, 0.3565412516841D+01, 0.5856477690889D+01, - : 0.1815836921166D-06, 0.4984507059020D+01, 0.6283075850446D+01, - : 0.1447461676364D-06, 0.3702753570108D+01, 0.9437762937313D+01, - : 0.1430760876382D-06, 0.3409658712357D+01, 0.1021328554739D+02 / - DATA ((E0(I,J,3),I=1,3),J= 11, 20) / - : 0.1120445753226D-06, 0.4829561570246D+01, 0.1414349524433D+02, - : 0.1090232840797D-06, 0.2080729178066D+01, 0.6812766822558D+01, - : 0.9715727346551D-07, 0.3476295881948D+01, 0.4694002934110D+01, - : 0.1036267136217D-06, 0.4056639536648D+01, 0.7109288135493D+02, - : 0.8752665271340D-07, 0.4448159519911D+01, 0.5753384878334D+01, - : 0.8331864956004D-07, 0.4991704044208D+01, 0.7084896783808D+01, - : 0.6901658670245D-07, 0.4325358994219D+01, 0.6275962395778D+01, - : 0.9144536848998D-07, 0.1141826375363D+01, 0.6620890113188D+01, - : 0.7205085037435D-07, 0.3624344170143D+01, 0.5296909721118D+00, - : 0.7697874654176D-07, 0.5554257458998D+01, 0.1676215758509D+03 / - DATA ((E0(I,J,3),I=1,3),J= 21, 30) / - : 0.5197545738384D-07, 0.6251760961735D+01, 0.1807370494127D+02, - : 0.5031345378608D-07, 0.2497341091913D+01, 0.4705732307012D+01, - : 0.4527110205840D-07, 0.2335079920992D+01, 0.6309374173736D+01, - : 0.4753355798089D-07, 0.7094148987474D+00, 0.5884926831456D+01, - : 0.4296951977516D-07, 0.1101916352091D+01, 0.6681224869435D+01, - : 0.3855341568387D-07, 0.1825495405486D+01, 0.5486777812467D+01, - : 0.5253930970990D-07, 0.4424740687208D+01, 0.7860419393880D+01, - : 0.4024630496471D-07, 0.5120498157053D+01, 0.1336797263425D+02, - : 0.4061069791453D-07, 0.6029771435451D+01, 0.3930209696940D+01, - : 0.3797883804205D-07, 0.4435193600836D+00, 0.3154687086868D+01 / - DATA ((E0(I,J,3),I=1,3),J= 31, 40) / - : 0.2933033225587D-07, 0.5124157356507D+01, 0.1059381944224D+01, - : 0.3503000930426D-07, 0.5421830162065D+01, 0.6069776770667D+01, - : 0.3670096214050D-07, 0.4582101667297D+01, 0.1219403291462D+02, - : 0.2905609437008D-07, 0.1926566420072D+01, 0.1097707878456D+02, - : 0.2466827821713D-07, 0.6090174539834D+00, 0.6496374930224D+01, - : 0.2691647295332D-07, 0.1393432595077D+01, 0.2200391463820D+02, - : 0.2150554667946D-07, 0.4308671715951D+01, 0.5643178611111D+01, - : 0.2237481922680D-07, 0.8133968269414D+00, 0.8635942003952D+01, - : 0.1817741038157D-07, 0.3755205127454D+01, 0.3340612434717D+01, - : 0.2227820762132D-07, 0.2759558596664D+01, 0.1203646072878D+02 / - DATA ((E0(I,J,3),I=1,3),J= 41, 50) / - : 0.1944713772307D-07, 0.5699645869121D+01, 0.1179062909082D+02, - : 0.1527340520662D-07, 0.1986749091746D+01, 0.3981490189893D+00, - : 0.1577282574914D-07, 0.3205017217983D+01, 0.5088628793478D+01, - : 0.1424738825424D-07, 0.6256747903666D+01, 0.2544314396739D+01, - : 0.1616563121701D-07, 0.2601671259394D+00, 0.1729818233119D+02, - : 0.1401210391692D-07, 0.4686939173506D+01, 0.7058598460518D+01, - : 0.1488726974214D-07, 0.2815862451372D+01, 0.2593412433514D+02, - : 0.1692626442388D-07, 0.4956894109797D+01, 0.1564752902480D+03, - : 0.1123571582910D-07, 0.2381192697696D+01, 0.3738761453707D+01, - : 0.9903308606317D-08, 0.4294851657684D+01, 0.9225539266174D+01 / - DATA ((E0(I,J,3),I=1,3),J= 51, 60) / - : 0.9174533187191D-08, 0.3075171510642D+01, 0.4164311961999D+01, - : 0.8645985631457D-08, 0.5477534821633D+00, 0.8429241228195D+01, - : -0.1085876492688D-07, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.9264309077815D-08, 0.5968571670097D+01, 0.7079373888424D+01, - : 0.8243116984954D-08, 0.1489098777643D+01, 0.1044738781244D+02, - : 0.8268102113708D-08, 0.3512977691983D+01, 0.1150676975667D+02, - : 0.9043613988227D-08, 0.1290704408221D+00, 0.1101510648075D+02, - : 0.7432912038789D-08, 0.1991086893337D+01, 0.2608790314060D+02, - : 0.8586233727285D-08, 0.4238357924414D+01, 0.2986433403208D+02, - : 0.7612230060131D-08, 0.2911090150166D+01, 0.4732030630302D+01 / - DATA ((E0(I,J,3),I=1,3),J= 61, 70) / - : 0.7097787751408D-08, 0.1908938392390D+01, 0.8031092209206D+01, - : 0.7640237040175D-08, 0.6129219000168D+00, 0.7962980379786D+00, - : 0.7070445688081D-08, 0.1380417036651D+01, 0.2146165377750D+01, - : 0.7690770957702D-08, 0.1680504249084D+01, 0.2122839202813D+02, - : 0.8051292542594D-08, 0.5127423484511D+01, 0.2942463415728D+01, - : 0.5902709104515D-08, 0.2020274190917D+01, 0.7755226100720D+00, - : 0.5134567496462D-08, 0.2606778676418D+01, 0.1256615170089D+02, - : 0.5525802046102D-08, 0.1613011769663D+01, 0.8018209333619D+00, - : 0.5880724784221D-08, 0.4604483417236D+01, 0.4690479774488D+01, - : 0.5211699081370D-08, 0.5718964114193D+01, 0.8827390247185D+01 / - DATA ((E0(I,J,3),I=1,3),J= 71, 80) / - : 0.4891849573562D-08, 0.3689658932196D+01, 0.2132990797783D+00, - : 0.5150246069997D-08, 0.4099769855122D+01, 0.6480980550449D+02, - : 0.5102434319633D-08, 0.5660834602509D+01, 0.3379454372902D+02, - : 0.5083405254252D-08, 0.9842221218974D+00, 0.4136910472696D+01, - : 0.4206562585682D-08, 0.1341363634163D+00, 0.3128388763578D+01, - : 0.4663249683579D-08, 0.8130132735866D+00, 0.5216580451554D+01, - : 0.4099474416530D-08, 0.5791497770644D+01, 0.4265981595566D+00, - : 0.4628251220767D-08, 0.1249802769331D+01, 0.1572083878776D+02, - : 0.5024068728142D-08, 0.4795684802743D+01, 0.6290189305114D+01, - : 0.5120234327758D-08, 0.3810420387208D+01, 0.5230807360890D+01 / - DATA ((E0(I,J,3),I=1,3),J= 81, 90) / - : 0.5524029815280D-08, 0.1029264714351D+01, 0.2397622045175D+03, - : 0.4757415718860D-08, 0.3528044781779D+01, 0.1649636139783D+02, - : 0.3915786131127D-08, 0.5593889282646D+01, 0.1589072916335D+01, - : 0.4869053149991D-08, 0.3299636454433D+01, 0.7632943190217D+01, - : 0.3649365703729D-08, 0.1286049002584D+01, 0.6206810014183D+01, - : 0.3992493949002D-08, 0.3100307589464D+01, 0.2515860172507D+02, - : 0.3320247477418D-08, 0.6212683940807D+01, 0.1216800268190D+02, - : 0.3287123739696D-08, 0.4699118445928D+01, 0.7234794171227D+01, - : 0.3472776811103D-08, 0.2630507142004D+01, 0.7342457794669D+01, - : 0.3423253294767D-08, 0.2946432844305D+01, 0.9623688285163D+01 / - DATA ((E0(I,J,3),I=1,3),J= 91,100) / - : 0.3896173898244D-08, 0.1224834179264D+01, 0.6438496133249D+01, - : 0.3388455337924D-08, 0.1543807616351D+01, 0.1494531617769D+02, - : 0.3062704716523D-08, 0.1191777572310D+01, 0.8662240327241D+01, - : 0.3270075600400D-08, 0.5483498767737D+01, 0.1194447056968D+01, - : 0.3101209215259D-08, 0.8000833804348D+00, 0.3772475342596D+02, - : 0.2780883347311D-08, 0.4077980721888D+00, 0.5863591145557D+01, - : 0.2903605931824D-08, 0.2617490302147D+01, 0.1965104848470D+02, - : 0.2682014743119D-08, 0.2634703158290D+01, 0.7238675589263D+01, - : 0.2534360108492D-08, 0.6102446114873D+01, 0.6836645152238D+01, - : 0.2392564882509D-08, 0.3681820208691D+01, 0.5849364236221D+01 / - DATA ((E0(I,J,3),I=1,3),J=101,110) / - : 0.2656667254856D-08, 0.6216045388886D+01, 0.6133512519065D+01, - : 0.2331242096773D-08, 0.5864949777744D+01, 0.4535059491685D+01, - : 0.2287898363668D-08, 0.4566628532802D+01, 0.7477522907414D+01, - : 0.2336944521306D-08, 0.2442722126930D+01, 0.1137170464392D+02, - : 0.3156632236269D-08, 0.1626628050682D+01, 0.2509084901204D+03, - : 0.2982612402766D-08, 0.2803604512609D+01, 0.1748016358760D+01, - : 0.2774031674807D-08, 0.4654002897158D+01, 0.8223916695780D+02, - : 0.2295236548638D-08, 0.4326518333253D+01, 0.3378142627421D+00, - : 0.2190714699873D-08, 0.4519614578328D+01, 0.2908881142201D+02, - : 0.2191495845045D-08, 0.3012626912549D+01, 0.1673046366289D+02 / - DATA ((E0(I,J,3),I=1,3),J=111,120) / - : 0.2492901628386D-08, 0.1290101424052D+00, 0.1543797956245D+03, - : 0.1993778064319D-08, 0.3864046799414D+01, 0.1778984560711D+02, - : 0.1898146479022D-08, 0.5053777235891D+01, 0.2042657109477D+02, - : 0.1918280127634D-08, 0.2222470192548D+01, 0.4165496312290D+02, - : 0.1916351061607D-08, 0.8719067257774D+00, 0.7737595720538D+02, - : 0.1834720181466D-08, 0.4031491098040D+01, 0.2358125818164D+02, - : 0.1249201523806D-08, 0.5938379466835D+01, 0.3301902111895D+02, - : 0.1477304050539D-08, 0.6544722606797D+00, 0.9548094718417D+02, - : 0.1264316431249D-08, 0.2059072853236D+01, 0.8399684731857D+02, - : 0.1203526495039D-08, 0.3644813532605D+01, 0.4558517281984D+02 / - DATA ((E0(I,J,3),I=1,3),J=121,130) / - : 0.9221681059831D-09, 0.3241815055602D+01, 0.7805158573086D+02, - : 0.7849278367646D-09, 0.5043812342457D+01, 0.5217580628120D+02, - : 0.7983392077387D-09, 0.5000024502753D+01, 0.1501922143975D+03, - : 0.7925395431654D-09, 0.1398734871821D-01, 0.9061773743175D+02, - : 0.7640473285886D-09, 0.5067111723130D+01, 0.4951538251678D+02, - : 0.5398937754482D-09, 0.5597382200075D+01, 0.1613385000004D+03, - : 0.5626247550193D-09, 0.2601338209422D+01, 0.7318837597844D+02, - : 0.5525197197855D-09, 0.5814832109256D+01, 0.1432335100216D+03, - : 0.5407629837898D-09, 0.3384820609076D+01, 0.3230491187871D+03, - : 0.3856739119801D-09, 0.1072391840473D+01, 0.2334791286671D+03 / - DATA ((E0(I,J,3),I=1,3),J=131,NE0Z) / - : 0.3856425239987D-09, 0.2369540393327D+01, 0.1739046517013D+03, - : 0.4350867755983D-09, 0.5255575751082D+01, 0.1620484330494D+03, - : 0.3844113924996D-09, 0.5482356246182D+01, 0.9757644180768D+02, - : 0.2854869155431D-09, 0.9573634763143D+00, 0.1697170704744D+03, - : 0.1719227671416D-09, 0.1887203025202D+01, 0.2265204242912D+03, - : 0.1527846879755D-09, 0.3982183931157D+01, 0.3341954043900D+03, - : 0.1128229264847D-09, 0.2787457156298D+01, 0.3119028331842D+03 / - -* Sun-to-Earth, T^1, Z - DATA ((E1(I,J,3),I=1,3),J= 1, 10) / - : 0.2278290449966D-05, 0.3413716033863D+01, 0.6283075850446D+01, - : 0.5429458209830D-07, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.1903240492525D-07, 0.3370592358297D+01, 0.1256615170089D+02, - : 0.2385409276743D-09, 0.3327914718416D+01, 0.1884922755134D+02, - : 0.8676928342573D-10, 0.1824006811264D+01, 0.5223693906222D+01, - : 0.7765442593544D-10, 0.3888564279247D+01, 0.5507553240374D+01, - : 0.7066158332715D-10, 0.5194267231944D+01, 0.2352866153506D+01, - : 0.7092175288657D-10, 0.2333246960021D+01, 0.8399684731857D+02, - : 0.5357582213535D-10, 0.2224031176619D+01, 0.5296909721118D+00, - : 0.3828035865021D-10, 0.2156710933584D+01, 0.6279552690824D+01 / - DATA ((E1(I,J,3),I=1,3),J= 11,NE1Z) / - : 0.3824857220427D-10, 0.1529755219915D+01, 0.6286599010068D+01, - : 0.3286995181628D-10, 0.4879512900483D+01, 0.1021328554739D+02 / - -* Sun-to-Earth, T^2, Z - DATA ((E2(I,J,3),I=1,3),J= 1,NE2Z) / - : 0.9722666114891D-10, 0.5152219582658D+01, 0.6283075850446D+01, - : -0.3494819171909D-11, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.6713034376076D-12, 0.6440188750495D+00, 0.1256615170089D+02 / - -* SSB-to-Sun, T^0, X - DATA ((S0(I,J,1),I=1,3),J= 1, 10) / - : 0.4956757536410D-02, 0.3741073751789D+01, 0.5296909721118D+00, - : 0.2718490072522D-02, 0.4016011511425D+01, 0.2132990797783D+00, - : 0.1546493974344D-02, 0.2170528330642D+01, 0.3813291813120D-01, - : 0.8366855276341D-03, 0.2339614075294D+01, 0.7478166569050D-01, - : 0.2936777942117D-03, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.1201317439469D-03, 0.4090736353305D+01, 0.1059381944224D+01, - : 0.7578550887230D-04, 0.3241518088140D+01, 0.4265981595566D+00, - : 0.1941787367773D-04, 0.1012202064330D+01, 0.2061856251104D+00, - : 0.1889227765991D-04, 0.3892520416440D+01, 0.2204125344462D+00, - : 0.1937896968613D-04, 0.4797779441161D+01, 0.1495633313810D+00 / - DATA ((S0(I,J,1),I=1,3),J= 11, 20) / - : 0.1434506110873D-04, 0.3868960697933D+01, 0.5225775174439D+00, - : 0.1406659911580D-04, 0.4759766557397D+00, 0.5368044267797D+00, - : 0.1179022300202D-04, 0.7774961520598D+00, 0.7626583626240D-01, - : 0.8085864460959D-05, 0.3254654471465D+01, 0.3664874755930D-01, - : 0.7622752967615D-05, 0.4227633103489D+01, 0.3961708870310D-01, - : 0.6209171139066D-05, 0.2791828325711D+00, 0.7329749511860D-01, - : 0.4366435633970D-05, 0.4440454875925D+01, 0.1589072916335D+01, - : 0.3792124889348D-05, 0.5156393842356D+01, 0.7113454667900D-02, - : 0.3154548963402D-05, 0.6157005730093D+01, 0.4194847048887D+00, - : 0.3088359882942D-05, 0.2494567553163D+01, 0.6398972393349D+00 / - DATA ((S0(I,J,1),I=1,3),J= 21, 30) / - : 0.2788440902136D-05, 0.4934318747989D+01, 0.1102062672231D+00, - : 0.3039928456376D-05, 0.4895077702640D+01, 0.6283075850446D+01, - : 0.2272258457679D-05, 0.5278394064764D+01, 0.1030928125552D+00, - : 0.2162007057957D-05, 0.5802978019099D+01, 0.3163918923335D+00, - : 0.1767632855737D-05, 0.3415346595193D-01, 0.1021328554739D+02, - : 0.1349413459362D-05, 0.2001643230755D+01, 0.1484170571900D-02, - : 0.1170141900476D-05, 0.2424750491620D+01, 0.6327837846670D+00, - : 0.1054355266820D-05, 0.3123311487576D+01, 0.4337116142245D+00, - : 0.9800822461610D-06, 0.3026258088130D+01, 0.1052268489556D+01, - : 0.1091203749931D-05, 0.3157811670347D+01, 0.1162474756779D+01 / - DATA ((S0(I,J,1),I=1,3),J= 31, 40) / - : 0.6960236715913D-06, 0.8219570542313D+00, 0.1066495398892D+01, - : 0.5689257296909D-06, 0.1323052375236D+01, 0.9491756770005D+00, - : 0.6613172135802D-06, 0.2765348881598D+00, 0.8460828644453D+00, - : 0.6277702517571D-06, 0.5794064466382D+01, 0.1480791608091D+00, - : 0.6304884066699D-06, 0.7323555380787D+00, 0.2243449970715D+00, - : 0.4897850467382D-06, 0.3062464235399D+01, 0.3340612434717D+01, - : 0.3759148598786D-06, 0.4588290469664D+01, 0.3516457698740D-01, - : 0.3110520548195D-06, 0.1374299536572D+01, 0.6373574839730D-01, - : 0.3064708359780D-06, 0.4222267485047D+01, 0.1104591729320D-01, - : 0.2856347168241D-06, 0.3714202944973D+01, 0.1510475019529D+00 / - DATA ((S0(I,J,1),I=1,3),J= 41, 50) / - : 0.2840945514288D-06, 0.2847972875882D+01, 0.4110125927500D-01, - : 0.2378951599405D-06, 0.3762072563388D+01, 0.2275259891141D+00, - : 0.2714229481417D-06, 0.1036049980031D+01, 0.2535050500000D-01, - : 0.2323551717307D-06, 0.4682388599076D+00, 0.8582758298370D-01, - : 0.1881790512219D-06, 0.4790565425418D+01, 0.2118763888447D+01, - : 0.2261353968371D-06, 0.1669144912212D+01, 0.7181332454670D-01, - : 0.2214546389848D-06, 0.3937717281614D+01, 0.2968341143800D-02, - : 0.2184915594933D-06, 0.1129169845099D+00, 0.7775000683430D-01, - : 0.2000164937936D-06, 0.4030009638488D+01, 0.2093666171530D+00, - : 0.1966105136719D-06, 0.8745955786834D+00, 0.2172315424036D+00 / - DATA ((S0(I,J,1),I=1,3),J= 51, 60) / - : 0.1904742332624D-06, 0.5919743598964D+01, 0.2022531624851D+00, - : 0.1657399705031D-06, 0.2549141484884D+01, 0.7358765972222D+00, - : 0.1574070533987D-06, 0.5277533020230D+01, 0.7429900518901D+00, - : 0.1832261651039D-06, 0.3064688127777D+01, 0.3235053470014D+00, - : 0.1733615346569D-06, 0.3011432799094D+01, 0.1385174140878D+00, - : 0.1549124014496D-06, 0.4005569132359D+01, 0.5154640627760D+00, - : 0.1637044713838D-06, 0.1831375966632D+01, 0.8531963191132D+00, - : 0.1123420082383D-06, 0.1180270407578D+01, 0.1990721704425D+00, - : 0.1083754165740D-06, 0.3414101320863D+00, 0.5439178814476D+00, - : 0.1156638012655D-06, 0.6130479452594D+00, 0.5257585094865D+00 / - DATA ((S0(I,J,1),I=1,3),J= 61, 70) / - : 0.1142548785134D-06, 0.3724761948846D+01, 0.5336234347371D+00, - : 0.7921463895965D-07, 0.2435425589361D+01, 0.1478866649112D+01, - : 0.7428600285231D-07, 0.3542144398753D+01, 0.2164800718209D+00, - : 0.8323211246747D-07, 0.3525058072354D+01, 0.1692165728891D+01, - : 0.7257595116312D-07, 0.1364299431982D+01, 0.2101180877357D+00, - : 0.7111185833236D-07, 0.2460478875808D+01, 0.4155522422634D+00, - : 0.6868090383716D-07, 0.4397327670704D+01, 0.1173197218910D+00, - : 0.7226419974175D-07, 0.4042647308905D+01, 0.1265567569334D+01, - : 0.6955642383177D-07, 0.2865047906085D+01, 0.9562891316684D+00, - : 0.7492139296331D-07, 0.5014278994215D+01, 0.1422690933580D-01 / - DATA ((S0(I,J,1),I=1,3),J= 71, 80) / - : 0.6598363128857D-07, 0.2376730020492D+01, 0.6470106940028D+00, - : 0.7381147293385D-07, 0.3272990384244D+01, 0.1581959461667D+01, - : 0.6402909624032D-07, 0.5302290955138D+01, 0.9597935788730D-01, - : 0.6237454263857D-07, 0.5444144425332D+01, 0.7084920306520D-01, - : 0.5241198544016D-07, 0.4215359579205D+01, 0.5265099800692D+00, - : 0.5144463853918D-07, 0.1218916689916D+00, 0.5328719641544D+00, - : 0.5868164772299D-07, 0.2369402002213D+01, 0.7871412831580D-01, - : 0.6233195669151D-07, 0.1254922242403D+01, 0.2608790314060D+02, - : 0.6068463791422D-07, 0.5679713760431D+01, 0.1114304132498D+00, - : 0.4359361135065D-07, 0.6097219641646D+00, 0.1375773836557D+01 / - DATA ((S0(I,J,1),I=1,3),J= 81, 90) / - : 0.4686510366826D-07, 0.4786231041431D+01, 0.1143987543936D+00, - : 0.3758977287225D-07, 0.1167368068139D+01, 0.1596186371003D+01, - : 0.4282051974778D-07, 0.1519471064319D+01, 0.2770348281756D+00, - : 0.5153765386113D-07, 0.1860532322984D+01, 0.2228608264996D+00, - : 0.4575129387188D-07, 0.7632857887158D+00, 0.1465949902372D+00, - : 0.3326844933286D-07, 0.1298219485285D+01, 0.5070101000000D-01, - : 0.3748617450984D-07, 0.1046510321062D+01, 0.4903339079539D+00, - : 0.2816756661499D-07, 0.3434522346190D+01, 0.2991266627620D+00, - : 0.3412750405039D-07, 0.2523766270318D+01, 0.3518164938661D+00, - : 0.2655796761776D-07, 0.2904422260194D+01, 0.6256703299991D+00 / - DATA ((S0(I,J,1),I=1,3),J= 91,100) / - : 0.2963597929458D-07, 0.5923900431149D+00, 0.1099462426779D+00, - : 0.2539523734781D-07, 0.4851947722567D+01, 0.1256615170089D+02, - : 0.2283087914139D-07, 0.3400498595496D+01, 0.6681224869435D+01, - : 0.2321309799331D-07, 0.5789099148673D+01, 0.3368040641550D-01, - : 0.2549657649750D-07, 0.3991856479792D-01, 0.1169588211447D+01, - : 0.2290462303977D-07, 0.2788567577052D+01, 0.1045155034888D+01, - : 0.1945398522914D-07, 0.3290896998176D+01, 0.1155361302111D+01, - : 0.1849171512638D-07, 0.2698060129367D+01, 0.4452511715700D-02, - : 0.1647199834254D-07, 0.3016735644085D+01, 0.4408250688924D+00, - : 0.1529530765273D-07, 0.5573043116178D+01, 0.6521991896920D-01 / - DATA ((S0(I,J,1),I=1,3),J=101,110) / - : 0.1433199339978D-07, 0.1481192356147D+01, 0.9420622223326D+00, - : 0.1729134193602D-07, 0.1422817538933D+01, 0.2108507877249D+00, - : 0.1716463931346D-07, 0.3469468901855D+01, 0.2157473718317D+00, - : 0.1391206061378D-07, 0.6122436220547D+01, 0.4123712502208D+00, - : 0.1404746661924D-07, 0.1647765641936D+01, 0.4258542984690D-01, - : 0.1410452399455D-07, 0.5989729161964D+01, 0.2258291676434D+00, - : 0.1089828772168D-07, 0.2833705509371D+01, 0.4226656969313D+00, - : 0.1047374564948D-07, 0.5090690007331D+00, 0.3092784376656D+00, - : 0.1358279126532D-07, 0.5128990262836D+01, 0.7923417740620D-01, - : 0.1020456476148D-07, 0.9632772880808D+00, 0.1456308687557D+00 / - DATA ((S0(I,J,1),I=1,3),J=111,120) / - : 0.1033428735328D-07, 0.3223779318418D+01, 0.1795258541446D+01, - : 0.1412435841540D-07, 0.2410271572721D+01, 0.1525316725248D+00, - : 0.9722759371574D-08, 0.2333531395690D+01, 0.8434341241180D-01, - : 0.9657334084704D-08, 0.6199270974168D+01, 0.1272681024002D+01, - : 0.1083641148690D-07, 0.2864222292929D+01, 0.7032915397480D-01, - : 0.1067318403838D-07, 0.5833458866568D+00, 0.2123349582968D+00, - : 0.1062366201976D-07, 0.4307753989494D+01, 0.2142632012598D+00, - : 0.1236364149266D-07, 0.2873917870593D+01, 0.1847279083684D+00, - : 0.1092759489593D-07, 0.2959887266733D+01, 0.1370332435159D+00, - : 0.8912069362899D-08, 0.5141213702562D+01, 0.2648454860559D+01 / - DATA ((S0(I,J,1),I=1,3),J=121,130) / - : 0.9656467707970D-08, 0.4532182462323D+01, 0.4376440768498D+00, - : 0.8098386150135D-08, 0.2268906338379D+01, 0.2880807454688D+00, - : 0.7857714675000D-08, 0.4055544260745D+01, 0.2037373330570D+00, - : 0.7288455940646D-08, 0.5357901655142D+01, 0.1129145838217D+00, - : 0.9450595950552D-08, 0.4264926963939D+01, 0.5272426800584D+00, - : 0.9381718247537D-08, 0.7489366976576D-01, 0.5321392641652D+00, - : 0.7079052646038D-08, 0.1923311052874D+01, 0.6288513220417D+00, - : 0.9259004415344D-08, 0.2970256853438D+01, 0.1606092486742D+00, - : 0.8259801499742D-08, 0.3327056314697D+01, 0.8389694097774D+00, - : 0.6476334355779D-08, 0.2954925505727D+01, 0.2008557621224D+01 / - DATA ((S0(I,J,1),I=1,3),J=131,140) / - : 0.5984021492007D-08, 0.9138753105829D+00, 0.2042657109477D+02, - : 0.5989546863181D-08, 0.3244464082031D+01, 0.2111650433779D+01, - : 0.6233108606023D-08, 0.4995232638403D+00, 0.4305306221819D+00, - : 0.6877299149965D-08, 0.2834987233449D+01, 0.9561746721300D-02, - : 0.8311234227190D-08, 0.2202951835758D+01, 0.3801276407308D+00, - : 0.6599472832414D-08, 0.4478581462618D+01, 0.1063314406849D+01, - : 0.6160491096549D-08, 0.5145858696411D+01, 0.1368660381889D+01, - : 0.6164772043891D-08, 0.3762976697911D+00, 0.4234171675140D+00, - : 0.6363248684450D-08, 0.3162246718685D+01, 0.1253008786510D-01, - : 0.6448587520999D-08, 0.3442693302119D+01, 0.5287268506303D+00 / - DATA ((S0(I,J,1),I=1,3),J=141,150) / - : 0.6431662283977D-08, 0.8977549136606D+00, 0.5306550935933D+00, - : 0.6351223158474D-08, 0.4306447410369D+01, 0.5217580628120D+02, - : 0.5476721393451D-08, 0.3888529177855D+01, 0.2221856701002D+01, - : 0.5341772572619D-08, 0.2655560662512D+01, 0.7466759693650D-01, - : 0.5337055758302D-08, 0.5164990735946D+01, 0.7489573444450D-01, - : 0.5373120816787D-08, 0.6041214553456D+01, 0.1274714967946D+00, - : 0.5392351705426D-08, 0.9177763485932D+00, 0.1055449481598D+01, - : 0.6688495850205D-08, 0.3089608126937D+01, 0.2213766559277D+00, - : 0.5072003660362D-08, 0.4311316541553D+01, 0.2132517061319D+00, - : 0.5070726650455D-08, 0.5790675464444D+00, 0.2133464534247D+00 / - DATA ((S0(I,J,1),I=1,3),J=151,160) / - : 0.5658012950032D-08, 0.2703945510675D+01, 0.7287631425543D+00, - : 0.4835509924854D-08, 0.2975422976065D+01, 0.7160067364790D-01, - : 0.6479821978012D-08, 0.1324168733114D+01, 0.2209183458640D-01, - : 0.6230636494980D-08, 0.2860103632836D+01, 0.3306188016693D+00, - : 0.4649239516213D-08, 0.4832259763403D+01, 0.7796265773310D-01, - : 0.6487325792700D-08, 0.2726165825042D+01, 0.3884652414254D+00, - : 0.4682823682770D-08, 0.6966602455408D+00, 0.1073608853559D+01, - : 0.5704230804976D-08, 0.5669634104606D+01, 0.8731175355560D-01, - : 0.6125413585489D-08, 0.1513386538915D+01, 0.7605151500000D-01, - : 0.6035825038187D-08, 0.1983509168227D+01, 0.9846002785331D+00 / - DATA ((S0(I,J,1),I=1,3),J=161,170) / - : 0.4331123462303D-08, 0.2782892992807D+01, 0.4297791515992D+00, - : 0.4681107685143D-08, 0.5337232886836D+01, 0.2127790306879D+00, - : 0.4669105829655D-08, 0.5837133792160D+01, 0.2138191288687D+00, - : 0.5138823602365D-08, 0.3080560200507D+01, 0.7233337363710D-01, - : 0.4615856664534D-08, 0.1661747897471D+01, 0.8603097737811D+00, - : 0.4496916702197D-08, 0.2112508027068D+01, 0.7381754420900D-01, - : 0.4278479042945D-08, 0.5716528462627D+01, 0.7574578717200D-01, - : 0.3840525503932D-08, 0.6424172726492D+00, 0.3407705765729D+00, - : 0.4866636509685D-08, 0.4919244697715D+01, 0.7722995774390D-01, - : 0.3526100639296D-08, 0.2550821052734D+01, 0.6225157782540D-01 / - DATA ((S0(I,J,1),I=1,3),J=171,180) / - : 0.3939558488075D-08, 0.3939331491710D+01, 0.5268983110410D-01, - : 0.4041268772576D-08, 0.2275337571218D+01, 0.3503323232942D+00, - : 0.3948761842853D-08, 0.1999324200790D+01, 0.1451108196653D+00, - : 0.3258394550029D-08, 0.9121001378200D+00, 0.5296435984654D+00, - : 0.3257897048761D-08, 0.3428428660869D+01, 0.5297383457582D+00, - : 0.3842559031298D-08, 0.6132927720035D+01, 0.9098186128426D+00, - : 0.3109920095448D-08, 0.7693650193003D+00, 0.3932462625300D-02, - : 0.3132237775119D-08, 0.3621293854908D+01, 0.2346394437820D+00, - : 0.3942189421510D-08, 0.4841863659733D+01, 0.3180992042600D-02, - : 0.3796972285340D-08, 0.1814174994268D+01, 0.1862120789403D+00 / - DATA ((S0(I,J,1),I=1,3),J=181,190) / - : 0.3995640233688D-08, 0.1386990406091D+01, 0.4549093064213D+00, - : 0.2875013727414D-08, 0.9178318587177D+00, 0.1905464808669D+01, - : 0.3073719932844D-08, 0.2688923811835D+01, 0.3628624111593D+00, - : 0.2731016580075D-08, 0.1188259127584D+01, 0.2131850110243D+00, - : 0.2729549896546D-08, 0.3702160634273D+01, 0.2134131485323D+00, - : 0.3339372892449D-08, 0.7199163960331D+00, 0.2007689919132D+00, - : 0.2898833764204D-08, 0.1916709364999D+01, 0.5291709230214D+00, - : 0.2894536549362D-08, 0.2424043195547D+01, 0.5302110212022D+00, - : 0.3096872473843D-08, 0.4445894977497D+01, 0.2976424921901D+00, - : 0.2635672326810D-08, 0.3814366984117D+01, 0.1485980103780D+01 / - DATA ((S0(I,J,1),I=1,3),J=191,200) / - : 0.3649302697001D-08, 0.2924200596084D+01, 0.6044726378023D+00, - : 0.3127954585895D-08, 0.1842251648327D+01, 0.1084620721060D+00, - : 0.2616040173947D-08, 0.4155841921984D+01, 0.1258454114666D+01, - : 0.2597395859860D-08, 0.1158045978874D+00, 0.2103781122809D+00, - : 0.2593286172210D-08, 0.4771850408691D+01, 0.2162200472757D+00, - : 0.2481823585747D-08, 0.4608842558889D+00, 0.1062562936266D+01, - : 0.2742219550725D-08, 0.1538781127028D+01, 0.5651155736444D+00, - : 0.3199558469610D-08, 0.3226647822878D+00, 0.7036329877322D+00, - : 0.2666088542957D-08, 0.1967991731219D+00, 0.1400015846597D+00, - : 0.2397067430580D-08, 0.3707036669873D+01, 0.2125476091956D+00 / - DATA ((S0(I,J,1),I=1,3),J=201,210) / - : 0.2376570772738D-08, 0.1182086628042D+01, 0.2140505503610D+00, - : 0.2547228007887D-08, 0.4906256820629D+01, 0.1534957940063D+00, - : 0.2265575594114D-08, 0.3414949866857D+01, 0.2235935264888D+00, - : 0.2464381430585D-08, 0.4599122275378D+01, 0.2091065926078D+00, - : 0.2433408527044D-08, 0.2830751145445D+00, 0.2174915669488D+00, - : 0.2443605509076D-08, 0.4212046432538D+01, 0.1739420156204D+00, - : 0.2319779262465D-08, 0.9881978408630D+00, 0.7530171478090D-01, - : 0.2284622835465D-08, 0.5565347331588D+00, 0.7426161660010D-01, - : 0.2467268750783D-08, 0.5655708150766D+00, 0.2526561439362D+00, - : 0.2808513492782D-08, 0.1418405053408D+01, 0.5636314030725D+00 / - DATA ((S0(I,J,1),I=1,3),J=211,NS0X) / - : 0.2329528932532D-08, 0.4069557545675D+01, 0.1056200952181D+01, - : 0.9698639532817D-09, 0.1074134313634D+01, 0.7826370942180D+02 / - -* SSB-to-Sun, T^1, X - DATA ((S1(I,J,1),I=1,3),J= 1, 10) / - : -0.1296310361520D-07, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.8975769009438D-08, 0.1128891609250D+01, 0.4265981595566D+00, - : 0.7771113441307D-08, 0.2706039877077D+01, 0.2061856251104D+00, - : 0.7538303866642D-08, 0.2191281289498D+01, 0.2204125344462D+00, - : 0.6061384579336D-08, 0.3248167319958D+01, 0.1059381944224D+01, - : 0.5726994235594D-08, 0.5569981398610D+01, 0.5225775174439D+00, - : 0.5616492836424D-08, 0.5057386614909D+01, 0.5368044267797D+00, - : 0.1010881584769D-08, 0.3473577116095D+01, 0.7113454667900D-02, - : 0.7259606157626D-09, 0.3651858593665D+00, 0.6398972393349D+00, - : 0.8755095026935D-09, 0.1662835408338D+01, 0.4194847048887D+00 / - DATA ((S1(I,J,1),I=1,3),J= 11, 20) / - : 0.5370491182812D-09, 0.1327673878077D+01, 0.4337116142245D+00, - : 0.5743773887665D-09, 0.4250200846687D+01, 0.2132990797783D+00, - : 0.4408103140300D-09, 0.3598752574277D+01, 0.1589072916335D+01, - : 0.3101892374445D-09, 0.4887822983319D+01, 0.1052268489556D+01, - : 0.3209453713578D-09, 0.9702272295114D+00, 0.5296909721118D+00, - : 0.3017228286064D-09, 0.5484462275949D+01, 0.1066495398892D+01, - : 0.3200700038601D-09, 0.2846613338643D+01, 0.1495633313810D+00, - : 0.2137637279911D-09, 0.5692163292729D+00, 0.3163918923335D+00, - : 0.1899686386727D-09, 0.2061077157189D+01, 0.2275259891141D+00, - : 0.1401994545308D-09, 0.4177771136967D+01, 0.1102062672231D+00 / - DATA ((S1(I,J,1),I=1,3),J= 21, 30) / - : 0.1578057810499D-09, 0.5782460597335D+01, 0.7626583626240D-01, - : 0.1237713253351D-09, 0.5705900866881D+01, 0.5154640627760D+00, - : 0.1313076837395D-09, 0.5163438179576D+01, 0.3664874755930D-01, - : 0.1184963304860D-09, 0.3054804427242D+01, 0.6327837846670D+00, - : 0.1238130878565D-09, 0.2317292575962D+01, 0.3961708870310D-01, - : 0.1015959527736D-09, 0.2194643645526D+01, 0.7329749511860D-01, - : 0.9017954423714D-10, 0.2868603545435D+01, 0.1990721704425D+00, - : 0.8668024955603D-10, 0.4923849675082D+01, 0.5439178814476D+00, - : 0.7756083930103D-10, 0.3014334135200D+01, 0.9491756770005D+00, - : 0.7536503401741D-10, 0.2704886279769D+01, 0.1030928125552D+00 / - DATA ((S1(I,J,1),I=1,3),J= 31, 40) / - : 0.5483308679332D-10, 0.6010983673799D+01, 0.8531963191132D+00, - : 0.5184339620428D-10, 0.1952704573291D+01, 0.2093666171530D+00, - : 0.5108658712030D-10, 0.2958575786649D+01, 0.2172315424036D+00, - : 0.5019424524650D-10, 0.1736317621318D+01, 0.2164800718209D+00, - : 0.4909312625978D-10, 0.3167216416257D+01, 0.2101180877357D+00, - : 0.4456638901107D-10, 0.7697579923471D+00, 0.3235053470014D+00, - : 0.4227030350925D-10, 0.3490910137928D+01, 0.6373574839730D-01, - : 0.4095456040093D-10, 0.5178888984491D+00, 0.6470106940028D+00, - : 0.4990537041422D-10, 0.3323887668974D+01, 0.1422690933580D-01, - : 0.4321170010845D-10, 0.4288484987118D+01, 0.7358765972222D+00 / - DATA ((S1(I,J,1),I=1,3),J= 41,NS1X) / - : 0.3544072091802D-10, 0.6021051579251D+01, 0.5265099800692D+00, - : 0.3480198638687D-10, 0.4600027054714D+01, 0.5328719641544D+00, - : 0.3440287244435D-10, 0.4349525970742D+01, 0.8582758298370D-01, - : 0.3330628322713D-10, 0.2347391505082D+01, 0.1104591729320D-01, - : 0.2973060707184D-10, 0.4789409286400D+01, 0.5257585094865D+00, - : 0.2932606766089D-10, 0.5831693799927D+01, 0.5336234347371D+00, - : 0.2876972310953D-10, 0.2692638514771D+01, 0.1173197218910D+00, - : 0.2827488278556D-10, 0.2056052487960D+01, 0.2022531624851D+00, - : 0.2515028239756D-10, 0.7411863262449D+00, 0.9597935788730D-01, - : 0.2853033744415D-10, 0.3948481024894D+01, 0.2118763888447D+01 / - -* SSB-to-Sun, T^2, X - DATA ((S2(I,J,1),I=1,3),J= 1,NS2X) / - : 0.1603551636587D-11, 0.4404109410481D+01, 0.2061856251104D+00, - : 0.1556935889384D-11, 0.4818040873603D+00, 0.2204125344462D+00, - : 0.1182594414915D-11, 0.9935762734472D+00, 0.5225775174439D+00, - : 0.1158794583180D-11, 0.3353180966450D+01, 0.5368044267797D+00, - : 0.9597358943932D-12, 0.5567045358298D+01, 0.2132990797783D+00, - : 0.6511516579605D-12, 0.5630872420788D+01, 0.4265981595566D+00, - : 0.7419792747688D-12, 0.2156188581957D+01, 0.5296909721118D+00, - : 0.3951972655848D-12, 0.1981022541805D+01, 0.1059381944224D+01, - : 0.4478223877045D-12, 0.0000000000000D+00, 0.0000000000000D+00 / - -* SSB-to-Sun, T^0, Y - DATA ((S0(I,J,2),I=1,3),J= 1, 10) / - : 0.4955392320126D-02, 0.2170467313679D+01, 0.5296909721118D+00, - : 0.2722325167392D-02, 0.2444433682196D+01, 0.2132990797783D+00, - : 0.1546579925346D-02, 0.5992779281546D+00, 0.3813291813120D-01, - : 0.8363140252966D-03, 0.7687356310801D+00, 0.7478166569050D-01, - : 0.3385792683603D-03, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.1201192221613D-03, 0.2520035601514D+01, 0.1059381944224D+01, - : 0.7587125720554D-04, 0.1669954006449D+01, 0.4265981595566D+00, - : 0.1964155361250D-04, 0.5707743963343D+01, 0.2061856251104D+00, - : 0.1891900364909D-04, 0.2320960679937D+01, 0.2204125344462D+00, - : 0.1937373433356D-04, 0.3226940689555D+01, 0.1495633313810D+00 / - DATA ((S0(I,J,2),I=1,3),J= 11, 20) / - : 0.1437139941351D-04, 0.2301626908096D+01, 0.5225775174439D+00, - : 0.1406267683099D-04, 0.5188579265542D+01, 0.5368044267797D+00, - : 0.1178703080346D-04, 0.5489483248476D+01, 0.7626583626240D-01, - : 0.8079835186041D-05, 0.1683751835264D+01, 0.3664874755930D-01, - : 0.7623253594652D-05, 0.2656400462961D+01, 0.3961708870310D-01, - : 0.6248667483971D-05, 0.4992775362055D+01, 0.7329749511860D-01, - : 0.4366353695038D-05, 0.2869706279678D+01, 0.1589072916335D+01, - : 0.3829101568895D-05, 0.3572131359950D+01, 0.7113454667900D-02, - : 0.3175733773908D-05, 0.4535372530045D+01, 0.4194847048887D+00, - : 0.3092437902159D-05, 0.9230153317909D+00, 0.6398972393349D+00 / - DATA ((S0(I,J,2),I=1,3),J= 21, 30) / - : 0.2874168812154D-05, 0.3363143761101D+01, 0.1102062672231D+00, - : 0.3040119321826D-05, 0.3324250895675D+01, 0.6283075850446D+01, - : 0.2699723308006D-05, 0.2917882441928D+00, 0.1030928125552D+00, - : 0.2134832683534D-05, 0.4220997202487D+01, 0.3163918923335D+00, - : 0.1770412139433D-05, 0.4747318496462D+01, 0.1021328554739D+02, - : 0.1377264209373D-05, 0.4305058462401D+00, 0.1484170571900D-02, - : 0.1127814538960D-05, 0.8538177240740D+00, 0.6327837846670D+00, - : 0.1055608090130D-05, 0.1551800742580D+01, 0.4337116142245D+00, - : 0.9802673861420D-06, 0.1459646735377D+01, 0.1052268489556D+01, - : 0.1090329461951D-05, 0.1587351228711D+01, 0.1162474756779D+01 / - DATA ((S0(I,J,2),I=1,3),J= 31, 40) / - : 0.6959590025090D-06, 0.5534442628766D+01, 0.1066495398892D+01, - : 0.5664914529542D-06, 0.6030673003297D+01, 0.9491756770005D+00, - : 0.6607787763599D-06, 0.4989507233927D+01, 0.8460828644453D+00, - : 0.6269725742838D-06, 0.4222951804572D+01, 0.1480791608091D+00, - : 0.6301889697863D-06, 0.5444316669126D+01, 0.2243449970715D+00, - : 0.4891042662861D-06, 0.1490552839784D+01, 0.3340612434717D+01, - : 0.3457083123290D-06, 0.3030475486049D+01, 0.3516457698740D-01, - : 0.3032559967314D-06, 0.2652038793632D+01, 0.1104591729320D-01, - : 0.2841133988903D-06, 0.1276744786829D+01, 0.4110125927500D-01, - : 0.2855564444432D-06, 0.2143368674733D+01, 0.1510475019529D+00 / - DATA ((S0(I,J,2),I=1,3),J= 41, 50) / - : 0.2765157135038D-06, 0.5444186109077D+01, 0.6373574839730D-01, - : 0.2382312465034D-06, 0.2190521137593D+01, 0.2275259891141D+00, - : 0.2808060365077D-06, 0.5735195064841D+01, 0.2535050500000D-01, - : 0.2332175234405D-06, 0.9481985524859D-01, 0.7181332454670D-01, - : 0.2322488199659D-06, 0.5180499361533D+01, 0.8582758298370D-01, - : 0.1881850258423D-06, 0.3219788273885D+01, 0.2118763888447D+01, - : 0.2196111392808D-06, 0.2366941159761D+01, 0.2968341143800D-02, - : 0.2183810335519D-06, 0.4825445110915D+01, 0.7775000683430D-01, - : 0.2002733093326D-06, 0.2457148995307D+01, 0.2093666171530D+00, - : 0.1967111767229D-06, 0.5586291545459D+01, 0.2172315424036D+00 / - DATA ((S0(I,J,2),I=1,3),J= 51, 60) / - : 0.1568473250543D-06, 0.3708003123320D+01, 0.7429900518901D+00, - : 0.1852528314300D-06, 0.4310638151560D+01, 0.2022531624851D+00, - : 0.1832111226447D-06, 0.1494665322656D+01, 0.3235053470014D+00, - : 0.1746805502310D-06, 0.1451378500784D+01, 0.1385174140878D+00, - : 0.1555730966650D-06, 0.1068040418198D+01, 0.7358765972222D+00, - : 0.1554883462559D-06, 0.2442579035461D+01, 0.5154640627760D+00, - : 0.1638380568746D-06, 0.2597913420625D+00, 0.8531963191132D+00, - : 0.1159938593640D-06, 0.5834512021280D+01, 0.1990721704425D+00, - : 0.1083427965695D-06, 0.5054033177950D+01, 0.5439178814476D+00, - : 0.1156480369431D-06, 0.5325677432457D+01, 0.5257585094865D+00 / - DATA ((S0(I,J,2),I=1,3),J= 61, 70) / - : 0.1141308860095D-06, 0.2153403923857D+01, 0.5336234347371D+00, - : 0.7913146470946D-07, 0.8642846847027D+00, 0.1478866649112D+01, - : 0.7439752463733D-07, 0.1970628496213D+01, 0.2164800718209D+00, - : 0.7280277104079D-07, 0.6073307250609D+01, 0.2101180877357D+00, - : 0.8319567719136D-07, 0.1954371928334D+01, 0.1692165728891D+01, - : 0.7137705549290D-07, 0.8904989440909D+00, 0.4155522422634D+00, - : 0.6900825396225D-07, 0.2825717714977D+01, 0.1173197218910D+00, - : 0.7245757216635D-07, 0.2481677513331D+01, 0.1265567569334D+01, - : 0.6961165696255D-07, 0.1292955312978D+01, 0.9562891316684D+00, - : 0.7571804456890D-07, 0.3427517575069D+01, 0.1422690933580D-01 / - DATA ((S0(I,J,2),I=1,3),J= 71, 80) / - : 0.6605425721904D-07, 0.8052192701492D+00, 0.6470106940028D+00, - : 0.7375477357248D-07, 0.1705076390088D+01, 0.1581959461667D+01, - : 0.7041664951470D-07, 0.4848356967891D+00, 0.9597935788730D-01, - : 0.6322199535763D-07, 0.3878069473909D+01, 0.7084920306520D-01, - : 0.5244380279191D-07, 0.2645560544125D+01, 0.5265099800692D+00, - : 0.5143125704988D-07, 0.4834486101370D+01, 0.5328719641544D+00, - : 0.5871866319373D-07, 0.7981472548900D+00, 0.7871412831580D-01, - : 0.6300822573871D-07, 0.5979398788281D+01, 0.2608790314060D+02, - : 0.6062154271548D-07, 0.4108655402756D+01, 0.1114304132498D+00, - : 0.4361912339976D-07, 0.5322624319280D+01, 0.1375773836557D+01 / - DATA ((S0(I,J,2),I=1,3),J= 81, 90) / - : 0.4417005920067D-07, 0.6240817359284D+01, 0.2770348281756D+00, - : 0.4686806749936D-07, 0.3214977301156D+01, 0.1143987543936D+00, - : 0.3758892132305D-07, 0.5879809634765D+01, 0.1596186371003D+01, - : 0.5151351332319D-07, 0.2893377688007D+00, 0.2228608264996D+00, - : 0.4554683578572D-07, 0.5475427144122D+01, 0.1465949902372D+00, - : 0.3442381385338D-07, 0.5992034796640D+01, 0.5070101000000D-01, - : 0.2831093954933D-07, 0.5367350273914D+01, 0.3092784376656D+00, - : 0.3756267090084D-07, 0.5758171285420D+01, 0.4903339079539D+00, - : 0.2816374679892D-07, 0.1863718700923D+01, 0.2991266627620D+00, - : 0.3419307025569D-07, 0.9524347534130D+00, 0.3518164938661D+00 / - DATA ((S0(I,J,2),I=1,3),J= 91,100) / - : 0.2904250494239D-07, 0.5304471615602D+01, 0.1099462426779D+00, - : 0.2471734511206D-07, 0.1297069793530D+01, 0.6256703299991D+00, - : 0.2539620831872D-07, 0.3281126083375D+01, 0.1256615170089D+02, - : 0.2281017868007D-07, 0.1829122133165D+01, 0.6681224869435D+01, - : 0.2275319473335D-07, 0.5797198160181D+01, 0.3932462625300D-02, - : 0.2547755368442D-07, 0.4752697708330D+01, 0.1169588211447D+01, - : 0.2285979669317D-07, 0.1223205292886D+01, 0.1045155034888D+01, - : 0.1913386560994D-07, 0.1757532993389D+01, 0.1155361302111D+01, - : 0.1809020525147D-07, 0.4246116108791D+01, 0.3368040641550D-01, - : 0.1649213300201D-07, 0.1445162890627D+01, 0.4408250688924D+00 / - DATA ((S0(I,J,2),I=1,3),J=101,110) / - : 0.1834972793932D-07, 0.1126917567225D+01, 0.4452511715700D-02, - : 0.1439550648138D-07, 0.6160756834764D+01, 0.9420622223326D+00, - : 0.1487645457041D-07, 0.4358761931792D+01, 0.4123712502208D+00, - : 0.1731729516660D-07, 0.6134456753344D+01, 0.2108507877249D+00, - : 0.1717747163567D-07, 0.1898186084455D+01, 0.2157473718317D+00, - : 0.1418190430374D-07, 0.4180286741266D+01, 0.6521991896920D-01, - : 0.1404844134873D-07, 0.7654053565412D-01, 0.4258542984690D-01, - : 0.1409842846538D-07, 0.4418612420312D+01, 0.2258291676434D+00, - : 0.1090948346291D-07, 0.1260615686131D+01, 0.4226656969313D+00, - : 0.1357577323612D-07, 0.3558248818690D+01, 0.7923417740620D-01 / - DATA ((S0(I,J,2),I=1,3),J=111,120) / - : 0.1018154061960D-07, 0.5676087241256D+01, 0.1456308687557D+00, - : 0.1412073972109D-07, 0.8394392632422D+00, 0.1525316725248D+00, - : 0.1030938326496D-07, 0.1653593274064D+01, 0.1795258541446D+01, - : 0.1180081567104D-07, 0.1285802592036D+01, 0.7032915397480D-01, - : 0.9708510575650D-08, 0.7631889488106D+00, 0.8434341241180D-01, - : 0.9637689663447D-08, 0.4630642649176D+01, 0.1272681024002D+01, - : 0.1068910429389D-07, 0.5294934032165D+01, 0.2123349582968D+00, - : 0.1063716179336D-07, 0.2736266800832D+01, 0.2142632012598D+00, - : 0.1234858713814D-07, 0.1302891146570D+01, 0.1847279083684D+00, - : 0.8912631189738D-08, 0.3570415993621D+01, 0.2648454860559D+01 / - DATA ((S0(I,J,2),I=1,3),J=121,130) / - : 0.1036378285534D-07, 0.4236693440949D+01, 0.1370332435159D+00, - : 0.9667798501561D-08, 0.2960768892398D+01, 0.4376440768498D+00, - : 0.8108314201902D-08, 0.6987781646841D+00, 0.2880807454688D+00, - : 0.7648364324628D-08, 0.2499017863863D+01, 0.2037373330570D+00, - : 0.7286136828406D-08, 0.3787426951665D+01, 0.1129145838217D+00, - : 0.9448237743913D-08, 0.2694354332983D+01, 0.5272426800584D+00, - : 0.9374276106428D-08, 0.4787121277064D+01, 0.5321392641652D+00, - : 0.7100226287462D-08, 0.3530238792101D+00, 0.6288513220417D+00, - : 0.9253056659571D-08, 0.1399478925664D+01, 0.1606092486742D+00, - : 0.6636432145504D-08, 0.3479575438447D+01, 0.1368660381889D+01 / - DATA ((S0(I,J,2),I=1,3),J=131,140) / - : 0.6469975312932D-08, 0.1383669964800D+01, 0.2008557621224D+01, - : 0.7335849729765D-08, 0.1243698166898D+01, 0.9561746721300D-02, - : 0.8743421205855D-08, 0.3776164289301D+01, 0.3801276407308D+00, - : 0.5993635744494D-08, 0.5627122113596D+01, 0.2042657109477D+02, - : 0.5981008479693D-08, 0.1674336636752D+01, 0.2111650433779D+01, - : 0.6188535145838D-08, 0.5214925208672D+01, 0.4305306221819D+00, - : 0.6596074017566D-08, 0.2907653268124D+01, 0.1063314406849D+01, - : 0.6630815126226D-08, 0.2127643669658D+01, 0.8389694097774D+00, - : 0.6156772830040D-08, 0.5082160803295D+01, 0.4234171675140D+00, - : 0.6446960563014D-08, 0.1872100916905D+01, 0.5287268506303D+00 / - DATA ((S0(I,J,2),I=1,3),J=141,150) / - : 0.6429324424668D-08, 0.5610276103577D+01, 0.5306550935933D+00, - : 0.6302232396465D-08, 0.1592152049607D+01, 0.1253008786510D-01, - : 0.6399244436159D-08, 0.2746214421532D+01, 0.5217580628120D+02, - : 0.5474965172558D-08, 0.2317666374383D+01, 0.2221856701002D+01, - : 0.5339293190692D-08, 0.1084724961156D+01, 0.7466759693650D-01, - : 0.5334733683389D-08, 0.3594106067745D+01, 0.7489573444450D-01, - : 0.5392665782110D-08, 0.5630254365606D+01, 0.1055449481598D+01, - : 0.6682075673789D-08, 0.1518480041732D+01, 0.2213766559277D+00, - : 0.5079130495960D-08, 0.2739765115711D+01, 0.2132517061319D+00, - : 0.5077759793261D-08, 0.5290711290094D+01, 0.2133464534247D+00 / - DATA ((S0(I,J,2),I=1,3),J=151,160) / - : 0.4832037368310D-08, 0.1404473217200D+01, 0.7160067364790D-01, - : 0.6463279674802D-08, 0.6038381695210D+01, 0.2209183458640D-01, - : 0.6240592771560D-08, 0.1290170653666D+01, 0.3306188016693D+00, - : 0.4672013521493D-08, 0.3261895939677D+01, 0.7796265773310D-01, - : 0.6500650750348D-08, 0.1154522312095D+01, 0.3884652414254D+00, - : 0.6344161389053D-08, 0.6206111545062D+01, 0.7605151500000D-01, - : 0.4682518370646D-08, 0.5409118796685D+01, 0.1073608853559D+01, - : 0.5329460015591D-08, 0.1202985784864D+01, 0.7287631425543D+00, - : 0.5701588675898D-08, 0.4098715257064D+01, 0.8731175355560D-01, - : 0.6030690867211D-08, 0.4132033218460D+00, 0.9846002785331D+00 / - DATA ((S0(I,J,2),I=1,3),J=161,170) / - : 0.4336256312655D-08, 0.1211415991827D+01, 0.4297791515992D+00, - : 0.4688498808975D-08, 0.3765479072409D+01, 0.2127790306879D+00, - : 0.4675578609335D-08, 0.4265540037226D+01, 0.2138191288687D+00, - : 0.4225578112158D-08, 0.5237566010676D+01, 0.3407705765729D+00, - : 0.5139422230028D-08, 0.1507173079513D+01, 0.7233337363710D-01, - : 0.4619995093571D-08, 0.9023957449848D-01, 0.8603097737811D+00, - : 0.4494776255461D-08, 0.5414930552139D+00, 0.7381754420900D-01, - : 0.4274026276788D-08, 0.4145735303659D+01, 0.7574578717200D-01, - : 0.5018141789353D-08, 0.3344408829055D+01, 0.3180992042600D-02, - : 0.4866163952181D-08, 0.3348534657607D+01, 0.7722995774390D-01 / - DATA ((S0(I,J,2),I=1,3),J=171,180) / - : 0.4111986020501D-08, 0.4198823597220D+00, 0.1451108196653D+00, - : 0.3356142784950D-08, 0.5609144747180D+01, 0.1274714967946D+00, - : 0.4070575554551D-08, 0.7028411059224D+00, 0.3503323232942D+00, - : 0.3257451857278D-08, 0.5624697983086D+01, 0.5296435984654D+00, - : 0.3256973703026D-08, 0.1857842076707D+01, 0.5297383457582D+00, - : 0.3830771508640D-08, 0.4562887279931D+01, 0.9098186128426D+00, - : 0.3725024005962D-08, 0.2358058692652D+00, 0.1084620721060D+00, - : 0.3136763921756D-08, 0.2049731526845D+01, 0.2346394437820D+00, - : 0.3795147256194D-08, 0.2432356296933D+00, 0.1862120789403D+00, - : 0.2877342229911D-08, 0.5631101279387D+01, 0.1905464808669D+01 / - DATA ((S0(I,J,2),I=1,3),J=181,190) / - : 0.3076931798805D-08, 0.1117615737392D+01, 0.3628624111593D+00, - : 0.2734765945273D-08, 0.5899826516955D+01, 0.2131850110243D+00, - : 0.2733405296885D-08, 0.2130562964070D+01, 0.2134131485323D+00, - : 0.2898552353410D-08, 0.3462387048225D+00, 0.5291709230214D+00, - : 0.2893736103681D-08, 0.8534352781543D+00, 0.5302110212022D+00, - : 0.3095717734137D-08, 0.2875061429041D+01, 0.2976424921901D+00, - : 0.2636190425832D-08, 0.2242512846659D+01, 0.1485980103780D+01, - : 0.3645512095537D-08, 0.1354016903958D+01, 0.6044726378023D+00, - : 0.2808173547723D-08, 0.6705114365631D-01, 0.6225157782540D-01, - : 0.2625012866888D-08, 0.4775705748482D+01, 0.5268983110410D-01 / - DATA ((S0(I,J,2),I=1,3),J=191,200) / - : 0.2572233995651D-08, 0.2638924216139D+01, 0.1258454114666D+01, - : 0.2604238824792D-08, 0.4826358927373D+01, 0.2103781122809D+00, - : 0.2596886385239D-08, 0.3200388483118D+01, 0.2162200472757D+00, - : 0.3228057304264D-08, 0.5384848409563D+01, 0.2007689919132D+00, - : 0.2481601798252D-08, 0.5173373487744D+01, 0.1062562936266D+01, - : 0.2745977498864D-08, 0.6250966149853D+01, 0.5651155736444D+00, - : 0.2669878833811D-08, 0.4906001352499D+01, 0.1400015846597D+00, - : 0.3203986611711D-08, 0.5034333010005D+01, 0.7036329877322D+00, - : 0.3354961227212D-08, 0.6108262423137D+01, 0.4549093064213D+00, - : 0.2400407324558D-08, 0.2135399294955D+01, 0.2125476091956D+00 / - DATA ((S0(I,J,2),I=1,3),J=201,210) / - : 0.2379905859802D-08, 0.5893721933961D+01, 0.2140505503610D+00, - : 0.2550844302187D-08, 0.3331940762063D+01, 0.1534957940063D+00, - : 0.2268824211001D-08, 0.1843418461035D+01, 0.2235935264888D+00, - : 0.2464700891204D-08, 0.3029548547230D+01, 0.2091065926078D+00, - : 0.2436814726024D-08, 0.4994717970364D+01, 0.2174915669488D+00, - : 0.2443623894745D-08, 0.2645102591375D+01, 0.1739420156204D+00, - : 0.2318701783838D-08, 0.5700547397897D+01, 0.7530171478090D-01, - : 0.2284448700256D-08, 0.5268898905872D+01, 0.7426161660010D-01, - : 0.2468848123510D-08, 0.5276280575078D+01, 0.2526561439362D+00, - : 0.2814052350303D-08, 0.6130168623475D+01, 0.5636314030725D+00 / - DATA ((S0(I,J,2),I=1,3),J=211,NS0Y) / - : 0.2243662755220D-08, 0.6631692457995D+00, 0.8886590321940D-01, - : 0.2330795855941D-08, 0.2499435487702D+01, 0.1056200952181D+01, - : 0.9757679038404D-09, 0.5796846023126D+01, 0.7826370942180D+02 / - -* SSB-to-Sun, T^1, Y - DATA ((S1(I,J,2),I=1,3),J= 1, 10) / - : 0.8989047573576D-08, 0.5840593672122D+01, 0.4265981595566D+00, - : 0.7815938401048D-08, 0.1129664707133D+01, 0.2061856251104D+00, - : 0.7550926713280D-08, 0.6196589104845D+00, 0.2204125344462D+00, - : 0.6056556925895D-08, 0.1677494667846D+01, 0.1059381944224D+01, - : 0.5734142698204D-08, 0.4000920852962D+01, 0.5225775174439D+00, - : 0.5614341822459D-08, 0.3486722577328D+01, 0.5368044267797D+00, - : 0.1028678147656D-08, 0.1877141024787D+01, 0.7113454667900D-02, - : 0.7270792075266D-09, 0.5077167301739D+01, 0.6398972393349D+00, - : 0.8734141726040D-09, 0.9069550282609D-01, 0.4194847048887D+00, - : 0.5377371402113D-09, 0.6039381844671D+01, 0.4337116142245D+00 / - DATA ((S1(I,J,2),I=1,3),J= 11, 20) / - : 0.4729719431571D-09, 0.2153086311760D+01, 0.2132990797783D+00, - : 0.4458052820973D-09, 0.5059830025565D+01, 0.5296909721118D+00, - : 0.4406855467908D-09, 0.2027971692630D+01, 0.1589072916335D+01, - : 0.3101659310977D-09, 0.3317677981860D+01, 0.1052268489556D+01, - : 0.3016749232545D-09, 0.3913703482532D+01, 0.1066495398892D+01, - : 0.3198541352656D-09, 0.1275513098525D+01, 0.1495633313810D+00, - : 0.2142065389871D-09, 0.5301351614597D+01, 0.3163918923335D+00, - : 0.1902615247592D-09, 0.4894943352736D+00, 0.2275259891141D+00, - : 0.1613410990871D-09, 0.2449891130437D+01, 0.1102062672231D+00, - : 0.1576992165097D-09, 0.4211421447633D+01, 0.7626583626240D-01 / - DATA ((S1(I,J,2),I=1,3),J= 21, 30) / - : 0.1241637259894D-09, 0.4140803368133D+01, 0.5154640627760D+00, - : 0.1313974830355D-09, 0.3591920305503D+01, 0.3664874755930D-01, - : 0.1181697118258D-09, 0.1506314382788D+01, 0.6327837846670D+00, - : 0.1238239742779D-09, 0.7461405378404D+00, 0.3961708870310D-01, - : 0.1010107068241D-09, 0.6271010795475D+00, 0.7329749511860D-01, - : 0.9226316616509D-10, 0.1259158839583D+01, 0.1990721704425D+00, - : 0.8664946419555D-10, 0.3353244696934D+01, 0.5439178814476D+00, - : 0.7757230468978D-10, 0.1447677295196D+01, 0.9491756770005D+00, - : 0.7693168628139D-10, 0.1120509896721D+01, 0.1030928125552D+00, - : 0.5487897454612D-10, 0.4439380426795D+01, 0.8531963191132D+00 / - DATA ((S1(I,J,2),I=1,3),J= 31, 40) / - : 0.5196118677218D-10, 0.3788856619137D+00, 0.2093666171530D+00, - : 0.5110853339935D-10, 0.1386879372016D+01, 0.2172315424036D+00, - : 0.5027804534813D-10, 0.1647881805466D+00, 0.2164800718209D+00, - : 0.4922485922674D-10, 0.1594315079862D+01, 0.2101180877357D+00, - : 0.6155599524400D-10, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.4447147832161D-10, 0.5480720918976D+01, 0.3235053470014D+00, - : 0.4144691276422D-10, 0.1931371033660D+01, 0.6373574839730D-01, - : 0.4099950625452D-10, 0.5229611294335D+01, 0.6470106940028D+00, - : 0.5060541682953D-10, 0.1731112486298D+01, 0.1422690933580D-01, - : 0.4293615946300D-10, 0.2714571038925D+01, 0.7358765972222D+00 / - DATA ((S1(I,J,2),I=1,3),J= 41,NS1Y) / - : 0.3545659845763D-10, 0.4451041444634D+01, 0.5265099800692D+00, - : 0.3479112041196D-10, 0.3029385448081D+01, 0.5328719641544D+00, - : 0.3438516493570D-10, 0.2778507143731D+01, 0.8582758298370D-01, - : 0.3297341285033D-10, 0.7898709807584D+00, 0.1104591729320D-01, - : 0.2972585818015D-10, 0.3218785316973D+01, 0.5257585094865D+00, - : 0.2931707295017D-10, 0.4260731012098D+01, 0.5336234347371D+00, - : 0.2897198149403D-10, 0.1120753978101D+01, 0.1173197218910D+00, - : 0.2832293240878D-10, 0.4597682717827D+00, 0.2022531624851D+00, - : 0.2864348326612D-10, 0.2169939928448D+01, 0.9597935788730D-01, - : 0.2852714675471D-10, 0.2377659870578D+01, 0.2118763888447D+01 / - -* SSB-to-Sun, T^2, Y - DATA ((S2(I,J,2),I=1,3),J= 1,NS2Y) / - : 0.1609114495091D-11, 0.2831096993481D+01, 0.2061856251104D+00, - : 0.1560330784946D-11, 0.5193058213906D+01, 0.2204125344462D+00, - : 0.1183535479202D-11, 0.5707003443890D+01, 0.5225775174439D+00, - : 0.1158183066182D-11, 0.1782400404928D+01, 0.5368044267797D+00, - : 0.1032868027407D-11, 0.4036925452011D+01, 0.2132990797783D+00, - : 0.6540142847741D-12, 0.4058241056717D+01, 0.4265981595566D+00, - : 0.7305236491596D-12, 0.6175401942957D+00, 0.5296909721118D+00, - : -0.5580725052968D-12, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.3946122651015D-12, 0.4108265279171D+00, 0.1059381944224D+01 / - -* SSB-to-Sun, T^0, Z - DATA ((S0(I,J,3),I=1,3),J= 1, 10) / - : 0.1181255122986D-03, 0.4607918989164D+00, 0.2132990797783D+00, - : 0.1127777651095D-03, 0.4169146331296D+00, 0.5296909721118D+00, - : 0.4777754401806D-04, 0.4582657007130D+01, 0.3813291813120D-01, - : 0.1129354285772D-04, 0.5758735142480D+01, 0.7478166569050D-01, - : -0.1149543637123D-04, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.3298730512306D-05, 0.5978801994625D+01, 0.4265981595566D+00, - : 0.2733376706079D-05, 0.7665413691040D+00, 0.1059381944224D+01, - : 0.9426389657270D-06, 0.3710201265838D+01, 0.2061856251104D+00, - : 0.8187517749552D-06, 0.3390675605802D+00, 0.2204125344462D+00, - : 0.4080447871819D-06, 0.4552296640088D+00, 0.5225775174439D+00 / - DATA ((S0(I,J,3),I=1,3),J= 11, 20) / - : 0.3169973017028D-06, 0.3445455899321D+01, 0.5368044267797D+00, - : 0.2438098615549D-06, 0.5664675150648D+01, 0.3664874755930D-01, - : 0.2601897517235D-06, 0.1931894095697D+01, 0.1495633313810D+00, - : 0.2314558080079D-06, 0.3666319115574D+00, 0.3961708870310D-01, - : 0.1962549548002D-06, 0.3167411699020D+01, 0.7626583626240D-01, - : 0.2180518287925D-06, 0.1544420746580D+01, 0.7113454667900D-02, - : 0.1451382442868D-06, 0.1583756740070D+01, 0.1102062672231D+00, - : 0.1358439007389D-06, 0.5239941758280D+01, 0.6398972393349D+00, - : 0.1050585898028D-06, 0.2266958352859D+01, 0.3163918923335D+00, - : 0.1050029870186D-06, 0.2711495250354D+01, 0.4194847048887D+00 / - DATA ((S0(I,J,3),I=1,3),J= 21, 30) / - : 0.9934920679800D-07, 0.1116208151396D+01, 0.1589072916335D+01, - : 0.1048395331560D-06, 0.3408619600206D+01, 0.1021328554739D+02, - : 0.8370147196668D-07, 0.3810459401087D+01, 0.2535050500000D-01, - : 0.7989856510998D-07, 0.3769910473647D+01, 0.7329749511860D-01, - : 0.5441221655233D-07, 0.2416994903374D+01, 0.1030928125552D+00, - : 0.4610812906784D-07, 0.5858503336994D+01, 0.4337116142245D+00, - : 0.3923022803444D-07, 0.3354170010125D+00, 0.1484170571900D-02, - : 0.2610725582128D-07, 0.5410600646324D+01, 0.6327837846670D+00, - : 0.2455279767721D-07, 0.6120216681403D+01, 0.1162474756779D+01, - : 0.2375530706525D-07, 0.6055443426143D+01, 0.1052268489556D+01 / - DATA ((S0(I,J,3),I=1,3),J= 31, 40) / - : 0.1782967577553D-07, 0.3146108708004D+01, 0.8460828644453D+00, - : 0.1581687095238D-07, 0.6255496089819D+00, 0.3340612434717D+01, - : 0.1594657672461D-07, 0.3782604300261D+01, 0.1066495398892D+01, - : 0.1563448615040D-07, 0.1997775733196D+01, 0.2022531624851D+00, - : 0.1463624258525D-07, 0.1736316792088D+00, 0.3516457698740D-01, - : 0.1331585056673D-07, 0.4331941830747D+01, 0.9491756770005D+00, - : 0.1130634557637D-07, 0.6152017751825D+01, 0.2968341143800D-02, - : 0.1028949607145D-07, 0.2101792614637D+00, 0.2275259891141D+00, - : 0.1024074971618D-07, 0.4071833211074D+01, 0.5070101000000D-01, - : 0.8826956060303D-08, 0.4861633688145D+00, 0.2093666171530D+00 / - DATA ((S0(I,J,3),I=1,3),J= 41, 50) / - : 0.8572230171541D-08, 0.5268190724302D+01, 0.4110125927500D-01, - : 0.7649332643544D-08, 0.5134543417106D+01, 0.2608790314060D+02, - : 0.8581673291033D-08, 0.2920218146681D+01, 0.1480791608091D+00, - : 0.8430589300938D-08, 0.3604576619108D+01, 0.2172315424036D+00, - : 0.7776165501012D-08, 0.3772942249792D+01, 0.6373574839730D-01, - : 0.8311070234408D-08, 0.6200412329888D+01, 0.3235053470014D+00, - : 0.6927365212582D-08, 0.4543353113437D+01, 0.8531963191132D+00, - : 0.6791574208598D-08, 0.2882188406238D+01, 0.7181332454670D-01, - : 0.5593100811839D-08, 0.1776646892780D+01, 0.7429900518901D+00, - : 0.4553381853021D-08, 0.3949617611240D+01, 0.7775000683430D-01 / - DATA ((S0(I,J,3),I=1,3),J= 51, 60) / - : 0.5758000450068D-08, 0.3859251775075D+01, 0.1990721704425D+00, - : 0.4281283457133D-08, 0.1466294631206D+01, 0.2118763888447D+01, - : 0.4206935661097D-08, 0.5421776011706D+01, 0.1104591729320D-01, - : 0.4213751641837D-08, 0.3412048993322D+01, 0.2243449970715D+00, - : 0.5310506239878D-08, 0.5421641370995D+00, 0.5154640627760D+00, - : 0.3827450341320D-08, 0.8887314524995D+00, 0.1510475019529D+00, - : 0.4292435241187D-08, 0.1405043757194D+01, 0.1422690933580D-01, - : 0.3189780702289D-08, 0.1060049293445D+01, 0.1173197218910D+00, - : 0.3226611928069D-08, 0.6270858897442D+01, 0.2164800718209D+00, - : 0.2893897608830D-08, 0.5117563223301D+01, 0.6470106940028D+00 / - DATA ((S0(I,J,3),I=1,3),J= 61,NS0Z) / - : 0.3239852024578D-08, 0.4079092237983D+01, 0.2101180877357D+00, - : 0.2956892222200D-08, 0.1594917021704D+01, 0.3092784376656D+00, - : 0.2980177912437D-08, 0.5258787667564D+01, 0.4155522422634D+00, - : 0.3163725690776D-08, 0.3854589225479D+01, 0.8582758298370D-01, - : 0.2662262399118D-08, 0.3561326430187D+01, 0.5257585094865D+00, - : 0.2766689135729D-08, 0.3180732086830D+00, 0.1385174140878D+00, - : 0.2411600278464D-08, 0.3324798335058D+01, 0.5439178814476D+00, - : 0.2483527695131D-08, 0.4169069291947D+00, 0.5336234347371D+00, - : 0.7788777276590D-09, 0.1900569908215D+01, 0.5217580628120D+02 / - -* SSB-to-Sun, T^1, Z - DATA ((S1(I,J,3),I=1,3),J= 1, 10) / - : 0.5444220475678D-08, 0.1803825509310D+01, 0.2132990797783D+00, - : 0.3883412695596D-08, 0.4668616389392D+01, 0.5296909721118D+00, - : 0.1334341434551D-08, 0.0000000000000D+00, 0.0000000000000D+00, - : 0.3730001266883D-09, 0.5401405918943D+01, 0.2061856251104D+00, - : 0.2894929197956D-09, 0.4932415609852D+01, 0.2204125344462D+00, - : 0.2857950357701D-09, 0.3154625362131D+01, 0.7478166569050D-01, - : 0.2499226432292D-09, 0.3657486128988D+01, 0.4265981595566D+00, - : 0.1937705443593D-09, 0.5740434679002D+01, 0.1059381944224D+01, - : 0.1374894396320D-09, 0.1712857366891D+01, 0.5368044267797D+00, - : 0.1217248678408D-09, 0.2312090870932D+01, 0.5225775174439D+00 / - DATA ((S1(I,J,3),I=1,3),J= 11,NS1Z) / - : 0.7961052740870D-10, 0.5283368554163D+01, 0.3813291813120D-01, - : 0.4979225949689D-10, 0.4298290471860D+01, 0.4194847048887D+00, - : 0.4388552286597D-10, 0.6145515047406D+01, 0.7113454667900D-02, - : 0.2586835212560D-10, 0.3019448001809D+01, 0.6398972393349D+00 / - -* SSB-to-Sun, T^2, Z - DATA ((S2(I,J,3),I=1,3),J= 1,NS2Z) / - : 0.3749920358054D-12, 0.3230285558668D+01, 0.2132990797783D+00, - : 0.2735037220939D-12, 0.6154322683046D+01, 0.5296909721118D+00 / - -* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -* Time since reference epoch, years. - T = ( DATE - DJM0 ) / DJY - T2 = T*T - -* X then Y then Z. - DO K=1,3 - -* Initialize position and velocity component. - XYZ = 0D0 - XYZD = 0D0 - -* ------------------------------------------------ -* Obtain component of Sun to Earth ecliptic vector -* ------------------------------------------------ - -* Sun to Earth, T^0 terms. - DO J=1,NE0(K) - A = E0(1,J,K) - B = E0(2,J,K) - C = E0(3,J,K) - P = B + C*T - XYZ = XYZ + A*COS(P) - XYZD = XYZD - A*C*SIN(P) - END DO - -* Sun to Earth, T^1 terms. - DO J=1,NE1(K) - A = E1(1,J,K) - B = E1(2,J,K) - C = E1(3,J,K) - CT = C*T - P = B + CT - CP = COS(P) - XYZ = XYZ + A*T*CP - XYZD = XYZD + A*(CP-CT*SIN(P)) - END DO - -* Sun to Earth, T^2 terms. - DO J=1,NE2(K) - A = E2(1,J,K) - B = E2(2,J,K) - C = E2(3,J,K) - CT = C*T - P = B + CT - CP = COS(P) - XYZ = XYZ + A*T2*CP - XYZD = XYZD + A*T*(2D0*CP-CT*SIN(P)) - END DO - -* Heliocentric Earth position and velocity component. - HP(K) = XYZ - HV(K) = XYZD / DJY - -* ------------------------------------------------ -* Obtain component of SSB to Earth ecliptic vector -* ------------------------------------------------ - -* SSB to Sun, T^0 terms. - DO J=1,NS0(K) - A = S0(1,J,K) - B = S0(2,J,K) - C = S0(3,J,K) - P = B + C*T - XYZ = XYZ + A*COS(P) - XYZD = XYZD - A*C*SIN(P) - END DO - -* SSB to Sun, T^1 terms. - DO J=1,NS1(K) - A = S1(1,J,K) - B = S1(2,J,K) - C = S1(3,J,K) - CT = C*T - P = B + CT - CP = COS(P) - XYZ = XYZ + A*T*CP - XYZD = XYZD + A*(CP-CT*SIN(P)) - END DO - -* SSB to Sun, T^2 terms. - DO J=1,NS2(K) - A = S2(1,J,K) - B = S2(2,J,K) - C = S2(3,J,K) - CT = C*T - P = B + CT - CP = COS(P) - XYZ = XYZ + A*T2*CP - XYZD = XYZD + A*T*(2D0*CP-CT*SIN(P)) - END DO - -* Barycentric Earth position and velocity component. - BP(K) = XYZ - BV(K) = XYZD / DJY - -* Next Cartesian component. - END DO - -* Rotate from ecliptic to ICRS coordinates and return the results. - X = HP(1) - Y = HP(2) - Z = HP(3) - PH(1) = X + AM12*Y + AM13*Z - PH(2) = AM21*X + AM22*Y + AM23*Z - PH(3) = AM32*Y + AM33*Z - X = HV(1) - Y = HV(2) - Z = HV(3) - VH(1) = X + AM12*Y + AM13*Z - VH(2) = AM21*X + AM22*Y + AM23*Z - VH(3) = AM32*Y + AM33*Z - X = BP(1) - Y = BP(2) - Z = BP(3) - PB(1) = X + AM12*Y + AM13*Z - PB(2) = AM21*X + AM22*Y + AM23*Z - PB(3) = AM32*Y + AM33*Z - X = BV(1) - Y = BV(2) - Z = BV(3) - VB(1) = X + AM12*Y + AM13*Z - VB(2) = AM21*X + AM22*Y + AM23*Z - VB(3) = AM32*Y + AM33*Z - - END diff --git a/src/slalib/eqecl.f b/src/slalib/eqecl.f deleted file mode 100644 index dab59eed8..000000000 --- a/src/slalib/eqecl.f +++ /dev/null @@ -1,72 +0,0 @@ - SUBROUTINE sla_EQECL (DR, DD, DATE, DL, DB) -*+ -* - - - - - - -* E Q E C L -* - - - - - - -* -* Transformation from J2000.0 equatorial coordinates to -* ecliptic coordinates (double precision) -* -* Given: -* DR,DD dp J2000.0 mean RA,Dec (radians) -* DATE dp TDB (loosely ET) as Modified Julian Date -* (JD-2400000.5) -* Returned: -* DL,DB dp ecliptic longitude and latitude -* (mean of date, IAU 1980 theory, radians) -* -* Called: -* sla_DCS2C, sla_PREC, sla_EPJ, sla_DMXV, sla_ECMAT, sla_DCC2S, -* sla_DRANRM, sla_DRANGE -* -* P.T.Wallace Starlink March 1986 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DR,DD,DATE,DL,DB - - DOUBLE PRECISION sla_EPJ,sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION RMAT(3,3),V1(3),V2(3) - - - -* Spherical to Cartesian - CALL sla_DCS2C(DR,DD,V1) - -* Mean J2000 to mean of date - CALL sla_PREC(2000D0,sla_EPJ(DATE),RMAT) - CALL sla_DMXV(RMAT,V1,V2) - -* Equatorial to ecliptic - CALL sla_ECMAT(DATE,RMAT) - CALL sla_DMXV(RMAT,V2,V1) - -* Cartesian to spherical - CALL sla_DCC2S(V1,DL,DB) - -* Express in conventional ranges - DL=sla_DRANRM(DL) - DB=sla_DRANGE(DB) - - END diff --git a/src/slalib/eqeqx.f b/src/slalib/eqeqx.f deleted file mode 100644 index 51669cb4b..000000000 --- a/src/slalib/eqeqx.f +++ /dev/null @@ -1,74 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_EQEQX (DATE) -*+ -* - - - - - - -* E Q E Q X -* - - - - - - -* -* Equation of the equinoxes (IAU 1994, double precision) -* -* Given: -* DATE dp TDB (loosely ET) as Modified Julian Date -* (JD-2400000.5) -* -* The result is the equation of the equinoxes (double precision) -* in radians: -* -* Greenwich apparent ST = GMST + sla_EQEQX -* -* References: IAU Resolution C7, Recommendation 3 (1994) -* Capitaine, N. & Gontier, A.-M., Astron. Astrophys., -* 275, 645-650 (1993) -* -* Called: sla_NUTC -* -* Patrick Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - -* Turns to arc seconds and arc seconds to radians - DOUBLE PRECISION T2AS,AS2R - PARAMETER (T2AS=1296000D0, - : AS2R=0.484813681109535994D-5) - - DOUBLE PRECISION T,OM,DPSI,DEPS,EPS0 - - - -* Interval between basic epoch J2000.0 and current epoch (JC) - T=(DATE-51544.5D0)/36525D0 - -* Longitude of the mean ascending node of the lunar orbit on the -* ecliptic, measured from the mean equinox of date - OM=AS2R*(450160.280D0+(-5D0*T2AS-482890.539D0 - : +(7.455D0+0.008D0*T)*T)*T) - -* Nutation - CALL sla_NUTC(DATE,DPSI,DEPS,EPS0) - -* Equation of the equinoxes - sla_EQEQX=DPSI*COS(EPS0)+AS2R*(0.00264D0*SIN(OM)+ - : 0.000063D0*SIN(OM+OM)) - - END diff --git a/src/slalib/eqgal.f b/src/slalib/eqgal.f deleted file mode 100644 index 56b527e63..000000000 --- a/src/slalib/eqgal.f +++ /dev/null @@ -1,96 +0,0 @@ - SUBROUTINE sla_EQGAL (DR, DD, DL, DB) -*+ -* - - - - - - -* E Q G A L -* - - - - - - -* -* Transformation from J2000.0 equatorial coordinates to -* IAU 1958 galactic coordinates (double precision) -* -* Given: -* DR,DD dp J2000.0 RA,Dec -* -* Returned: -* DL,DB dp galactic longitude and latitude L2,B2 -* -* (all arguments are radians) -* -* Called: -* sla_DCS2C, sla_DMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE -* -* Note: -* The equatorial coordinates are J2000.0. Use the routine -* sla_EG50 if conversion from B1950.0 'FK4' coordinates is -* required. -* -* Reference: -* Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960) -* -* P.T.Wallace Starlink 21 September 1998 -* -* Copyright (C) 1998 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DR,DD,DL,DB - - DOUBLE PRECISION sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION V1(3),V2(3) - -* -* L2,B2 system of galactic coordinates -* -* P = 192.25 RA of galactic north pole (mean B1950.0) -* Q = 62.6 inclination of galactic to mean B1950.0 equator -* R = 33 longitude of ascending node -* -* P,Q,R are degrees -* -* Equatorial to galactic rotation matrix (J2000.0), obtained by -* applying the standard FK4 to FK5 transformation, for zero proper -* motion in FK5, to the columns of the B1950 equatorial to -* galactic rotation matrix: -* - DOUBLE PRECISION RMAT(3,3) - DATA RMAT(1,1),RMAT(1,2),RMAT(1,3), - : RMAT(2,1),RMAT(2,2),RMAT(2,3), - : RMAT(3,1),RMAT(3,2),RMAT(3,3)/ - : -0.054875539726D0,-0.873437108010D0,-0.483834985808D0, - : +0.494109453312D0,-0.444829589425D0,+0.746982251810D0, - : -0.867666135858D0,-0.198076386122D0,+0.455983795705D0/ - - - -* Spherical to Cartesian - CALL sla_DCS2C(DR,DD,V1) - -* Equatorial to galactic - CALL sla_DMXV(RMAT,V1,V2) - -* Cartesian to spherical - CALL sla_DCC2S(V2,DL,DB) - -* Express in conventional ranges - DL=sla_DRANRM(DL) - DB=sla_DRANGE(DB) - - END diff --git a/src/slalib/etrms.f b/src/slalib/etrms.f deleted file mode 100644 index bb2696ce7..000000000 --- a/src/slalib/etrms.f +++ /dev/null @@ -1,79 +0,0 @@ - SUBROUTINE sla_ETRMS (EP, EV) -*+ -* - - - - - - -* E T R M S -* - - - - - - -* -* Compute the E-terms (elliptic component of annual aberration) -* vector (double precision) -* -* Given: -* EP dp Besselian epoch -* -* Returned: -* EV dp(3) E-terms as (dx,dy,dz) -* -* Note the use of the J2000 aberration constant (20.49552 arcsec). -* This is a reflection of the fact that the E-terms embodied in -* existing star catalogues were computed from a variety of -* aberration constants. Rather than adopting one of the old -* constants the latest value is used here. -* -* References: -* 1 Smith, C.A. et al., 1989. Astr.J. 97, 265. -* 2 Yallop, B.D. et al., 1989. Astr.J. 97, 274. -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EP,EV(3) - -* Arcseconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - - DOUBLE PRECISION T,E,E0,P,EK,CP - - - -* Julian centuries since B1950 - T=(EP-1950D0)*1.00002135903D-2 - -* Eccentricity - E=0.01673011D0-(0.00004193D0+0.000000126D0*T)*T - -* Mean obliquity - E0=(84404.836D0-(46.8495D0+(0.00319D0+0.00181D0*T)*T)*T)*AS2R - -* Mean longitude of perihelion - P=(1015489.951D0+(6190.67D0+(1.65D0+0.012D0*T)*T)*T)*AS2R - -* E-terms - EK=E*20.49552D0*AS2R - CP=COS(P) - EV(1)= EK*SIN(P) - EV(2)=-EK*CP*COS(E0) - EV(3)=-EK*CP*SIN(E0) - - END diff --git a/src/slalib/euler.f b/src/slalib/euler.f deleted file mode 100644 index 54a6660c8..000000000 --- a/src/slalib/euler.f +++ /dev/null @@ -1,85 +0,0 @@ - SUBROUTINE sla_EULER (ORDER, PHI, THETA, PSI, RMAT) -*+ -* - - - - - - -* E U L E R -* - - - - - - -* -* Form a rotation matrix from the Euler angles - three successive -* rotations about specified Cartesian axes (single precision) -* -* Given: -* ORDER c*(*) specifies about which axes the rotations occur -* PHI r 1st rotation (radians) -* THETA r 2nd rotation ( " ) -* PSI r 3rd rotation ( " ) -* -* Returned: -* RMAT r(3,3) rotation matrix -* -* A rotation is positive when the reference frame rotates -* anticlockwise as seen looking towards the origin from the -* positive region of the specified axis. -* -* The characters of ORDER define which axes the three successive -* rotations are about. A typical value is 'ZXZ', indicating that -* RMAT is to become the direction cosine matrix corresponding to -* rotations of the reference frame through PHI radians about the -* old Z-axis, followed by THETA radians about the resulting X-axis, -* then PSI radians about the resulting Z-axis. -* -* The axis names can be any of the following, in any order or -* combination: X, Y, Z, uppercase or lowercase, 1, 2, 3. Normal -* axis labelling/numbering conventions apply; the xyz (=123) -* triad is right-handed. Thus, the 'ZXZ' example given above -* could be written 'zxz' or '313' (or even 'ZxZ' or '3xZ'). ORDER -* is terminated by length or by the first unrecognized character. -* -* Fewer than three rotations are acceptable, in which case the later -* angle arguments are ignored. If all rotations are zero, the -* identity matrix is produced. -* -* Called: sla_DEULER -* -* P.T.Wallace Starlink 23 May 1997 -* -* Copyright (C) 1997 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) ORDER - REAL PHI,THETA,PSI,RMAT(3,3) - - INTEGER J,I - DOUBLE PRECISION W(3,3) - - - -* Compute matrix in double precision - CALL sla_DEULER(ORDER,DBLE(PHI),DBLE(THETA),DBLE(PSI),W) - -* Copy the result - DO J=1,3 - DO I=1,3 - RMAT(I,J) = REAL(W(I,J)) - END DO - END DO - - END diff --git a/src/slalib/evp.f b/src/slalib/evp.f deleted file mode 100644 index a71759014..000000000 --- a/src/slalib/evp.f +++ /dev/null @@ -1,456 +0,0 @@ - SUBROUTINE sla_EVP (DATE, DEQX, DVB, DPB, DVH, DPH) -*+ -* - - - - -* E V P -* - - - - -* -* Barycentric and heliocentric velocity and position of the Earth -* -* All arguments are double precision -* -* Given: -* -* DATE TDB (loosely ET) as a Modified Julian Date -* (JD-2400000.5) -* -* DEQX Julian Epoch (e.g. 2000.0D0) of mean equator and -* equinox of the vectors returned. If DEQX .LE. 0D0, -* all vectors are referred to the mean equator and -* equinox (FK5) of epoch DATE. -* -* Returned (all 3D Cartesian vectors): -* -* DVB,DPB barycentric velocity, position (AU/s, AU) -* DVH,DPH heliocentric velocity, position (AU/s, AU) -* -* Called: sla_EPJ, sla_PREC -* -* Notes: -* -* 1 This routine is accurate enough for many purposes but faster and -* more compact than the sla_EPV routine. The maximum deviations -* from the JPL DE96 ephemeris are as follows: -* -* barycentric velocity 0.42 m/s -* barycentric position 6900 km -* -* heliocentric velocity 0.42 m/s -* heliocentric position 1600 km -* -* 2 The routine is adapted from the BARVEL and BARCOR subroutines of -* Stumpff (1980). Most of the changes are merely cosmetic and do -* not affect the results at all. However, some adjustments have -* been made so as to give results that refer to the IAU 1976 'FK5' -* equinox and precession, although the differences these changes -* make relative to the results from Stumpff's original 'FK4' version -* are smaller than the inherent accuracy of the algorithm. One -* minor shortcoming in the original routines that has NOT been -* corrected is that better numerical accuracy could be achieved if -* the various polynomial evaluations were nested. -* -* Reference: -* -* Stumpff, P., Astron.Astrophys.Suppl.Ser. 41, 1-8 (1980). -* -* Last revision: 7 April 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,DEQX,DVB(3),DPB(3),DVH(3),DPH(3) - - INTEGER IDEQ,I,J,K - - REAL CC2PI,CCSEC3,CCSGD,CCKM,CCMLD,CCFDI,CCIM,T,TSQ,A,PERTL, - : PERTLD,PERTR,PERTRD,COSA,SINA,ESQ,E,PARAM,TWOE,TWOG,G, - : PHI,F,SINF,COSF,PHID,PSID,PERTP,PERTPD,TL,SINLM,COSLM, - : SIGMA,B,PLON,POMG,PECC,FLATM,FLAT - - DOUBLE PRECISION DC2PI,DS2R,DCSLD,DC1MME,DT,DTSQ,DLOCAL,DML, - : DEPS,DPARAM,DPSI,D1PDRO,DRD,DRLD,DTL,DSINLS, - : DCOSLS,DXHD,DYHD,DZHD,DXBD,DYBD,DZBD,DCOSEP, - : DSINEP,DYAHD,DZAHD,DYABD,DZABD,DR, - : DXH,DYH,DZH,DXB,DYB,DZB,DYAH,DZAH,DYAB, - : DZAB,DEPJ,DEQCOR,B1950 - - REAL SN(4),CCSEL(3,17),CCAMPS(5,15),CCSEC(3,4),CCAMPM(4,3), - : CCPAMV(4),CCPAM(4),FORBEL(7),SORBEL(17),SINLP(4),COSLP(4) - EQUIVALENCE (SORBEL(1),E),(FORBEL(1),G) - - DOUBLE PRECISION DCFEL(3,8),DCEPS(3),DCARGS(2,15),DCARGM(2,3), - : DPREMA(3,3),W,VW(3) - - DOUBLE PRECISION sla_EPJ - - PARAMETER (DC2PI=6.2831853071796D0,CC2PI=6.283185) - PARAMETER (DS2R=0.7272205216643D-4) - PARAMETER (B1950=1949.9997904423D0) - -* -* Constants DCFEL(I,K) of fast changing elements -* I=1 I=2 I=3 - DATA DCFEL/ 1.7400353D+00, 6.2833195099091D+02, 5.2796D-06, - : 6.2565836D+00, 6.2830194572674D+02,-2.6180D-06, - : 4.7199666D+00, 8.3997091449254D+03,-1.9780D-05, - : 1.9636505D-01, 8.4334662911720D+03,-5.6044D-05, - : 4.1547339D+00, 5.2993466764997D+01, 5.8845D-06, - : 4.6524223D+00, 2.1354275911213D+01, 5.6797D-06, - : 4.2620486D+00, 7.5025342197656D+00, 5.5317D-06, - : 1.4740694D+00, 3.8377331909193D+00, 5.6093D-06/ - -* -* Constants DCEPS and CCSEL(I,K) of slowly changing elements -* I=1 I=2 I=3 - DATA DCEPS/ 4.093198D-01,-2.271110D-04,-2.860401D-08 / - DATA CCSEL/ 1.675104E-02,-4.179579E-05,-1.260516E-07, - : 2.220221E-01, 2.809917E-02, 1.852532E-05, - : 1.589963E+00, 3.418075E-02, 1.430200E-05, - : 2.994089E+00, 2.590824E-02, 4.155840E-06, - : 8.155457E-01, 2.486352E-02, 6.836840E-06, - : 1.735614E+00, 1.763719E-02, 6.370440E-06, - : 1.968564E+00, 1.524020E-02,-2.517152E-06, - : 1.282417E+00, 8.703393E-03, 2.289292E-05, - : 2.280820E+00, 1.918010E-02, 4.484520E-06, - : 4.833473E-02, 1.641773E-04,-4.654200E-07, - : 5.589232E-02,-3.455092E-04,-7.388560E-07, - : 4.634443E-02,-2.658234E-05, 7.757000E-08, - : 8.997041E-03, 6.329728E-06,-1.939256E-09, - : 2.284178E-02,-9.941590E-05, 6.787400E-08, - : 4.350267E-02,-6.839749E-05,-2.714956E-07, - : 1.348204E-02, 1.091504E-05, 6.903760E-07, - : 3.106570E-02,-1.665665E-04,-1.590188E-07/ - -* -* Constants of the arguments of the short-period perturbations -* by the planets: DCARGS(I,K) -* I=1 I=2 - DATA DCARGS/ 5.0974222D+00,-7.8604195454652D+02, - : 3.9584962D+00,-5.7533848094674D+02, - : 1.6338070D+00,-1.1506769618935D+03, - : 2.5487111D+00,-3.9302097727326D+02, - : 4.9255514D+00,-5.8849265665348D+02, - : 1.3363463D+00,-5.5076098609303D+02, - : 1.6072053D+00,-5.2237501616674D+02, - : 1.3629480D+00,-1.1790629318198D+03, - : 5.5657014D+00,-1.0977134971135D+03, - : 5.0708205D+00,-1.5774000881978D+02, - : 3.9318944D+00, 5.2963464780000D+01, - : 4.8989497D+00, 3.9809289073258D+01, - : 1.3097446D+00, 7.7540959633708D+01, - : 3.5147141D+00, 7.9618578146517D+01, - : 3.5413158D+00,-5.4868336758022D+02/ - -* -* Amplitudes CCAMPS(N,K) of the short-period perturbations -* N=1 N=2 N=3 N=4 N=5 - DATA CCAMPS/ - : -2.279594E-5, 1.407414E-5, 8.273188E-6, 1.340565E-5,-2.490817E-7, - : -3.494537E-5, 2.860401E-7, 1.289448E-7, 1.627237E-5,-1.823138E-7, - : 6.593466E-7, 1.322572E-5, 9.258695E-6,-4.674248E-7,-3.646275E-7, - : 1.140767E-5,-2.049792E-5,-4.747930E-6,-2.638763E-6,-1.245408E-7, - : 9.516893E-6,-2.748894E-6,-1.319381E-6,-4.549908E-6,-1.864821E-7, - : 7.310990E-6,-1.924710E-6,-8.772849E-7,-3.334143E-6,-1.745256E-7, - : -2.603449E-6, 7.359472E-6, 3.168357E-6, 1.119056E-6,-1.655307E-7, - : -3.228859E-6, 1.308997E-7, 1.013137E-7, 2.403899E-6,-3.736225E-7, - : 3.442177E-7, 2.671323E-6, 1.832858E-6,-2.394688E-7,-3.478444E-7, - : 8.702406E-6,-8.421214E-6,-1.372341E-6,-1.455234E-6,-4.998479E-8, - : -1.488378E-6,-1.251789E-5, 5.226868E-7,-2.049301E-7, 0.0E0, - : -8.043059E-6,-2.991300E-6, 1.473654E-7,-3.154542E-7, 0.0E0, - : 3.699128E-6,-3.316126E-6, 2.901257E-7, 3.407826E-7, 0.0E0, - : 2.550120E-6,-1.241123E-6, 9.901116E-8, 2.210482E-7, 0.0E0, - : -6.351059E-7, 2.341650E-6, 1.061492E-6, 2.878231E-7, 0.0E0/ - -* -* Constants of the secular perturbations in longitude -* CCSEC3 and CCSEC(N,K) -* N=1 N=2 N=3 - DATA CCSEC3/-7.757020E-08/, - : CCSEC/ 1.289600E-06, 5.550147E-01, 2.076942E+00, - : 3.102810E-05, 4.035027E+00, 3.525565E-01, - : 9.124190E-06, 9.990265E-01, 2.622706E+00, - : 9.793240E-07, 5.508259E+00, 1.559103E+01/ - -* Sidereal rate DCSLD in longitude, rate CCSGD in mean anomaly - DATA DCSLD/1.990987D-07/, - : CCSGD/1.990969E-07/ - -* Some constants used in the calculation of the lunar contribution - DATA CCKM/3.122140E-05/, - : CCMLD/2.661699E-06/, - : CCFDI/2.399485E-07/ - -* -* Constants DCARGM(I,K) of the arguments of the perturbations -* of the motion of the Moon -* I=1 I=2 - DATA DCARGM/ 5.1679830D+00, 8.3286911095275D+03, - : 5.4913150D+00,-7.2140632838100D+03, - : 5.9598530D+00, 1.5542754389685D+04/ - -* -* Amplitudes CCAMPM(N,K) of the perturbations of the Moon -* N=1 N=2 N=3 N=4 - DATA CCAMPM/ - : 1.097594E-01, 2.896773E-07, 5.450474E-02, 1.438491E-07, - : -2.223581E-02, 5.083103E-08, 1.002548E-02,-2.291823E-08, - : 1.148966E-02, 5.658888E-08, 8.249439E-03, 4.063015E-08/ - -* -* CCPAMV(K)=A*M*DL/DT (planets), DC1MME=1-MASS(Earth+Moon) - DATA CCPAMV/8.326827E-11,1.843484E-11,1.988712E-12,1.881276E-12/ - DATA DC1MME/0.99999696D0/ - -* CCPAM(K)=A*M(planets), CCIM=INCLINATION(Moon) - DATA CCPAM/4.960906E-3,2.727436E-3,8.392311E-4,1.556861E-3/ - DATA CCIM/8.978749E-2/ - - - - -* -* EXECUTION -* --------- - -* Control parameter IDEQ, and time arguments - IDEQ = 0 - IF (DEQX.GT.0D0) IDEQ=1 - DT = (DATE-15019.5D0)/36525D0 - T = REAL(DT) - DTSQ = DT*DT - TSQ = REAL(DTSQ) - -* Values of all elements for the instant DATE - DO K=1,8 - DLOCAL = MOD(DCFEL(1,K)+DT*DCFEL(2,K)+DTSQ*DCFEL(3,K), DC2PI) - IF (K.EQ.1) THEN - DML = DLOCAL - ELSE - FORBEL(K-1) = REAL(DLOCAL) - END IF - END DO - DEPS = MOD(DCEPS(1)+DT*DCEPS(2)+DTSQ*DCEPS(3), DC2PI) - DO K=1,17 - SORBEL(K) = MOD(CCSEL(1,K)+T*CCSEL(2,K)+TSQ*CCSEL(3,K), - : CC2PI) - END DO - -* Secular perturbations in longitude - DO K=1,4 - A = MOD(CCSEC(2,K)+T*CCSEC(3,K), CC2PI) - SN(K) = SIN(A) - END DO - -* Periodic perturbations of the EMB (Earth-Moon barycentre) - PERTL = CCSEC(1,1) *SN(1) +CCSEC(1,2)*SN(2)+ - : (CCSEC(1,3)+T*CCSEC3)*SN(3) +CCSEC(1,4)*SN(4) - PERTLD = 0.0 - PERTR = 0.0 - PERTRD = 0.0 - DO K=1,15 - A = SNGL(MOD(DCARGS(1,K)+DT*DCARGS(2,K), DC2PI)) - COSA = COS(A) - SINA = SIN(A) - PERTL = PERTL + CCAMPS(1,K)*COSA+CCAMPS(2,K)*SINA - PERTR = PERTR + CCAMPS(3,K)*COSA+CCAMPS(4,K)*SINA - IF (K.LT.11) THEN - PERTLD = PERTLD+ - : (CCAMPS(2,K)*COSA-CCAMPS(1,K)*SINA)*CCAMPS(5,K) - PERTRD = PERTRD+ - : (CCAMPS(4,K)*COSA-CCAMPS(3,K)*SINA)*CCAMPS(5,K) - END IF - END DO - -* Elliptic part of the motion of the EMB - ESQ = E*E - DPARAM = 1D0-DBLE(ESQ) - PARAM = REAL(DPARAM) - TWOE = E+E - TWOG = G+G - PHI = TWOE*((1.0-ESQ*0.125)*SIN(G)+E*0.625*SIN(TWOG) - : +ESQ*0.54166667*SIN(G+TWOG) ) - F = G+PHI - SINF = SIN(F) - COSF = COS(F) - DPSI = DPARAM/(1D0+DBLE(E*COSF)) - PHID = TWOE*CCSGD*((1.0+ESQ*1.5)*COSF+E*(1.25-SINF*SINF*0.5)) - PSID = CCSGD*E*SINF/SQRT(PARAM) - -* Perturbed heliocentric motion of the EMB - D1PDRO = 1D0+DBLE(PERTR) - DRD = D1PDRO*(DBLE(PSID)+DPSI*DBLE(PERTRD)) - DRLD = D1PDRO*DPSI*(DCSLD+DBLE(PHID)+DBLE(PERTLD)) - DTL = MOD(DML+DBLE(PHI)+DBLE(PERTL), DC2PI) - DSINLS = SIN(DTL) - DCOSLS = COS(DTL) - DXHD = DRD*DCOSLS-DRLD*DSINLS - DYHD = DRD*DSINLS+DRLD*DCOSLS - -* Influence of eccentricity, evection and variation on the -* geocentric motion of the Moon - PERTL = 0.0 - PERTLD = 0.0 - PERTP = 0.0 - PERTPD = 0.0 - DO K=1,3 - A = SNGL(MOD(DCARGM(1,K)+DT*DCARGM(2,K), DC2PI)) - SINA = SIN(A) - COSA = COS(A) - PERTL = PERTL +CCAMPM(1,K)*SINA - PERTLD = PERTLD+CCAMPM(2,K)*COSA - PERTP = PERTP +CCAMPM(3,K)*COSA - PERTPD = PERTPD-CCAMPM(4,K)*SINA - END DO - -* Heliocentric motion of the Earth - TL = FORBEL(2)+PERTL - SINLM = SIN(TL) - COSLM = COS(TL) - SIGMA = CCKM/(1.0+PERTP) - A = SIGMA*(CCMLD+PERTLD) - B = SIGMA*PERTPD - DXHD = DXHD+DBLE(A*SINLM)+DBLE(B*COSLM) - DYHD = DYHD-DBLE(A*COSLM)+DBLE(B*SINLM) - DZHD = -DBLE(SIGMA*CCFDI*COS(FORBEL(3))) - -* Barycentric motion of the Earth - DXBD = DXHD*DC1MME - DYBD = DYHD*DC1MME - DZBD = DZHD*DC1MME - DO K=1,4 - PLON = FORBEL(K+3) - POMG = SORBEL(K+1) - PECC = SORBEL(K+9) - TL = MOD(PLON+2.0*PECC*SIN(PLON-POMG), CC2PI) - SINLP(K) = SIN(TL) - COSLP(K) = COS(TL) - DXBD = DXBD+DBLE(CCPAMV(K)*(SINLP(K)+PECC*SIN(POMG))) - DYBD = DYBD-DBLE(CCPAMV(K)*(COSLP(K)+PECC*COS(POMG))) - DZBD = DZBD-DBLE(CCPAMV(K)*SORBEL(K+13)*COS(PLON-SORBEL(K+5))) - END DO - -* Transition to mean equator of date - DCOSEP = COS(DEPS) - DSINEP = SIN(DEPS) - DYAHD = DCOSEP*DYHD-DSINEP*DZHD - DZAHD = DSINEP*DYHD+DCOSEP*DZHD - DYABD = DCOSEP*DYBD-DSINEP*DZBD - DZABD = DSINEP*DYBD+DCOSEP*DZBD - -* Heliocentric coordinates of the Earth - DR = DPSI*D1PDRO - FLATM = CCIM*SIN(FORBEL(3)) - A = SIGMA*COS(FLATM) - DXH = DR*DCOSLS-DBLE(A*COSLM) - DYH = DR*DSINLS-DBLE(A*SINLM) - DZH = -DBLE(SIGMA*SIN(FLATM)) - -* Barycentric coordinates of the Earth - DXB = DXH*DC1MME - DYB = DYH*DC1MME - DZB = DZH*DC1MME - DO K=1,4 - FLAT = SORBEL(K+13)*SIN(FORBEL(K+3)-SORBEL(K+5)) - A = CCPAM(K)*(1.0-SORBEL(K+9)*COS(FORBEL(K+3)-SORBEL(K+1))) - B = A*COS(FLAT) - DXB = DXB-DBLE(B*COSLP(K)) - DYB = DYB-DBLE(B*SINLP(K)) - DZB = DZB-DBLE(A*SIN(FLAT)) - END DO - -* Transition to mean equator of date - DYAH = DCOSEP*DYH-DSINEP*DZH - DZAH = DSINEP*DYH+DCOSEP*DZH - DYAB = DCOSEP*DYB-DSINEP*DZB - DZAB = DSINEP*DYB+DCOSEP*DZB - -* Copy result components into vectors, correcting for FK4 equinox - DEPJ=sla_EPJ(DATE) - DEQCOR = DS2R*(0.035D0+0.00085D0*(DEPJ-B1950)) - DVH(1) = DXHD-DEQCOR*DYAHD - DVH(2) = DYAHD+DEQCOR*DXHD - DVH(3) = DZAHD - DVB(1) = DXBD-DEQCOR*DYABD - DVB(2) = DYABD+DEQCOR*DXBD - DVB(3) = DZABD - DPH(1) = DXH-DEQCOR*DYAH - DPH(2) = DYAH+DEQCOR*DXH - DPH(3) = DZAH - DPB(1) = DXB-DEQCOR*DYAB - DPB(2) = DYAB+DEQCOR*DXB - DPB(3) = DZAB - -* Was precession to another equinox requested? - IF (IDEQ.NE.0) THEN - -* Yes: compute precession matrix from MJD DATE to Julian epoch DEQX - CALL sla_PREC(DEPJ,DEQX,DPREMA) - -* Rotate DVH - DO J=1,3 - W=0D0 - DO I=1,3 - W=W+DPREMA(J,I)*DVH(I) - END DO - VW(J)=W - END DO - DO J=1,3 - DVH(J)=VW(J) - END DO - -* Rotate DVB - DO J=1,3 - W=0D0 - DO I=1,3 - W=W+DPREMA(J,I)*DVB(I) - END DO - VW(J)=W - END DO - DO J=1,3 - DVB(J)=VW(J) - END DO - -* Rotate DPH - DO J=1,3 - W=0D0 - DO I=1,3 - W=W+DPREMA(J,I)*DPH(I) - END DO - VW(J)=W - END DO - DO J=1,3 - DPH(J)=VW(J) - END DO - -* Rotate DPB - DO J=1,3 - W=0D0 - DO I=1,3 - W=W+DPREMA(J,I)*DPB(I) - END DO - VW(J)=W - END DO - DO J=1,3 - DPB(J)=VW(J) - END DO - END IF - - END diff --git a/src/slalib/fitxy.f b/src/slalib/fitxy.f deleted file mode 100644 index a22efe61d..000000000 --- a/src/slalib/fitxy.f +++ /dev/null @@ -1,328 +0,0 @@ - SUBROUTINE sla_FITXY (ITYPE,NP,XYE,XYM,COEFFS,J) -*+ -* - - - - - - -* F I T X Y -* - - - - - - -* -* Fit a linear model to relate two sets of [X,Y] coordinates. -* -* Given: -* ITYPE i type of model: 4 or 6 (note 1) -* NP i number of samples (note 2) -* XYE d(2,np) expected [X,Y] for each sample -* XYM d(2,np) measured [X,Y] for each sample -* -* Returned: -* COEFFS d(6) coefficients of model (note 3) -* J i status: 0 = OK -* -1 = illegal ITYPE -* -2 = insufficient data -* -3 = no solution -* -* Notes: -* -* 1) ITYPE, which must be either 4 or 6, selects the type of model -* fitted. Both allowed ITYPE values produce a model COEFFS which -* consists of six coefficients, namely the zero points and, for -* each of XE and YE, the coefficient of XM and YM. For ITYPE=6, -* all six coefficients are independent, modelling squash and shear -* as well as origin, scale, and orientation. However, ITYPE=4 -* selects the "solid body rotation" option; the model COEFFS -* still consists of the same six coefficients, but now two of -* them are used twice (appropriately signed). Origin, scale -* and orientation are still modelled, but not squash or shear - -* the units of X and Y have to be the same. -* -* 2) For NC=4, NP must be at least 2. For NC=6, NP must be at -* least 3. -* -* 3) The model is returned in the array COEFFS. Naming the -* elements of COEFFS as follows: -* -* COEFFS(1) = A -* COEFFS(2) = B -* COEFFS(3) = C -* COEFFS(4) = D -* COEFFS(5) = E -* COEFFS(6) = F -* -* the model is: -* -* XE = A + B*XM + C*YM -* YE = D + E*XM + F*YM -* -* For the "solid body rotation" option (ITYPE=4), the -* magnitudes of B and F, and of C and E, are equal. The -* signs of these coefficients depend on whether there is a -* sign reversal between XE,YE and XM,YM; fits are performed -* with and without a sign reversal and the best one chosen. -* -* 4) Error status values J=-1 and -2 leave COEFFS unchanged; -* if J=-3 COEFFS may have been changed. -* -* See also sla_PXY, sla_INVF, sla_XY2XY, sla_DCMPF -* -* Called: sla_DMAT, sla_DMXV -* -* Last revision: 8 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER ITYPE,NP - DOUBLE PRECISION XYE(2,NP),XYM(2,NP),COEFFS(6) - INTEGER J - - INTEGER I,JSTAT,IW(4),NSOL - DOUBLE PRECISION A,B,C,D,AOLD,BOLD,COLD,DOLD,SOLD, - : P,SXE,SXEXM,SXEYM,SYE,SYEYM,SYEXM,SXM, - : SYM,SXMXM,SXMYM,SYMYM,XE,YE, - : XM,YM,V(4),DM3(3,3),DM4(4,4),DET, - : SGN,SXXYY,SXYYX,SX2Y2,SDR2,XR,YR - - - -* Preset the status - J=0 - -* Variable initializations to avoid compiler warnings - A = 0D0 - B = 0D0 - C = 0D0 - D = 0D0 - AOLD = 0D0 - BOLD = 0D0 - COLD = 0D0 - DOLD = 0D0 - SOLD = 0D0 - -* Float the number of samples - P=DBLE(NP) - -* Check ITYPE - IF (ITYPE.EQ.6) THEN - -* -* Six-coefficient linear model -* ---------------------------- - -* Check enough samples - IF (NP.GE.3) THEN - -* Form summations - SXE=0D0 - SXEXM=0D0 - SXEYM=0D0 - SYE=0D0 - SYEYM=0D0 - SYEXM=0D0 - SXM=0D0 - SYM=0D0 - SXMXM=0D0 - SXMYM=0D0 - SYMYM=0D0 - DO I=1,NP - XE=XYE(1,I) - YE=XYE(2,I) - XM=XYM(1,I) - YM=XYM(2,I) - SXE=SXE+XE - SXEXM=SXEXM+XE*XM - SXEYM=SXEYM+XE*YM - SYE=SYE+YE - SYEYM=SYEYM+YE*YM - SYEXM=SYEXM+YE*XM - SXM=SXM+XM - SYM=SYM+YM - SXMXM=SXMXM+XM*XM - SXMYM=SXMYM+XM*YM - SYMYM=SYMYM+YM*YM - END DO - -* Solve for A,B,C in XE = A + B*XM + C*YM - V(1)=SXE - V(2)=SXEXM - V(3)=SXEYM - DM3(1,1)=P - DM3(1,2)=SXM - DM3(1,3)=SYM - DM3(2,1)=SXM - DM3(2,2)=SXMXM - DM3(2,3)=SXMYM - DM3(3,1)=SYM - DM3(3,2)=SXMYM - DM3(3,3)=SYMYM - CALL sla_DMAT(3,DM3,V,DET,JSTAT,IW) - IF (JSTAT.EQ.0) THEN - DO I=1,3 - COEFFS(I)=V(I) - END DO - -* Solve for D,E,F in YE = D + E*XM + F*YM - V(1)=SYE - V(2)=SYEXM - V(3)=SYEYM - CALL sla_DMXV(DM3,V,COEFFS(4)) - - ELSE - -* No 6-coefficient solution possible - J=-3 - - END IF - - ELSE - -* Insufficient data for 6-coefficient fit - J=-2 - - END IF - - ELSE IF (ITYPE.EQ.4) THEN - -* -* Four-coefficient solid body rotation model -* ------------------------------------------ - -* Check enough samples - IF (NP.GE.2) THEN - -* Try two solutions, first without then with flip in X - DO NSOL=1,2 - IF (NSOL.EQ.1) THEN - SGN=1D0 - ELSE - SGN=-1D0 - END IF - -* Form summations - SXE=0D0 - SXXYY=0D0 - SXYYX=0D0 - SYE=0D0 - SXM=0D0 - SYM=0D0 - SX2Y2=0D0 - DO I=1,NP - XE=XYE(1,I)*SGN - YE=XYE(2,I) - XM=XYM(1,I) - YM=XYM(2,I) - SXE=SXE+XE - SXXYY=SXXYY+XE*XM+YE*YM - SXYYX=SXYYX+XE*YM-YE*XM - SYE=SYE+YE - SXM=SXM+XM - SYM=SYM+YM - SX2Y2=SX2Y2+XM*XM+YM*YM - END DO - -* -* Solve for A,B,C,D in: +/- XE = A + B*XM - C*YM -* + YE = D + C*XM + B*YM - V(1)=SXE - V(2)=SXXYY - V(3)=SXYYX - V(4)=SYE - DM4(1,1)=P - DM4(1,2)=SXM - DM4(1,3)=-SYM - DM4(1,4)=0D0 - DM4(2,1)=SXM - DM4(2,2)=SX2Y2 - DM4(2,3)=0D0 - DM4(2,4)=SYM - DM4(3,1)=SYM - DM4(3,2)=0D0 - DM4(3,3)=-SX2Y2 - DM4(3,4)=-SXM - DM4(4,1)=0D0 - DM4(4,2)=SYM - DM4(4,3)=SXM - DM4(4,4)=P - CALL sla_DMAT(4,DM4,V,DET,JSTAT,IW) - IF (JSTAT.EQ.0) THEN - A=V(1) - B=V(2) - C=V(3) - D=V(4) - -* Determine sum of radial errors squared - SDR2=0D0 - DO I=1,NP - XM=XYM(1,I) - YM=XYM(2,I) - XR=A+B*XM-C*YM-XYE(1,I)*SGN - YR=D+C*XM+B*YM-XYE(2,I) - SDR2=SDR2+XR*XR+YR*YR - END DO - - ELSE - -* Singular: set flag - SDR2=-1D0 - - END IF - -* If first pass and non-singular, save variables - IF (NSOL.EQ.1.AND.JSTAT.EQ.0) THEN - AOLD=A - BOLD=B - COLD=C - DOLD=D - SOLD=SDR2 - END IF - - END DO - -* Pick the best of the two solutions - IF (SOLD.GE.0D0.AND.(SOLD.LE.SDR2.OR.NP.EQ.2)) THEN - COEFFS(1)=AOLD - COEFFS(2)=BOLD - COEFFS(3)=-COLD - COEFFS(4)=DOLD - COEFFS(5)=COLD - COEFFS(6)=BOLD - ELSE IF (JSTAT.EQ.0) THEN - COEFFS(1)=-A - COEFFS(2)=-B - COEFFS(3)=C - COEFFS(4)=D - COEFFS(5)=C - COEFFS(6)=B - ELSE - -* No 4-coefficient fit possible - J=-3 - END IF - ELSE - -* Insufficient data for 4-coefficient fit - J=-2 - END IF - ELSE - -* Illegal ITYPE - not 4 or 6 - J=-1 - END IF - - END diff --git a/src/slalib/fk425.f b/src/slalib/fk425.f deleted file mode 100644 index 74c1ed4f1..000000000 --- a/src/slalib/fk425.f +++ /dev/null @@ -1,266 +0,0 @@ - SUBROUTINE sla_FK425 (R1950,D1950,DR1950,DD1950,P1950,V1950, - : R2000,D2000,DR2000,DD2000,P2000,V2000) -*+ -* - - - - - - -* F K 4 2 5 -* - - - - - - -* -* Convert B1950.0 FK4 star data to J2000.0 FK5 (double precision) -* -* This routine converts stars from the old, Bessel-Newcomb, FK4 -* system to the new, IAU 1976, FK5, Fricke system. The precepts -* of Smith et al (Ref 1) are followed, using the implementation -* by Yallop et al (Ref 2) of a matrix method due to Standish. -* Kinoshita's development of Andoyer's post-Newcomb precession is -* used. The numerical constants from Seidelmann et al (Ref 3) are -* used canonically. -* -* Given: (all B1950.0,FK4) -* R1950,D1950 dp B1950.0 RA,Dec (rad) -* DR1950,DD1950 dp B1950.0 proper motions (rad/trop.yr) -* P1950 dp parallax (arcsec) -* V1950 dp radial velocity (km/s, +ve = moving away) -* -* Returned: (all J2000.0,FK5) -* R2000,D2000 dp J2000.0 RA,Dec (rad) -* DR2000,DD2000 dp J2000.0 proper motions (rad/Jul.yr) -* P2000 dp parallax (arcsec) -* V2000 dp radial velocity (km/s, +ve = moving away) -* -* Notes: -* -* 1) The proper motions in RA are dRA/dt rather than -* cos(Dec)*dRA/dt, and are per year rather than per century. -* -* 2) Conversion from Besselian epoch 1950.0 to Julian epoch -* 2000.0 only is provided for. Conversions involving other -* epochs will require use of the appropriate precession, -* proper motion, and E-terms routines before and/or -* after FK425 is called. -* -* 3) In the FK4 catalogue the proper motions of stars within -* 10 degrees of the poles do not embody the differential -* E-term effect and should, strictly speaking, be handled -* in a different manner from stars outside these regions. -* However, given the general lack of homogeneity of the star -* data available for routine astrometry, the difficulties of -* handling positions that may have been determined from -* astrometric fields spanning the polar and non-polar regions, -* the likelihood that the differential E-terms effect was not -* taken into account when allowing for proper motion in past -* astrometry, and the undesirability of a discontinuity in -* the algorithm, the decision has been made in this routine to -* include the effect of differential E-terms on the proper -* motions for all stars, whether polar or not. At epoch 2000, -* and measuring on the sky rather than in terms of dRA, the -* errors resulting from this simplification are less than -* 1 milliarcsecond in position and 1 milliarcsecond per -* century in proper motion. -* -* References: -* -* 1 Smith, C.A. et al, 1989. "The transformation of astrometric -* catalog systems to the equinox J2000.0". Astron.J. 97, 265. -* -* 2 Yallop, B.D. et al, 1989. "Transformation of mean star places -* from FK4 B1950.0 to FK5 J2000.0 using matrices in 6-space". -* Astron.J. 97, 274. -* -* 3 Seidelmann, P.K. (ed), 1992. "Explanatory Supplement to -* the Astronomical Almanac", ISBN 0-935702-68-7. -* -* P.T.Wallace Starlink 19 December 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R1950,D1950,DR1950,DD1950,P1950,V1950, - : R2000,D2000,DR2000,DD2000,P2000,V2000 - - -* Miscellaneous - DOUBLE PRECISION R,D,UR,UD,PX,RV,SR,CR,SD,CD,W,WD - DOUBLE PRECISION X,Y,Z,XD,YD,ZD - DOUBLE PRECISION RXYSQ,RXYZSQ,RXY,RXYZ,SPXY,SPXYZ - INTEGER I,J - -* Star position and velocity vectors - DOUBLE PRECISION R0(3),RD0(3) - -* Combined position and velocity vectors - DOUBLE PRECISION V1(6),V2(6) - -* 2Pi - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925287D0) - -* Radians per year to arcsec per century - DOUBLE PRECISION PMF - PARAMETER (PMF=100D0*60D0*60D0*360D0/D2PI) - -* Small number to avoid arithmetic problems - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-30) - - -* -* CANONICAL CONSTANTS (see references) -* - -* Km per sec to AU per tropical century -* = 86400 * 36524.2198782 / 149597870 - DOUBLE PRECISION VF - PARAMETER (VF=21.095D0) - -* Constant vector and matrix (by columns) - DOUBLE PRECISION A(3),AD(3),EM(6,6) - DATA A,AD/ -1.62557D-6, -0.31919D-6, -0.13843D-6, - : +1.245D-3, -1.580D-3, -0.659D-3/ - - DATA (EM(I,1),I=1,6) / +0.9999256782D0, - : +0.0111820610D0, - : +0.0048579479D0, - : -0.000551D0, - : +0.238514D0, - : -0.435623D0 / - - DATA (EM(I,2),I=1,6) / -0.0111820611D0, - : +0.9999374784D0, - : -0.0000271474D0, - : -0.238565D0, - : -0.002667D0, - : +0.012254D0 / - - DATA (EM(I,3),I=1,6) / -0.0048579477D0, - : -0.0000271765D0, - : +0.9999881997D0, - : +0.435739D0, - : -0.008541D0, - : +0.002117D0 / - - DATA (EM(I,4),I=1,6) / +0.00000242395018D0, - : +0.00000002710663D0, - : +0.00000001177656D0, - : +0.99994704D0, - : +0.01118251D0, - : +0.00485767D0 / - - DATA (EM(I,5),I=1,6) / -0.00000002710663D0, - : +0.00000242397878D0, - : -0.00000000006582D0, - : -0.01118251D0, - : +0.99995883D0, - : -0.00002714D0 / - - DATA (EM(I,6),I=1,6) / -0.00000001177656D0, - : -0.00000000006587D0, - : +0.00000242410173D0, - : -0.00485767D0, - : -0.00002718D0, - : +1.00000956D0 / - - - -* Pick up B1950 data (units radians and arcsec/TC) - R=R1950 - D=D1950 - UR=DR1950*PMF - UD=DD1950*PMF - PX=P1950 - RV=V1950 - -* Spherical to Cartesian - SR=SIN(R) - CR=COS(R) - SD=SIN(D) - CD=COS(D) - - R0(1)=CR*CD - R0(2)=SR*CD - R0(3)= SD - - W=VF*RV*PX - - RD0(1)=-SR*CD*UR-CR*SD*UD+W*R0(1) - RD0(2)= CR*CD*UR-SR*SD*UD+W*R0(2) - RD0(3)= CD*UD+W*R0(3) - -* Allow for e-terms and express as position+velocity 6-vector - W=R0(1)*A(1)+R0(2)*A(2)+R0(3)*A(3) - WD=R0(1)*AD(1)+R0(2)*AD(2)+R0(3)*AD(3) - DO I=1,3 - V1(I)=R0(I)-A(I)+W*R0(I) - V1(I+3)=RD0(I)-AD(I)+WD*R0(I) - END DO - -* Convert position+velocity vector to Fricke system - DO I=1,6 - W=0D0 - DO J=1,6 - W=W+EM(I,J)*V1(J) - END DO - V2(I)=W - END DO - -* Revert to spherical coordinates - X=V2(1) - Y=V2(2) - Z=V2(3) - XD=V2(4) - YD=V2(5) - ZD=V2(6) - - RXYSQ=X*X+Y*Y - RXYZSQ=RXYSQ+Z*Z - RXY=SQRT(RXYSQ) - RXYZ=SQRT(RXYZSQ) - - SPXY=X*XD+Y*YD - SPXYZ=SPXY+Z*ZD - - IF (X.EQ.0D0.AND.Y.EQ.0D0) THEN - R=0D0 - ELSE - R=ATAN2(Y,X) - IF (R.LT.0.0D0) R=R+D2PI - END IF - D=ATAN2(Z,RXY) - - IF (RXY.GT.TINY) THEN - UR=(X*YD-Y*XD)/RXYSQ - UD=(ZD*RXYSQ-Z*SPXY)/(RXYZSQ*RXY) - END IF - - IF (PX.GT.TINY) THEN - RV=SPXYZ/(PX*RXYZ*VF) - PX=PX/RXYZ - END IF - -* Return results - R2000=R - D2000=D - DR2000=UR/PMF - DD2000=UD/PMF - V2000=RV - P2000=PX - - END diff --git a/src/slalib/fk45z.f b/src/slalib/fk45z.f deleted file mode 100644 index 60e76092d..000000000 --- a/src/slalib/fk45z.f +++ /dev/null @@ -1,182 +0,0 @@ - SUBROUTINE sla_FK45Z (R1950,D1950,BEPOCH,R2000,D2000) -*+ -* - - - - - - -* F K 4 5 Z -* - - - - - - -* -* Convert B1950.0 FK4 star data to J2000.0 FK5 assuming zero -* proper motion in the FK5 frame (double precision) -* -* This routine converts stars from the old, Bessel-Newcomb, FK4 -* system to the new, IAU 1976, FK5, Fricke system, in such a -* way that the FK5 proper motion is zero. Because such a star -* has, in general, a non-zero proper motion in the FK4 system, -* the routine requires the epoch at which the position in the -* FK4 system was determined. -* -* The method is from Appendix 2 of Ref 1, but using the constants -* of Ref 4. -* -* Given: -* R1950,D1950 dp B1950.0 FK4 RA,Dec at epoch (rad) -* BEPOCH dp Besselian epoch (e.g. 1979.3D0) -* -* Returned: -* R2000,D2000 dp J2000.0 FK5 RA,Dec (rad) -* -* Notes: -* -* 1) The epoch BEPOCH is strictly speaking Besselian, but -* if a Julian epoch is supplied the result will be -* affected only to a negligible extent. -* -* 2) Conversion from Besselian epoch 1950.0 to Julian epoch -* 2000.0 only is provided for. Conversions involving other -* epochs will require use of the appropriate precession, -* proper motion, and E-terms routines before and/or -* after FK45Z is called. -* -* 3) In the FK4 catalogue the proper motions of stars within -* 10 degrees of the poles do not embody the differential -* E-term effect and should, strictly speaking, be handled -* in a different manner from stars outside these regions. -* However, given the general lack of homogeneity of the star -* data available for routine astrometry, the difficulties of -* handling positions that may have been determined from -* astrometric fields spanning the polar and non-polar regions, -* the likelihood that the differential E-terms effect was not -* taken into account when allowing for proper motion in past -* astrometry, and the undesirability of a discontinuity in -* the algorithm, the decision has been made in this routine to -* include the effect of differential E-terms on the proper -* motions for all stars, whether polar or not. At epoch 2000, -* and measuring on the sky rather than in terms of dRA, the -* errors resulting from this simplification are less than -* 1 milliarcsecond in position and 1 milliarcsecond per -* century in proper motion. -* -* References: -* -* 1 Aoki,S., et al, 1983. Astron.Astrophys., 128, 263. -* -* 2 Smith, C.A. et al, 1989. "The transformation of astrometric -* catalog systems to the equinox J2000.0". Astron.J. 97, 265. -* -* 3 Yallop, B.D. et al, 1989. "Transformation of mean star places -* from FK4 B1950.0 to FK5 J2000.0 using matrices in 6-space". -* Astron.J. 97, 274. -* -* 4 Seidelmann, P.K. (ed), 1992. "Explanatory Supplement to -* the Astronomical Almanac", ISBN 0-935702-68-7. -* -* Called: sla_DCS2C, sla_EPJ, sla_EPB2D, sla_DCC2S, sla_DRANRM -* -* P.T.Wallace Starlink 21 September 1998 -* -* Copyright (C) 1998 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R1950,D1950,BEPOCH,R2000,D2000 - - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925287D0) - - DOUBLE PRECISION W - INTEGER I,J - -* Position and position+velocity vectors - DOUBLE PRECISION R0(3),A1(3),V1(3),V2(6) - -* Radians per year to arcsec per century - DOUBLE PRECISION PMF - PARAMETER (PMF=100D0*60D0*60D0*360D0/D2PI) - -* Functions - DOUBLE PRECISION sla_EPJ,sla_EPB2D,sla_DRANRM - -* -* CANONICAL CONSTANTS (see references) -* - -* Vectors A and Adot, and matrix M (only half of which is needed here) - DOUBLE PRECISION A(3),AD(3),EM(6,3) - DATA A,AD/ -1.62557D-6, -0.31919D-6, -0.13843D-6, - : +1.245D-3, -1.580D-3, -0.659D-3/ - - DATA (EM(I,1),I=1,6) / +0.9999256782D0, - : +0.0111820610D0, - : +0.0048579479D0, - : -0.000551D0, - : +0.238514D0, - : -0.435623D0 / - - DATA (EM(I,2),I=1,6) / -0.0111820611D0, - : +0.9999374784D0, - : -0.0000271474D0, - : -0.238565D0, - : -0.002667D0, - : +0.012254D0 / - - DATA (EM(I,3),I=1,6) / -0.0048579477D0, - : -0.0000271765D0, - : +0.9999881997D0, - : +0.435739D0, - : -0.008541D0, - : +0.002117D0 / - - - -* Spherical to Cartesian - CALL sla_DCS2C(R1950,D1950,R0) - -* Adjust vector A to give zero proper motion in FK5 - W=(BEPOCH-1950D0)/PMF - DO I=1,3 - A1(I)=A(I)+W*AD(I) - END DO - -* Remove e-terms - W=R0(1)*A1(1)+R0(2)*A1(2)+R0(3)*A1(3) - DO I=1,3 - V1(I)=R0(I)-A1(I)+W*R0(I) - END DO - -* Convert position vector to Fricke system - DO I=1,6 - W=0D0 - DO J=1,3 - W=W+EM(I,J)*V1(J) - END DO - V2(I)=W - END DO - -* Allow for fictitious proper motion in FK4 - W=(sla_EPJ(sla_EPB2D(BEPOCH))-2000D0)/PMF - DO I=1,3 - V2(I)=V2(I)+W*V2(I+3) - END DO - -* Revert to spherical coordinates - CALL sla_DCC2S(V2,W,D2000) - R2000=sla_DRANRM(W) - - END diff --git a/src/slalib/fk524.f b/src/slalib/fk524.f deleted file mode 100644 index a95dcb068..000000000 --- a/src/slalib/fk524.f +++ /dev/null @@ -1,274 +0,0 @@ - SUBROUTINE sla_FK524 (R2000,D2000,DR2000,DD2000,P2000,V2000, - : R1950,D1950,DR1950,DD1950,P1950,V1950) -*+ -* - - - - - - -* F K 5 2 4 -* - - - - - - -* -* Convert J2000.0 FK5 star data to B1950.0 FK4 (double precision) -* -* This routine converts stars from the new, IAU 1976, FK5, Fricke -* system, to the old, Bessel-Newcomb, FK4 system. The precepts -* of Smith et al (Ref 1) are followed, using the implementation -* by Yallop et al (Ref 2) of a matrix method due to Standish. -* Kinoshita's development of Andoyer's post-Newcomb precession is -* used. The numerical constants from Seidelmann et al (Ref 3) are -* used canonically. -* -* Given: (all J2000.0,FK5) -* R2000,D2000 dp J2000.0 RA,Dec (rad) -* DR2000,DD2000 dp J2000.0 proper motions (rad/Jul.yr) -* P2000 dp parallax (arcsec) -* V2000 dp radial velocity (km/s, +ve = moving away) -* -* Returned: (all B1950.0,FK4) -* R1950,D1950 dp B1950.0 RA,Dec (rad) -* DR1950,DD1950 dp B1950.0 proper motions (rad/trop.yr) -* P1950 dp parallax (arcsec) -* V1950 dp radial velocity (km/s, +ve = moving away) -* -* Notes: -* -* 1) The proper motions in RA are dRA/dt rather than -* cos(Dec)*dRA/dt, and are per year rather than per century. -* -* 2) Note that conversion from Julian epoch 2000.0 to Besselian -* epoch 1950.0 only is provided for. Conversions involving -* other epochs will require use of the appropriate precession, -* proper motion, and E-terms routines before and/or after -* FK524 is called. -* -* 3) In the FK4 catalogue the proper motions of stars within -* 10 degrees of the poles do not embody the differential -* E-term effect and should, strictly speaking, be handled -* in a different manner from stars outside these regions. -* However, given the general lack of homogeneity of the star -* data available for routine astrometry, the difficulties of -* handling positions that may have been determined from -* astrometric fields spanning the polar and non-polar regions, -* the likelihood that the differential E-terms effect was not -* taken into account when allowing for proper motion in past -* astrometry, and the undesirability of a discontinuity in -* the algorithm, the decision has been made in this routine to -* include the effect of differential E-terms on the proper -* motions for all stars, whether polar or not. At epoch 2000, -* and measuring on the sky rather than in terms of dRA, the -* errors resulting from this simplification are less than -* 1 milliarcsecond in position and 1 milliarcsecond per -* century in proper motion. -* -* References: -* -* 1 Smith, C.A. et al, 1989. "The transformation of astrometric -* catalog systems to the equinox J2000.0". Astron.J. 97, 265. -* -* 2 Yallop, B.D. et al, 1989. "Transformation of mean star places -* from FK4 B1950.0 to FK5 J2000.0 using matrices in 6-space". -* Astron.J. 97, 274. -* -* 3 Seidelmann, P.K. (ed), 1992. "Explanatory Supplement to -* the Astronomical Almanac", ISBN 0-935702-68-7. -* -* P.T.Wallace Starlink 19 December 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R2000,D2000,DR2000,DD2000,P2000,V2000, - : R1950,D1950,DR1950,DD1950,P1950,V1950 - - -* Miscellaneous - DOUBLE PRECISION R,D,UR,UD,PX,RV - DOUBLE PRECISION SR,CR,SD,CD,X,Y,Z,W - DOUBLE PRECISION V1(6),V2(6) - DOUBLE PRECISION XD,YD,ZD - DOUBLE PRECISION RXYZ,WD,RXYSQ,RXY - INTEGER I,J - -* 2Pi - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925287D0) - -* Radians per year to arcsec per century - DOUBLE PRECISION PMF - PARAMETER (PMF=100D0*60D0*60D0*360D0/D2PI) - -* Small number to avoid arithmetic problems - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-30) - -* -* CANONICAL CONSTANTS (see references) -* - -* Km per sec to AU per tropical century -* = 86400 * 36524.2198782 / 149597870 - DOUBLE PRECISION VF - PARAMETER (VF=21.095D0) - -* Constant vector and matrix (by columns) - DOUBLE PRECISION A(6),EMI(6,6) - DATA A/ -1.62557D-6, -0.31919D-6, -0.13843D-6, - : +1.245D-3, -1.580D-3, -0.659D-3/ - - DATA (EMI(I,1),I=1,6) / +0.9999256795D0, - : -0.0111814828D0, - : -0.0048590040D0, - : -0.000551D0, - : -0.238560D0, - : +0.435730D0 / - - DATA (EMI(I,2),I=1,6) / +0.0111814828D0, - : +0.9999374849D0, - : -0.0000271557D0, - : +0.238509D0, - : -0.002667D0, - : -0.008541D0 / - - DATA (EMI(I,3),I=1,6) / +0.0048590039D0, - : -0.0000271771D0, - : +0.9999881946D0, - : -0.435614D0, - : +0.012254D0, - : +0.002117D0 / - - DATA (EMI(I,4),I=1,6) / -0.00000242389840D0, - : +0.00000002710544D0, - : +0.00000001177742D0, - : +0.99990432D0, - : -0.01118145D0, - : -0.00485852D0 / - - DATA (EMI(I,5),I=1,6) / -0.00000002710544D0, - : -0.00000242392702D0, - : +0.00000000006585D0, - : +0.01118145D0, - : +0.99991613D0, - : -0.00002716D0 / - - DATA (EMI(I,6),I=1,6) / -0.00000001177742D0, - : +0.00000000006585D0, - : -0.00000242404995D0, - : +0.00485852D0, - : -0.00002717D0, - : +0.99996684D0 / - - - -* Pick up J2000 data (units radians and arcsec/JC) - R=R2000 - D=D2000 - UR=DR2000*PMF - UD=DD2000*PMF - PX=P2000 - RV=V2000 - -* Spherical to Cartesian - SR=SIN(R) - CR=COS(R) - SD=SIN(D) - CD=COS(D) - - X=CR*CD - Y=SR*CD - Z= SD - - W=VF*RV*PX - - V1(1)=X - V1(2)=Y - V1(3)=Z - - V1(4)=-UR*Y-CR*SD*UD+W*X - V1(5)= UR*X-SR*SD*UD+W*Y - V1(6)= CD*UD+W*Z - -* Convert position+velocity vector to BN system - DO I=1,6 - W=0D0 - DO J=1,6 - W=W+EMI(I,J)*V1(J) - END DO - V2(I)=W - END DO - -* Position vector components and magnitude - X=V2(1) - Y=V2(2) - Z=V2(3) - RXYZ=SQRT(X*X+Y*Y+Z*Z) - -* Apply E-terms to position - W=X*A(1)+Y*A(2)+Z*A(3) - X=X+A(1)*RXYZ-W*X - Y=Y+A(2)*RXYZ-W*Y - Z=Z+A(3)*RXYZ-W*Z - -* Recompute magnitude - RXYZ=SQRT(X*X+Y*Y+Z*Z) - -* Apply E-terms to both position and velocity - X=V2(1) - Y=V2(2) - Z=V2(3) - W=X*A(1)+Y*A(2)+Z*A(3) - WD=X*A(4)+Y*A(5)+Z*A(6) - X=X+A(1)*RXYZ-W*X - Y=Y+A(2)*RXYZ-W*Y - Z=Z+A(3)*RXYZ-W*Z - XD=V2(4)+A(4)*RXYZ-WD*X - YD=V2(5)+A(5)*RXYZ-WD*Y - ZD=V2(6)+A(6)*RXYZ-WD*Z - -* Convert to spherical - RXYSQ=X*X+Y*Y - RXY=SQRT(RXYSQ) - - IF (X.EQ.0D0.AND.Y.EQ.0D0) THEN - R=0D0 - ELSE - R=ATAN2(Y,X) - IF (R.LT.0.0D0) R=R+D2PI - END IF - D=ATAN2(Z,RXY) - - IF (RXY.GT.TINY) THEN - UR=(X*YD-Y*XD)/RXYSQ - UD=(ZD*RXYSQ-Z*(X*XD+Y*YD))/((RXYSQ+Z*Z)*RXY) - END IF - -* Radial velocity and parallax - IF (PX.GT.TINY) THEN - RV=(X*XD+Y*YD+Z*ZD)/(PX*VF*RXYZ) - PX=PX/RXYZ - END IF - -* Return results - R1950=R - D1950=D - DR1950=UR/PMF - DD1950=UD/PMF - P1950=PX - V1950=RV - - END diff --git a/src/slalib/fk52h.f b/src/slalib/fk52h.f deleted file mode 100644 index 30eeb21f0..000000000 --- a/src/slalib/fk52h.f +++ /dev/null @@ -1,122 +0,0 @@ - SUBROUTINE sla_FK52H (R5,D5,DR5,DD5,RH,DH,DRH,DDH) -*+ -* - - - - - - -* F K 5 2 H -* - - - - - - -* -* Transform FK5 (J2000) star data into the Hipparcos frame. -* -* (double precision) -* -* This routine transforms FK5 star positions and proper motions -* into the frame of the Hipparcos catalogue. -* -* Given (all FK5, equinox J2000, epoch J2000): -* R5 d RA (radians) -* D5 d Dec (radians) -* DR5 d proper motion in RA (dRA/dt, rad/Jyear) -* DD5 d proper motion in Dec (dDec/dt, rad/Jyear) -* -* Returned (all Hipparcos, epoch J2000): -* RH d RA (radians) -* DH d Dec (radians) -* DRH d proper motion in RA (dRA/dt, rad/Jyear) -* DDH d proper motion in Dec (dDec/dt, rad/Jyear) -* -* Called: sla_DS2C6, sla_DAV2M, sla_DMXV, sla_DVXV, sla_DC62S, -* sla_DRANRM -* -* Notes: -* -* 1) The proper motions in RA are dRA/dt rather than -* cos(Dec)*dRA/dt, and are per year rather than per century. -* -* 2) The FK5 to Hipparcos transformation consists of a pure -* rotation and spin; zonal errors in the FK5 catalogue are -* not taken into account. -* -* 3) The published orientation and spin components are interpreted -* as "axial vectors". An axial vector points at the pole of the -* rotation and its length is the amount of rotation in radians. -* -* 4) See also sla_H2FK5, sla_FK5HZ, sla_HFK5Z. -* -* Reference: -* -* M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998). -* -* P.T.Wallace Starlink 22 June 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R5,D5,DR5,DD5,RH,DH,DRH,DDH - - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - -* FK5 to Hipparcos orientation and spin (radians, radians/year) - DOUBLE PRECISION EPX,EPY,EPZ - DOUBLE PRECISION OMX,OMY,OMZ - - PARAMETER ( EPX = -19.9D-3 * AS2R, - : EPY = -9.1D-3 * AS2R, - : EPZ = +22.9D-3 * AS2R ) - - PARAMETER ( OMX = -0.30D-3 * AS2R, - : OMY = +0.60D-3 * AS2R, - : OMZ = +0.70D-3 * AS2R ) - - DOUBLE PRECISION PV5(6),ORTN(3),R5H(3,3),S5(3),VV(3),PVH(6),W,R,V - INTEGER I - - DOUBLE PRECISION sla_DRANRM - - - -* FK5 barycentric position/velocity 6-vector (normalized). - CALL sla_DS2C6(R5,D5,1D0,DR5,DD5,0D0,PV5) - -* FK5 to Hipparcos orientation matrix. - ORTN(1) = EPX - ORTN(2) = EPY - ORTN(3) = EPZ - CALL sla_DAV2M(ORTN,R5H) - -* Hipparcos wrt FK5 spin vector. - S5(1) = OMX - S5(2) = OMY - S5(3) = OMZ - -* Orient & spin the 6-vector into the Hipparcos frame. - CALL sla_DMXV(R5H,PV5,PVH) - CALL sla_DVXV(PV5,S5,VV) - DO I=1,3 - VV(I) = PV5(I+3)+VV(I) - END DO - CALL sla_DMXV(R5H,VV,PVH(4)) - -* Hipparcos 6-vector to spherical. - CALL sla_DC62S(PVH,W,DH,R,DRH,DDH,V) - RH = sla_DRANRM(W) - - END diff --git a/src/slalib/fk54z.f b/src/slalib/fk54z.f deleted file mode 100644 index 556ca56af..000000000 --- a/src/slalib/fk54z.f +++ /dev/null @@ -1,86 +0,0 @@ - SUBROUTINE sla_FK54Z (R2000,D2000,BEPOCH, - : R1950,D1950,DR1950,DD1950) -*+ -* - - - - - - -* F K 5 4 Z -* - - - - - - -* -* Convert a J2000.0 FK5 star position to B1950.0 FK4 assuming -* zero proper motion and parallax (double precision) -* -* This routine converts star positions from the new, IAU 1976, -* FK5, Fricke system to the old, Bessel-Newcomb, FK4 system. -* -* Given: -* R2000,D2000 dp J2000.0 FK5 RA,Dec (rad) -* BEPOCH dp Besselian epoch (e.g. 1950D0) -* -* Returned: -* R1950,D1950 dp B1950.0 FK4 RA,Dec (rad) at epoch BEPOCH -* DR1950,DD1950 dp B1950.0 FK4 proper motions (rad/trop.yr) -* -* Notes: -* -* 1) The proper motion in RA is dRA/dt rather than cos(Dec)*dRA/dt. -* -* 2) Conversion from Julian epoch 2000.0 to Besselian epoch 1950.0 -* only is provided for. Conversions involving other epochs will -* require use of the appropriate precession routines before and -* after this routine is called. -* -* 3) Unlike in the sla_FK524 routine, the FK5 proper motions, the -* parallax and the radial velocity are presumed zero. -* -* 4) It is the intention that FK5 should be a close approximation -* to an inertial frame, so that distant objects have zero proper -* motion; such objects have (in general) non-zero proper motion -* in FK4, and this routine returns those fictitious proper -* motions. -* -* 5) The position returned by this routine is in the B1950 -* reference frame but at Besselian epoch BEPOCH. For -* comparison with catalogues the BEPOCH argument will -* frequently be 1950D0. -* -* Called: sla_FK524, sla_PM -* -* P.T.Wallace Starlink 10 April 1990 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R2000,D2000,BEPOCH, - : R1950,D1950,DR1950,DD1950 - - DOUBLE PRECISION R,D,PX,RV - - - -* FK5 equinox J2000 (any epoch) to FK4 equinox B1950 epoch B1950 - CALL sla_FK524(R2000,D2000,0D0,0D0,0D0,0D0, - : R,D,DR1950,DD1950,PX,RV) - -* Fictitious proper motion to epoch BEPOCH - CALL sla_PM(R,D,DR1950,DD1950,0D0,0D0,1950D0,BEPOCH, - : R1950,D1950) - - END diff --git a/src/slalib/fk5hz.f b/src/slalib/fk5hz.f deleted file mode 100644 index 17d1618ad..000000000 --- a/src/slalib/fk5hz.f +++ /dev/null @@ -1,124 +0,0 @@ - SUBROUTINE sla_FK5HZ (R5,D5,EPOCH,RH,DH) -*+ -* - - - - - - -* F K 5 H Z -* - - - - - - -* -* Transform an FK5 (J2000) star position into the frame of the -* Hipparcos catalogue, assuming zero Hipparcos proper motion. -* -* (double precision) -* -* This routine converts a star position from the FK5 system to -* the Hipparcos system, in such a way that the Hipparcos proper -* motion is zero. Because such a star has, in general, a non-zero -* proper motion in the FK5 system, the routine requires the epoch -* at which the position in the FK5 system was determined. -* -* Given: -* R5 d FK5 RA (radians), equinox J2000, epoch EPOCH -* D5 d FK5 Dec (radians), equinox J2000, epoch EPOCH -* EPOCH d Julian epoch (TDB) -* -* Returned (all Hipparcos): -* RH d RA (radians) -* DH d Dec (radians) -* -* Called: sla_DCS2C, sla_DAV2M, sla_DIMXV, sla_DMXV, sla_DCC2S, -* sla_DRANRM -* -* Notes: -* -* 1) The FK5 to Hipparcos transformation consists of a pure -* rotation and spin; zonal errors in the FK5 catalogue are -* not taken into account. -* -* 2) The published orientation and spin components are interpreted -* as "axial vectors". An axial vector points at the pole of the -* rotation and its length is the amount of rotation in radians. -* -* 3) See also sla_FK52H, sla_H2FK5, sla_HFK5Z. -* -* Reference: -* -* M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998). -* -* P.T.Wallace Starlink 22 June 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R5,D5,EPOCH,RH,DH - - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - -* FK5 to Hipparcos orientation and spin (radians, radians/year) - DOUBLE PRECISION EPX,EPY,EPZ - DOUBLE PRECISION OMX,OMY,OMZ - - PARAMETER ( EPX = -19.9D-3 * AS2R, - : EPY = -9.1D-3 * AS2R, - : EPZ = +22.9D-3 * AS2R ) - - PARAMETER ( OMX = -0.30D-3 * AS2R, - : OMY = +0.60D-3 * AS2R, - : OMZ = +0.70D-3 * AS2R ) - - DOUBLE PRECISION P5E(3),ORTN(3),R5H(3,3),T,VST(3),RST(3,3), - : P5(3),PH(3),W - - DOUBLE PRECISION sla_DRANRM - - - -* FK5 barycentric position vector. - CALL sla_DCS2C(R5,D5,P5E) - -* FK5 to Hipparcos orientation matrix. - ORTN(1) = EPX - ORTN(2) = EPY - ORTN(3) = EPZ - CALL sla_DAV2M(ORTN,R5H) - -* Time interval from epoch to J2000. - T = 2000D0-EPOCH - -* Axial vector: accumulated Hipparcos wrt FK5 spin over that interval. - VST(1) = OMX*T - VST(2) = OMY*T - VST(3) = OMZ*T - -* Express the accumulated spin as a rotation matrix. - CALL sla_DAV2M(VST,RST) - -* Derotate the vector's FK5 axes back to epoch. - CALL sla_DIMXV(RST,P5E,P5) - -* Rotate the vector into the Hipparcos frame. - CALL sla_DMXV(R5H,P5,PH) - -* Hipparcos vector to spherical. - CALL sla_DCC2S(PH,W,DH) - RH = sla_DRANRM(W) - - END diff --git a/src/slalib/flotin.f b/src/slalib/flotin.f deleted file mode 100644 index 569923285..000000000 --- a/src/slalib/flotin.f +++ /dev/null @@ -1,145 +0,0 @@ - SUBROUTINE sla_FLOTIN (STRING, NSTRT, RESLT, JFLAG) -*+ -* - - - - - - - -* F L O T I N -* - - - - - - - -* -* Convert free-format input into single precision floating point -* -* Given: -* STRING c string containing number to be decoded -* NSTRT i pointer to where decoding is to start -* RESLT r current value of result -* -* Returned: -* NSTRT i advanced to next number -* RESLT r result -* JFLAG i status: -1 = -OK, 0 = +OK, 1 = null, 2 = error -* -* Called: sla_DFLTIN -* -* Notes: -* -* 1 The reason FLOTIN has separate OK status values for + -* and - is to enable minus zero to be detected. This is -* of crucial importance when decoding mixed-radix numbers. -* For example, an angle expressed as deg, arcmin, arcsec -* may have a leading minus sign but a zero degrees field. -* -* 2 A TAB is interpreted as a space, and lowercase characters -* are interpreted as uppercase. -* -* 3 The basic format is the sequence of fields #^.^@#^, where -* # is a sign character + or -, ^ means a string of decimal -* digits, and @, which indicates an exponent, means D or E. -* Various combinations of these fields can be omitted, and -* embedded blanks are permissible in certain places. -* -* 4 Spaces: -* -* . Leading spaces are ignored. -* -* . Embedded spaces are allowed only after +, -, D or E, -* and after the decomal point if the first sequence of -* digits is absent. -* -* . Trailing spaces are ignored; the first signifies -* end of decoding and subsequent ones are skipped. -* -* 5 Delimiters: -* -* . Any character other than +,-,0-9,.,D,E or space may be -* used to signal the end of the number and terminate -* decoding. -* -* . Comma is recognized by FLOTIN as a special case; it -* is skipped, leaving the pointer on the next character. -* See 13, below. -* -* 6 Both signs are optional. The default is +. -* -* 7 The mantissa ^.^ defaults to 1. -* -* 8 The exponent @#^ defaults to E0. -* -* 9 The strings of decimal digits may be of any length. -* -* 10 The decimal point is optional for whole numbers. -* -* 11 A "null result" occurs when the string of characters being -* decoded does not begin with +,-,0-9,.,D or E, or consists -* entirely of spaces. When this condition is detected, JFLAG -* is set to 1 and RESLT is left untouched. -* -* 12 NSTRT = 1 for the first character in the string. -* -* 13 On return from FLOTIN, NSTRT is set ready for the next -* decode - following trailing blanks and any comma. If a -* delimiter other than comma is being used, NSTRT must be -* incremented before the next call to FLOTIN, otherwise -* all subsequent calls will return a null result. -* -* 14 Errors (JFLAG=2) occur when: -* -* . a +, -, D or E is left unsatisfied; or -* -* . the decimal point is present without at least -* one decimal digit before or after it; or -* -* . an exponent more than 100 has been presented. -* -* 15 When an error has been detected, NSTRT is left -* pointing to the character following the last -* one used before the error came to light. This -* may be after the point at which a more sophisticated -* program could have detected the error. For example, -* FLOTIN does not detect that '1E999' is unacceptable -* (on a computer where this is so) until the entire number -* has been decoded. -* -* 16 Certain highly unlikely combinations of mantissa & -* exponent can cause arithmetic faults during the -* decode, in some cases despite the fact that they -* together could be construed as a valid number. -* -* 17 Decoding is left to right, one pass. -* -* 18 See also DFLTIN and INTIN -* -* P.T.Wallace Starlink 23 November 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER NSTRT - REAL RESLT - INTEGER JFLAG - - DOUBLE PRECISION DRESLT - - -* Call the double precision version - CALL sla_DFLTIN(STRING,NSTRT,DRESLT,JFLAG) - IF (JFLAG.LE.0) RESLT=REAL(DRESLT) - - END diff --git a/src/slalib/galeq.f b/src/slalib/galeq.f deleted file mode 100644 index 3bccf71e8..000000000 --- a/src/slalib/galeq.f +++ /dev/null @@ -1,96 +0,0 @@ - SUBROUTINE sla_GALEQ (DL, DB, DR, DD) -*+ -* - - - - - - -* G A L E Q -* - - - - - - -* -* Transformation from IAU 1958 galactic coordinates to -* J2000.0 equatorial coordinates (double precision) -* -* Given: -* DL,DB dp galactic longitude and latitude L2,B2 -* -* Returned: -* DR,DD dp J2000.0 RA,Dec -* -* (all arguments are radians) -* -* Called: -* sla_DCS2C, sla_DIMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE -* -* Note: -* The equatorial coordinates are J2000.0. Use the routine -* sla_GE50 if conversion to B1950.0 'FK4' coordinates is -* required. -* -* Reference: -* Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960) -* -* P.T.Wallace Starlink 21 September 1998 -* -* Copyright (C) 1998 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DL,DB,DR,DD - - DOUBLE PRECISION sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION V1(3),V2(3) - -* -* L2,B2 system of galactic coordinates -* -* P = 192.25 RA of galactic north pole (mean B1950.0) -* Q = 62.6 inclination of galactic to mean B1950.0 equator -* R = 33 longitude of ascending node -* -* P,Q,R are degrees -* -* Equatorial to galactic rotation matrix (J2000.0), obtained by -* applying the standard FK4 to FK5 transformation, for zero proper -* motion in FK5, to the columns of the B1950 equatorial to -* galactic rotation matrix: -* - DOUBLE PRECISION RMAT(3,3) - DATA RMAT(1,1),RMAT(1,2),RMAT(1,3), - : RMAT(2,1),RMAT(2,2),RMAT(2,3), - : RMAT(3,1),RMAT(3,2),RMAT(3,3)/ - : -0.054875539726D0,-0.873437108010D0,-0.483834985808D0, - : +0.494109453312D0,-0.444829589425D0,+0.746982251810D0, - : -0.867666135858D0,-0.198076386122D0,+0.455983795705D0/ - - - -* Spherical to Cartesian - CALL sla_DCS2C(DL,DB,V1) - -* Galactic to equatorial - CALL sla_DIMXV(RMAT,V1,V2) - -* Cartesian to spherical - CALL sla_DCC2S(V2,DR,DD) - -* Express in conventional ranges - DR=sla_DRANRM(DR) - DD=sla_DRANGE(DD) - - END diff --git a/src/slalib/galsup.f b/src/slalib/galsup.f deleted file mode 100644 index 65b98626d..000000000 --- a/src/slalib/galsup.f +++ /dev/null @@ -1,96 +0,0 @@ - SUBROUTINE sla_GALSUP (DL, DB, DSL, DSB) -*+ -* - - - - - - - -* G A L S U P -* - - - - - - - -* -* Transformation from IAU 1958 galactic coordinates to -* de Vaucouleurs supergalactic coordinates (double precision) -* -* Given: -* DL,DB dp galactic longitude and latitude L2,B2 -* -* Returned: -* DSL,DSB dp supergalactic longitude and latitude -* -* (all arguments are radians) -* -* Called: -* sla_DCS2C, sla_DMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE -* -* References: -* -* de Vaucouleurs, de Vaucouleurs, & Corwin, Second Reference -* Catalogue of Bright Galaxies, U. Texas, page 8. -* -* Systems & Applied Sciences Corp., Documentation for the -* machine-readable version of the above catalogue, -* Contract NAS 5-26490. -* -* (These two references give different values for the galactic -* longitude of the supergalactic origin. Both are wrong; the -* correct value is L2=137.37.) -* -* P.T.Wallace Starlink 25 January 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DL,DB,DSL,DSB - - DOUBLE PRECISION sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION V1(3),V2(3) - -* -* System of supergalactic coordinates: -* -* SGL SGB L2 B2 (deg) -* - +90 47.37 +6.32 -* 0 0 - 0 -* -* Galactic to supergalactic rotation matrix: -* - DOUBLE PRECISION RMAT(3,3) - DATA RMAT(1,1),RMAT(1,2),RMAT(1,3), - : RMAT(2,1),RMAT(2,2),RMAT(2,3), - : RMAT(3,1),RMAT(3,2),RMAT(3,3)/ - : -0.735742574804D0,+0.677261296414D0,+0.000000000000D0, - : -0.074553778365D0,-0.080991471307D0,+0.993922590400D0, - : +0.673145302109D0,+0.731271165817D0,+0.110081262225D0/ - - - -* Spherical to Cartesian - CALL sla_DCS2C(DL,DB,V1) - -* Galactic to supergalactic - CALL sla_DMXV(RMAT,V1,V2) - -* Cartesian to spherical - CALL sla_DCC2S(V2,DSL,DSB) - -* Express in conventional ranges - DSL=sla_DRANRM(DSL) - DSB=sla_DRANGE(DSB) - - END diff --git a/src/slalib/ge50.f b/src/slalib/ge50.f deleted file mode 100644 index b3e6eb682..000000000 --- a/src/slalib/ge50.f +++ /dev/null @@ -1,107 +0,0 @@ - SUBROUTINE sla_GE50 (DL, DB, DR, DD) -*+ -* - - - - - -* G E 5 0 -* - - - - - -* -* Transformation from IAU 1958 galactic coordinates to -* B1950.0 'FK4' equatorial coordinates (double precision) -* -* Given: -* DL,DB dp galactic longitude and latitude L2,B2 -* -* Returned: -* DR,DD dp B1950.0 'FK4' RA,Dec -* -* (all arguments are radians) -* -* Called: -* sla_DCS2C, sla_DIMXV, sla_DCC2S, sla_ADDET, sla_DRANRM, sla_DRANGE -* -* Note: -* The equatorial coordinates are B1950.0 'FK4'. Use the -* routine sla_GALEQ if conversion to J2000.0 coordinates -* is required. -* -* Reference: -* Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960) -* -* P.T.Wallace Starlink 5 September 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DL,DB,DR,DD - - DOUBLE PRECISION sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION V1(3),V2(3),R,D,RE,DE - -* -* L2,B2 system of galactic coordinates -* -* P = 192.25 RA of galactic north pole (mean B1950.0) -* Q = 62.6 inclination of galactic to mean B1950.0 equator -* R = 33 longitude of ascending node -* -* P,Q,R are degrees -* -* -* Equatorial to galactic rotation matrix -* -* The Euler angles are P, Q, 90-R, about the z then y then -* z axes. -* -* +CP.CQ.SR-SP.CR +SP.CQ.SR+CP.CR -SQ.SR -* -* -CP.CQ.CR-SP.SR -SP.CQ.CR+CP.SR +SQ.CR -* -* +CP.SQ +SP.SQ +CQ -* - - DOUBLE PRECISION RMAT(3,3) - DATA RMAT(1,1),RMAT(1,2),RMAT(1,3), - : RMAT(2,1),RMAT(2,2),RMAT(2,3), - : RMAT(3,1),RMAT(3,2),RMAT(3,3) / - : -0.066988739415D0,-0.872755765852D0,-0.483538914632D0, - : +0.492728466075D0,-0.450346958020D0,+0.744584633283D0, - : -0.867600811151D0,-0.188374601723D0,+0.460199784784D0 / - - - -* Spherical to Cartesian - CALL sla_DCS2C(DL,DB,V1) - -* Rotate to mean B1950.0 - CALL sla_DIMXV(RMAT,V1,V2) - -* Cartesian to spherical - CALL sla_DCC2S(V2,R,D) - -* Introduce E-terms - CALL sla_ADDET(R,D,1950D0,RE,DE) - -* Express in conventional ranges - DR=sla_DRANRM(RE) - DD=sla_DRANGE(DE) - - END diff --git a/src/slalib/geoc.f b/src/slalib/geoc.f deleted file mode 100644 index d2e83ad8c..000000000 --- a/src/slalib/geoc.f +++ /dev/null @@ -1,77 +0,0 @@ - SUBROUTINE sla_GEOC (P, H, R, Z) -*+ -* - - - - - -* G E O C -* - - - - - -* -* Convert geodetic position to geocentric (double precision) -* -* Given: -* P dp latitude (geodetic, radians) -* H dp height above reference spheroid (geodetic, metres) -* -* Returned: -* R dp distance from Earth axis (AU) -* Z dp distance from plane of Earth equator (AU) -* -* Notes: -* -* 1 Geocentric latitude can be obtained by evaluating ATAN2(Z,R). -* -* 2 IAU 1976 constants are used. -* -* Reference: -* -* Green,R.M., Spherical Astronomy, CUP 1985, p98. -* -* Last revision: 22 July 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION P,H,R,Z - -* Earth equatorial radius (metres) - DOUBLE PRECISION A0 - PARAMETER (A0=6378140D0) - -* Reference spheroid flattening factor and useful function - DOUBLE PRECISION F,B - PARAMETER (F=1D0/298.257D0,B=(1D0-F)**2) - -* Astronomical unit in metres - DOUBLE PRECISION AU - PARAMETER (AU=1.49597870D11) - - DOUBLE PRECISION SP,CP,C,S - - - -* Geodetic to geocentric conversion - SP = SIN(P) - CP = COS(P) - C = 1D0/SQRT(CP*CP+B*SP*SP) - S = B*C - R = (A0*C+H)*CP/AU - Z = (A0*S+H)*SP/AU - - END diff --git a/src/slalib/gmst.f b/src/slalib/gmst.f deleted file mode 100644 index 343a7132e..000000000 --- a/src/slalib/gmst.f +++ /dev/null @@ -1,77 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_GMST (UT1) -*+ -* - - - - - -* G M S T -* - - - - - -* -* Conversion from universal time to sidereal time (double precision) -* -* Given: -* UT1 dp universal time (strictly UT1) expressed as -* modified Julian Date (JD-2400000.5) -* -* The result is the Greenwich mean sidereal time (double -* precision, radians). -* -* The IAU 1982 expression (see page S15 of 1984 Astronomical Almanac) -* is used, but rearranged to reduce rounding errors. This expression -* is always described as giving the GMST at 0 hours UT. In fact, it -* gives the difference between the GMST and the UT, which happens to -* equal the GMST (modulo 24 hours) at 0 hours UT each day. In this -* routine, the entire UT is used directly as the argument for the -* standard formula, and the fractional part of the UT is added -* separately. Note that the factor 1.0027379... does not appear in the -* IAU 1982 expression explicitly but in the form of the coefficient -* 8640184.812866, which is 86400x36525x0.0027379... -* -* See also the routine sla_GMSTA, which delivers better numerical -* precision by accepting the UT date and time as separate arguments. -* -* Called: sla_DRANRM -* -* P.T.Wallace Starlink 14 October 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION UT1 - - DOUBLE PRECISION sla_DRANRM - - DOUBLE PRECISION D2PI,S2R - PARAMETER (D2PI=6.283185307179586476925286766559D0, - : S2R=7.272205216643039903848711535369D-5) - - DOUBLE PRECISION TU - - - -* Julian centuries from fundamental epoch J2000 to this UT - TU=(UT1-51544.5D0)/36525D0 - -* GMST at this UT - sla_GMST=sla_DRANRM(MOD(UT1,1D0)*D2PI+ - : (24110.54841D0+ - : (8640184.812866D0+ - : (0.093104D0-6.2D-6*TU)*TU)*TU)*S2R) - - END diff --git a/src/slalib/gmsta.f b/src/slalib/gmsta.f deleted file mode 100644 index 5d718b5f2..000000000 --- a/src/slalib/gmsta.f +++ /dev/null @@ -1,99 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_GMSTA (DATE, UT) -*+ -* - - - - - - -* G M S T A -* - - - - - - -* -* Conversion from Universal Time to Greenwich mean sidereal time, -* with rounding errors minimized. -* -* double precision -* -* Given: -* DATE d UT1 date (MJD: integer part of JD-2400000.5)) -* UT d UT1 time (fraction of a day) -* -* The result is the Greenwich mean sidereal time (double precision, -* radians, in the range 0 to 2pi). -* -* There is no restriction on how the UT is apportioned between the -* DATE and UT arguments. Either of the two arguments could, for -* example, be zero and the entire date+time supplied in the other. -* However, the routine is designed to deliver maximum accuracy when -* the DATE argument is a whole number and the UT lies in the range -* 0 to 1 (or vice versa). -* -* The algorithm is based on the IAU 1982 expression (see page S15 of -* the 1984 Astronomical Almanac). This is always described as giving -* the GMST at 0 hours UT1. In fact, it gives the difference between -* the GMST and the UT, the steady 4-minutes-per-day drawing-ahead of -* ST with respect to UT. When whole days are ignored, the expression -* happens to equal the GMST at 0 hours UT1 each day. Note that the -* factor 1.0027379... does not appear explicitly but in the form of -* the coefficient 8640184.812866, which is 86400x36525x0.0027379... -* -* In this routine, the entire UT1 (the sum of the two arguments DATE -* and UT) is used directly as the argument for the standard formula. -* The UT1 is then added, but omitting whole days to conserve accuracy. -* -* See also the routine sla_GMST, which accepts the UT as a single -* argument. Compared with sla_GMST, the extra numerical precision -* delivered by the present routine is unlikely to be important in -* an absolute sense, but may be useful when critically comparing -* algorithms and in applications where two sidereal times close -* together are differenced. -* -* Called: sla_DRANRM -* -* P.T.Wallace Starlink 14 October 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,UT - -* Seconds of time to radians - DOUBLE PRECISION S2R - PARAMETER (S2R=7.272205216643039903848712D-5) - - DOUBLE PRECISION D1,D2,T - DOUBLE PRECISION sla_DRANRM - - -* Julian centuries since J2000. - IF (DATE.LT.UT) THEN - D1=DATE - D2=UT - ELSE - D1=UT - D2=DATE - END IF - T=(D1+(D2-51544.5D0))/36525D0 - -* GMST at this UT1. - sla_GMSTA=sla_DRANRM(S2R*(24110.54841D0+ - : (8640184.812866D0+ - : (0.093104D0 - : -6.2D-6*T)*T)*T - : +86400D0*(MOD(D1,1D0)+MOD(D2,1D0)))) - - END diff --git a/src/slalib/gresid.F b/src/slalib/gresid.F deleted file mode 100644 index 24929e08e..000000000 --- a/src/slalib/gresid.F +++ /dev/null @@ -1,113 +0,0 @@ -#include - REAL FUNCTION sla_GRESID (S) -*+ -* - - - - - - - -* G R E S I D -* - - - - - - - -* -* Generate pseudo-random normal deviate ( = 'Gaussian residual') -* (single precision) -* -* Given: -* S real standard deviation -* -* The results of many calls to this routine will be -* normally distributed with mean zero and standard deviation S. -* -* The Box-Muller algorithm is used. This is described in -* Numerical Recipes, section 7.2. -* -* Called: RAN or RAND (a REAL function returning a random variate -- -* the precise function which is called depends on which functions -* are available when the library is built). If neither of these -* is available, we use the local substitute RANDOM defined -* in rtl_random.c -* -* P.T.Wallace Starlink 14 October 1991 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -*- - - IMPLICIT NONE - - REAL S - - REAL X,Y,R,W,GNEXT,G - LOGICAL FTF,FIRST - -#if HAVE_RAND - REAL RAND -#elif HAVE_RANDOM - REAL RANDOM -#else - error "Can't find random-number function" -#endif - - SAVE GNEXT,FTF,FIRST - DATA FTF,FIRST / .TRUE.,.TRUE. / - - X = 0.0 - Y = 0.0 - -* First time through, initialise the random-number generator -#if HAVE_RAND - IF (FTF) THEN - X = RAND(123456789) - FTF = .FALSE. - END IF -#endif - -* Second normal deviate of the pair available? - IF (FIRST) THEN - -* No - generate two random numbers inside unit circle - R = 2.0 - DO WHILE (R.GE.1.0) - -* Generate two random numbers in range +/- 1 -#if HAVE_RAND - X = 2.0*RAND(0)-1.0 - Y = 2.0*RAND(0)-1.0 -#elif HAVE_RANDOM - X = 2.0*RAN(ISEED)-1.0 - Y = 2.0*RAN(ISEED)-1.0 -#endif - -* Try again if not in unit circle - R = X*X+Y*Y - END DO - -* Box-Muller transformation, generating two deviates - W = SQRT(-2.0*LOG(R)/MAX(R,1E-20)) - GNEXT = X*W - G = Y*W - -* Set flag to indicate availability of next deviate - FIRST = .FALSE. - ELSE - -* Return second deviate of the pair & reset flag - G = GNEXT - FIRST = .TRUE. - END IF - -* Scale the deviate by the required standard deviation - sla_GRESID = G*S - - END diff --git a/src/slalib/h2e.f b/src/slalib/h2e.f deleted file mode 100644 index 51d63dd20..000000000 --- a/src/slalib/h2e.f +++ /dev/null @@ -1,100 +0,0 @@ - SUBROUTINE sla_H2E ( AZ, EL, PHI, HA, DEC ) -*+ -* - - - - - -* D E 2 H -* - - - - - -* -* Horizon to equatorial coordinates: Az,El to HA,Dec -* -* (single precision) -* -* Given: -* AZ r azimuth -* EL r elevation -* PHI r observatory latitude -* -* Returned: -* HA r hour angle -* DEC r declination -* -* Notes: -* -* 1) All the arguments are angles in radians. -* -* 2) The sign convention for azimuth is north zero, east +pi/2. -* -* 3) HA is returned in the range +/-pi. Declination is returned -* in the range +/-pi/2. -* -* 4) The latitude is (in principle) geodetic. In critical -* applications, corrections for polar motion should be applied. -* -* 5) In some applications it will be important to specify the -* correct type of elevation in order to produce the required -* type of HA,Dec. In particular, it may be important to -* distinguish between the elevation as affected by refraction, -* which will yield the "observed" HA,Dec, and the elevation -* in vacuo, which will yield the "topocentric" HA,Dec. If the -* effects of diurnal aberration can be neglected, the -* topocentric HA,Dec may be used as an approximation to the -* "apparent" HA,Dec. -* -* 6) No range checking of arguments is done. -* -* 7) In applications which involve many such calculations, rather -* than calling the present routine it will be more efficient to -* use inline code, having previously computed fixed terms such -* as sine and cosine of latitude. -* -* Last revision: 11 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL AZ, EL, PHI, HA, DEC - - DOUBLE PRECISION SA, CA, SE, CE, SP, CP, X, Y, Z, R - - -* Useful trig functions. - SA = SIN(AZ) - CA = COS(AZ) - SE = SIN(EL) - CE = COS(EL) - SP = SIN(PHI) - CP = COS(PHI) - -* HA,Dec as x,y,z. - X = -CA*CE*SP+SE*CP - Y = -SA*CE - Z = CA*CE*CP+SE*SP - -* To HA,Dec. - R = SQRT(X*X+Y*Y) - IF (R.EQ.0.0) THEN - HA = 0.0 - ELSE - HA = REAL(ATAN2(Y,X)) - END IF - DEC = REAL(ATAN2(Z,R)) - - END diff --git a/src/slalib/h2fk5.f b/src/slalib/h2fk5.f deleted file mode 100644 index 559dda691..000000000 --- a/src/slalib/h2fk5.f +++ /dev/null @@ -1,126 +0,0 @@ - SUBROUTINE sla_H2FK5 (RH,DH,DRH,DDH,R5,D5,DR5,DD5) -*+ -* - - - - - - -* H 2 F K 5 -* - - - - - - -* -* Transform Hipparcos star data into the FK5 (J2000) system. -* -* (double precision) -* -* This routine transforms Hipparcos star positions and proper -* motions into FK5 J2000. -* -* Given (all Hipparcos, epoch J2000): -* RH d RA (radians) -* DH d Dec (radians) -* DRH d proper motion in RA (dRA/dt, rad/Jyear) -* DDH d proper motion in Dec (dDec/dt, rad/Jyear) -* -* Returned (all FK5, equinox J2000, epoch J2000): -* R5 d RA (radians) -* D5 d Dec (radians) -* DR5 d proper motion in RA (dRA/dt, rad/Jyear) -* DD5 d proper motion in Dec (dDec/dt, rad/Jyear) -* -* Called: sla_DS2C6, sla_DAV2M, sla_DMXV, sla_DIMXV, sla_DVXV, -* sla_DC62S, sla_DRANRM -* -* Notes: -* -* 1) The proper motions in RA are dRA/dt rather than -* cos(Dec)*dRA/dt, and are per year rather than per century. -* -* 2) The FK5 to Hipparcos transformation consists of a pure -* rotation and spin; zonal errors in the FK5 catalogue are -* not taken into account. -* -* 3) The published orientation and spin components are interpreted -* as "axial vectors". An axial vector points at the pole of the -* rotation and its length is the amount of rotation in radians. -* -* 4) See also sla_FK52H, sla_FK5HZ, sla_HFK5Z. -* -* Reference: -* -* M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998). -* -* P.T.Wallace Starlink 22 June 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RH,DH,DRH,DDH,R5,D5,DR5,DD5 - - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - -* FK5 to Hipparcos orientation and spin (radians, radians/year) - DOUBLE PRECISION EPX,EPY,EPZ - DOUBLE PRECISION OMX,OMY,OMZ - - PARAMETER ( EPX = -19.9D-3 * AS2R, - : EPY = -9.1D-3 * AS2R, - : EPZ = +22.9D-3 * AS2R ) - - PARAMETER ( OMX = -0.30D-3 * AS2R, - : OMY = +0.60D-3 * AS2R, - : OMZ = +0.70D-3 * AS2R ) - - DOUBLE PRECISION PVH(6),ORTN(3),R5H(3,3),S5(3),SH(3),VV(3), - : PV5(6),W,R,V - INTEGER I - - DOUBLE PRECISION sla_DRANRM - - - -* Hipparcos barycentric position/velocity 6-vector (normalized). - CALL sla_DS2C6(RH,DH,1D0,DRH,DDH,0D0,PVH) - -* FK5 to Hipparcos orientation matrix. - ORTN(1) = EPX - ORTN(2) = EPY - ORTN(3) = EPZ - CALL sla_DAV2M(ORTN,R5H) - -* Hipparcos wrt FK5 spin vector. - S5(1) = OMX - S5(2) = OMY - S5(3) = OMZ - -* Rotate the spin vector into the Hipparcos frame. - CALL sla_DMXV(R5H,S5,SH) - -* De-orient & de-spin the 6-vector into FK5 J2000. - CALL sla_DIMXV(R5H,PVH,PV5) - CALL sla_DVXV(PVH,SH,VV) - DO I=1,3 - VV(I) = PVH(I+3)-VV(I) - END DO - CALL sla_DIMXV(R5H,VV,PV5(4)) - -* FK5 6-vector to spherical. - CALL sla_DC62S(PV5,W,D5,R,DR5,DD5,V) - R5 = sla_DRANRM(W) - - END diff --git a/src/slalib/hfk5z.f b/src/slalib/hfk5z.f deleted file mode 100644 index 49c33e4d8..000000000 --- a/src/slalib/hfk5z.f +++ /dev/null @@ -1,139 +0,0 @@ - SUBROUTINE sla_HFK5Z (RH,DH,EPOCH,R5,D5,DR5,DD5) -*+ -* - - - - - - -* H F K 5 Z -* - - - - - - -* -* Transform a Hipparcos star position into FK5 J2000, assuming -* zero Hipparcos proper motion. -* -* (double precision) -* -* Given: -* RH d Hipparcos RA (radians) -* DH d Hipparcos Dec (radians) -* EPOCH d Julian epoch (TDB) -* -* Returned (all FK5, equinox J2000, epoch EPOCH): -* R5 d RA (radians) -* D5 d Dec (radians) -* -* Called: sla_DCS2C, sla_DAV2M, sla_DMXV, sla_DMXM, -* sla_DIMXV, sla_DVXV, sla_DC62S, sla_DRANRM -* -* Notes: -* -* 1) The proper motion in RA is dRA/dt rather than cos(Dec)*dRA/dt. -* -* 2) The FK5 to Hipparcos transformation consists of a pure -* rotation and spin; zonal errors in the FK5 catalogue are -* not taken into account. -* -* 3) The published orientation and spin components are interpreted -* as "axial vectors". An axial vector points at the pole of the -* rotation and its length is the amount of rotation in radians. -* -* 4) It was the intention that Hipparcos should be a close -* approximation to an inertial frame, so that distant objects -* have zero proper motion; such objects have (in general) -* non-zero proper motion in FK5, and this routine returns those -* fictitious proper motions. -* -* 5) The position returned by this routine is in the FK5 J2000 -* reference frame but at Julian epoch EPOCH. -* -* 6) See also sla_FK52H, sla_H2FK5, sla_FK5ZHZ. -* -* Reference: -* -* M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998). -* -* P.T.Wallace Starlink 30 December 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RH,DH,EPOCH,R5,D5,DR5,DD5 - - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - -* FK5 to Hipparcos orientation and spin (radians, radians/year) - DOUBLE PRECISION EPX,EPY,EPZ - DOUBLE PRECISION OMX,OMY,OMZ - - PARAMETER ( EPX = -19.9D-3 * AS2R, - : EPY = -9.1D-3 * AS2R, - : EPZ = +22.9D-3 * AS2R ) - - PARAMETER ( OMX = -0.30D-3 * AS2R, - : OMY = +0.60D-3 * AS2R, - : OMZ = +0.70D-3 * AS2R ) - - DOUBLE PRECISION PH(3),ORTN(3),R5H(3,3),S5(3),SH(3),T,VST(3), - : RST(3,3),R5HT(3,3),PV5E(6),VV(3),W,R,V - - DOUBLE PRECISION sla_DRANRM - - - -* Hipparcos barycentric position vector (normalized). - CALL sla_DCS2C(RH,DH,PH) - -* FK5 to Hipparcos orientation matrix. - ORTN(1) = EPX - ORTN(2) = EPY - ORTN(3) = EPZ - CALL sla_DAV2M(ORTN,R5H) - -* Hipparcos wrt FK5 spin vector. - S5(1) = OMX - S5(2) = OMY - S5(3) = OMZ - -* Rotate the spin vector into the Hipparcos frame. - CALL sla_DMXV(R5H,S5,SH) - -* Time interval from J2000 to epoch. - T = EPOCH-2000D0 - -* Axial vector: accumulated Hipparcos wrt FK5 spin over that interval. - VST(1) = OMX*T - VST(2) = OMY*T - VST(3) = OMZ*T - -* Express the accumulated spin as a rotation matrix. - CALL sla_DAV2M(VST,RST) - -* Rotation matrix: accumulated spin, then FK5 to Hipparcos. - CALL sla_DMXM(R5H,RST,R5HT) - -* De-orient & de-spin the vector into FK5 J2000 at epoch. - CALL sla_DIMXV(R5HT,PH,PV5E) - CALL sla_DVXV(SH,PH,VV) - CALL sla_DIMXV(R5HT,VV,PV5E(4)) - -* FK5 position/velocity 6-vector to spherical. - CALL sla_DC62S(PV5E,W,D5,R,DR5,DD5,V) - R5 = sla_DRANRM(W) - - END diff --git a/src/slalib/idchf.f b/src/slalib/idchf.f deleted file mode 100644 index c3061e278..000000000 --- a/src/slalib/idchf.f +++ /dev/null @@ -1,111 +0,0 @@ - SUBROUTINE sla__IDCHF (STRING, NPTR, NVEC, NDIGIT, DIGIT) -*+ -* - - - - - - -* I D C H F -* - - - - - - -* -* Internal routine used by DFLTIN -* -* Identify next character in string -* -* Given: -* STRING char string -* NPTR int pointer to character to be identified -* -* Returned: -* NPTR int incremented unless end of field -* NVEC int vector for identified character -* NDIGIT int 0-9 if character was a numeral -* DIGIT double equivalent of NDIGIT -* -* NVEC takes the following values: -* -* 1 0-9 -* 2 space or TAB !!! n.b. ASCII TAB assumed !!! -* 3 D,d,E or e -* 4 . -* 5 + -* 6 - -* 7 , -* 8 else -* 9 outside field -* -* If the character is not 0-9, NDIGIT and DIGIT are either not -* altered or are set to arbitrary values. -* -* P.T.Wallace Starlink 22 December 1992 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER NPTR,NVEC,NDIGIT - DOUBLE PRECISION DIGIT - - CHARACTER K - INTEGER NCHAR - -* Character/vector tables - INTEGER NCREC - PARAMETER (NCREC=19) - CHARACTER KCTAB(NCREC) - INTEGER KVTAB(NCREC) - DATA KCTAB/'0','1','2','3','4','5','6','7','8','9', - : ' ','D','d','E','e','.','+','-',','/ - DATA KVTAB/10*1,2,4*3,4,5,6,7/ - - -* Handle pointer outside field - IF (NPTR.LT.1.OR.NPTR.GT.LEN(STRING)) THEN - NVEC=9 - ELSE - -* Not end of field: identify the character - K=STRING(NPTR:NPTR) - DO NCHAR=1,NCREC - IF (K.EQ.KCTAB(NCHAR)) THEN - -* Recognized - NVEC=KVTAB(NCHAR) - NDIGIT=NCHAR-1 - DIGIT=DBLE(NDIGIT) - GO TO 2300 - END IF - END DO - -* Not recognized: check for TAB !!! n.b. ASCII assumed !!! - IF (K.EQ.CHAR(9)) THEN - -* TAB: treat as space - NVEC=2 - ELSE - -* Unrecognized - NVEC=8 - END IF - -* Increment pointer - 2300 CONTINUE - NPTR=NPTR+1 - END IF - - END diff --git a/src/slalib/idchi.f b/src/slalib/idchi.f deleted file mode 100644 index 9d56d864a..000000000 --- a/src/slalib/idchi.f +++ /dev/null @@ -1,108 +0,0 @@ - SUBROUTINE sla__IDCHI (STRING, NPTR, NVEC, DIGIT) -*+ -* - - - - - - -* I D C H I -* - - - - - - -* -* Internal routine used by INTIN -* -* Identify next character in string -* -* Given: -* STRING char string -* NPTR int pointer to character to be identified -* -* Returned: -* NPTR int incremented unless end of field -* NVEC int vector for identified character -* DIGIT double double precision digit if 0-9 -* -* NVEC takes the following values: -* -* 1 0-9 -* 2 space or TAB !!! n.b. ASCII TAB assumed !!! -* 3 + -* 4 - -* 5 , -* 6 else -* 7 outside string -* -* If the character is not 0-9, DIGIT is either unaltered or -* is set to an arbitrary value. -* -* P.T.Wallace Starlink 22 December 1992 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER NPTR,NVEC - DOUBLE PRECISION DIGIT - - CHARACTER K - INTEGER NCHAR - -* Character/vector tables - INTEGER NCREC - PARAMETER (NCREC=14) - CHARACTER KCTAB(NCREC) - INTEGER KVTAB(NCREC) - DATA KCTAB/'0','1','2','3','4','5','6','7','8','9', - : ' ', '+','-',','/ - DATA KVTAB/10*1,2,3,4,5/ - - - -* Handle pointer outside field - IF (NPTR.LT.1.OR.NPTR.GT.LEN(STRING)) THEN - NVEC=7 - ELSE - -* Not end of field: identify character - K=STRING(NPTR:NPTR) - DO NCHAR=1,NCREC - IF (K.EQ.KCTAB(NCHAR)) THEN - -* Recognized - NVEC=KVTAB(NCHAR) - DIGIT=DBLE(NCHAR-1) - GO TO 2300 - END IF - END DO - -* Not recognized: check for TAB !!! n.b. ASCII assumed !!! - IF (K.EQ.CHAR(9)) THEN - -* TAB: treat as space - NVEC=2 - ELSE - -* Unrecognized - NVEC=6 - END IF - -* Increment pointer - 2300 CONTINUE - NPTR=NPTR+1 - END IF - - END diff --git a/src/slalib/imxv.f b/src/slalib/imxv.f deleted file mode 100644 index 7f9042cfd..000000000 --- a/src/slalib/imxv.f +++ /dev/null @@ -1,68 +0,0 @@ - SUBROUTINE sla_IMXV (RM, VA, VB) -*+ -* - - - - - -* I M X V -* - - - - - -* -* Performs the 3-D backward unitary transformation: -* -* vector VB = (inverse of matrix RM) * vector VA -* -* (single precision) -* -* (n.b. the matrix must be unitary, as this routine assumes that -* the inverse and transpose are identical) -* -* Given: -* RM real(3,3) matrix -* VA real(3) vector -* -* Returned: -* VB real(3) result vector -* -* P.T.Wallace Starlink November 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL RM(3,3),VA(3),VB(3) - - INTEGER I,J - REAL W,VW(3) - - - -* Inverse of matrix RM * vector VA -> vector VW - DO J=1,3 - W=0.0 - DO I=1,3 - W=W+RM(I,J)*VA(I) - END DO - VW(J)=W - END DO - -* Vector VW -> vector VB - DO J=1,3 - VB(J)=VW(J) - END DO - - END diff --git a/src/slalib/intin.f b/src/slalib/intin.f deleted file mode 100644 index fe056bc8e..000000000 --- a/src/slalib/intin.f +++ /dev/null @@ -1,193 +0,0 @@ - SUBROUTINE sla_INTIN (STRING, NSTRT, IRESLT, JFLAG) -*+ -* - - - - - - -* I N T I N -* - - - - - - -* -* Convert free-format input into an integer -* -* Given: -* STRING c string containing number to be decoded -* NSTRT i pointer to where decoding is to start -* IRESLT i current value of result -* -* Returned: -* NSTRT i advanced to next number -* IRESLT i result -* JFLAG i status: -1 = -OK, 0 = +OK, 1 = null, 2 = error -* -* Called: sla__IDCHI -* -* Notes: -* -* 1 The reason INTIN has separate OK status values for + -* and - is to enable minus zero to be detected. This is -* of crucial importance when decoding mixed-radix numbers. -* For example, an angle expressed as deg, arcmin, arcsec -* may have a leading minus sign but a zero degrees field. -* -* 2 A TAB is interpreted as a space. -* -* 3 The basic format is the sequence of fields #^, where -* # is a sign character + or -, and ^ means a string of -* decimal digits. -* -* 4 Spaces: -* -* . Leading spaces are ignored. -* -* . Spaces between the sign and the number are allowed. -* -* . Trailing spaces are ignored; the first signifies -* end of decoding and subsequent ones are skipped. -* -* 5 Delimiters: -* -* . Any character other than +,-,0-9 or space may be -* used to signal the end of the number and terminate -* decoding. -* -* . Comma is recognized by INTIN as a special case; it -* is skipped, leaving the pointer on the next character. -* See 9, below. -* -* 6 The sign is optional. The default is +. -* -* 7 A "null result" occurs when the string of characters being -* decoded does not begin with +,- or 0-9, or consists -* entirely of spaces. When this condition is detected, JFLAG -* is set to 1 and IRESLT is left untouched. -* -* 8 NSTRT = 1 for the first character in the string. -* -* 9 On return from INTIN, NSTRT is set ready for the next -* decode - following trailing blanks and any comma. If a -* delimiter other than comma is being used, NSTRT must be -* incremented before the next call to INTIN, otherwise -* all subsequent calls will return a null result. -* -* 10 Errors (JFLAG=2) occur when: -* -* . there is a + or - but no number; or -* -* . the number is greater than BIG (defined below). -* -* 11 When an error has been detected, NSTRT is left -* pointing to the character following the last -* one used before the error came to light. -* -* 12 See also FLOTIN and DFLTIN. -* -* P.T.Wallace Starlink 27 April 1998 -* -* Copyright (C) 1998 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) STRING - INTEGER NSTRT,IRESLT,JFLAG - -* Maximum allowed value - DOUBLE PRECISION BIG - PARAMETER (BIG=2147483647D0) - - INTEGER JPTR,MSIGN,NVEC,J - DOUBLE PRECISION DRES,DIGIT - - - -* Current character - JPTR=NSTRT - -* Set defaults - DRES=0D0 - MSIGN=1 - -* Look for sign - 100 CONTINUE - CALL sla__IDCHI(STRING,JPTR,NVEC,DIGIT) - GO TO ( 400, 100, 300, 200, 9110, 9100, 9110),NVEC -* 0-9 SP + - , ELSE END - -* Negative - 200 CONTINUE - MSIGN=-1 - -* Look for first decimal - 300 CONTINUE - CALL sla__IDCHI(STRING,JPTR,NVEC,DIGIT) - GO TO ( 400, 300, 9200, 9200, 9200, 9200, 9210),NVEC -* 0-9 SP + - , ELSE END - -* Accept decimals - 400 CONTINUE - DRES=DRES*1D1+DIGIT - -* Test for overflow - IF (DRES.GT.BIG) GO TO 9200 - -* Look for subsequent decimals - CALL sla__IDCHI(STRING,JPTR,NVEC,DIGIT) - GO TO ( 400, 1610, 1600, 1600, 1600, 1600, 1610),NVEC -* 0-9 SP + - , ELSE END - -* Get result & status - 1600 CONTINUE - JPTR=JPTR-1 - 1610 CONTINUE - J=0 - IF (MSIGN.EQ.1) GO TO 1620 - J=-1 - DRES=-DRES - 1620 CONTINUE - IRESLT=NINT(DRES) - -* Skip to end of field - 1630 CONTINUE - CALL sla__IDCHI(STRING,JPTR,NVEC,DIGIT) - GO TO (1720, 1630, 1720, 1720, 9900, 1720, 9900),NVEC -* 0-9 SP + - , ELSE END - - 1720 CONTINUE - JPTR=JPTR-1 - GO TO 9900 - -* Exits - -* Null field - 9100 CONTINUE - JPTR=JPTR-1 - 9110 CONTINUE - J=1 - GO TO 9900 - -* Errors - 9200 CONTINUE - JPTR=JPTR-1 - 9210 CONTINUE - J=2 - -* Return - 9900 CONTINUE - NSTRT=JPTR - JFLAG=J - - END diff --git a/src/slalib/invf.f b/src/slalib/invf.f deleted file mode 100644 index 3d6a29cd5..000000000 --- a/src/slalib/invf.f +++ /dev/null @@ -1,105 +0,0 @@ - SUBROUTINE sla_INVF (FWDS,BKWDS,J) -*+ -* - - - - - -* I N V F -* - - - - - -* -* Invert a linear model of the type produced by the sla_FITXY routine. -* -* Given: -* FWDS d(6) model coefficients -* -* Returned: -* BKWDS d(6) inverse model -* J i status: 0 = OK, -1 = no inverse -* -* The models relate two sets of [X,Y] coordinates as follows. -* Naming the elements of FWDS: -* -* FWDS(1) = A -* FWDS(2) = B -* FWDS(3) = C -* FWDS(4) = D -* FWDS(5) = E -* FWDS(6) = F -* -* where two sets of coordinates [X1,Y1] and [X2,Y1] are related -* thus: -* -* X2 = A + B*X1 + C*Y1 -* Y2 = D + E*X1 + F*Y1 -* -* the present routine generates a new set of coefficients: -* -* BKWDS(1) = P -* BKWDS(2) = Q -* BKWDS(3) = R -* BKWDS(4) = S -* BKWDS(5) = T -* BKWDS(6) = U -* -* such that: -* -* X1 = P + Q*X2 + R*Y2 -* Y1 = S + T*X2 + U*Y2 -* -* Two successive calls to sla_INVF will thus deliver a set -* of coefficients equal to the starting values. -* -* To comply with the ANSI Fortran standard, FWDS and BKWDS must -* not be the same array, even though the routine is coded to -* work on many platforms even if this rule is violated. -* -* See also sla_FITXY, sla_PXY, sla_XY2XY, sla_DCMPF -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION FWDS(6),BKWDS(6) - INTEGER J - - DOUBLE PRECISION A,B,C,D,E,F,DET - - - - A=FWDS(1) - B=FWDS(2) - C=FWDS(3) - D=FWDS(4) - E=FWDS(5) - F=FWDS(6) - DET=B*F-C*E - IF (DET.NE.0D0) THEN - BKWDS(1)=(C*D-A*F)/DET - BKWDS(2)=F/DET - BKWDS(3)=-C/DET - BKWDS(4)=(A*E-B*D)/DET - BKWDS(5)=-E/DET - BKWDS(6)=B/DET - J=0 - ELSE - J=-1 - END IF - - END diff --git a/src/slalib/kbj.f b/src/slalib/kbj.f deleted file mode 100644 index 45270d178..000000000 --- a/src/slalib/kbj.f +++ /dev/null @@ -1,73 +0,0 @@ - SUBROUTINE sla_KBJ (JB, E, K, J) -*+ -* - - - - -* K B J -* - - - - -* -* Select epoch prefix 'B' or 'J' -* -* Given: -* JB int sla_DBJIN prefix status: 0=none, 1='B', 2='J' -* E dp epoch - Besselian or Julian -* -* Returned: -* K char 'B' or 'J' -* J int status: 0=OK -* -* If JB=0, B is assumed for E < 1984D0, otherwise J. -* -* P.T.Wallace Starlink 31 July 1989 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER JB - DOUBLE PRECISION E - CHARACTER K*(*) - INTEGER J - -* Preset status - J=0 - -* If prefix given expressly, use it - IF (JB.EQ.1) THEN - K='B' - ELSE IF (JB.EQ.2) THEN - K='J' - -* If no prefix, examine the epoch - ELSE IF (JB.EQ.0) THEN - -* If epoch is pre-1984.0, assume Besselian; otherwise Julian - IF (E.LT.1984D0) THEN - K='B' - ELSE - K='J' - END IF - -* If illegal prefix, return error status - ELSE - K=' ' - J=1 - END IF - - END diff --git a/src/slalib/m2av.f b/src/slalib/m2av.f deleted file mode 100644 index 15d324662..000000000 --- a/src/slalib/m2av.f +++ /dev/null @@ -1,74 +0,0 @@ - SUBROUTINE sla_M2AV (RMAT, AXVEC) -*+ -* - - - - - -* M 2 A V -* - - - - - -* -* From a rotation matrix, determine the corresponding axial vector -* (single precision) -* -* A rotation matrix describes a rotation about some arbitrary axis, -* called the Euler axis. The "axial vector" returned by this routine -* has the same direction as the Euler axis, and its magnitude is the -* amount of rotation in radians. (The magnitude and direction can be -* separated by means of the routine sla_VN.) -* -* Given: -* RMAT r(3,3) rotation matrix -* -* Returned: -* AXVEC r(3) axial vector (radians) -* -* The reference frame rotates clockwise as seen looking along -* the axial vector from the origin. -* -* If RMAT is null, so is the result. -* -* Last revision: 26 November 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL RMAT(3,3),AXVEC(3) - - REAL X,Y,Z,S2,C2,PHI,F - - - - X = RMAT(2,3)-RMAT(3,2) - Y = RMAT(3,1)-RMAT(1,3) - Z = RMAT(1,2)-RMAT(2,1) - S2 = SQRT(X*X+Y*Y+Z*Z) - IF (S2.NE.0.0) THEN - C2 = (RMAT(1,1)+RMAT(2,2)+RMAT(3,3)-1.0) - PHI = ATAN2(S2/2.0,C2/2.0) - F = PHI/S2 - AXVEC(1) = X*F - AXVEC(2) = Y*F - AXVEC(3) = Z*F - ELSE - AXVEC(1) = 0.0 - AXVEC(2) = 0.0 - AXVEC(3) = 0.0 - END IF - - END diff --git a/src/slalib/map.f b/src/slalib/map.f deleted file mode 100644 index cf83c5f09..000000000 --- a/src/slalib/map.f +++ /dev/null @@ -1,98 +0,0 @@ - SUBROUTINE sla_MAP (RM, DM, PR, PD, PX, RV, EQ, DATE, RA, DA) -*+ -* - - - - -* M A P -* - - - - -* -* Transform star RA,Dec from mean place to geocentric apparent -* -* The reference frames and timescales used are post IAU 1976. -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Given: -* RM,DM dp mean RA,Dec (rad) -* PR,PD dp proper motions: RA,Dec changes per Julian year -* PX dp parallax (arcsec) -* RV dp radial velocity (km/sec, +ve if receding) -* EQ dp epoch and equinox of star data (Julian) -* DATE dp TDB for apparent place (JD-2400000.5) -* -* Returned: -* RA,DA dp apparent RA,Dec (rad) -* -* Called: -* sla_MAPPA star-independent parameters -* sla_MAPQK quick mean to apparent -* -* Notes: -* -* 1) EQ is the Julian epoch specifying both the reference frame and -* the epoch of the position - usually 2000. For positions where -* the epoch and equinox are different, use the routine sla_PM to -* apply proper motion corrections before using this routine. -* -* 2) The distinction between the required TDB and TT is always -* negligible. Moreover, for all but the most critical -* applications UTC is adequate. -* -* 3) The proper motions in RA are dRA/dt rather than cos(Dec)*dRA/dt. -* -* 4) This routine may be wasteful for some applications because it -* recomputes the Earth position/velocity and the precession- -* nutation matrix each time, and because it allows for parallax -* and proper motion. Where multiple transformations are to be -* carried out for one epoch, a faster method is to call the -* sla_MAPPA routine once and then either the sla_MAPQK routine -* (which includes parallax and proper motion) or sla_MAPQKZ (which -* assumes zero parallax and proper motion). -* -* 5) The accuracy is sub-milliarcsecond, limited by the -* precession-nutation model (IAU 1976 precession, Shirai & -* Fukushima 2001 forced nutation and precession corrections). -* -* 6) The accuracy is further limited by the routine sla_EVP, called -* by sla_MAPPA, which computes the Earth position and velocity -* using the methods of Stumpff. The maximum error is about -* 0.3 mas. -* -* P.T.Wallace Starlink 17 September 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RM,DM,PR,PD,PX,RV,EQ,DATE,RA,DA - - DOUBLE PRECISION AMPRMS(21) - - - -* Star-independent parameters - CALL sla_MAPPA(EQ,DATE,AMPRMS) - -* Mean to apparent - CALL sla_MAPQK(RM,DM,PR,PD,PX,RV,AMPRMS,RA,DA) - - END diff --git a/src/slalib/mappa.f b/src/slalib/mappa.f deleted file mode 100644 index 8b701d729..000000000 --- a/src/slalib/mappa.f +++ /dev/null @@ -1,128 +0,0 @@ - SUBROUTINE sla_MAPPA (EQ, DATE, AMPRMS) -*+ -* - - - - - - -* M A P P A -* - - - - - - -* -* Compute star-independent parameters in preparation for -* conversions between mean place and geocentric apparent place. -* -* The parameters produced by this routine are required in the -* parallax, light deflection, aberration, and precession/nutation -* parts of the mean/apparent transformations. -* -* The reference frames and timescales used are post IAU 1976. -* -* Given: -* EQ d epoch of mean equinox to be used (Julian) -* DATE d TDB (JD-2400000.5) -* -* Returned: -* AMPRMS d(21) star-independent mean-to-apparent parameters: -* -* (1) time interval for proper motion (Julian years) -* (2-4) barycentric position of the Earth (AU) -* (5-7) heliocentric direction of the Earth (unit vector) -* (8) (grav rad Sun)*2/(Sun-Earth distance) -* (9-11) ABV: barycentric Earth velocity in units of c -* (12) sqrt(1-v**2) where v=modulus(ABV) -* (13-21) precession/nutation (3,3) matrix -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Notes: -* -* 1) For DATE, the distinction between the required TDB and TT -* is always negligible. Moreover, for all but the most -* critical applications UTC is adequate. -* -* 2) The vectors AMPRMS(2-4) and AMPRMS(5-7) are referred to -* the mean equinox and equator of epoch EQ. -* -* 3) The parameters AMPRMS produced by this routine are used by -* sla_AMPQK, sla_MAPQK and sla_MAPQKZ. -* -* 4) The accuracy is sub-milliarcsecond, limited by the -* precession-nutation model (IAU 1976 precession, Shirai & -* Fukushima 2001 forced nutation and precession corrections). -* -* 5) A further limit to the accuracy of routines using the parameter -* array AMPRMS is imposed by the routine sla_EVP, used here to -* compute the Earth position and velocity by the methods of -* Stumpff. The maximum error in the resulting aberration -* corrections is about 0.3 milliarcsecond. -* -* Called: -* sla_EPJ MDJ to Julian epoch -* sla_EVP earth position & velocity -* sla_DVN normalize vector -* sla_PRENUT precession/nutation matrix -* -* P.T.Wallace Starlink 24 October 2003 -* -* Copyright (C) 2003 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EQ,DATE,AMPRMS(21) - -* Light time for 1 AU (sec) - DOUBLE PRECISION CR - PARAMETER (CR=499.004782D0) - -* Gravitational radius of the Sun x 2 (2*mu/c**2, AU) - DOUBLE PRECISION GR2 - PARAMETER (GR2=2D0*9.87063D-9) - - INTEGER I - - DOUBLE PRECISION EBD(3),EHD(3),EH(3),E,VN(3),VM - - DOUBLE PRECISION sla_EPJ - - - -* Time interval for proper motion correction - AMPRMS(1) = sla_EPJ(DATE)-EQ - -* Get Earth barycentric and heliocentric position and velocity - CALL sla_EVP(DATE,EQ,EBD,AMPRMS(2),EHD,EH) - -* Heliocentric direction of earth (normalized) and modulus - CALL sla_DVN(EH,AMPRMS(5),E) - -* Light deflection parameter - AMPRMS(8) = GR2/E - -* Aberration parameters - DO I=1,3 - AMPRMS(I+8) = EBD(I)*CR - END DO - CALL sla_DVN(AMPRMS(9),VN,VM) - AMPRMS(12) = SQRT(1D0-VM*VM) - -* Precession/nutation matrix - CALL sla_PRENUT(EQ,DATE,AMPRMS(13)) - - END diff --git a/src/slalib/mapqk.f b/src/slalib/mapqk.f deleted file mode 100644 index 1a3111aab..000000000 --- a/src/slalib/mapqk.f +++ /dev/null @@ -1,159 +0,0 @@ - SUBROUTINE sla_MAPQK (RM, DM, PR, PD, PX, RV, AMPRMS, RA, DA) -*+ -* - - - - - - -* M A P Q K -* - - - - - - -* -* Quick mean to apparent place: transform a star RA,Dec from -* mean place to geocentric apparent place, given the -* star-independent parameters. -* -* Use of this routine is appropriate when efficiency is important -* and where many star positions, all referred to the same equator -* and equinox, are to be transformed for one epoch. The -* star-independent parameters can be obtained by calling the -* sla_MAPPA routine. -* -* If the parallax and proper motions are zero the sla_MAPQKZ -* routine can be used instead. -* -* The reference frames and timescales used are post IAU 1976. -* -* Given: -* RM,DM d mean RA,Dec (rad) -* PR,PD d proper motions: RA,Dec changes per Julian year -* PX d parallax (arcsec) -* RV d radial velocity (km/sec, +ve if receding) -* -* AMPRMS d(21) star-independent mean-to-apparent parameters: -* -* (1) time interval for proper motion (Julian years) -* (2-4) barycentric position of the Earth (AU) -* (5-7) heliocentric direction of the Earth (unit vector) -* (8) (grav rad Sun)*2/(Sun-Earth distance) -* (9-11) barycentric Earth velocity in units of c -* (12) sqrt(1-v**2) where v=modulus(ABV) -* (13-21) precession/nutation (3,3) matrix -* -* Returned: -* RA,DA d apparent RA,Dec (rad) -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Notes: -* -* 1) The vectors AMPRMS(2-4) and AMPRMS(5-7) are referred to -* the mean equinox and equator of epoch EQ. -* -* 2) Strictly speaking, the routine is not valid for solar-system -* sources, though the error will usually be extremely small. -* However, to prevent gross errors in the case where the -* position of the Sun is specified, the gravitational -* deflection term is restrained within about 920 arcsec of the -* centre of the Sun's disc. The term has a maximum value of -* about 1.85 arcsec at this radius, and decreases to zero as -* the centre of the disc is approached. -* -* Called: -* sla_DCS2C spherical to Cartesian -* sla_DVDV dot product -* sla_DMXV matrix x vector -* sla_DCC2S Cartesian to spherical -* sla_DRANRM normalize angle 0-2Pi -* -* P.T.Wallace Starlink 15 January 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RM,DM,PR,PD,PX,RV,AMPRMS(21),RA,DA - -* Arc seconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - -* Km/s to AU/year - DOUBLE PRECISION VF - PARAMETER (VF=0.21094502D0) - - INTEGER I - - DOUBLE PRECISION PMT,GR2E,AB1,EB(3),EHN(3),ABV(3), - : Q(3),PXR,W,EM(3),P(3),PN(3),PDE,PDEP1, - : P1(3),P1DV,P2(3),P3(3) - - DOUBLE PRECISION sla_DVDV,sla_DRANRM - - - -* Unpack scalar and vector parameters - PMT = AMPRMS(1) - GR2E = AMPRMS(8) - AB1 = AMPRMS(12) - DO I=1,3 - EB(I) = AMPRMS(I+1) - EHN(I) = AMPRMS(I+4) - ABV(I) = AMPRMS(I+8) - END DO - -* Spherical to x,y,z - CALL sla_DCS2C(RM,DM,Q) - -* Space motion (radians per year) - PXR = PX*AS2R - W = VF*RV*PXR - EM(1) = -PR*Q(2)-PD*COS(RM)*SIN(DM)+W*Q(1) - EM(2) = PR*Q(1)-PD*SIN(RM)*SIN(DM)+W*Q(2) - EM(3) = PD*COS(DM) +W*Q(3) - -* Geocentric direction of star (normalized) - DO I=1,3 - P(I) = Q(I)+PMT*EM(I)-PXR*EB(I) - END DO - CALL sla_DVN(P,PN,W) - -* Light deflection (restrained within the Sun's disc) - PDE = sla_DVDV(PN,EHN) - PDEP1 = PDE+1D0 - W = GR2E/MAX(PDEP1,1D-5) - DO I=1,3 - P1(I) = PN(I)+W*(EHN(I)-PDE*PN(I)) - END DO - -* Aberration (normalization omitted) - P1DV = sla_DVDV(P1,ABV) - W = 1D0+P1DV/(AB1+1D0) - DO I=1,3 - P2(I) = AB1*P1(I)+W*ABV(I) - END DO - -* Precession and nutation - CALL sla_DMXV(AMPRMS(13),P2,P3) - -* Geocentric apparent RA,Dec - CALL sla_DCC2S(P3,RA,DA) - RA = sla_DRANRM(RA) - - END diff --git a/src/slalib/mapqkz.f b/src/slalib/mapqkz.f deleted file mode 100644 index 981fe2594..000000000 --- a/src/slalib/mapqkz.f +++ /dev/null @@ -1,130 +0,0 @@ - SUBROUTINE sla_MAPQKZ (RM, DM, AMPRMS, RA, DA) -*+ -* - - - - - - - -* M A P Q K Z -* - - - - - - - -* -* Quick mean to apparent place: transform a star RA,Dec from -* mean place to geocentric apparent place, given the -* star-independent parameters, and assuming zero parallax -* and proper motion. -* -* Use of this routine is appropriate when efficiency is important -* and where many star positions, all with parallax and proper -* motion either zero or already allowed for, and all referred to -* the same equator and equinox, are to be transformed for one -* epoch. The star-independent parameters can be obtained by -* calling the sla_MAPPA routine. -* -* The corresponding routine for the case of non-zero parallax -* and proper motion is sla_MAPQK. -* -* The reference frames and timescales used are post IAU 1976. -* -* Given: -* RM,DM d mean RA,Dec (rad) -* AMPRMS d(21) star-independent mean-to-apparent parameters: -* -* (1-4) not used -* (5-7) heliocentric direction of the Earth (unit vector) -* (8) (grav rad Sun)*2/(Sun-Earth distance) -* (9-11) ABV: barycentric Earth velocity in units of c -* (12) sqrt(1-v**2) where v=modulus(ABV) -* (13-21) precession/nutation (3,3) matrix -* -* Returned: -* RA,DA d apparent RA,Dec (rad) -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Notes: -* -* 1) The vectors AMPRMS(2-4) and AMPRMS(5-7) are referred to the -* mean equinox and equator of epoch EQ. -* -* 2) Strictly speaking, the routine is not valid for solar-system -* sources, though the error will usually be extremely small. -* However, to prevent gross errors in the case where the -* position of the Sun is specified, the gravitational -* deflection term is restrained within about 920 arcsec of the -* centre of the Sun's disc. The term has a maximum value of -* about 1.85 arcsec at this radius, and decreases to zero as -* the centre of the disc is approached. -* -* Called: sla_DCS2C, sla_DVDV, sla_DMXV, sla_DCC2S, sla_DRANRM -* -* P.T.Wallace Starlink 18 March 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RM,DM,AMPRMS(21),RA,DA - - INTEGER I - - DOUBLE PRECISION GR2E,AB1,EHN(3),ABV(3), - : P(3),PDE,PDEP1,W,P1(3),P1DV, - : P1DVP1,P2(3),P3(3) - - DOUBLE PRECISION sla_DVDV,sla_DRANRM - - - - -* Unpack scalar and vector parameters - GR2E = AMPRMS(8) - AB1 = AMPRMS(12) - DO I=1,3 - EHN(I) = AMPRMS(I+4) - ABV(I) = AMPRMS(I+8) - END DO - -* Spherical to x,y,z - CALL sla_DCS2C(RM,DM,P) - -* Light deflection - PDE = sla_DVDV(P,EHN) - PDEP1 = PDE+1D0 - W = GR2E/MAX(PDEP1,1D-5) - DO I=1,3 - P1(I) = P(I)+W*(EHN(I)-PDE*P(I)) - END DO - -* Aberration - P1DV = sla_DVDV(P1,ABV) - P1DVP1 = P1DV+1D0 - W = 1D0+P1DV/(AB1+1D0) - DO I=1,3 - P2(I) = (AB1*P1(I)+W*ABV(I))/P1DVP1 - END DO - -* Precession and nutation - CALL sla_DMXV(AMPRMS(13),P2,P3) - -* Geocentric apparent RA,Dec - CALL sla_DCC2S(P3,RA,DA) - RA = sla_DRANRM(RA) - - END diff --git a/src/slalib/moon.f b/src/slalib/moon.f deleted file mode 100644 index a46ebe866..000000000 --- a/src/slalib/moon.f +++ /dev/null @@ -1,379 +0,0 @@ - SUBROUTINE sla_MOON (IY, ID, FD, PV) -*+ -* - - - - - -* M O O N -* - - - - - -* -* Approximate geocentric position and velocity of the Moon -* (single precision). -* -* Given: -* IY i year -* ID i day in year (1 = Jan 1st) -* FD r fraction of day -* -* Returned: -* PV r(6) Moon position & velocity vector -* -* Notes: -* -* 1 The date and time is TDB (loosely ET) in a Julian calendar -* which has been aligned to the ordinary Gregorian -* calendar for the interval 1900 March 1 to 2100 February 28. -* The year and day can be obtained by calling sla_CALYD or -* sla_CLYD. -* -* 2 The Moon 6-vector is Moon centre relative to Earth centre, -* mean equator and equinox of date. Position part, PV(1-3), -* is in AU; velocity part, PV(4-6), is in AU/sec. -* -* 3 The position is accurate to better than 0.5 arcminute -* in direction and 1000 km in distance. The velocity -* is accurate to better than 0.5"/hour in direction and -* 4 m/s in distance. (RMS figures with respect to JPL DE200 -* for the interval 1960-2025 are 14 arcsec and 0.2 arcsec/hour in -* longitude, 9 arcsec and 0.2 arcsec/hour in latitude, 350 km and -* 2 m/s in distance.) Note that the distance accuracy is -* comparatively poor because this routine is principally intended -* for computing topocentric direction. -* -* 4 This routine is only a partial implementation of the original -* Meeus algorithm (reference below), which offers 4 times the -* accuracy in direction and 30 times the accuracy in distance -* when fully implemented (as it is in sla_DMOON). -* -* Reference: -* Meeus, l'Astronomie, June 1984, p348. -* -* Called: sla_CS2C6 -* -* P.T.Wallace Starlink 8 December 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IY,ID - REAL FD,PV(6) - - INTEGER ITP(4,4),ITL(4,39),ITB(4,29),I,IY4,N - REAL D2R,RATCON,ERADAU - REAL ELP0,ELP1,ELP1I,ELP1F - REAL EM0,EM1,EM1F - REAL EMP0,EMP1,EMP1I,EMP1F - REAL D0,D1,D1I,D1F - REAL F0,F1,F1I,F1F - REAL TL(39) - REAL TB(29) - REAL TP(4) - REAL YI,YF,T,ELP,EM,EMP,D,F,EL,ELD,COEFF,CEM,CEMP - REAL CD,CF,THETA,THETAD,B,BD,P,PD,SP,R,RD - REAL V(6),EPS,SINEPS,COSEPS - -* Degrees to radians - PARAMETER (D2R=1.745329252E-2) - -* Rate conversion factor: D2R**2/(86400*365.25) - PARAMETER (RATCON=9.652743551E-12) - -* Earth radius in AU: 6378.137/149597870 - PARAMETER (ERADAU=4.2635212653763E-5) - -* -* Coefficients for fundamental arguments -* -* Fixed term (deg), term in T (deg & whole revs + fraction per year) -* -* Moon's mean longitude - DATA ELP0,ELP1,ELP1I,ELP1F / - : 270.434164, 4812.678831, 4680., 132.678831 / -* -* Sun's mean anomaly - DATA EM0,EM1,EM1F / - : 358.475833, 359.990498, 359.990498 / -* -* Moon's mean anomaly - DATA EMP0,EMP1,EMP1I,EMP1F / - : 296.104608, 4771.988491, 4680., 91.988491 / -* -* Moon's mean elongation - DATA D0,D1,D1I,D1F / - : 350.737486, 4452.671142, 4320., 132.671142 / -* -* Mean distance of the Moon from its ascending node - DATA F0,F1,F1I,F1F / - : 11.250889, 4832.020251, 4680., 152.020251 / - -* -* Coefficients for Moon position -* -* T(N) = coefficient of term (deg) -* IT(N,1-4) = coefficients of M, M', D, F in argument -* -* Longitude -* M M' D F - DATA TL( 1)/ +6.288750 /, - : (ITL(I, 1),I=1,4)/ 0, +1, 0, 0 / - DATA TL( 2)/ +1.274018 /, - : (ITL(I, 2),I=1,4)/ 0, -1, +2, 0 / - DATA TL( 3)/ +0.658309 /, - : (ITL(I, 3),I=1,4)/ 0, 0, +2, 0 / - DATA TL( 4)/ +0.213616 /, - : (ITL(I, 4),I=1,4)/ 0, +2, 0, 0 / - DATA TL( 5)/ -0.185596 /, - : (ITL(I, 5),I=1,4)/ +1, 0, 0, 0 / - DATA TL( 6)/ -0.114336 /, - : (ITL(I, 6),I=1,4)/ 0, 0, 0, +2 / - DATA TL( 7)/ +0.058793 /, - : (ITL(I, 7),I=1,4)/ 0, -2, +2, 0 / - DATA TL( 8)/ +0.057212 /, - : (ITL(I, 8),I=1,4)/ -1, -1, +2, 0 / - DATA TL( 9)/ +0.053320 /, - : (ITL(I, 9),I=1,4)/ 0, +1, +2, 0 / - DATA TL(10)/ +0.045874 /, - : (ITL(I,10),I=1,4)/ -1, 0, +2, 0 / - DATA TL(11)/ +0.041024 /, - : (ITL(I,11),I=1,4)/ -1, +1, 0, 0 / - DATA TL(12)/ -0.034718 /, - : (ITL(I,12),I=1,4)/ 0, 0, +1, 0 / - DATA TL(13)/ -0.030465 /, - : (ITL(I,13),I=1,4)/ +1, +1, 0, 0 / - DATA TL(14)/ +0.015326 /, - : (ITL(I,14),I=1,4)/ 0, 0, +2, -2 / - DATA TL(15)/ -0.012528 /, - : (ITL(I,15),I=1,4)/ 0, +1, 0, +2 / - DATA TL(16)/ -0.010980 /, - : (ITL(I,16),I=1,4)/ 0, -1, 0, +2 / - DATA TL(17)/ +0.010674 /, - : (ITL(I,17),I=1,4)/ 0, -1, +4, 0 / - DATA TL(18)/ +0.010034 /, - : (ITL(I,18),I=1,4)/ 0, +3, 0, 0 / - DATA TL(19)/ +0.008548 /, - : (ITL(I,19),I=1,4)/ 0, -2, +4, 0 / - DATA TL(20)/ -0.007910 /, - : (ITL(I,20),I=1,4)/ +1, -1, +2, 0 / - DATA TL(21)/ -0.006783 /, - : (ITL(I,21),I=1,4)/ +1, 0, +2, 0 / - DATA TL(22)/ +0.005162 /, - : (ITL(I,22),I=1,4)/ 0, +1, -1, 0 / - DATA TL(23)/ +0.005000 /, - : (ITL(I,23),I=1,4)/ +1, 0, +1, 0 / - DATA TL(24)/ +0.004049 /, - : (ITL(I,24),I=1,4)/ -1, +1, +2, 0 / - DATA TL(25)/ +0.003996 /, - : (ITL(I,25),I=1,4)/ 0, +2, +2, 0 / - DATA TL(26)/ +0.003862 /, - : (ITL(I,26),I=1,4)/ 0, 0, +4, 0 / - DATA TL(27)/ +0.003665 /, - : (ITL(I,27),I=1,4)/ 0, -3, +2, 0 / - DATA TL(28)/ +0.002695 /, - : (ITL(I,28),I=1,4)/ -1, +2, 0, 0 / - DATA TL(29)/ +0.002602 /, - : (ITL(I,29),I=1,4)/ 0, +1, -2, -2 / - DATA TL(30)/ +0.002396 /, - : (ITL(I,30),I=1,4)/ -1, -2, +2, 0 / - DATA TL(31)/ -0.002349 /, - : (ITL(I,31),I=1,4)/ 0, +1, +1, 0 / - DATA TL(32)/ +0.002249 /, - : (ITL(I,32),I=1,4)/ -2, 0, +2, 0 / - DATA TL(33)/ -0.002125 /, - : (ITL(I,33),I=1,4)/ +1, +2, 0, 0 / - DATA TL(34)/ -0.002079 /, - : (ITL(I,34),I=1,4)/ +2, 0, 0, 0 / - DATA TL(35)/ +0.002059 /, - : (ITL(I,35),I=1,4)/ -2, -1, +2, 0 / - DATA TL(36)/ -0.001773 /, - : (ITL(I,36),I=1,4)/ 0, +1, +2, -2 / - DATA TL(37)/ -0.001595 /, - : (ITL(I,37),I=1,4)/ 0, 0, +2, +2 / - DATA TL(38)/ +0.001220 /, - : (ITL(I,38),I=1,4)/ -1, -1, +4, 0 / - DATA TL(39)/ -0.001110 /, - : (ITL(I,39),I=1,4)/ 0, +2, 0, +2 / -* -* Latitude -* M M' D F - DATA TB( 1)/ +5.128189 /, - : (ITB(I, 1),I=1,4)/ 0, 0, 0, +1 / - DATA TB( 2)/ +0.280606 /, - : (ITB(I, 2),I=1,4)/ 0, +1, 0, +1 / - DATA TB( 3)/ +0.277693 /, - : (ITB(I, 3),I=1,4)/ 0, +1, 0, -1 / - DATA TB( 4)/ +0.173238 /, - : (ITB(I, 4),I=1,4)/ 0, 0, +2, -1 / - DATA TB( 5)/ +0.055413 /, - : (ITB(I, 5),I=1,4)/ 0, -1, +2, +1 / - DATA TB( 6)/ +0.046272 /, - : (ITB(I, 6),I=1,4)/ 0, -1, +2, -1 / - DATA TB( 7)/ +0.032573 /, - : (ITB(I, 7),I=1,4)/ 0, 0, +2, +1 / - DATA TB( 8)/ +0.017198 /, - : (ITB(I, 8),I=1,4)/ 0, +2, 0, +1 / - DATA TB( 9)/ +0.009267 /, - : (ITB(I, 9),I=1,4)/ 0, +1, +2, -1 / - DATA TB(10)/ +0.008823 /, - : (ITB(I,10),I=1,4)/ 0, +2, 0, -1 / - DATA TB(11)/ +0.008247 /, - : (ITB(I,11),I=1,4)/ -1, 0, +2, -1 / - DATA TB(12)/ +0.004323 /, - : (ITB(I,12),I=1,4)/ 0, -2, +2, -1 / - DATA TB(13)/ +0.004200 /, - : (ITB(I,13),I=1,4)/ 0, +1, +2, +1 / - DATA TB(14)/ +0.003372 /, - : (ITB(I,14),I=1,4)/ -1, 0, -2, +1 / - DATA TB(15)/ +0.002472 /, - : (ITB(I,15),I=1,4)/ -1, -1, +2, +1 / - DATA TB(16)/ +0.002222 /, - : (ITB(I,16),I=1,4)/ -1, 0, +2, +1 / - DATA TB(17)/ +0.002072 /, - : (ITB(I,17),I=1,4)/ -1, -1, +2, -1 / - DATA TB(18)/ +0.001877 /, - : (ITB(I,18),I=1,4)/ -1, +1, 0, +1 / - DATA TB(19)/ +0.001828 /, - : (ITB(I,19),I=1,4)/ 0, -1, +4, -1 / - DATA TB(20)/ -0.001803 /, - : (ITB(I,20),I=1,4)/ +1, 0, 0, +1 / - DATA TB(21)/ -0.001750 /, - : (ITB(I,21),I=1,4)/ 0, 0, 0, +3 / - DATA TB(22)/ +0.001570 /, - : (ITB(I,22),I=1,4)/ -1, +1, 0, -1 / - DATA TB(23)/ -0.001487 /, - : (ITB(I,23),I=1,4)/ 0, 0, +1, +1 / - DATA TB(24)/ -0.001481 /, - : (ITB(I,24),I=1,4)/ +1, +1, 0, +1 / - DATA TB(25)/ +0.001417 /, - : (ITB(I,25),I=1,4)/ -1, -1, 0, +1 / - DATA TB(26)/ +0.001350 /, - : (ITB(I,26),I=1,4)/ -1, 0, 0, +1 / - DATA TB(27)/ +0.001330 /, - : (ITB(I,27),I=1,4)/ 0, 0, -1, +1 / - DATA TB(28)/ +0.001106 /, - : (ITB(I,28),I=1,4)/ 0, +3, 0, +1 / - DATA TB(29)/ +0.001020 /, - : (ITB(I,29),I=1,4)/ 0, 0, +4, -1 / -* -* Parallax -* M M' D F - DATA TP( 1)/ +0.051818 /, - : (ITP(I, 1),I=1,4)/ 0, +1, 0, 0 / - DATA TP( 2)/ +0.009531 /, - : (ITP(I, 2),I=1,4)/ 0, -1, +2, 0 / - DATA TP( 3)/ +0.007843 /, - : (ITP(I, 3),I=1,4)/ 0, 0, +2, 0 / - DATA TP( 4)/ +0.002824 /, - : (ITP(I, 4),I=1,4)/ 0, +2, 0, 0 / - - - -* Whole years & fraction of year, and years since J1900.0 - YI=FLOAT(IY-1900) - IY4=MOD(MOD(IY,4)+4,4) - YF=(FLOAT(4*(ID-1/(IY4+1))-IY4-2)+4.0*FD)/1461.0 - T=YI+YF - -* Moon's mean longitude - ELP=D2R*MOD(ELP0+ELP1I*YF+ELP1F*T,360.0) - -* Sun's mean anomaly - EM=D2R*MOD(EM0+EM1F*T,360.0) - -* Moon's mean anomaly - EMP=D2R*MOD(EMP0+EMP1I*YF+EMP1F*T,360.0) - -* Moon's mean elongation - D=D2R*MOD(D0+D1I*YF+D1F*T,360.0) - -* Mean distance of the moon from its ascending node - F=D2R*MOD(F0+F1I*YF+F1F*T,360.0) - -* Longitude - EL=0.0 - ELD=0.0 - DO N=39,1,-1 - COEFF=TL(N) - CEM=FLOAT(ITL(1,N)) - CEMP=FLOAT(ITL(2,N)) - CD=FLOAT(ITL(3,N)) - CF=FLOAT(ITL(4,N)) - THETA=CEM*EM+CEMP*EMP+CD*D+CF*F - THETAD=CEM*EM1+CEMP*EMP1+CD*D1+CF*F1 - EL=EL+COEFF*SIN(THETA) - ELD=ELD+COEFF*COS(THETA)*THETAD - END DO - EL=EL*D2R+ELP - ELD=RATCON*(ELD+ELP1/D2R) - -* Latitude - B=0.0 - BD=0.0 - DO N=29,1,-1 - COEFF=TB(N) - CEM=FLOAT(ITB(1,N)) - CEMP=FLOAT(ITB(2,N)) - CD=FLOAT(ITB(3,N)) - CF=FLOAT(ITB(4,N)) - THETA=CEM*EM+CEMP*EMP+CD*D+CF*F - THETAD=CEM*EM1+CEMP*EMP1+CD*D1+CF*F1 - B=B+COEFF*SIN(THETA) - BD=BD+COEFF*COS(THETA)*THETAD - END DO - B=B*D2R - BD=RATCON*BD - -* Parallax - P=0.0 - PD=0.0 - DO N=4,1,-1 - COEFF=TP(N) - CEM=FLOAT(ITP(1,N)) - CEMP=FLOAT(ITP(2,N)) - CD=FLOAT(ITP(3,N)) - CF=FLOAT(ITP(4,N)) - THETA=CEM*EM+CEMP*EMP+CD*D+CF*F - THETAD=CEM*EM1+CEMP*EMP1+CD*D1+CF*F1 - P=P+COEFF*COS(THETA) - PD=PD-COEFF*SIN(THETA)*THETAD - END DO - P=(P+0.950724)*D2R - PD=RATCON*PD - -* Transform parallax to distance (AU, AU/sec) - SP=SIN(P) - R=ERADAU/SP - RD=-R*PD/SP - -* Longitude, latitude to x,y,z (AU) - CALL sla_CS2C6(EL,B,R,ELD,BD,RD,V) - -* Mean obliquity - EPS=D2R*(23.45229-0.00013*T) - SINEPS=SIN(EPS) - COSEPS=COS(EPS) - -* Rotate Moon position and velocity into equatorial system - PV(1)=V(1) - PV(2)=V(2)*COSEPS-V(3)*SINEPS - PV(3)=V(2)*SINEPS+V(3)*COSEPS - PV(4)=V(4) - PV(5)=V(5)*COSEPS-V(6)*SINEPS - PV(6)=V(5)*SINEPS+V(6)*COSEPS - - END diff --git a/src/slalib/mxm.f b/src/slalib/mxm.f deleted file mode 100644 index 6950ade2e..000000000 --- a/src/slalib/mxm.f +++ /dev/null @@ -1,71 +0,0 @@ - SUBROUTINE sla_MXM (A, B, C) -*+ -* - - - - -* M X M -* - - - - -* -* Product of two 3x3 matrices: -* matrix C = matrix A x matrix B -* -* (single precision) -* -* Given: -* A real(3,3) matrix -* B real(3,3) matrix -* -* Returned: -* C real(3,3) matrix result -* -* To comply with the ANSI Fortran 77 standard, A, B and C must -* be different arrays. However, the routine is coded so as to -* work properly on many platforms even if this rule is violated. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL A(3,3),B(3,3),C(3,3) - - INTEGER I,J,K - REAL W,WM(3,3) - - -* Multiply into scratch matrix - DO I=1,3 - DO J=1,3 - W=0.0 - DO K=1,3 - W=W+A(I,K)*B(K,J) - END DO - WM(I,J)=W - END DO - END DO - -* Return the result - DO J=1,3 - DO I=1,3 - C(I,J)=WM(I,J) - END DO - END DO - - END diff --git a/src/slalib/mxv.f b/src/slalib/mxv.f deleted file mode 100644 index 1dd091abc..000000000 --- a/src/slalib/mxv.f +++ /dev/null @@ -1,68 +0,0 @@ - SUBROUTINE sla_MXV (RM, VA, VB) -*+ -* - - - - -* M X V -* - - - - -* -* Performs the 3-D forward unitary transformation: -* -* vector VB = matrix RM * vector VA -* -* (single precision) -* -* Given: -* RM real(3,3) matrix -* VA real(3) vector -* -* Returned: -* VB real(3) result vector -* -* To comply with the ANSI Fortran 77 standard, VA and VB must be -* different arrays. However, the routine is coded so as to work -* properly on many platforms even if this rule is violated. -* -* Last revision: 26 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL RM(3,3),VA(3),VB(3) - - INTEGER I,J - REAL W,VW(3) - - -* Matrix RM * vector VA -> vector VW - DO J=1,3 - W=0.0 - DO I=1,3 - W=W+RM(J,I)*VA(I) - END DO - VW(J)=W - END DO - -* Vector VW -> vector VB - DO J=1,3 - VB(J)=VW(J) - END DO - - END diff --git a/src/slalib/nut.f b/src/slalib/nut.f deleted file mode 100644 index d66dc4ed0..000000000 --- a/src/slalib/nut.f +++ /dev/null @@ -1,75 +0,0 @@ - SUBROUTINE sla_NUT (DATE, RMATN) -*+ -* - - - - -* N U T -* - - - - -* -* Form the matrix of nutation for a given date - Shirai & Fukushima -* 2001 theory (double precision) -* -* Reference: -* Shirai, T. & Fukushima, T., Astron.J. 121, 3270-3283 (2001). -* -* Given: -* DATE d TDB (loosely ET) as Modified Julian Date -* (=JD-2400000.5) -* Returned: -* RMATN d(3,3) nutation matrix -* -* Notes: -* -* 1 The matrix is in the sense v(true) = rmatn * v(mean) . -* where v(true) is the star vector relative to the true equator and -* equinox of date and v(mean) is the star vector relative to the -* mean equator and equinox of date. -* -* 2 The matrix represents forced nutation (but not free core -* nutation) plus corrections to the IAU~1976 precession model. -* -* 3 Earth attitude predictions made by combining the present nutation -* matrix with IAU~1976 precession are accurate to 1~mas (with -* respect to the ICRS) for a few decades around 2000. -* -* 4 The distinction between the required TDB and TT is always -* negligible. Moreover, for all but the most critical applications -* UTC is adequate. -* -* Called: sla_NUTC, sla_DEULER -* -* Last revision: 1 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,RMATN(3,3) - - DOUBLE PRECISION DPSI,DEPS,EPS0 - - - -* Nutation components and mean obliquity - CALL sla_NUTC(DATE,DPSI,DEPS,EPS0) - -* Rotation matrix - CALL sla_DEULER('XZX',EPS0,-DPSI,-(EPS0+DEPS),RMATN) - - END diff --git a/src/slalib/nutc.f b/src/slalib/nutc.f deleted file mode 100644 index d0c068eab..000000000 --- a/src/slalib/nutc.f +++ /dev/null @@ -1,830 +0,0 @@ - SUBROUTINE sla_NUTC (DATE, DPSI, DEPS, EPS0) -*+ -* - - - - - -* N U T C -* - - - - - -* -* Nutation: longitude & obliquity components and mean obliquity, -* using the Shirai & Fukushima (2001) theory. -* -* Given: -* DATE d TDB (loosely ET) as Modified Julian Date -* (JD-2400000.5) -* Returned: -* DPSI,DEPS d nutation in longitude,obliquity -* EPS0 d mean obliquity -* -* Notes: -* -* 1 The routine predicts forced nutation (but not free core nutation) -* plus corrections to the IAU 1976 precession model. -* -* 2 Earth attitude predictions made by combining the present nutation -* model with IAU 1976 precession are accurate to 1 mas (with respect -* to the ICRF) for a few decades around 2000. -* -* 3 The sla_NUTC80 routine is the equivalent of the present routine -* but using the IAU 1980 nutation theory. The older theory is less -* accurate, leading to errors as large as 350 mas over the interval -* 1900-2100, mainly because of the error in the IAU 1976 precession. -* -* References: -* -* Shirai, T. & Fukushima, T., Astron.J. 121, 3270-3283 (2001). -* -* Fukushima, T., Astron.Astrophys. 244, L11 (1991). -* -* Simon, J. L., Bretagnon, P., Chapront, J., Chapront-Touze, M., -* Francou, G. & Laskar, J., Astron.Astrophys. 282, 663 (1994). -* -* This revision: 24 November 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,DPSI,DEPS,EPS0 - -* Degrees to radians - DOUBLE PRECISION DD2R - PARAMETER (DD2R=1.745329251994329576923691D-2) - -* Arc seconds to radians - DOUBLE PRECISION DAS2R - PARAMETER (DAS2R=4.848136811095359935899141D-6) - -* Arc seconds in a full circle - DOUBLE PRECISION TURNAS - PARAMETER (TURNAS=1296000D0) - -* Reference epoch (J2000), MJD - DOUBLE PRECISION DJM0 - PARAMETER (DJM0=51544.5D0 ) - -* Days per Julian century - DOUBLE PRECISION DJC - PARAMETER (DJC=36525D0) - - INTEGER I,J - DOUBLE PRECISION T,EL,ELP,F,D,OM,VE,MA,JU,SA,THETA,C,S,DP,DE - -* Number of terms in the nutation model - INTEGER NTERMS - PARAMETER (NTERMS=194) - -* The SF2001 forced nutation model - INTEGER NA(9,NTERMS) - DOUBLE PRECISION PSI(4,NTERMS), EPS(4,NTERMS) - -* Coefficients of fundamental angles - DATA ( ( NA(I,J), I=1,9 ), J=1,10 ) / - : 0, 0, 0, 0, -1, 0, 0, 0, 0, - : 0, 0, 2, -2, 2, 0, 0, 0, 0, - : 0, 0, 2, 0, 2, 0, 0, 0, 0, - : 0, 0, 0, 0, -2, 0, 0, 0, 0, - : 0, 1, 0, 0, 0, 0, 0, 0, 0, - : 0, 1, 2, -2, 2, 0, 0, 0, 0, - : 1, 0, 0, 0, 0, 0, 0, 0, 0, - : 0, 0, 2, 0, 1, 0, 0, 0, 0, - : 1, 0, 2, 0, 2, 0, 0, 0, 0, - : 0, -1, 2, -2, 2, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=11,20 ) / - : 0, 0, 2, -2, 1, 0, 0, 0, 0, - : -1, 0, 2, 0, 2, 0, 0, 0, 0, - : -1, 0, 0, 2, 0, 0, 0, 0, 0, - : 1, 0, 0, 0, 1, 0, 0, 0, 0, - : 1, 0, 0, 0, -1, 0, 0, 0, 0, - : -1, 0, 2, 2, 2, 0, 0, 0, 0, - : 1, 0, 2, 0, 1, 0, 0, 0, 0, - : -2, 0, 2, 0, 1, 0, 0, 0, 0, - : 0, 0, 0, 2, 0, 0, 0, 0, 0, - : 0, 0, 2, 2, 2, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=21,30 ) / - : 2, 0, 0, -2, 0, 0, 0, 0, 0, - : 2, 0, 2, 0, 2, 0, 0, 0, 0, - : 1, 0, 2, -2, 2, 0, 0, 0, 0, - : -1, 0, 2, 0, 1, 0, 0, 0, 0, - : 2, 0, 0, 0, 0, 0, 0, 0, 0, - : 0, 0, 2, 0, 0, 0, 0, 0, 0, - : 0, 1, 0, 0, 1, 0, 0, 0, 0, - : -1, 0, 0, 2, 1, 0, 0, 0, 0, - : 0, 2, 2, -2, 2, 0, 0, 0, 0, - : 0, 0, 2, -2, 0, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=31,40 ) / - : -1, 0, 0, 2, -1, 0, 0, 0, 0, - : 0, 1, 0, 0, -1, 0, 0, 0, 0, - : 0, 2, 0, 0, 0, 0, 0, 0, 0, - : -1, 0, 2, 2, 1, 0, 0, 0, 0, - : 1, 0, 2, 2, 2, 0, 0, 0, 0, - : 0, 1, 2, 0, 2, 0, 0, 0, 0, - : -2, 0, 2, 0, 0, 0, 0, 0, 0, - : 0, 0, 2, 2, 1, 0, 0, 0, 0, - : 0, -1, 2, 0, 2, 0, 0, 0, 0, - : 0, 0, 0, 2, 1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=41,50 ) / - : 1, 0, 2, -2, 1, 0, 0, 0, 0, - : 2, 0, 0, -2, -1, 0, 0, 0, 0, - : 2, 0, 2, -2, 2, 0, 0, 0, 0, - : 2, 0, 2, 0, 1, 0, 0, 0, 0, - : 0, 0, 0, 2, -1, 0, 0, 0, 0, - : 0, -1, 2, -2, 1, 0, 0, 0, 0, - : -1, -1, 0, 2, 0, 0, 0, 0, 0, - : 2, 0, 0, -2, 1, 0, 0, 0, 0, - : 1, 0, 0, 2, 0, 0, 0, 0, 0, - : 0, 1, 2, -2, 1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=51,60 ) / - : 1, -1, 0, 0, 0, 0, 0, 0, 0, - : -2, 0, 2, 0, 2, 0, 0, 0, 0, - : 0, -1, 0, 2, 0, 0, 0, 0, 0, - : 3, 0, 2, 0, 2, 0, 0, 0, 0, - : 0, 0, 0, 1, 0, 0, 0, 0, 0, - : 1, -1, 2, 0, 2, 0, 0, 0, 0, - : 1, 0, 0, -1, 0, 0, 0, 0, 0, - : -1, -1, 2, 2, 2, 0, 0, 0, 0, - : -1, 0, 2, 0, 0, 0, 0, 0, 0, - : 2, 0, 0, 0, -1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=61,70 ) / - : 0, -1, 2, 2, 2, 0, 0, 0, 0, - : 1, 1, 2, 0, 2, 0, 0, 0, 0, - : 2, 0, 0, 0, 1, 0, 0, 0, 0, - : 1, 1, 0, 0, 0, 0, 0, 0, 0, - : 1, 0, -2, 2, -1, 0, 0, 0, 0, - : 1, 0, 2, 0, 0, 0, 0, 0, 0, - : -1, 1, 0, 1, 0, 0, 0, 0, 0, - : 1, 0, 0, 0, 2, 0, 0, 0, 0, - : -1, 0, 1, 0, 1, 0, 0, 0, 0, - : 0, 0, 2, 1, 2, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=71,80 ) / - : -1, 1, 0, 1, 1, 0, 0, 0, 0, - : -1, 0, 2, 4, 2, 0, 0, 0, 0, - : 0, -2, 2, -2, 1, 0, 0, 0, 0, - : 1, 0, 2, 2, 1, 0, 0, 0, 0, - : 1, 0, 0, 0, -2, 0, 0, 0, 0, - : -2, 0, 2, 2, 2, 0, 0, 0, 0, - : 1, 1, 2, -2, 2, 0, 0, 0, 0, - : -2, 0, 2, 4, 2, 0, 0, 0, 0, - : -1, 0, 4, 0, 2, 0, 0, 0, 0, - : 2, 0, 2, -2, 1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=81,90 ) / - : 1, 0, 0, -1, -1, 0, 0, 0, 0, - : 2, 0, 2, 2, 2, 0, 0, 0, 0, - : 1, 0, 0, 2, 1, 0, 0, 0, 0, - : 3, 0, 0, 0, 0, 0, 0, 0, 0, - : 0, 0, 2, -2, -1, 0, 0, 0, 0, - : 3, 0, 2, -2, 2, 0, 0, 0, 0, - : 0, 0, 4, -2, 2, 0, 0, 0, 0, - : -1, 0, 0, 4, 0, 0, 0, 0, 0, - : 0, 1, 2, 0, 1, 0, 0, 0, 0, - : 0, 0, 2, -2, 3, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=91,100 ) / - : -2, 0, 0, 4, 0, 0, 0, 0, 0, - : -1, -1, 0, 2, 1, 0, 0, 0, 0, - : -2, 0, 2, 0, -1, 0, 0, 0, 0, - : 0, 0, 2, 0, -1, 0, 0, 0, 0, - : 0, -1, 2, 0, 1, 0, 0, 0, 0, - : 0, 1, 0, 0, 2, 0, 0, 0, 0, - : 0, 0, 2, -1, 2, 0, 0, 0, 0, - : 2, 1, 0, -2, 0, 0, 0, 0, 0, - : 0, 0, 2, 4, 2, 0, 0, 0, 0, - : -1, -1, 0, 2, -1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=101,110 ) / - : -1, 1, 0, 2, 0, 0, 0, 0, 0, - : 1, -1, 0, 0, 1, 0, 0, 0, 0, - : 0, -1, 2, -2, 0, 0, 0, 0, 0, - : 0, 1, 0, 0, -2, 0, 0, 0, 0, - : 1, -1, 2, 2, 2, 0, 0, 0, 0, - : 1, 0, 0, 2, -1, 0, 0, 0, 0, - : -1, 1, 2, 2, 2, 0, 0, 0, 0, - : 3, 0, 2, 0, 1, 0, 0, 0, 0, - : 0, 1, 2, 2, 2, 0, 0, 0, 0, - : 1, 0, 2, -2, 0, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=111,120 ) / - : -1, 0, -2, 4, -1, 0, 0, 0, 0, - : -1, -1, 2, 2, 1, 0, 0, 0, 0, - : 0, -1, 2, 2, 1, 0, 0, 0, 0, - : 2, -1, 2, 0, 2, 0, 0, 0, 0, - : 0, 0, 0, 2, 2, 0, 0, 0, 0, - : 1, -1, 2, 0, 1, 0, 0, 0, 0, - : -1, 1, 2, 0, 2, 0, 0, 0, 0, - : 0, 1, 0, 2, 0, 0, 0, 0, 0, - : 0, 1, 2, -2, 0, 0, 0, 0, 0, - : 0, 3, 2, -2, 2, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=121,130 ) / - : 0, 0, 0, 1, 1, 0, 0, 0, 0, - : -1, 0, 2, 2, 0, 0, 0, 0, 0, - : 2, 1, 2, 0, 2, 0, 0, 0, 0, - : 1, 1, 0, 0, 1, 0, 0, 0, 0, - : 2, 0, 0, 2, 0, 0, 0, 0, 0, - : 1, 1, 2, 0, 1, 0, 0, 0, 0, - : -1, 0, 0, 2, 2, 0, 0, 0, 0, - : 1, 0, -2, 2, 0, 0, 0, 0, 0, - : 0, -1, 0, 2, -1, 0, 0, 0, 0, - : -1, 0, 1, 0, 2, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=131,140 ) / - : 0, 1, 0, 1, 0, 0, 0, 0, 0, - : 1, 0, -2, 2, -2, 0, 0, 0, 0, - : 0, 0, 0, 1, -1, 0, 0, 0, 0, - : 1, -1, 0, 0, -1, 0, 0, 0, 0, - : 0, 0, 0, 4, 0, 0, 0, 0, 0, - : 1, -1, 0, 2, 0, 0, 0, 0, 0, - : 1, 0, 2, 1, 2, 0, 0, 0, 0, - : 1, 0, 2, -1, 2, 0, 0, 0, 0, - : -1, 0, 0, 2, -2, 0, 0, 0, 0, - : 0, 0, 2, 1, 1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=141,150 ) / - : -1, 0, 2, 0, -1, 0, 0, 0, 0, - : -1, 0, 2, 4, 1, 0, 0, 0, 0, - : 0, 0, 2, 2, 0, 0, 0, 0, 0, - : 1, 1, 2, -2, 1, 0, 0, 0, 0, - : 0, 0, 1, 0, 1, 0, 0, 0, 0, - : -1, 0, 2, -1, 1, 0, 0, 0, 0, - : -2, 0, 2, 2, 1, 0, 0, 0, 0, - : 2, -1, 0, 0, 0, 0, 0, 0, 0, - : 4, 0, 2, 0, 2, 0, 0, 0, 0, - : 2, 1, 2, -2, 2, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=151,160 ) / - : 0, 1, 2, 1, 2, 0, 0, 0, 0, - : 1, 0, 4, -2, 2, 0, 0, 0, 0, - : 1, 1, 0, 0, -1, 0, 0, 0, 0, - : -2, 0, 2, 4, 1, 0, 0, 0, 0, - : 2, 0, 2, 0, 0, 0, 0, 0, 0, - : -1, 0, 1, 0, 0, 0, 0, 0, 0, - : 1, 0, 0, 1, 0, 0, 0, 0, 0, - : 0, 1, 0, 2, 1, 0, 0, 0, 0, - : -1, 0, 4, 0, 1, 0, 0, 0, 0, - : -1, 0, 0, 4, 1, 0, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=161,170 ) / - : 2, 0, 2, 2, 1, 0, 0, 0, 0, - : 2, 1, 0, 0, 0, 0, 0, 0, 0, - : 0, 0, 5, -5, 5, -3, 0, 0, 0, - : 0, 0, 0, 0, 0, 0, 0, 2, 0, - : 0, 0, 1, -1, 1, 0, 0, -1, 0, - : 0, 0, -1, 1, -1, 1, 0, 0, 0, - : 0, 0, -1, 1, 0, 0, 2, 0, 0, - : 0, 0, 3, -3, 3, 0, 0, -1, 0, - : 0, 0, -8, 8, -7, 5, 0, 0, 0, - : 0, 0, -1, 1, -1, 0, 2, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=171,180 ) / - : 0, 0, -2, 2, -2, 2, 0, 0, 0, - : 0, 0, -6, 6, -6, 4, 0, 0, 0, - : 0, 0, -2, 2, -2, 0, 8, -3, 0, - : 0, 0, 6, -6, 6, 0, -8, 3, 0, - : 0, 0, 4, -4, 4, -2, 0, 0, 0, - : 0, 0, -3, 3, -3, 2, 0, 0, 0, - : 0, 0, 4, -4, 3, 0, -8, 3, 0, - : 0, 0, -4, 4, -5, 0, 8, -3, 0, - : 0, 0, 0, 0, 0, 2, 0, 0, 0, - : 0, 0, -4, 4, -4, 3, 0, 0, 0 / - DATA ( ( NA(I,J), I=1,9 ), J=181,190 ) / - : 0, 1, -1, 1, -1, 0, 0, 1, 0, - : 0, 0, 0, 0, 0, 0, 0, 1, 0, - : 0, 0, 1, -1, 1, 1, 0, 0, 0, - : 0, 0, 2, -2, 2, 0, -2, 0, 0, - : 0, -1, -7, 7, -7, 5, 0, 0, 0, - : -2, 0, 2, 0, 2, 0, 0, -2, 0, - : -2, 0, 2, 0, 1, 0, 0, -3, 0, - : 0, 0, 2, -2, 2, 0, 0, -2, 0, - : 0, 0, 1, -1, 1, 0, 0, 1, 0, - : 0, 0, 0, 0, 0, 0, 0, 0, 2 / - DATA ( ( NA(I,J), I=1,9 ), J=191,NTERMS ) / - : 0, 0, 0, 0, 0, 0, 0, 0, 1, - : 2, 0, -2, 0, -2, 0, 0, 3, 0, - : 0, 0, 1, -1, 1, 0, 0, -2, 0, - : 0, 0, -7, 7, -7, 5, 0, 0, 0 / - -* Nutation series: longitude - DATA ( ( PSI(I,J), I=1,4 ), J=1,10 ) / - : 3341.5D0, 17206241.8D0, 3.1D0, 17409.5D0, - : -1716.8D0, -1317185.3D0, 1.4D0, -156.8D0, - : 285.7D0, -227667.0D0, 0.3D0, -23.5D0, - : -68.6D0, -207448.0D0, 0.0D0, -21.4D0, - : 950.3D0, 147607.9D0, -2.3D0, -355.0D0, - : -66.7D0, -51689.1D0, 0.2D0, 122.6D0, - : -108.6D0, 71117.6D0, 0.0D0, 7.0D0, - : 35.6D0, -38740.2D0, 0.1D0, -36.2D0, - : 85.4D0, -30127.6D0, 0.0D0, -3.1D0, - : 9.0D0, 21583.0D0, 0.1D0, -50.3D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=11,20 ) / - : 22.1D0, 12822.8D0, 0.0D0, 13.3D0, - : 3.4D0, 12350.8D0, 0.0D0, 1.3D0, - : -21.1D0, 15699.4D0, 0.0D0, 1.6D0, - : 4.2D0, 6313.8D0, 0.0D0, 6.2D0, - : -22.8D0, 5796.9D0, 0.0D0, 6.1D0, - : 15.7D0, -5961.1D0, 0.0D0, -0.6D0, - : 13.1D0, -5159.1D0, 0.0D0, -4.6D0, - : 1.8D0, 4592.7D0, 0.0D0, 4.5D0, - : -17.5D0, 6336.0D0, 0.0D0, 0.7D0, - : 16.3D0, -3851.1D0, 0.0D0, -0.4D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=21,30 ) / - : -2.8D0, 4771.7D0, 0.0D0, 0.5D0, - : 13.8D0, -3099.3D0, 0.0D0, -0.3D0, - : 0.2D0, 2860.3D0, 0.0D0, 0.3D0, - : 1.4D0, 2045.3D0, 0.0D0, 2.0D0, - : -8.6D0, 2922.6D0, 0.0D0, 0.3D0, - : -7.7D0, 2587.9D0, 0.0D0, 0.2D0, - : 8.8D0, -1408.1D0, 0.0D0, 3.7D0, - : 1.4D0, 1517.5D0, 0.0D0, 1.5D0, - : -1.9D0, -1579.7D0, 0.0D0, 7.7D0, - : 1.3D0, -2178.6D0, 0.0D0, -0.2D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=31,40 ) / - : -4.8D0, 1286.8D0, 0.0D0, 1.3D0, - : 6.3D0, 1267.2D0, 0.0D0, -4.0D0, - : -1.0D0, 1669.3D0, 0.0D0, -8.3D0, - : 2.4D0, -1020.0D0, 0.0D0, -0.9D0, - : 4.5D0, -766.9D0, 0.0D0, 0.0D0, - : -1.1D0, 756.5D0, 0.0D0, -1.7D0, - : -1.4D0, -1097.3D0, 0.0D0, -0.5D0, - : 2.6D0, -663.0D0, 0.0D0, -0.6D0, - : 0.8D0, -714.1D0, 0.0D0, 1.6D0, - : 0.4D0, -629.9D0, 0.0D0, -0.6D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=41,50 ) / - : 0.3D0, 580.4D0, 0.0D0, 0.6D0, - : -1.6D0, 577.3D0, 0.0D0, 0.5D0, - : -0.9D0, 644.4D0, 0.0D0, 0.0D0, - : 2.2D0, -534.0D0, 0.0D0, -0.5D0, - : -2.5D0, 493.3D0, 0.0D0, 0.5D0, - : -0.1D0, -477.3D0, 0.0D0, -2.4D0, - : -0.9D0, 735.0D0, 0.0D0, -1.7D0, - : 0.7D0, 406.2D0, 0.0D0, 0.4D0, - : -2.8D0, 656.9D0, 0.0D0, 0.0D0, - : 0.6D0, 358.0D0, 0.0D0, 2.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=51,60 ) / - : -0.7D0, 472.5D0, 0.0D0, -1.1D0, - : -0.1D0, -300.5D0, 0.0D0, 0.0D0, - : -1.2D0, 435.1D0, 0.0D0, -1.0D0, - : 1.8D0, -289.4D0, 0.0D0, 0.0D0, - : 0.6D0, -422.6D0, 0.0D0, 0.0D0, - : 0.8D0, -287.6D0, 0.0D0, 0.6D0, - : -38.6D0, -392.3D0, 0.0D0, 0.0D0, - : 0.7D0, -281.8D0, 0.0D0, 0.6D0, - : 0.6D0, -405.7D0, 0.0D0, 0.0D0, - : -1.2D0, 229.0D0, 0.0D0, 0.2D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=61,70 ) / - : 1.1D0, -264.3D0, 0.0D0, 0.5D0, - : -0.7D0, 247.9D0, 0.0D0, -0.5D0, - : -0.2D0, 218.0D0, 0.0D0, 0.2D0, - : 0.6D0, -339.0D0, 0.0D0, 0.8D0, - : -0.7D0, 198.7D0, 0.0D0, 0.2D0, - : -1.5D0, 334.0D0, 0.0D0, 0.0D0, - : 0.1D0, 334.0D0, 0.0D0, 0.0D0, - : -0.1D0, -198.1D0, 0.0D0, 0.0D0, - : -106.6D0, 0.0D0, 0.0D0, 0.0D0, - : -0.5D0, 165.8D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=71,80 ) / - : 0.0D0, 134.8D0, 0.0D0, 0.0D0, - : 0.9D0, -151.6D0, 0.0D0, 0.0D0, - : 0.0D0, -129.7D0, 0.0D0, 0.0D0, - : 0.8D0, -132.8D0, 0.0D0, -0.1D0, - : 0.5D0, -140.7D0, 0.0D0, 0.0D0, - : -0.1D0, 138.4D0, 0.0D0, 0.0D0, - : 0.0D0, 129.0D0, 0.0D0, -0.3D0, - : 0.5D0, -121.2D0, 0.0D0, 0.0D0, - : -0.3D0, 114.5D0, 0.0D0, 0.0D0, - : -0.1D0, 101.8D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=81,90 ) / - : -3.6D0, -101.9D0, 0.0D0, 0.0D0, - : 0.8D0, -109.4D0, 0.0D0, 0.0D0, - : 0.2D0, -97.0D0, 0.0D0, 0.0D0, - : -0.7D0, 157.3D0, 0.0D0, 0.0D0, - : 0.2D0, -83.3D0, 0.0D0, 0.0D0, - : -0.3D0, 93.3D0, 0.0D0, 0.0D0, - : -0.1D0, 92.1D0, 0.0D0, 0.0D0, - : -0.5D0, 133.6D0, 0.0D0, 0.0D0, - : -0.1D0, 81.5D0, 0.0D0, 0.0D0, - : 0.0D0, 123.9D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=91,100 ) / - : -0.3D0, 128.1D0, 0.0D0, 0.0D0, - : 0.1D0, 74.1D0, 0.0D0, -0.3D0, - : -0.2D0, -70.3D0, 0.0D0, 0.0D0, - : -0.4D0, 66.6D0, 0.0D0, 0.0D0, - : 0.1D0, -66.7D0, 0.0D0, 0.0D0, - : -0.7D0, 69.3D0, 0.0D0, -0.3D0, - : 0.0D0, -70.4D0, 0.0D0, 0.0D0, - : -0.1D0, 101.5D0, 0.0D0, 0.0D0, - : 0.5D0, -69.1D0, 0.0D0, 0.0D0, - : -0.2D0, 58.5D0, 0.0D0, 0.2D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=101,110 ) / - : 0.1D0, -94.9D0, 0.0D0, 0.2D0, - : 0.0D0, 52.9D0, 0.0D0, -0.2D0, - : 0.1D0, 86.7D0, 0.0D0, -0.2D0, - : -0.1D0, -59.2D0, 0.0D0, 0.2D0, - : 0.3D0, -58.8D0, 0.0D0, 0.1D0, - : -0.3D0, 49.0D0, 0.0D0, 0.0D0, - : -0.2D0, 56.9D0, 0.0D0, -0.1D0, - : 0.3D0, -50.2D0, 0.0D0, 0.0D0, - : -0.2D0, 53.4D0, 0.0D0, -0.1D0, - : 0.1D0, -76.5D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=111,120 ) / - : -0.2D0, 45.3D0, 0.0D0, 0.0D0, - : 0.1D0, -46.8D0, 0.0D0, 0.0D0, - : 0.2D0, -44.6D0, 0.0D0, 0.0D0, - : 0.2D0, -48.7D0, 0.0D0, 0.0D0, - : 0.1D0, -46.8D0, 0.0D0, 0.0D0, - : 0.1D0, -42.0D0, 0.0D0, 0.0D0, - : 0.0D0, 46.4D0, 0.0D0, -0.1D0, - : 0.2D0, -67.3D0, 0.0D0, 0.1D0, - : 0.0D0, -65.8D0, 0.0D0, 0.2D0, - : -0.1D0, -43.9D0, 0.0D0, 0.3D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=121,130 ) / - : 0.0D0, -38.9D0, 0.0D0, 0.0D0, - : -0.3D0, 63.9D0, 0.0D0, 0.0D0, - : -0.2D0, 41.2D0, 0.0D0, 0.0D0, - : 0.0D0, -36.1D0, 0.0D0, 0.2D0, - : -0.3D0, 58.5D0, 0.0D0, 0.0D0, - : -0.1D0, 36.1D0, 0.0D0, 0.0D0, - : 0.0D0, -39.7D0, 0.0D0, 0.0D0, - : 0.1D0, -57.7D0, 0.0D0, 0.0D0, - : -0.2D0, 33.4D0, 0.0D0, 0.0D0, - : 36.4D0, 0.0D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=131,140 ) / - : -0.1D0, 55.7D0, 0.0D0, -0.1D0, - : 0.1D0, -35.4D0, 0.0D0, 0.0D0, - : 0.1D0, -31.0D0, 0.0D0, 0.0D0, - : -0.1D0, 30.1D0, 0.0D0, 0.0D0, - : -0.3D0, 49.2D0, 0.0D0, 0.0D0, - : -0.2D0, 49.1D0, 0.0D0, 0.0D0, - : -0.1D0, 33.6D0, 0.0D0, 0.0D0, - : 0.1D0, -33.5D0, 0.0D0, 0.0D0, - : 0.1D0, -31.0D0, 0.0D0, 0.0D0, - : -0.1D0, 28.0D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=141,150 ) / - : 0.1D0, -25.2D0, 0.0D0, 0.0D0, - : 0.1D0, -26.2D0, 0.0D0, 0.0D0, - : -0.2D0, 41.5D0, 0.0D0, 0.0D0, - : 0.0D0, 24.5D0, 0.0D0, 0.1D0, - : -16.2D0, 0.0D0, 0.0D0, 0.0D0, - : 0.0D0, -22.3D0, 0.0D0, 0.0D0, - : 0.0D0, 23.1D0, 0.0D0, 0.0D0, - : -0.1D0, 37.5D0, 0.0D0, 0.0D0, - : 0.2D0, -25.7D0, 0.0D0, 0.0D0, - : 0.0D0, 25.2D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=151,160 ) / - : 0.1D0, -24.5D0, 0.0D0, 0.0D0, - : -0.1D0, 24.3D0, 0.0D0, 0.0D0, - : 0.1D0, -20.7D0, 0.0D0, 0.0D0, - : 0.1D0, -20.8D0, 0.0D0, 0.0D0, - : -0.2D0, 33.4D0, 0.0D0, 0.0D0, - : 32.9D0, 0.0D0, 0.0D0, 0.0D0, - : 0.1D0, -32.6D0, 0.0D0, 0.0D0, - : 0.0D0, 19.9D0, 0.0D0, 0.0D0, - : -0.1D0, 19.6D0, 0.0D0, 0.0D0, - : 0.0D0, -18.7D0, 0.0D0, 0.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=161,170 ) / - : 0.1D0, -19.0D0, 0.0D0, 0.0D0, - : 0.1D0, -28.6D0, 0.0D0, 0.0D0, - : 4.0D0, 178.8D0,-11.8D0, 0.3D0, - : 39.8D0, -107.3D0, -5.6D0, -1.0D0, - : 9.9D0, 164.0D0, -4.1D0, 0.1D0, - : -4.8D0, -135.3D0, -3.4D0, -0.1D0, - : 50.5D0, 75.0D0, 1.4D0, -1.2D0, - : -1.1D0, -53.5D0, 1.3D0, 0.0D0, - : -45.0D0, -2.4D0, -0.4D0, 6.6D0, - : -11.5D0, -61.0D0, -0.9D0, 0.4D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=171,180 ) / - : 4.4D0, -68.4D0, -3.4D0, 0.0D0, - : 7.7D0, -47.1D0, -4.7D0, -1.0D0, - : -42.9D0, -12.6D0, -1.2D0, 4.2D0, - : -42.8D0, 12.7D0, -1.2D0, -4.2D0, - : -7.6D0, -44.1D0, 2.1D0, -0.5D0, - : -64.1D0, 1.7D0, 0.2D0, 4.5D0, - : 36.4D0, -10.4D0, 1.0D0, 3.5D0, - : 35.6D0, 10.2D0, 1.0D0, -3.5D0, - : -1.7D0, 39.5D0, 2.0D0, 0.0D0, - : 50.9D0, -8.2D0, -0.8D0, -5.0D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=181,190 ) / - : 0.0D0, 52.3D0, 1.2D0, 0.0D0, - : -42.9D0, -17.8D0, 0.4D0, 0.0D0, - : 2.6D0, 34.3D0, 0.8D0, 0.0D0, - : -0.8D0, -48.6D0, 2.4D0, -0.1D0, - : -4.9D0, 30.5D0, 3.7D0, 0.7D0, - : 0.0D0, -43.6D0, 2.1D0, 0.0D0, - : 0.0D0, -25.4D0, 1.2D0, 0.0D0, - : 2.0D0, 40.9D0, -2.0D0, 0.0D0, - : -2.1D0, 26.1D0, 0.6D0, 0.0D0, - : 22.6D0, -3.2D0, -0.5D0, -0.5D0 / - DATA ( ( PSI(I,J), I=1,4 ), J=191,NTERMS ) / - : -7.6D0, 24.9D0, -0.4D0, -0.2D0, - : -6.2D0, 34.9D0, 1.7D0, 0.3D0, - : 2.0D0, 17.4D0, -0.4D0, 0.1D0, - : -3.9D0, 20.5D0, 2.4D0, 0.6D0 / - -* Nutation series: obliquity - DATA ( ( EPS(I,J), I=1,4 ), J=1,10 ) / - : 9205365.8D0, -1506.2D0, 885.7D0, -0.2D0, - : 573095.9D0, -570.2D0, -305.0D0, -0.3D0, - : 97845.5D0, 147.8D0, -48.8D0, -0.2D0, - : -89753.6D0, 28.0D0, 46.9D0, 0.0D0, - : 7406.7D0, -327.1D0, -18.2D0, 0.8D0, - : 22442.3D0, -22.3D0, -67.6D0, 0.0D0, - : -683.6D0, 46.8D0, 0.0D0, 0.0D0, - : 20070.7D0, 36.0D0, 1.6D0, 0.0D0, - : 12893.8D0, 39.5D0, -6.2D0, 0.0D0, - : -9593.2D0, 14.4D0, 30.2D0, -0.1D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=11,20 ) / - : -6899.5D0, 4.8D0, -0.6D0, 0.0D0, - : -5332.5D0, -0.1D0, 2.7D0, 0.0D0, - : -125.2D0, 10.5D0, 0.0D0, 0.0D0, - : -3323.4D0, -0.9D0, -0.3D0, 0.0D0, - : 3142.3D0, 8.9D0, 0.3D0, 0.0D0, - : 2552.5D0, 7.3D0, -1.2D0, 0.0D0, - : 2634.4D0, 8.8D0, 0.2D0, 0.0D0, - : -2424.4D0, 1.6D0, -0.4D0, 0.0D0, - : -123.3D0, 3.9D0, 0.0D0, 0.0D0, - : 1642.4D0, 7.3D0, -0.8D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=21,30 ) / - : 47.9D0, 3.2D0, 0.0D0, 0.0D0, - : 1321.2D0, 6.2D0, -0.6D0, 0.0D0, - : -1234.1D0, -0.3D0, 0.6D0, 0.0D0, - : -1076.5D0, -0.3D0, 0.0D0, 0.0D0, - : -61.6D0, 1.8D0, 0.0D0, 0.0D0, - : -55.4D0, 1.6D0, 0.0D0, 0.0D0, - : 856.9D0, -4.9D0, -2.1D0, 0.0D0, - : -800.7D0, -0.1D0, 0.0D0, 0.0D0, - : 685.1D0, -0.6D0, -3.8D0, 0.0D0, - : -16.9D0, -1.5D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=31,40 ) / - : 695.7D0, 1.8D0, 0.0D0, 0.0D0, - : 642.2D0, -2.6D0, -1.6D0, 0.0D0, - : 13.3D0, 1.1D0, -0.1D0, 0.0D0, - : 521.9D0, 1.6D0, 0.0D0, 0.0D0, - : 325.8D0, 2.0D0, -0.1D0, 0.0D0, - : -325.1D0, -0.5D0, 0.9D0, 0.0D0, - : 10.1D0, 0.3D0, 0.0D0, 0.0D0, - : 334.5D0, 1.6D0, 0.0D0, 0.0D0, - : 307.1D0, 0.4D0, -0.9D0, 0.0D0, - : 327.2D0, 0.5D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=41,50 ) / - : -304.6D0, -0.1D0, 0.0D0, 0.0D0, - : 304.0D0, 0.6D0, 0.0D0, 0.0D0, - : -276.8D0, -0.5D0, 0.1D0, 0.0D0, - : 268.9D0, 1.3D0, 0.0D0, 0.0D0, - : 271.8D0, 1.1D0, 0.0D0, 0.0D0, - : 271.5D0, -0.4D0, -0.8D0, 0.0D0, - : -5.2D0, 0.5D0, 0.0D0, 0.0D0, - : -220.5D0, 0.1D0, 0.0D0, 0.0D0, - : -20.1D0, 0.3D0, 0.0D0, 0.0D0, - : -191.0D0, 0.1D0, 0.5D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=51,60 ) / - : -4.1D0, 0.3D0, 0.0D0, 0.0D0, - : 130.6D0, -0.1D0, 0.0D0, 0.0D0, - : 3.0D0, 0.3D0, 0.0D0, 0.0D0, - : 122.9D0, 0.8D0, 0.0D0, 0.0D0, - : 3.7D0, -0.3D0, 0.0D0, 0.0D0, - : 123.1D0, 0.4D0, -0.3D0, 0.0D0, - : -52.7D0, 15.3D0, 0.0D0, 0.0D0, - : 120.7D0, 0.3D0, -0.3D0, 0.0D0, - : 4.0D0, -0.3D0, 0.0D0, 0.0D0, - : 126.5D0, 0.5D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=61,70 ) / - : 112.7D0, 0.5D0, -0.3D0, 0.0D0, - : -106.1D0, -0.3D0, 0.3D0, 0.0D0, - : -112.9D0, -0.2D0, 0.0D0, 0.0D0, - : 3.6D0, -0.2D0, 0.0D0, 0.0D0, - : 107.4D0, 0.3D0, 0.0D0, 0.0D0, - : -10.9D0, 0.2D0, 0.0D0, 0.0D0, - : -0.9D0, 0.0D0, 0.0D0, 0.0D0, - : 85.4D0, 0.0D0, 0.0D0, 0.0D0, - : 0.0D0, -88.8D0, 0.0D0, 0.0D0, - : -71.0D0, -0.2D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=71,80 ) / - : -70.3D0, 0.0D0, 0.0D0, 0.0D0, - : 64.5D0, 0.4D0, 0.0D0, 0.0D0, - : 69.8D0, 0.0D0, 0.0D0, 0.0D0, - : 66.1D0, 0.4D0, 0.0D0, 0.0D0, - : -61.0D0, -0.2D0, 0.0D0, 0.0D0, - : -59.5D0, -0.1D0, 0.0D0, 0.0D0, - : -55.6D0, 0.0D0, 0.2D0, 0.0D0, - : 51.7D0, 0.2D0, 0.0D0, 0.0D0, - : -49.0D0, -0.1D0, 0.0D0, 0.0D0, - : -52.7D0, -0.1D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=81,90 ) / - : -49.6D0, 1.4D0, 0.0D0, 0.0D0, - : 46.3D0, 0.4D0, 0.0D0, 0.0D0, - : 49.6D0, 0.1D0, 0.0D0, 0.0D0, - : -5.1D0, 0.1D0, 0.0D0, 0.0D0, - : -44.0D0, -0.1D0, 0.0D0, 0.0D0, - : -39.9D0, -0.1D0, 0.0D0, 0.0D0, - : -39.5D0, -0.1D0, 0.0D0, 0.0D0, - : -3.9D0, 0.1D0, 0.0D0, 0.0D0, - : -42.1D0, -0.1D0, 0.0D0, 0.0D0, - : -17.2D0, 0.1D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=91,100 ) / - : -2.3D0, 0.1D0, 0.0D0, 0.0D0, - : -39.2D0, 0.0D0, 0.0D0, 0.0D0, - : -38.4D0, 0.1D0, 0.0D0, 0.0D0, - : 36.8D0, 0.2D0, 0.0D0, 0.0D0, - : 34.6D0, 0.1D0, 0.0D0, 0.0D0, - : -32.7D0, 0.3D0, 0.0D0, 0.0D0, - : 30.4D0, 0.0D0, 0.0D0, 0.0D0, - : 0.4D0, 0.1D0, 0.0D0, 0.0D0, - : 29.3D0, 0.2D0, 0.0D0, 0.0D0, - : 31.6D0, 0.1D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=101,110 ) / - : 0.8D0, -0.1D0, 0.0D0, 0.0D0, - : -27.9D0, 0.0D0, 0.0D0, 0.0D0, - : 2.9D0, 0.0D0, 0.0D0, 0.0D0, - : -25.3D0, 0.0D0, 0.0D0, 0.0D0, - : 25.0D0, 0.1D0, 0.0D0, 0.0D0, - : 27.5D0, 0.1D0, 0.0D0, 0.0D0, - : -24.4D0, -0.1D0, 0.0D0, 0.0D0, - : 24.9D0, 0.2D0, 0.0D0, 0.0D0, - : -22.8D0, -0.1D0, 0.0D0, 0.0D0, - : 0.9D0, -0.1D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=111,120 ) / - : 24.4D0, 0.1D0, 0.0D0, 0.0D0, - : 23.9D0, 0.1D0, 0.0D0, 0.0D0, - : 22.5D0, 0.1D0, 0.0D0, 0.0D0, - : 20.8D0, 0.1D0, 0.0D0, 0.0D0, - : 20.1D0, 0.0D0, 0.0D0, 0.0D0, - : 21.5D0, 0.1D0, 0.0D0, 0.0D0, - : -20.0D0, 0.0D0, 0.0D0, 0.0D0, - : 1.4D0, 0.0D0, 0.0D0, 0.0D0, - : -0.2D0, -0.1D0, 0.0D0, 0.0D0, - : 19.0D0, 0.0D0, -0.1D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=121,130 ) / - : 20.5D0, 0.0D0, 0.0D0, 0.0D0, - : -2.0D0, 0.0D0, 0.0D0, 0.0D0, - : -17.6D0, -0.1D0, 0.0D0, 0.0D0, - : 19.0D0, 0.0D0, 0.0D0, 0.0D0, - : -2.4D0, 0.0D0, 0.0D0, 0.0D0, - : -18.4D0, -0.1D0, 0.0D0, 0.0D0, - : 17.1D0, 0.0D0, 0.0D0, 0.0D0, - : 0.4D0, 0.0D0, 0.0D0, 0.0D0, - : 18.4D0, 0.1D0, 0.0D0, 0.0D0, - : 0.0D0, 17.4D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=131,140 ) / - : -0.6D0, 0.0D0, 0.0D0, 0.0D0, - : -15.4D0, 0.0D0, 0.0D0, 0.0D0, - : -16.8D0, -0.1D0, 0.0D0, 0.0D0, - : 16.3D0, 0.0D0, 0.0D0, 0.0D0, - : -2.0D0, 0.0D0, 0.0D0, 0.0D0, - : -1.5D0, 0.0D0, 0.0D0, 0.0D0, - : -14.3D0, -0.1D0, 0.0D0, 0.0D0, - : 14.4D0, 0.0D0, 0.0D0, 0.0D0, - : -13.4D0, 0.0D0, 0.0D0, 0.0D0, - : -14.3D0, -0.1D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=141,150 ) / - : -13.7D0, 0.0D0, 0.0D0, 0.0D0, - : 13.1D0, 0.1D0, 0.0D0, 0.0D0, - : -1.7D0, 0.0D0, 0.0D0, 0.0D0, - : -12.8D0, 0.0D0, 0.0D0, 0.0D0, - : 0.0D0, -14.4D0, 0.0D0, 0.0D0, - : 12.4D0, 0.0D0, 0.0D0, 0.0D0, - : -12.0D0, 0.0D0, 0.0D0, 0.0D0, - : -0.8D0, 0.0D0, 0.0D0, 0.0D0, - : 10.9D0, 0.1D0, 0.0D0, 0.0D0, - : -10.8D0, 0.0D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=151,160 ) / - : 10.5D0, 0.0D0, 0.0D0, 0.0D0, - : -10.4D0, 0.0D0, 0.0D0, 0.0D0, - : -11.2D0, 0.0D0, 0.0D0, 0.0D0, - : 10.5D0, 0.1D0, 0.0D0, 0.0D0, - : -1.4D0, 0.0D0, 0.0D0, 0.0D0, - : 0.0D0, 0.1D0, 0.0D0, 0.0D0, - : 0.7D0, 0.0D0, 0.0D0, 0.0D0, - : -10.3D0, 0.0D0, 0.0D0, 0.0D0, - : -10.0D0, 0.0D0, 0.0D0, 0.0D0, - : 9.6D0, 0.0D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=161,170 ) / - : 9.4D0, 0.1D0, 0.0D0, 0.0D0, - : 0.6D0, 0.0D0, 0.0D0, 0.0D0, - : -87.7D0, 4.4D0, -0.4D0, -6.3D0, - : 46.3D0, 22.4D0, 0.5D0, -2.4D0, - : 15.6D0, -3.4D0, 0.1D0, 0.4D0, - : 5.2D0, 5.8D0, 0.2D0, -0.1D0, - : -30.1D0, 26.9D0, 0.7D0, 0.0D0, - : 23.2D0, -0.5D0, 0.0D0, 0.6D0, - : 1.0D0, 23.2D0, 3.4D0, 0.0D0, - : -12.2D0, -4.3D0, 0.0D0, 0.0D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=171,180 ) / - : -2.1D0, -3.7D0, -0.2D0, 0.1D0, - : -18.6D0, -3.8D0, -0.4D0, 1.8D0, - : 5.5D0, -18.7D0, -1.8D0, -0.5D0, - : -5.5D0, -18.7D0, 1.8D0, -0.5D0, - : 18.4D0, -3.6D0, 0.3D0, 0.9D0, - : -0.6D0, 1.3D0, 0.0D0, 0.0D0, - : -5.6D0, -19.5D0, 1.9D0, 0.0D0, - : 5.5D0, -19.1D0, -1.9D0, 0.0D0, - : -17.3D0, -0.8D0, 0.0D0, 0.9D0, - : -3.2D0, -8.3D0, -0.8D0, 0.3D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=181,190 ) / - : -0.1D0, 0.0D0, 0.0D0, 0.0D0, - : -5.4D0, 7.8D0, -0.3D0, 0.0D0, - : -14.8D0, 1.4D0, 0.0D0, 0.3D0, - : -3.8D0, 0.4D0, 0.0D0, -0.2D0, - : 12.6D0, 3.2D0, 0.5D0, -1.5D0, - : 0.1D0, 0.0D0, 0.0D0, 0.0D0, - : -13.6D0, 2.4D0, -0.1D0, 0.0D0, - : 0.9D0, 1.2D0, 0.0D0, 0.0D0, - : -11.9D0, -0.5D0, 0.0D0, 0.3D0, - : 0.4D0, 12.0D0, 0.3D0, -0.2D0 / - DATA ( ( EPS(I,J), I=1,4 ), J=191,NTERMS ) / - : 8.3D0, 6.1D0, -0.1D0, 0.1D0, - : 0.0D0, 0.0D0, 0.0D0, 0.0D0, - : 0.4D0, -10.8D0, 0.3D0, 0.0D0, - : 9.6D0, 2.2D0, 0.3D0, -1.2D0 / - - - -* Interval between fundamental epoch J2000.0 and given epoch (JC). - T = (DATE-DJM0)/DJC - -* Mean anomaly of the Moon. - EL = 134.96340251D0*DD2R+ - : MOD(T*(1717915923.2178D0+ - : T*( 31.8792D0+ - : T*( 0.051635D0+ - : T*( - 0.00024470D0)))),TURNAS)*DAS2R - -* Mean anomaly of the Sun. - ELP = 357.52910918D0*DD2R+ - : MOD(T*( 129596581.0481D0+ - : T*( - 0.5532D0+ - : T*( 0.000136D0+ - : T*( - 0.00001149D0)))),TURNAS)*DAS2R - -* Mean argument of the latitude of the Moon. - F = 93.27209062D0*DD2R+ - : MOD(T*(1739527262.8478D0+ - : T*( - 12.7512D0+ - : T*( - 0.001037D0+ - : T*( 0.00000417D0)))),TURNAS)*DAS2R - -* Mean elongation of the Moon from the Sun. - D = 297.85019547D0*DD2R+ - : MOD(T*(1602961601.2090D0+ - : T*( - 6.3706D0+ - : T*( 0.006539D0+ - : T*( - 0.00003169D0)))),TURNAS)*DAS2R - -* Mean longitude of the ascending node of the Moon. - OM = 125.04455501D0*DD2R+ - : MOD(T*( - 6962890.5431D0+ - : T*( 7.4722D0+ - : T*( 0.007702D0+ - : T*( - 0.00005939D0)))),TURNAS)*DAS2R - -* Mean longitude of Venus. - VE = 181.97980085D0*DD2R+MOD(210664136.433548D0*T,TURNAS)*DAS2R - -* Mean longitude of Mars. - MA = 355.43299958D0*DD2R+MOD( 68905077.493988D0*T,TURNAS)*DAS2R - -* Mean longitude of Jupiter. - JU = 34.35151874D0*DD2R+MOD( 10925660.377991D0*T,TURNAS)*DAS2R - -* Mean longitude of Saturn. - SA = 50.07744430D0*DD2R+MOD( 4399609.855732D0*T,TURNAS)*DAS2R - -* Geodesic nutation (Fukushima 1991) in microarcsec. - DP = -153.1D0*SIN(ELP)-1.9D0*SIN(2D0*ELP) - DE = 0D0 - -* Shirai & Fukushima (2001) nutation series. - DO J=NTERMS,1,-1 - THETA = DBLE(NA(1,J))*EL+ - : DBLE(NA(2,J))*ELP+ - : DBLE(NA(3,J))*F+ - : DBLE(NA(4,J))*D+ - : DBLE(NA(5,J))*OM+ - : DBLE(NA(6,J))*VE+ - : DBLE(NA(7,J))*MA+ - : DBLE(NA(8,J))*JU+ - : DBLE(NA(9,J))*SA - C = COS(THETA) - S = SIN(THETA) - DP = DP+(PSI(1,J)+PSI(3,J)*T)*C+(PSI(2,J)+PSI(4,J)*T)*S - DE = DE+(EPS(1,J)+EPS(3,J)*T)*C+(EPS(2,J)+EPS(4,J)*T)*S - END DO - -* Change of units, and addition of the precession correction. - DPSI = (DP*1D-6-0.042888D0-0.29856D0*T)*DAS2R - DEPS = (DE*1D-6-0.005171D0-0.02408D0*T)*DAS2R - -* Mean obliquity of date (Simon et al. 1994). - EPS0 = (84381.412D0+ - : (-46.80927D0+ - : (-0.000152D0+ - : (0.0019989D0+ - : (-0.00000051D0+ - : (-0.000000025D0)*T)*T)*T)*T)*T)*DAS2R - - END diff --git a/src/slalib/nutc80.f b/src/slalib/nutc80.f deleted file mode 100644 index b3d728a4b..000000000 --- a/src/slalib/nutc80.f +++ /dev/null @@ -1,475 +0,0 @@ - SUBROUTINE sla_NUTC80 (DATE, DPSI, DEPS, EPS0) -*+ -* - - - - - - - -* N U T C 8 0 -* - - - - - - - -* -* Nutation: longitude & obliquity components and mean obliquity, -* using the IAU 1980 theory (double precision) -* -* Given: -* DATE d TDB (loosely ET) as Modified Julian Date -* (JD-2400000.5) -* Returned: -* DPSI,DEPS d nutation in longitude,obliquity -* EPS0 d mean obliquity -* -* Called: sla_DRANGE -* -* Notes: -* -* 1 Earth attitude predictions made by combining the present nutation -* model with IAU 1976 precession are accurate to 0.35 arcsec over -* the interval 1900-2100. (The accuracy is much better near the -* middle of the interval.) -* -* 2 The sla_NUTC routine is the equivalent of the present routine -* but using the Shirai & Fukushima 2001 forced nutation theory -* (SF2001). The newer theory is more accurate than IAU 1980, -* within 1 mas (with respect to the ICRF) for a few decades around -* 2000. The improvement is mainly because of the corrections to the -* IAU 1976 precession that the SF2001 theory includes. -* -* References: -* Final report of the IAU Working Group on Nutation, -* chairman P.K.Seidelmann, 1980. -* Kaplan,G.H., 1981, USNO circular no. 163, pA3-6. -* -* P.T.Wallace Starlink 7 October 2001 -* -* Copyright (C) 2001 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,DPSI,DEPS,EPS0 - - DOUBLE PRECISION T2AS,AS2R,U2R - DOUBLE PRECISION T,EL,EL2,EL3 - DOUBLE PRECISION ELP,ELP2 - DOUBLE PRECISION F,F2,F4 - DOUBLE PRECISION D,D2,D4 - DOUBLE PRECISION OM,OM2 - DOUBLE PRECISION DP,DE - DOUBLE PRECISION A - - DOUBLE PRECISION sla_DRANGE - - -* Turns to arc seconds - PARAMETER (T2AS=1296000D0) -* Arc seconds to radians - PARAMETER (AS2R=0.484813681109535994D-5) -* Units of 0.0001 arcsec to radians - PARAMETER (U2R=AS2R/1D4) - - - - -* Interval between basic epoch J2000.0 and current epoch (JC) - T=(DATE-51544.5D0)/36525D0 - -* -* FUNDAMENTAL ARGUMENTS in the FK5 reference system -* - -* Mean longitude of the Moon minus mean longitude of the Moon's perigee - EL=sla_DRANGE(AS2R*(485866.733D0+(1325D0*T2AS+715922.633D0 - : +(31.310D0+0.064D0*T)*T)*T)) - -* Mean longitude of the Sun minus mean longitude of the Sun's perigee - ELP=sla_DRANGE(AS2R*(1287099.804D0+(99D0*T2AS+1292581.224D0 - : +(-0.577D0-0.012D0*T)*T)*T)) - -* Mean longitude of the Moon minus mean longitude of the Moon's node - F=sla_DRANGE(AS2R*(335778.877D0+(1342D0*T2AS+295263.137D0 - : +(-13.257D0+0.011D0*T)*T)*T)) - -* Mean elongation of the Moon from the Sun - D=sla_DRANGE(AS2R*(1072261.307D0+(1236D0*T2AS+1105601.328D0 - : +(-6.891D0+0.019D0*T)*T)*T)) - -* Longitude of the mean ascending node of the lunar orbit on the -* ecliptic, measured from the mean equinox of date - OM=sla_DRANGE(AS2R*(450160.280D0+(-5D0*T2AS-482890.539D0 - : +(7.455D0+0.008D0*T)*T)*T)) - -* Multiples of arguments - EL2=EL+EL - EL3=EL2+EL - ELP2=ELP+ELP - F2=F+F - F4=F2+F2 - D2=D+D - D4=D2+D2 - OM2=OM+OM - - -* -* SERIES FOR THE NUTATION -* - DP=0D0 - DE=0D0 - -* 106 - DP=DP+SIN(ELP+D) -* 105 - DP=DP-SIN(F2+D4+OM2) -* 104 - DP=DP+SIN(EL2+D2) -* 103 - DP=DP-SIN(EL-F2+D2) -* 102 - DP=DP-SIN(EL+ELP-D2+OM) -* 101 - DP=DP-SIN(-ELP+F2+OM) -* 100 - DP=DP-SIN(EL-F2-D2) -* 99 - DP=DP-SIN(ELP+D2) -* 98 - DP=DP-SIN(F2-D+OM2) -* 97 - DP=DP-SIN(-F2+OM) -* 96 - DP=DP+SIN(-EL-ELP+D2+OM) -* 95 - DP=DP+SIN(ELP+F2+OM) -* 94 - DP=DP-SIN(EL+F2-D2) -* 93 - DP=DP+SIN(EL3+F2-D2+OM2) -* 92 - DP=DP+SIN(F4-D2+OM2) -* 91 - DP=DP-SIN(EL+D2+OM) -* 90 - DP=DP-SIN(EL2+F2+D2+OM2) -* 89 - A=EL2+F2-D2+OM - DP=DP+SIN(A) - DE=DE-COS(A) -* 88 - DP=DP+SIN(EL-ELP-D2) -* 87 - DP=DP+SIN(-EL+F4+OM2) -* 86 - A=-EL2+F2+D4+OM2 - DP=DP-SIN(A) - DE=DE+COS(A) -* 85 - A=EL+F2+D2+OM - DP=DP-SIN(A) - DE=DE+COS(A) -* 84 - A=EL+ELP+F2-D2+OM2 - DP=DP+SIN(A) - DE=DE-COS(A) -* 83 - DP=DP-SIN(EL2-D4) -* 82 - A=-EL+F2+D4+OM2 - DP=DP-2D0*SIN(A) - DE=DE+COS(A) -* 81 - A=-EL2+F2+D2+OM2 - DP=DP+SIN(A) - DE=DE-COS(A) -* 80 - DP=DP-SIN(EL-D4) -* 79 - A=-EL+OM2 - DP=DP+SIN(A) - DE=DE-COS(A) -* 78 - A=F2+D+OM2 - DP=DP+2D0*SIN(A) - DE=DE-COS(A) -* 77 - DP=DP+2D0*SIN(EL3) -* 76 - A=EL+OM2 - DP=DP-2D0*SIN(A) - DE=DE+COS(A) -* 75 - A=EL2+OM - DP=DP+2D0*SIN(A) - DE=DE-COS(A) -* 74 - A=-EL+F2-D2+OM - DP=DP-2D0*SIN(A) - DE=DE+COS(A) -* 73 - A=EL+ELP+F2+OM2 - DP=DP+2D0*SIN(A) - DE=DE-COS(A) -* 72 - A=-ELP+F2+D2+OM2 - DP=DP-3D0*SIN(A) - DE=DE+COS(A) -* 71 - A=EL3+F2+OM2 - DP=DP-3D0*SIN(A) - DE=DE+COS(A) -* 70 - A=-EL2+OM - DP=DP-2D0*SIN(A) - DE=DE+COS(A) -* 69 - A=-EL-ELP+F2+D2+OM2 - DP=DP-3D0*SIN(A) - DE=DE+COS(A) -* 68 - A=EL-ELP+F2+OM2 - DP=DP-3D0*SIN(A) - DE=DE+COS(A) -* 67 - DP=DP+3D0*SIN(EL+F2) -* 66 - DP=DP-3D0*SIN(EL+ELP) -* 65 - DP=DP-4D0*SIN(D) -* 64 - DP=DP+4D0*SIN(EL-F2) -* 63 - DP=DP-4D0*SIN(ELP-D2) -* 62 - A=EL2+F2+OM - DP=DP-5D0*SIN(A) - DE=DE+3D0*COS(A) -* 61 - DP=DP+5D0*SIN(EL-ELP) -* 60 - A=-D2+OM - DP=DP-5D0*SIN(A) - DE=DE+3D0*COS(A) -* 59 - A=EL+F2-D2+OM - DP=DP+6D0*SIN(A) - DE=DE-3D0*COS(A) -* 58 - A=F2+D2+OM - DP=DP-7D0*SIN(A) - DE=DE+3D0*COS(A) -* 57 - A=D2+OM - DP=DP-6D0*SIN(A) - DE=DE+3D0*COS(A) -* 56 - A=EL2+F2-D2+OM2 - DP=DP+6D0*SIN(A) - DE=DE-3D0*COS(A) -* 55 - DP=DP+6D0*SIN(EL+D2) -* 54 - A=EL+F2+D2+OM2 - DP=DP-8D0*SIN(A) - DE=DE+3D0*COS(A) -* 53 - A=-ELP+F2+OM2 - DP=DP-7D0*SIN(A) - DE=DE+3D0*COS(A) -* 52 - A=ELP+F2+OM2 - DP=DP+7D0*SIN(A) - DE=DE-3D0*COS(A) -* 51 - DP=DP-7D0*SIN(EL+ELP-D2) -* 50 - A=-EL+F2+D2+OM - DP=DP-10D0*SIN(A) - DE=DE+5D0*COS(A) -* 49 - A=EL-D2+OM - DP=DP-13D0*SIN(A) - DE=DE+7D0*COS(A) -* 48 - A=-EL+D2+OM - DP=DP+16D0*SIN(A) - DE=DE-8D0*COS(A) -* 47 - A=-EL+F2+OM - DP=DP+21D0*SIN(A) - DE=DE-10D0*COS(A) -* 46 - DP=DP+26D0*SIN(F2) - DE=DE-COS(F2) -* 45 - A=EL2+F2+OM2 - DP=DP-31D0*SIN(A) - DE=DE+13D0*COS(A) -* 44 - A=EL+F2-D2+OM2 - DP=DP+29D0*SIN(A) - DE=DE-12D0*COS(A) -* 43 - DP=DP+29D0*SIN(EL2) - DE=DE-COS(EL2) -* 42 - A=F2+D2+OM2 - DP=DP-38D0*SIN(A) - DE=DE+16D0*COS(A) -* 41 - A=EL+F2+OM - DP=DP-51D0*SIN(A) - DE=DE+27D0*COS(A) -* 40 - A=-EL+F2+D2+OM2 - DP=DP-59D0*SIN(A) - DE=DE+26D0*COS(A) -* 39 - A=-EL+OM - DP=DP+(-58D0-0.1D0*T)*SIN(A) - DE=DE+32D0*COS(A) -* 38 - A=EL+OM - DP=DP+(63D0+0.1D0*T)*SIN(A) - DE=DE-33D0*COS(A) -* 37 - DP=DP+63D0*SIN(D2) - DE=DE-2D0*COS(D2) -* 36 - A=-EL+F2+OM2 - DP=DP+123D0*SIN(A) - DE=DE-53D0*COS(A) -* 35 - A=EL-D2 - DP=DP-158D0*SIN(A) - DE=DE-COS(A) -* 34 - A=EL+F2+OM2 - DP=DP-301D0*SIN(A) - DE=DE+(129D0-0.1D0*T)*COS(A) -* 33 - A=F2+OM - DP=DP+(-386D0-0.4D0*T)*SIN(A) - DE=DE+200D0*COS(A) -* 32 - DP=DP+(712D0+0.1D0*T)*SIN(EL) - DE=DE-7D0*COS(EL) -* 31 - A=F2+OM2 - DP=DP+(-2274D0-0.2D0*T)*SIN(A) - DE=DE+(977D0-0.5D0*T)*COS(A) -* 30 - DP=DP-SIN(ELP+F2-D2) -* 29 - DP=DP+SIN(-EL+D+OM) -* 28 - DP=DP+SIN(ELP+OM2) -* 27 - DP=DP-SIN(ELP-F2+D2) -* 26 - DP=DP+SIN(-F2+D2+OM) -* 25 - DP=DP+SIN(EL2+ELP-D2) -* 24 - DP=DP-4D0*SIN(EL-D) -* 23 - A=ELP+F2-D2+OM - DP=DP+4D0*SIN(A) - DE=DE-2D0*COS(A) -* 22 - A=EL2-D2+OM - DP=DP+4D0*SIN(A) - DE=DE-2D0*COS(A) -* 21 - A=-ELP+F2-D2+OM - DP=DP-5D0*SIN(A) - DE=DE+3D0*COS(A) -* 20 - A=-EL2+D2+OM - DP=DP-6D0*SIN(A) - DE=DE+3D0*COS(A) -* 19 - A=-ELP+OM - DP=DP-12D0*SIN(A) - DE=DE+6D0*COS(A) -* 18 - A=ELP2+F2-D2+OM2 - DP=DP+(-16D0+0.1D0*T)*SIN(A) - DE=DE+7D0*COS(A) -* 17 - A=ELP+OM - DP=DP-15D0*SIN(A) - DE=DE+9D0*COS(A) -* 16 - DP=DP+(17D0-0.1D0*T)*SIN(ELP2) -* 15 - DP=DP-22D0*SIN(F2-D2) -* 14 - A=EL2-D2 - DP=DP+48D0*SIN(A) - DE=DE+COS(A) -* 13 - A=F2-D2+OM - DP=DP+(129D0+0.1D0*T)*SIN(A) - DE=DE-70D0*COS(A) -* 12 - A=-ELP+F2-D2+OM2 - DP=DP+(217D0-0.5D0*T)*SIN(A) - DE=DE+(-95D0+0.3D0*T)*COS(A) -* 11 - A=ELP+F2-D2+OM2 - DP=DP+(-517D0+1.2D0*T)*SIN(A) - DE=DE+(224D0-0.6D0*T)*COS(A) -* 10 - DP=DP+(1426D0-3.4D0*T)*SIN(ELP) - DE=DE+(54D0-0.1D0*T)*COS(ELP) -* 9 - A=F2-D2+OM2 - DP=DP+(-13187D0-1.6D0*T)*SIN(A) - DE=DE+(5736D0-3.1D0*T)*COS(A) -* 8 - DP=DP+SIN(EL2-F2+OM) -* 7 - A=-ELP2+F2-D2+OM - DP=DP-2D0*SIN(A) - DE=DE+1D0*COS(A) -* 6 - DP=DP-3D0*SIN(EL-ELP-D) -* 5 - A=-EL2+F2+OM2 - DP=DP-3D0*SIN(A) - DE=DE+1D0*COS(A) -* 4 - DP=DP+11D0*SIN(EL2-F2) -* 3 - A=-EL2+F2+OM - DP=DP+46D0*SIN(A) - DE=DE-24D0*COS(A) -* 2 - DP=DP+(2062D0+0.2D0*T)*SIN(OM2) - DE=DE+(-895D0+0.5D0*T)*COS(OM2) -* 1 - DP=DP+(-171996D0-174.2D0*T)*SIN(OM) - DE=DE+(92025D0+8.9D0*T)*COS(OM) - -* Convert results to radians - DPSI=DP*U2R - DEPS=DE*U2R - -* Mean obliquity - EPS0=AS2R*(84381.448D0+ - : (-46.8150D0+ - : (-0.00059D0+ - : 0.001813D0*T)*T)*T) - - END diff --git a/src/slalib/oap.f b/src/slalib/oap.f deleted file mode 100644 index 5ca77e6c7..000000000 --- a/src/slalib/oap.f +++ /dev/null @@ -1,192 +0,0 @@ - SUBROUTINE sla_OAP ( TYPE, OB1, OB2, DATE, DUT, ELONGM, PHIM, - : HM, XP, YP, TDK, PMB, RH, WL, TLR, - : RAP, DAP ) -*+ -* - - - - -* O A P -* - - - - -* -* Observed to apparent place. -* -* Given: -* TYPE c*(*) type of coordinates - 'R', 'H' or 'A' (see below) -* OB1 d observed Az, HA or RA (radians; Az is N=0,E=90) -* OB2 d observed ZD or Dec (radians) -* DATE d UTC date/time (modified Julian Date, JD-2400000.5) -* DUT d delta UT: UT1-UTC (UTC seconds) -* ELONGM d mean longitude of the observer (radians, east +ve) -* PHIM d mean geodetic latitude of the observer (radians) -* HM d observer's height above sea level (metres) -* XP d polar motion x-coordinate (radians) -* YP d polar motion y-coordinate (radians) -* TDK d local ambient temperature (K; std=273.15D0) -* PMB d local atmospheric pressure (mb; std=1013.25D0) -* RH d local relative humidity (in the range 0D0-1D0) -* WL d effective wavelength (micron, e.g. 0.55D0) -* TLR d tropospheric lapse rate (K/metre, e.g. 0.0065D0) -* -* Returned: -* RAP d geocentric apparent right ascension -* DAP d geocentric apparent declination -* -* Notes: -* -* 1) Only the first character of the TYPE argument is significant. -* 'R' or 'r' indicates that OBS1 and OBS2 are the observed right -* ascension and declination; 'H' or 'h' indicates that they are -* hour angle (west +ve) and declination; anything else ('A' or -* 'a' is recommended) indicates that OBS1 and OBS2 are azimuth -* (north zero, east 90 deg) and zenith distance. (Zenith -* distance is used rather than elevation in order to reflect the -* fact that no allowance is made for depression of the horizon.) -* -* 2) The accuracy of the result is limited by the corrections for -* refraction. Providing the meteorological parameters are -* known accurately and there are no gross local effects, the -* predicted apparent RA,Dec should be within about 0.1 arcsec -* for a zenith distance of less than 70 degrees. Even at a -* topocentric zenith distance of 90 degrees, the accuracy in -* elevation should be better than 1 arcmin; useful results -* are available for a further 3 degrees, beyond which the -* sla_REFRO routine returns a fixed value of the refraction. -* The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP -* (or sla_OAPQK) are self-consistent to better than 1 micro- -* arcsecond all over the celestial sphere. -* -* 3) It is advisable to take great care with units, as even -* unlikely values of the input parameters are accepted and -* processed in accordance with the models used. -* -* 4) "Observed" Az,El means the position that would be seen by a -* perfect theodolite located at the observer. This is -* related to the observed HA,Dec via the standard rotation, using -* the geodetic latitude (corrected for polar motion), while the -* observed HA and RA are related simply through the local -* apparent ST. "Observed" RA,Dec or HA,Dec thus means the -* position that would be seen by a perfect equatorial located -* at the observer and with its polar axis aligned to the -* Earth's axis of rotation (n.b. not to the refracted pole). -* By removing from the observed place the effects of -* atmospheric refraction and diurnal aberration, the -* geocentric apparent RA,Dec is obtained. -* -* 5) Frequently, mean rather than apparent RA,Dec will be required, -* in which case further transformations will be necessary. The -* sla_AMP etc routines will convert the apparent RA,Dec produced -* by the present routine into an "FK5" (J2000) mean place, by -* allowing for the Sun's gravitational lens effect, annual -* aberration, nutation and precession. Should "FK4" (1950) -* coordinates be needed, the routines sla_FK524 etc will also -* need to be applied. -* -* 6) To convert to apparent RA,Dec the coordinates read from a -* real telescope, corrections would have to be applied for -* encoder zero points, gear and encoder errors, tube flexure, -* the position of the rotator axis and the pointing axis -* relative to it, non-perpendicularity between the mounting -* axes, and finally for the tilt of the azimuth or polar axis -* of the mounting (with appropriate corrections for mount -* flexures). Some telescopes would, of course, exhibit other -* properties which would need to be accounted for at the -* appropriate point in the sequence. -* -* 7) This routine takes time to execute, due mainly to the rigorous -* integration used to evaluate the refraction. For processing -* multiple stars for one location and time, call sla_AOPPA once -* followed by one call per star to sla_OAPQK. Where a range of -* times within a limited period of a few hours is involved, and the -* highest precision is not required, call sla_AOPPA once, followed -* by a call to sla_AOPPAT each time the time changes, followed by -* one call per star to sla_OAPQK. -* -* 8) The DATE argument is UTC expressed as an MJD. This is, strictly -* speaking, wrong, because of leap seconds. However, as long as -* the delta UT and the UTC are consistent there are no -* difficulties, except during a leap second. In this case, the -* start of the 61st second of the final minute should begin a new -* MJD day and the old pre-leap delta UT should continue to be used. -* As the 61st second completes, the MJD should revert to the start -* of the day as, simultaneously, the delta UTC changes by one -* second to its post-leap new value. -* -* 9) The delta UT (UT1-UTC) is tabulated in IERS circulars and -* elsewhere. It increases by exactly one second at the end of -* each UTC leap second, introduced in order to keep delta UT -* within +/- 0.9 seconds. -* -* 10) IMPORTANT -- TAKE CARE WITH THE LONGITUDE SIGN CONVENTION. -* The longitude required by the present routine is east-positive, -* in accordance with geographical convention (and right-handed). -* In particular, note that the longitudes returned by the -* sla_OBS routine are west-positive, following astronomical -* usage, and must be reversed in sign before use in the present -* routine. -* -* 11) The polar coordinates XP,YP can be obtained from IERS -* circulars and equivalent publications. The maximum amplitude -* is about 0.3 arcseconds. If XP,YP values are unavailable, -* use XP=YP=0D0. See page B60 of the 1988 Astronomical Almanac -* for a definition of the two angles. -* -* 12) The height above sea level of the observing station, HM, -* can be obtained from the Astronomical Almanac (Section J -* in the 1988 edition), or via the routine sla_OBS. If P, -* the pressure in millibars, is available, an adequate -* estimate of HM can be obtained from the expression -* -* HM ~ -29.3D0*TSL*LOG(P/1013.25D0). -* -* where TSL is the approximate sea-level air temperature in K -* (see Astrophysical Quantities, C.W.Allen, 3rd edition, -* section 52). Similarly, if the pressure P is not known, -* it can be estimated from the height of the observing -* station, HM, as follows: -* -* P ~ 1013.25D0*EXP(-HM/(29.3D0*TSL)). -* -* Note, however, that the refraction is nearly proportional to the -* pressure and that an accurate P value is important for precise -* work. -* -* 13) The azimuths etc. used by the present routine are with respect -* to the celestial pole. Corrections from the terrestrial pole -* can be computed using sla_POLMO. -* -* Called: sla_AOPPA, sla_OAPQK -* -* Last revision: 2 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) TYPE - DOUBLE PRECISION OB1,OB2,DATE,DUT,ELONGM,PHIM,HM, - : XP,YP,TDK,PMB,RH,WL,TLR,RAP,DAP - - DOUBLE PRECISION AOPRMS(14) - - - CALL sla_AOPPA(DATE,DUT,ELONGM,PHIM,HM,XP,YP,TDK,PMB,RH,WL,TLR, - : AOPRMS) - CALL sla_OAPQK(TYPE,OB1,OB2,AOPRMS,RAP,DAP) - - END diff --git a/src/slalib/oapqk.f b/src/slalib/oapqk.f deleted file mode 100644 index 2a5ea22b4..000000000 --- a/src/slalib/oapqk.f +++ /dev/null @@ -1,250 +0,0 @@ - SUBROUTINE sla_OAPQK (TYPE, OB1, OB2, AOPRMS, RAP, DAP) -*+ -* - - - - - - -* O A P Q K -* - - - - - - -* -* Quick observed to apparent place -* -* Given: -* TYPE c*(*) type of coordinates - 'R', 'H' or 'A' (see below) -* OB1 d observed Az, HA or RA (radians; Az is N=0,E=90) -* OB2 d observed ZD or Dec (radians) -* AOPRMS d(14) star-independent apparent-to-observed parameters: -* -* (1) geodetic latitude (radians) -* (2,3) sine and cosine of geodetic latitude -* (4) magnitude of diurnal aberration vector -* (5) height (HM) -* (6) ambient temperature (T) -* (7) pressure (P) -* (8) relative humidity (RH) -* (9) wavelength (WL) -* (10) lapse rate (TLR) -* (11,12) refraction constants A and B (radians) -* (13) longitude + eqn of equinoxes + sidereal DUT (radians) -* (14) local apparent sidereal time (radians) -* -* Returned: -* RAP d geocentric apparent right ascension -* DAP d geocentric apparent declination -* -* Notes: -* -* 1) Only the first character of the TYPE argument is significant. -* 'R' or 'r' indicates that OBS1 and OBS2 are the observed right -* ascension and declination; 'H' or 'h' indicates that they are -* hour angle (west +ve) and declination; anything else ('A' or -* 'a' is recommended) indicates that OBS1 and OBS2 are azimuth -* (north zero, east 90 deg) and zenith distance. (Zenith distance -* is used rather than elevation in order to reflect the fact that -* no allowance is made for depression of the horizon.) -* -* 2) The accuracy of the result is limited by the corrections for -* refraction. Providing the meteorological parameters are -* known accurately and there are no gross local effects, the -* predicted apparent RA,Dec should be within about 0.1 arcsec -* for a zenith distance of less than 70 degrees. Even at a -* topocentric zenith distance of 90 degrees, the accuracy in -* elevation should be better than 1 arcmin; useful results -* are available for a further 3 degrees, beyond which the -* sla_REFRO routine returns a fixed value of the refraction. -* The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP -* (or sla_OAPQK) are self-consistent to better than 1 micro- -* arcsecond all over the celestial sphere. -* -* 3) It is advisable to take great care with units, as even -* unlikely values of the input parameters are accepted and -* processed in accordance with the models used. -* -* 5) "Observed" Az,El means the position that would be seen by a -* perfect theodolite located at the observer. This is -* related to the observed HA,Dec via the standard rotation, using -* the geodetic latitude (corrected for polar motion), while the -* observed HA and RA are related simply through the local -* apparent ST. "Observed" RA,Dec or HA,Dec thus means the -* position that would be seen by a perfect equatorial located -* at the observer and with its polar axis aligned to the -* Earth's axis of rotation (n.b. not to the refracted pole). -* By removing from the observed place the effects of -* atmospheric refraction and diurnal aberration, the -* geocentric apparent RA,Dec is obtained. -* -* 5) Frequently, mean rather than apparent RA,Dec will be required, -* in which case further transformations will be necessary. The -* sla_AMP etc routines will convert the apparent RA,Dec produced -* by the present routine into an "FK5" (J2000) mean place, by -* allowing for the Sun's gravitational lens effect, annual -* aberration, nutation and precession. Should "FK4" (1950) -* coordinates be needed, the routines sla_FK524 etc will also -* need to be applied. -* -* 6) To convert to apparent RA,Dec the coordinates read from a -* real telescope, corrections would have to be applied for -* encoder zero points, gear and encoder errors, tube flexure, -* the position of the rotator axis and the pointing axis -* relative to it, non-perpendicularity between the mounting -* axes, and finally for the tilt of the azimuth or polar axis -* of the mounting (with appropriate corrections for mount -* flexures). Some telescopes would, of course, exhibit other -* properties which would need to be accounted for at the -* appropriate point in the sequence. -* -* 7) The star-independent apparent-to-observed-place parameters -* in AOPRMS may be computed by means of the sla_AOPPA routine. -* If nothing has changed significantly except the time, the -* sla_AOPPAT routine may be used to perform the requisite -* partial recomputation of AOPRMS. -* -* 8) The azimuths etc used by the present routine are with respect -* to the celestial pole. Corrections from the terrestrial pole -* can be computed using sla_POLMO. -* -* Called: sla_DCS2C, sla_DCC2S, sla_REFRO, sla_DRANRM -* -* Last revision: 29 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) TYPE - DOUBLE PRECISION OB1,OB2,AOPRMS(14),RAP,DAP - -* Breakpoint for fast/slow refraction algorithm: -* ZD greater than arctan(4), (see sla_REFCO routine) -* or vector Z less than cosine(arctan(Z)) = 1/sqrt(17) - DOUBLE PRECISION ZBREAK - PARAMETER (ZBREAK=0.242535625D0) - - CHARACTER C - DOUBLE PRECISION C1,C2,SPHI,CPHI,ST,CE,XAEO,YAEO,ZAEO,V(3), - : XMHDO,YMHDO,ZMHDO,AZ,SZ,ZDO,TZ,DREF,ZDT, - : XAET,YAET,ZAET,XMHDA,YMHDA,ZMHDA,DIURAB,F,HMA - - DOUBLE PRECISION sla_DRANRM - - - -* Coordinate type - C = TYPE(1:1) - -* Coordinates - C1 = OB1 - C2 = OB2 - -* Sin, cos of latitude - SPHI = AOPRMS(2) - CPHI = AOPRMS(3) - -* Local apparent sidereal time - ST = AOPRMS(14) - -* Standardise coordinate type - IF (C.EQ.'R'.OR.C.EQ.'r') THEN - C = 'R' - ELSE IF (C.EQ.'H'.OR.C.EQ.'h') THEN - C = 'H' - ELSE - C = 'A' - END IF - -* If Az,ZD convert to Cartesian (S=0,E=90) - IF (C.EQ.'A') THEN - CE = SIN(C2) - XAEO = -COS(C1)*CE - YAEO = SIN(C1)*CE - ZAEO = COS(C2) - ELSE - -* If RA,Dec convert to HA,Dec - IF (C.EQ.'R') THEN - C1 = ST-C1 - END IF - -* To Cartesian -HA,Dec - CALL sla_DCS2C(-C1,C2,V) - XMHDO = V(1) - YMHDO = V(2) - ZMHDO = V(3) - -* To Cartesian Az,El (S=0,E=90) - XAEO = SPHI*XMHDO-CPHI*ZMHDO - YAEO = YMHDO - ZAEO = CPHI*XMHDO+SPHI*ZMHDO - END IF - -* Azimuth (S=0,E=90) - IF (XAEO.NE.0D0.OR.YAEO.NE.0D0) THEN - AZ = ATAN2(YAEO,XAEO) - ELSE - AZ = 0D0 - END IF - -* Sine of observed ZD, and observed ZD - SZ = SQRT(XAEO*XAEO+YAEO*YAEO) - ZDO = ATAN2(SZ,ZAEO) - -* -* Refraction -* ---------- - -* Large zenith distance? - IF (ZAEO.GE.ZBREAK) THEN - -* Fast algorithm using two constant model - TZ = SZ/ZAEO - DREF = (AOPRMS(11)+AOPRMS(12)*TZ*TZ)*TZ - - ELSE - -* Rigorous algorithm for large ZD - CALL sla_REFRO(ZDO,AOPRMS(5),AOPRMS(6),AOPRMS(7),AOPRMS(8), - : AOPRMS(9),AOPRMS(1),AOPRMS(10),1D-8,DREF) - END IF - - ZDT = ZDO+DREF - -* To Cartesian Az,ZD - CE = SIN(ZDT) - XAET = COS(AZ)*CE - YAET = SIN(AZ)*CE - ZAET = COS(ZDT) - -* Cartesian Az,ZD to Cartesian -HA,Dec - XMHDA = SPHI*XAET+CPHI*ZAET - YMHDA = YAET - ZMHDA = -CPHI*XAET+SPHI*ZAET - -* Diurnal aberration - DIURAB = -AOPRMS(4) - F = (1D0-DIURAB*YMHDA) - V(1) = F*XMHDA - V(2) = F*(YMHDA+DIURAB) - V(3) = F*ZMHDA - -* To spherical -HA,Dec - CALL sla_DCC2S(V,HMA,DAP) - -* Right Ascension - RAP = sla_DRANRM(ST+HMA) - - END diff --git a/src/slalib/obs.f b/src/slalib/obs.f deleted file mode 100644 index cf1ea1ee4..000000000 --- a/src/slalib/obs.f +++ /dev/null @@ -1,951 +0,0 @@ - SUBROUTINE sla_OBS (N, C, NAME, W, P, H) -*+ -* - - - - -* O B S -* - - - - -* -* Parameters of selected groundbased observing stations -* -* Given: -* N int number specifying observing station -* -* Either given or returned -* C c*(*) identifier specifying observing station -* -* Returned: -* NAME c*(*) name of specified observing station -* W dp longitude (radians, West +ve) -* P dp geodetic latitude (radians, North +ve) -* H dp height above sea level (metres) -* -* Notes: -* -* Station identifiers C may be up to 10 characters long, -* and station names NAME may be up to 40 characters long. -* -* C and N are alternative ways of specifying the observing -* station. The C option, which is the most generally useful, -* may be selected by specifying an N value of zero or less. -* If N is 1 or more, the parameters of the Nth station -* in the currently supported list are interrogated, and -* the station identifier C is returned as well as NAME, W, -* P and H. -* -* If the station parameters are not available, either because -* the station identifier C is not recognized, or because an -* N value greater than the number of stations supported is -* given, a name of '?' is returned and C, W, P and H are left -* in their current states. -* -* Programs can obtain a list of all currently supported -* stations by calling the routine repeatedly, with N=1,2,3... -* When NAME='?' is seen, the list of stations has been -* exhausted. -* -* Station numbers, identifiers, names and other details are -* subject to change and should not be hardwired into -* application programs. -* -* All station identifiers C are uppercase only; lowercase -* characters must be converted to uppercase by the calling -* program. The station names returned may contain both upper- -* and lowercase. All characters up to the first space are -* checked; thus an abbreviated ID will return the parameters -* for the first station in the list which matches the -* abbreviation supplied, and no station in the list will ever -* contain embedded spaces. C must not have leading spaces. -* -* IMPORTANT -- BEWARE OF THE LONGITUDE SIGN CONVENTION. The -* longitude returned by sla_OBS is west-positive in accordance -* with astronomical usage. However, this sign convention is -* left-handed and is the opposite of the one used by geographers; -* elsewhere in SLALIB the preferable east-positive convention is -* used. In particular, note that for use in sla_AOP, sla_AOPPA -* and sla_OAP the sign of the longitude must be reversed. -* -* Users are urged to inform the author of any improvements -* they would like to see made. For example: -* -* typographical corrections -* more accurate parameters -* better station identifiers or names -* additional stations -* -* P.T.Wallace Starlink 15 March 2002 -* -* Copyright (C) 2002 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER N - CHARACTER C*(*),NAME*(*) - DOUBLE PRECISION W,P,H - - INTEGER NMAX,M,NS,I - CHARACTER*10 CC - - DOUBLE PRECISION AS2R,WEST,NORTH,EAST,SOUTH - INTEGER ID,IAM - REAL AS - PARAMETER (AS2R=0.484813681109535994D-5) - -* Table of station identifiers - PARAMETER (NMAX=84) - CHARACTER*10 CTAB(NMAX) - DATA CTAB (1) /'AAT '/ - DATA CTAB (2) /'LPO4.2 '/ - DATA CTAB (3) /'LPO2.5 '/ - DATA CTAB (4) /'LPO1 '/ - DATA CTAB (5) /'LICK120 '/ - DATA CTAB (6) /'MMT '/ - DATA CTAB (7) /'DAO72 '/ - DATA CTAB (8) /'DUPONT '/ - DATA CTAB (9) /'MTHOP1.5 '/ - DATA CTAB (10) /'STROMLO74 '/ - DATA CTAB (11) /'ANU2.3 '/ - DATA CTAB (12) /'GBVA140 '/ - DATA CTAB (13) /'TOLOLO4M '/ - DATA CTAB (14) /'TOLOLO1.5M'/ - DATA CTAB (15) /'TIDBINBLA '/ - DATA CTAB (16) /'BLOEMF '/ - DATA CTAB (17) /'BOSQALEGRE'/ - DATA CTAB (18) /'FLAGSTF61 '/ - DATA CTAB (19) /'LOWELL72 '/ - DATA CTAB (20) /'HARVARD '/ - DATA CTAB (21) /'OKAYAMA '/ - DATA CTAB (22) /'KPNO158 '/ - DATA CTAB (23) /'KPNO90 '/ - DATA CTAB (24) /'KPNO84 '/ - DATA CTAB (25) /'KPNO36FT '/ - DATA CTAB (26) /'KOTTAMIA '/ - DATA CTAB (27) /'ESO3.6 '/ - DATA CTAB (28) /'MAUNAK88 '/ - DATA CTAB (29) /'UKIRT '/ - DATA CTAB (30) /'QUEBEC1.6 '/ - DATA CTAB (31) /'MTEKAR '/ - DATA CTAB (32) /'MTLEMMON60'/ - DATA CTAB (33) /'MCDONLD2.7'/ - DATA CTAB (34) /'MCDONLD2.1'/ - DATA CTAB (35) /'PALOMAR200'/ - DATA CTAB (36) /'PALOMAR60 '/ - DATA CTAB (37) /'DUNLAP74 '/ - DATA CTAB (38) /'HPROV1.93 '/ - DATA CTAB (39) /'HPROV1.52 '/ - DATA CTAB (40) /'SANPM83 '/ - DATA CTAB (41) /'SAAO74 '/ - DATA CTAB (42) /'TAUTNBG '/ - DATA CTAB (43) /'CATALINA61'/ - DATA CTAB (44) /'STEWARD90 '/ - DATA CTAB (45) /'USSR6 '/ - DATA CTAB (46) /'ARECIBO '/ - DATA CTAB (47) /'CAMB5KM '/ - DATA CTAB (48) /'CAMB1MILE '/ - DATA CTAB (49) /'EFFELSBERG'/ - DATA CTAB (50) /'GBT '/ - DATA CTAB (51) /'JODRELL1 '/ - DATA CTAB (52) /'PARKES '/ - DATA CTAB (53) /'VLA '/ - DATA CTAB (54) /'SUGARGROVE'/ - DATA CTAB (55) /'USSR600 '/ - DATA CTAB (56) /'NOBEYAMA '/ - DATA CTAB (57) /'JCMT '/ - DATA CTAB (58) /'ESONTT '/ - DATA CTAB (59) /'ST.ANDREWS'/ - DATA CTAB (60) /'APO3.5 '/ - DATA CTAB (61) /'KECK1 '/ - DATA CTAB (62) /'TAUTSCHM '/ - DATA CTAB (63) /'PALOMAR48 '/ - DATA CTAB (64) /'UKST '/ - DATA CTAB (65) /'KISO '/ - DATA CTAB (66) /'ESOSCHM '/ - DATA CTAB (67) /'ATCA '/ - DATA CTAB (68) /'MOPRA '/ - DATA CTAB (69) /'SUBARU '/ - DATA CTAB (70) /'CFHT '/ - DATA CTAB (71) /'KECK2 '/ - DATA CTAB (72) /'GEMININ '/ - DATA CTAB (73) /'FCRAO '/ - DATA CTAB (74) /'IRTF '/ - DATA CTAB (75) /'CSO '/ - DATA CTAB (76) /'VLT1 '/ - DATA CTAB (77) /'VLT2 '/ - DATA CTAB (78) /'VLT3 '/ - DATA CTAB (79) /'VLT4 '/ - DATA CTAB (80) /'GEMINIS '/ - DATA CTAB (81) /'KOSMA3M '/ - DATA CTAB (82) /'MAGELLAN1 '/ - DATA CTAB (83) /'MAGELLAN2 '/ - DATA CTAB (84) /'NRT '/ - -* Degrees, arcminutes, arcseconds to radians - WEST(ID,IAM,AS)=AS2R*(DBLE(60*(60*ID+IAM))+DBLE(AS)) - NORTH(ID,IAM,AS)=WEST(ID,IAM,AS) - EAST(ID,IAM,AS)=-WEST(ID,IAM,AS) - SOUTH(ID,IAM,AS)=-WEST(ID,IAM,AS) - - - - -* Station specified by number or identifier? - IF (N.GT.0) THEN - -* Station specified by number - M=N - IF (M.LE.NMAX) C=CTAB(M) - - ELSE - -* Station specified by identifier: determine corresponding number - CC=C - DO NS=1,NMAX - DO I=1,10 - IF (CC(I:I).EQ.' ') GO TO 5 - IF (CC(I:I).NE.CTAB(NS)(I:I)) GO TO 1 - END DO - GO TO 5 - 1 CONTINUE - END DO - NS=NMAX+1 - 5 CONTINUE - IF (C(1:1).NE.' ') THEN - M=NS - ELSE - M=NMAX+1 - END IF - - END IF - -* -* Return parameters of Mth station -* -------------------------------- - - GO TO (10,20,30,40,50,60,70,80,90,100, - : 110,120,130,140,150,160,170,180,190,200, - : 210,220,230,240,250,260,270,280,290,300, - : 310,320,330,340,350,360,370,380,390,400, - : 410,420,430,440,450,460,470,480,490,500, - : 510,520,530,540,550,560,570,580,590,600, - : 610,620,630,640,650,660,670,680,690,700, - : 710,720,730,740,750,760,770,780,790,800, - : 810,820,830,840) M - GO TO 9000 - -* AAT (Observer's Guide) AAT - 10 CONTINUE - NAME='Anglo-Australian 3.9m Telescope' - W=EAST(149,03,57.91) - P=SOUTH(31,16,37.34) - H=1164D0 - GO TO 9999 - -* WHT (Gemini, April 1987) LPO4.2 - 20 CONTINUE - NAME='William Herschel 4.2m Telescope' - W=WEST(17,52,53.9) - P=NORTH(28,45,38.1) - H=2332D0 - GO TO 9999 - -* INT (Gemini, April 1987) LPO2.5 - 30 CONTINUE - NAME='Isaac Newton 2.5m Telescope' - W=WEST(17,52,39.5) - P=NORTH(28,45,43.2) - H=2336D0 - GO TO 9999 - -* JKT (Gemini, April 1987) LPO1 - 40 CONTINUE - NAME='Jacobus Kapteyn 1m Telescope' - W=WEST(17,52,41.2) - P=NORTH(28,45,39.9) - H=2364D0 - GO TO 9999 - -* Lick 120" (S.L.Allen, private communication, 2002) LICK120 - 50 CONTINUE - NAME='Lick 120 inch' - W=WEST(121,38,13.689) - P=NORTH(37,20,34.931) - H=1286D0 - GO TO 9999 - -* MMT 6.5m conversion (MMT Observatory website) MMT - 60 CONTINUE - NAME='MMT 6.5m, Mt Hopkins' - W=WEST(110,53,04.4) - P=NORTH(31,41,19.6) - H=2608D0 - GO TO 9999 - -* Victoria B.C. 1.85m (1984 Almanac) DAO72 - 70 CONTINUE - NAME='DAO Victoria BC 1.85 metre' - W=WEST(123,25,01.18) - P=NORTH(48,31,11.9) - H=238D0 - GO TO 9999 - -* Las Campanas (1983 Almanac) DUPONT - 80 CONTINUE - NAME='Du Pont 2.5m Telescope, Las Campanas' - W=WEST(70,42,9.) - P=SOUTH(29,00,11.) - H=2280D0 - GO TO 9999 - -* Mt Hopkins 1.5m (1983 Almanac) MTHOP1.5 - 90 CONTINUE - NAME='Mt Hopkins 1.5 metre' - W=WEST(110,52,39.00) - P=NORTH(31,40,51.4) - H=2344D0 - GO TO 9999 - -* Mt Stromlo 74" (1983 Almanac) STROMLO74 - 100 CONTINUE - NAME='Mount Stromlo 74 inch' - W=EAST(149,00,27.59) - P=SOUTH(35,19,14.3) - H=767D0 - GO TO 9999 - -* ANU 2.3m, SSO (Gary Hovey) ANU2.3 - 110 CONTINUE - NAME='Siding Spring 2.3 metre' - W=EAST(149,03,40.3) - P=SOUTH(31,16,24.1) - H=1149D0 - GO TO 9999 - -* Greenbank 140' (1983 Almanac) GBVA140 - 120 CONTINUE - NAME='Greenbank 140 foot' - W=WEST(79,50,09.61) - P=NORTH(38,26,15.4) - H=881D0 - GO TO 9999 - -* Cerro Tololo 4m (1982 Almanac) TOLOLO4M - 130 CONTINUE - NAME='Cerro Tololo 4 metre' - W=WEST(70,48,53.6) - P=SOUTH(30,09,57.8) - H=2235D0 - GO TO 9999 - -* Cerro Tololo 1.5m (1982 Almanac) TOLOLO1.5M - 140 CONTINUE - NAME='Cerro Tololo 1.5 metre' - W=WEST(70,48,54.5) - P=SOUTH(30,09,56.3) - H=2225D0 - GO TO 9999 - -* Tidbinbilla 64m (1982 Almanac) TIDBINBLA - 150 CONTINUE - NAME='Tidbinbilla 64 metre' - W=EAST(148,58,48.20) - P=SOUTH(35,24,14.3) - H=670D0 - GO TO 9999 - -* Bloemfontein 1.52m (1981 Almanac) BLOEMF - 160 CONTINUE - NAME='Bloemfontein 1.52 metre' - W=EAST(26,24,18.) - P=SOUTH(29,02,18.) - H=1387D0 - GO TO 9999 - -* Bosque Alegre 1.54m (1981 Almanac) BOSQALEGRE - 170 CONTINUE - NAME='Bosque Alegre 1.54 metre' - W=WEST(64,32,48.0) - P=SOUTH(31,35,53.) - H=1250D0 - GO TO 9999 - -* USNO 61" astrographic reflector, Flagstaff (1981 Almanac) FLAGSTF61 - 180 CONTINUE - NAME='USNO 61 inch astrograph, Flagstaff' - W=WEST(111,44,23.6) - P=NORTH(35,11,02.5) - H=2316D0 - GO TO 9999 - -* Lowell 72" (1981 Almanac) LOWELL72 - 190 CONTINUE - NAME='Perkins 72 inch, Lowell' - W=WEST(111,32,09.3) - P=NORTH(35,05,48.6) - H=2198D0 - GO TO 9999 - -* Harvard 1.55m (1981 Almanac) HARVARD - 200 CONTINUE - NAME='Harvard College Observatory 1.55m' - W=WEST(71,33,29.32) - P=NORTH(42,30,19.0) - H=185D0 - GO TO 9999 - -* Okayama 1.88m (1981 Almanac) OKAYAMA - 210 CONTINUE - NAME='Okayama 1.88 metre' - W=EAST(133,35,47.29) - P=NORTH(34,34,26.1) - H=372D0 - GO TO 9999 - -* Kitt Peak Mayall 4m (1981 Almanac) KPNO158 - 220 CONTINUE - NAME='Kitt Peak 158 inch' - W=WEST(111,35,57.61) - P=NORTH(31,57,50.3) - H=2120D0 - GO TO 9999 - -* Kitt Peak 90 inch (1981 Almanac) KPNO90 - 230 CONTINUE - NAME='Kitt Peak 90 inch' - W=WEST(111,35,58.24) - P=NORTH(31,57,46.9) - H=2071D0 - GO TO 9999 - -* Kitt Peak 84 inch (1981 Almanac) KPNO84 - 240 CONTINUE - NAME='Kitt Peak 84 inch' - W=WEST(111,35,51.56) - P=NORTH(31,57,29.2) - H=2096D0 - GO TO 9999 - -* Kitt Peak 36 foot (1981 Almanac) KPNO36FT - 250 CONTINUE - NAME='Kitt Peak 36 foot' - W=WEST(111,36,51.12) - P=NORTH(31,57,12.1) - H=1939D0 - GO TO 9999 - -* Kottamia 74" (1981 Almanac) KOTTAMIA - 260 CONTINUE - NAME='Kottamia 74 inch' - W=EAST(31,49,30.) - P=NORTH(29,55,54.) - H=476D0 - GO TO 9999 - -* La Silla 3.6m (1981 Almanac) ESO3.6 - 270 CONTINUE - NAME='ESO 3.6 metre' - W=WEST(70,43,36.) - P=SOUTH(29,15,36.) - H=2428D0 - GO TO 9999 - -* Mauna Kea 88 inch MAUNAK88 -* (IfA website, Richard Wainscoat) - 280 CONTINUE - NAME='Mauna Kea 88 inch' - W=WEST(155,28,09.96) - P=NORTH(19,49,22.77) - H=4213.6D0 - GO TO 9999 - -* UKIRT (IfA website, Richard Wainscoat) UKIRT - 290 CONTINUE - NAME='UK Infra Red Telescope' - W=WEST(155,28,13.18) - P=NORTH(19,49,20.75) - H=4198.5D0 - GO TO 9999 - -* Quebec 1.6m (1981 Almanac) QUEBEC1.6 - 300 CONTINUE - NAME='Quebec 1.6 metre' - W=WEST(71,09,09.7) - P=NORTH(45,27,20.6) - H=1114D0 - GO TO 9999 - -* Mt Ekar 1.82m (1981 Almanac) MTEKAR - 310 CONTINUE - NAME='Mt Ekar 1.82 metre' - W=EAST(11,34,15.) - P=NORTH(45,50,48.) - H=1365D0 - GO TO 9999 - -* Mt Lemmon 60" (1981 Almanac) MTLEMMON60 - 320 CONTINUE - NAME='Mt Lemmon 60 inch' - W=WEST(110,42,16.9) - P=NORTH(32,26,33.9) - H=2790D0 - GO TO 9999 - -* Mt Locke 2.7m (1981 Almanac) MCDONLD2.7 - 330 CONTINUE - NAME='McDonald 2.7 metre' - W=WEST(104,01,17.60) - P=NORTH(30,40,17.7) - H=2075D0 - GO TO 9999 - -* Mt Locke 2.1m (1981 Almanac) MCDONLD2.1 - 340 CONTINUE - NAME='McDonald 2.1 metre' - W=WEST(104,01,20.10) - P=NORTH(30,40,17.7) - H=2075D0 - GO TO 9999 - -* Palomar 200" (1981 Almanac) PALOMAR200 - 350 CONTINUE - NAME='Palomar 200 inch' - W=WEST(116,51,50.) - P=NORTH(33,21,22.) - H=1706D0 - GO TO 9999 - -* Palomar 60" (1981 Almanac) PALOMAR60 - 360 CONTINUE - NAME='Palomar 60 inch' - W=WEST(116,51,31.) - P=NORTH(33,20,56.) - H=1706D0 - GO TO 9999 - -* David Dunlap 74" (1981 Almanac) DUNLAP74 - 370 CONTINUE - NAME='David Dunlap 74 inch' - W=WEST(79,25,20.) - P=NORTH(43,51,46.) - H=244D0 - GO TO 9999 - -* Haute Provence 1.93m (1981 Almanac) HPROV1.93 - 380 CONTINUE - NAME='Haute Provence 1.93 metre' - W=EAST(5,42,46.75) - P=NORTH(43,55,53.3) - H=665D0 - GO TO 9999 - -* Haute Provence 1.52m (1981 Almanac) HPROV1.52 - 390 CONTINUE - NAME='Haute Provence 1.52 metre' - W=EAST(5,42,43.82) - P=NORTH(43,56,00.2) - H=667D0 - GO TO 9999 - -* San Pedro Martir 83" (1981 Almanac) SANPM83 - 400 CONTINUE - NAME='San Pedro Martir 83 inch' - W=WEST(115,27,47.) - P=NORTH(31,02,38.) - H=2830D0 - GO TO 9999 - -* Sutherland 74" (1981 Almanac) SAAO74 - 410 CONTINUE - NAME='Sutherland 74 inch' - W=EAST(20,48,44.3) - P=SOUTH(32,22,43.4) - H=1771D0 - GO TO 9999 - -* Tautenburg 2m (1981 Almanac) TAUTNBG - 420 CONTINUE - NAME='Tautenburg 2 metre' - W=EAST(11,42,45.) - P=NORTH(50,58,51.) - H=331D0 - GO TO 9999 - -* Catalina 61" (1981 Almanac) CATALINA61 - 430 CONTINUE - NAME='Catalina 61 inch' - W=WEST(110,43,55.1) - P=NORTH(32,25,00.7) - H=2510D0 - GO TO 9999 - -* Steward 90" (1981 Almanac) STEWARD90 - 440 CONTINUE - NAME='Steward 90 inch' - W=WEST(111,35,58.24) - P=NORTH(31,57,46.9) - H=2071D0 - GO TO 9999 - -* Russian 6m (1981 Almanac) USSR6 - 450 CONTINUE - NAME='USSR 6 metre' - W=EAST(41,26,30.0) - P=NORTH(43,39,12.) - H=2100D0 - GO TO 9999 - -* Arecibo 1000' (1981 Almanac) ARECIBO - 460 CONTINUE - NAME='Arecibo 1000 foot' - W=WEST(66,45,11.1) - P=NORTH(18,20,36.6) - H=496D0 - GO TO 9999 - -* Cambridge 5km (1981 Almanac) CAMB5KM - 470 CONTINUE - NAME='Cambridge 5km' - W=EAST(0,02,37.23) - P=NORTH(52,10,12.2) - H=17D0 - GO TO 9999 - -* Cambridge 1 mile (1981 Almanac) CAMB1MILE - 480 CONTINUE - NAME='Cambridge 1 mile' - W=EAST(0,02,21.64) - P=NORTH(52,09,47.3) - H=17D0 - GO TO 9999 - -* Bonn 100m (1981 Almanac) EFFELSBERG - 490 CONTINUE - NAME='Effelsberg 100 metre' - W=EAST(6,53,01.5) - P=NORTH(50,31,28.6) - H=366D0 - GO TO 9999 - -* Green Bank Telescop 100m - 500 CONTINUE - NAME='Green Bank Telescope' - W=WEST(79,50,23.406) - P=NORTH(38,25,59.236) - H=880D0 - GO TO 9999 - -* Jodrell Bank Mk 1 (1981 Almanac) JODRELL1 - 510 CONTINUE - NAME='Jodrell Bank 250 foot' - W=WEST(2,18,25.) - P=NORTH(53,14,10.5) - H=78D0 - GO TO 9999 - -* Australia Telescope Parkes Observatory PARKES -* (Peter te Lintel Hekkert) - 520 CONTINUE - NAME='Parkes 64 metre' - W=EAST(148,15,44.3591) - P=SOUTH(32,59,59.8657) - H=391.79D0 - GO TO 9999 - -* VLA (1981 Almanac) VLA - 530 CONTINUE - NAME='Very Large Array' - W=WEST(107,37,03.82) - P=NORTH(34,04,43.5) - H=2124D0 - GO TO 9999 - -* Sugar Grove 150' (1981 Almanac) SUGARGROVE - 540 CONTINUE - NAME='Sugar Grove 150 foot' - W=WEST(79,16,23.) - P=NORTH(38,31,14.) - H=705D0 - GO TO 9999 - -* Russian 600' (1981 Almanac) USSR600 - 550 CONTINUE - NAME='USSR 600 foot' - W=EAST(41,35,25.5) - P=NORTH(43,49,32.) - H=973D0 - GO TO 9999 - -* Nobeyama 45 metre mm dish (based on 1981 Almanac entry) NOBEYAMA - 560 CONTINUE - NAME='Nobeyama 45 metre' - W=EAST(138,29,12.) - P=NORTH(35,56,19.) - H=1350D0 - GO TO 9999 - -* James Clerk Maxwell 15 metre mm telescope, Mauna Kea JCMT -* (IfA website, Richard Wainscoat, height from I.Coulson) - 570 CONTINUE - NAME='JCMT 15 metre' - W=WEST(155,28,37.20) - P=NORTH(19,49,22.11) - H=4111D0 - GO TO 9999 - -* ESO 3.5 metre NTT, La Silla (K.Wirenstrand) ESONTT - 580 CONTINUE - NAME='ESO 3.5 metre NTT' - W=WEST(70,43,07.) - P=SOUTH(29,15,30.) - H=2377D0 - GO TO 9999 - -* St Andrews University Observatory (1982 Almanac) ST.ANDREWS - 590 CONTINUE - NAME='St Andrews' - W=WEST(2,48,52.5) - P=NORTH(56,20,12.) - H=30D0 - GO TO 9999 - -* Apache Point 3.5 metre (R.Owen) APO3.5 - 600 CONTINUE - NAME='Apache Point 3.5m' - W=WEST(105,49,11.56) - P=NORTH(32,46,48.96) - H=2809D0 - GO TO 9999 - -* W.M.Keck Observatory, Telescope 1 KECK1 -* (William Lupton) - 610 CONTINUE - NAME='Keck 10m Telescope #1' - W=WEST(155,28,28.99) - P=NORTH(19,49,33.41) - H=4160D0 - GO TO 9999 - -* Tautenberg Schmidt (1983 Almanac) TAUTSCHM - 620 CONTINUE - NAME='Tautenberg 1.34 metre Schmidt' - W=EAST(11,42,45.0) - P=NORTH(50,58,51.0) - H=331D0 - GO TO 9999 - -* Palomar Schmidt (1981 Almanac) PALOMAR48 - 630 CONTINUE - NAME='Palomar 48-inch Schmidt' - W=WEST(116,51,32.0) - P=NORTH(33,21,26.0) - H=1706D0 - GO TO 9999 - -* UK Schmidt, Siding Spring (1983 Almanac) UKST - 640 CONTINUE - NAME='UK 1.2 metre Schmidt, Siding Spring' - W=EAST(149,04,12.8) - P=SOUTH(31,16,27.8) - H=1145D0 - GO TO 9999 - -* Kiso Schmidt, Japan (1981 Almanac) KISO - 650 CONTINUE - NAME='Kiso 1.05 metre Schmidt, Japan' - W=EAST(137,37,42.2) - P=NORTH(35,47,38.7) - H=1130D0 - GO TO 9999 - -* ESO Schmidt, La Silla (1981 Almanac) ESOSCHM - 660 CONTINUE - NAME='ESO 1 metre Schmidt, La Silla' - W=WEST(70,43,46.5) - P=SOUTH(29,15,25.8) - H=2347D0 - GO TO 9999 - -* Australia Telescope Compact Array ATCA -* (WGS84 coordinates of Station 35, Mark Calabretta) - 670 CONTINUE - NAME='Australia Telescope Compact Array' - W=EAST(149,33,00.500) - P=SOUTH(30,18,46.385) - H=236.9D0 - GO TO 9999 - -* Australia Telescope Mopra Observatory MOPRA -* (Peter te Lintel Hekkert) - 680 CONTINUE - NAME='ATNF Mopra Observatory' - W=EAST(149,05,58.732) - P=SOUTH(31,16,04.451) - H=850D0 - GO TO 9999 - -* Subaru telescope, Mauna Kea SUBARU -* (IfA website, Richard Wainscoat) - 690 CONTINUE - NAME='Subaru 8m telescope' - W=WEST(155,28,33.67) - P=NORTH(19,49,31.81) - H=4163D0 - GO TO 9999 - -* Canada-France-Hawaii Telescope, Mauna Kea CFHT -* (IfA website, Richard Wainscoat) - 700 CONTINUE - NAME='Canada-France-Hawaii 3.6m Telescope' - W=WEST(155,28,07.95) - P=NORTH(19,49,30.91) - H=4204.1D0 - GO TO 9999 - -* W.M.Keck Observatory, Telescope 2 KECK2 -* (William Lupton) - 710 CONTINUE - NAME='Keck 10m Telescope #2' - W=WEST(155,28,27.24) - P=NORTH(19,49,35.62) - H=4159.6D0 - GO TO 9999 - -* Gemini North, Mauna Kea GEMININ -* (IfA website, Richard Wainscoat) - 720 CONTINUE - NAME='Gemini North 8-m telescope' - W=WEST(155,28,08.57) - P=NORTH(19,49,25.69) - H=4213.4D0 - GO TO 9999 - -* Five College Radio Astronomy Observatory FCRAO -* (Tim Jenness) - 730 CONTINUE - NAME='Five College Radio Astronomy Obs' - W=WEST(72,20,42.0) - P=NORTH(42,23,30.0) - H=314D0 - GO TO 9999 - -* NASA Infra Red Telescope Facility IRTF -* (IfA website, Richard Wainscoat) - 740 CONTINUE - NAME='NASA IR Telescope Facility, Mauna Kea' - W=WEST(155,28,19.20) - P=NORTH(19,49,34.39) - H=4168.1D0 - GO TO 9999 - -* Caltech Submillimeter Observatory CSO -* (IfA website, Richard Wainscoat; height estimated) - 750 CONTINUE - NAME='Caltech Sub-mm Observatory, Mauna Kea' - W=WEST(155,28,31.79) - P=NORTH(19,49,20.78) - H=4080D0 - GO TO 9999 - -* ESO VLT, UT1 VLT1 -* (ESO website, VLT Whitebook Chapter 2) - 760 CONTINUE - NAME='ESO VLT, Paranal, Chile: UT1' - W=WEST(70,24,11.642) - P=SOUTH(24,37,33.117) - H=2635.43 - GO TO 9999 - -* ESO VLT, UT2 VLT2 -* (ESO website, VLT Whitebook Chapter 2) - 770 CONTINUE - NAME='ESO VLT, Paranal, Chile: UT2' - W=WEST(70,24,10.855) - P=SOUTH(24,37,31.465) - H=2635.43 - GO TO 9999 - -* ESO VLT, UT3 VLT3 -* (ESO website, VLT Whitebook Chapter 2) - 780 CONTINUE - NAME='ESO VLT, Paranal, Chile: UT3' - W=WEST(70,24,09.896) - P=SOUTH(24,37,30.300) - H=2635.43 - GO TO 9999 - -* ESO VLT, UT4 VLT4 -* (ESO website, VLT Whitebook Chapter 2) - 790 CONTINUE - NAME='ESO VLT, Paranal, Chile: UT4' - W=WEST(70,24,08.000) - P=SOUTH(24,37,31.000) - H=2635.43 - GO TO 9999 - -* Gemini South, Cerro Pachon GEMINIS -* (GPS readings by Patrick Wallace) - 800 CONTINUE - NAME='Gemini South 8-m telescope' - W=WEST(70,44,11.5) - P=SOUTH(30,14,26.7) - H=2738D0 - GO TO 9999 - -* Cologne Observatory for Submillimeter Astronomy (KOSMA) KOSMA3M -* (Holger Jakob) - 810 CONTINUE - NAME='KOSMA 3m telescope, Gornergrat' - W=EAST(7,47,3.48) - P=NORTH(45,58,59.772) - H=3141D0 - GO TO 9999 - -* Magellan 1, 6.5m telescope at Las Campanas, Chile MAGELLAN1 -* (Skip Schaller) - 820 CONTINUE - NAME='Magellan 1, 6.5m, Las Campanas' - W=WEST(70,41,31.9) - P=SOUTH(29,00,51.7) - H=2408D0 - GO TO 9999 - -* Magellan 2, 6.5m telescope at Las Campanas, Chile MAGELLAN2 -* (Skip Schaller) - 830 CONTINUE - NAME='Magellan 2, 6.5m, Las Campanas' - W=WEST(70,41,33.5) - P=SOUTH(29,00,50.3) - H=2408D0 - GO TO 9999 - -* Nancay Radio Telescope, France, 94m equivalent NRT - 840 CONTINUE - NAME='Nancay Radio Telescope, France, 94m equivalent' - W=EAST(2,11,50.92) - P=NORTH(47,22,24.97) - H=191.0 - GO TO 9999 - -* Unrecognized station - 9000 CONTINUE - NAME='?' - -* Exit - 9999 CONTINUE - - END diff --git a/src/slalib/pa.f b/src/slalib/pa.f deleted file mode 100644 index 367c4a5ab..000000000 --- a/src/slalib/pa.f +++ /dev/null @@ -1,63 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_PA (HA, DEC, PHI) -*+ -* - - - -* P A -* - - - -* -* HA, Dec to Parallactic Angle (double precision) -* -* Given: -* HA d hour angle in radians (geocentric apparent) -* DEC d declination in radians (geocentric apparent) -* PHI d observatory latitude in radians (geodetic) -* -* The result is in the range -pi to +pi -* -* Notes: -* -* 1) The parallactic angle at a point in the sky is the position -* angle of the vertical, i.e. the angle between the direction to -* the pole and to the zenith. In precise applications care must -* be taken only to use geocentric apparent HA,Dec and to consider -* separately the effects of atmospheric refraction and telescope -* mount errors. -* -* 2) At the pole a zero result is returned. -* -* P.T.Wallace Starlink 16 August 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION HA,DEC,PHI - - DOUBLE PRECISION CP,SQSZ,CQSZ - - - - CP=COS(PHI) - SQSZ=CP*SIN(HA) - CQSZ=SIN(PHI)*COS(DEC)-CP*SIN(DEC)*COS(HA) - IF (SQSZ.EQ.0D0.AND.CQSZ.EQ.0D0) CQSZ=1D0 - sla_PA=ATAN2(SQSZ,CQSZ) - - END diff --git a/src/slalib/pav.f b/src/slalib/pav.f deleted file mode 100644 index 5fe7c3b1d..000000000 --- a/src/slalib/pav.f +++ /dev/null @@ -1,70 +0,0 @@ - REAL FUNCTION sla_PAV ( V1, V2 ) -*+ -* - - - - -* P A V -* - - - - -* -* Position angle of one celestial direction with respect to another. -* -* (single precision) -* -* Given: -* V1 r(3) direction cosines of one point -* V2 r(3) direction cosines of the other point -* -* (The coordinate frames correspond to RA,Dec, Long,Lat etc.) -* -* The result is the bearing (position angle), in radians, of point -* V2 with respect to point V1. It is in the range +/- pi. The -* sense is such that if V2 is a small distance east of V1, the -* bearing is about +pi/2. Zero is returned if the two points -* are coincident. -* -* V1 and V2 do not have to be unit vectors. -* -* The routine sla_BEAR performs an equivalent function except -* that the points are specified in the form of spherical -* coordinates. -* -* Called: sla_DPAV -* -* Last revision: 11 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL V1(3), V2(3) - - INTEGER I - DOUBLE PRECISION D1(3), D2(3) - - DOUBLE PRECISION sla_DPAV - - -* Call the double precision version. - DO I=1,3 - D1(I) = V1(I) - D2(I) = V2(I) - END DO - sla_PAV = REAL(sla_DPAV(D1,D2)) - - END diff --git a/src/slalib/pcd.f b/src/slalib/pcd.f deleted file mode 100644 index 46d8a2699..000000000 --- a/src/slalib/pcd.f +++ /dev/null @@ -1,76 +0,0 @@ - SUBROUTINE sla_PCD (DISCO,X,Y) -*+ -* - - - - -* P C D -* - - - - -* -* Apply pincushion/barrel distortion to a tangent-plane [x,y]. -* -* Given: -* DISCO d pincushion/barrel distortion coefficient -* X,Y d tangent-plane coordinates -* -* Returned: -* X,Y d distorted coordinates -* -* Notes: -* -* 1) The distortion is of the form RP = R*(1 + C*R**2), where R is -* the radial distance from the tangent point, C is the DISCO -* argument, and RP is the radial distance in the presence of -* the distortion. -* -* 2) For pincushion distortion, C is +ve; for barrel distortion, -* C is -ve. -* -* 3) For X,Y in units of one projection radius (in the case of -* a photographic plate, the focal length), the following -* DISCO values apply: -* -* Geometry DISCO -* -* astrograph 0.0 -* Schmidt -0.3333 -* AAT PF doublet +147.069 -* AAT PF triplet +178.585 -* AAT f/8 +21.20 -* JKT f/8 +13.32 -* -* 4) There is a companion routine, sla_UNPCD, which performs the -* inverse operation. -* -* P.T.Wallace Starlink 3 September 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DISCO,X,Y - - DOUBLE PRECISION F - - - - F=1D0+DISCO*(X*X+Y*Y) - X=X*F - Y=Y*F - - END diff --git a/src/slalib/pda2h.f b/src/slalib/pda2h.f deleted file mode 100644 index c0600ddf2..000000000 --- a/src/slalib/pda2h.f +++ /dev/null @@ -1,117 +0,0 @@ - SUBROUTINE sla_PDA2H (P, D, A, H1, J1, H2, J2) -*+ -* - - - - - - -* P D A 2 H -* - - - - - - -* -* Hour Angle corresponding to a given azimuth -* -* (double precision) -* -* Given: -* P d latitude -* D d declination -* A d azimuth -* -* Returned: -* H1 d hour angle: first solution if any -* J1 i flag: 0 = solution 1 is valid -* H2 d hour angle: second solution if any -* J2 i flag: 0 = solution 2 is valid -* -* Called: sla_DRANGE -* -* P.T.Wallace Starlink 6 October 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION P,D,A,H1 - INTEGER J1 - DOUBLE PRECISION H2 - INTEGER J2 - - DOUBLE PRECISION DPI - PARAMETER (DPI=3.141592653589793238462643D0) - DOUBLE PRECISION D90 - PARAMETER (D90=DPI/2D0) - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-12) - DOUBLE PRECISION PN,AN,DN,SA,CA,SASP,QT,QB,HPT,T - DOUBLE PRECISION sla_DRANGE - - -* Preset status flags to OK - J1=0 - J2=0 - -* Adjust latitude, azimuth, declination to avoid critical values - PN=sla_DRANGE(P) - IF (ABS(ABS(PN)-D90).LT.TINY) THEN - PN=PN-SIGN(TINY,PN) - ELSE IF (ABS(PN).LT.TINY) THEN - PN=TINY - END IF - AN=sla_DRANGE(A) - IF (ABS(ABS(AN)-DPI).LT.TINY) THEN - AN=AN-SIGN(TINY,AN) - ELSE IF (ABS(AN).LT.TINY) THEN - AN=TINY - END IF - DN=sla_DRANGE(D) - IF (ABS(ABS(DN)-ABS(P)).LT.TINY) THEN - DN=DN-SIGN(TINY,DN) - ELSE IF (ABS(ABS(DN)-D90).LT.TINY) THEN - DN=DN-SIGN(TINY,DN) - ELSE IF (ABS(DN).LT.TINY) THEN - DN=TINY - END IF - -* Useful functions - SA=SIN(AN) - CA=COS(AN) - SASP=SA*SIN(PN) - -* Quotient giving sin(h+t) - QT=SIN(DN)*SA*COS(PN) - QB=COS(DN)*SQRT(CA*CA+SASP*SASP) - -* Any solutions? - IF (ABS(QT).LE.QB) THEN - -* Yes: find h+t and t - HPT=ASIN(QT/QB) - T=ATAN2(SASP,-CA) - -* The two solutions - H1=sla_DRANGE(HPT-T) - H2=sla_DRANGE(-HPT-(T+DPI)) - -* Reject unless h and A different signs - IF (H1*AN.GT.0D0) J1=-1 - IF (H2*AN.GT.0D0) J2=-1 - ELSE - J1=-1 - J2=-1 - END IF - - END diff --git a/src/slalib/pdq2h.f b/src/slalib/pdq2h.f deleted file mode 100644 index 0f565bd3d..000000000 --- a/src/slalib/pdq2h.f +++ /dev/null @@ -1,115 +0,0 @@ - SUBROUTINE sla_PDQ2H (P, D, Q, H1, J1, H2, J2) -*+ -* - - - - - - -* P D Q 2 H -* - - - - - - -* -* Hour Angle corresponding to a given parallactic angle -* -* (double precision) -* -* Given: -* P d latitude -* D d declination -* Q d parallactic angle -* -* Returned: -* H1 d hour angle: first solution if any -* J1 i flag: 0 = solution 1 is valid -* H2 d hour angle: second solution if any -* J2 i flag: 0 = solution 2 is valid -* -* Called: sla_DRANGE -* -* P.T.Wallace Starlink 6 October 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION P,D,Q,H1 - INTEGER J1 - DOUBLE PRECISION H2 - INTEGER J2 - - DOUBLE PRECISION DPI - PARAMETER (DPI=3.141592653589793238462643D0) - DOUBLE PRECISION D90 - PARAMETER (D90=DPI/2D0) - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-12) - DOUBLE PRECISION PN,QN,DN,SQ,CQ,SQSD,QT,QB,HPT,T - DOUBLE PRECISION sla_DRANGE - - -* Preset status flags to OK - J1=0 - J2=0 - -* Adjust latitude, declination, parallactic angle to avoid critical values - PN=sla_DRANGE(P) - IF (ABS(ABS(PN)-D90).LT.TINY) THEN - PN=PN-SIGN(TINY,PN) - ELSE IF (ABS(PN).LT.TINY) THEN - PN=TINY - END IF - QN=sla_DRANGE(Q) - IF (ABS(ABS(QN)-DPI).LT.TINY) THEN - QN=QN-SIGN(TINY,QN) - ELSE IF (ABS(QN).LT.TINY) THEN - QN=TINY - END IF - DN=sla_DRANGE(D) - IF (ABS(ABS(D)-ABS(P)).LT.TINY) THEN - DN=DN-SIGN(TINY,DN) - ELSE IF (ABS(ABS(D)-D90).LT.TINY) THEN - DN=DN-SIGN(TINY,DN) - END IF - -* Useful functions - SQ=SIN(QN) - CQ=COS(QN) - SQSD=SQ*SIN(DN) - -* Quotient giving sin(h+t) - QT=SIN(PN)*SQ*COS(DN) - QB=COS(PN)*SQRT(CQ*CQ+SQSD*SQSD) - -* Any solutions? - IF (ABS(QT).LE.QB) THEN - -* Yes: find h+t and t - HPT=ASIN(QT/QB) - T=ATAN2(SQSD,CQ) - -* The two solutions - H1=sla_DRANGE(HPT-T) - H2=sla_DRANGE(-HPT-(T+DPI)) - -* Reject if h and Q different signs - IF (H1*QN.LT.0D0) J1=-1 - IF (H2*QN.LT.0D0) J2=-1 - ELSE - J1=-1 - J2=-1 - END IF - - END diff --git a/src/slalib/permut.f b/src/slalib/permut.f deleted file mode 100644 index df686ef29..000000000 --- a/src/slalib/permut.f +++ /dev/null @@ -1,159 +0,0 @@ - SUBROUTINE sla_PERMUT ( N, ISTATE, IORDER, J ) -*+ -* - - - - - - - -* P E R M U T -* - - - - - - - -* -* Generate the next permutation of a specified number of items. -* -* Given: -* N i number of items: there will be N! permutations -* -* Given and returned: -* ISTATE i(N) state, ISTATE(1)=-1 to initialize -* -* Returned: -* IORDER i(N) next permutation of numbers 1,2,...,N -* J i status: -1 = illegal N (zero or less is illegal) -* 0 = OK -* +1 = no more permutations available -* -* Notes: -* -* 1) This routine returns, in the IORDER array, the integers 1 to N -* inclusive, in an order that depends on the current contents of -* the ISTATE array. Before calling the routine for the first -* time, the caller must set the first element of the ISTATE array -* to -1 (any negative number will do) to cause the ISTATE array -* to be fully initialized. -* -* 2) The first permutation to be generated is: -* -* IORDER(1)=N, IORDER(2)=N-1, ..., IORDER(N)=1 -* -* This is also the permutation returned for the "finished" -* (J=1) case. -* -* The final permutation to be generated is: -* -* IORDER(1)=1, IORDER(2)=2, ..., IORDER(N)=N -* -* 3) If the "finished" (J=1) status is ignored, the routine continues -* to deliver permutations, the pattern repeating every N! calls. -* -* Last revision: 19 February 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER N,IORDER(N),ISTATE(N),J - - INTEGER I,IP1,ISLOT,ISKIP - - -* ------------- -* Preliminaries -* ------------- - -* Validate, and set status. - IF (N.LT.1) THEN - J = -1 - GO TO 9999 - ELSE - J = 0 - END IF - -* If just starting, initialize state array - IF (ISTATE(1).LT.0) THEN - ISTATE(1) = -1 - DO I=2,N - ISTATE(I) = 0 - END DO - END IF - -* -------------------------- -* Increment the state number -* -------------------------- - -* The state number, maintained in the ISTATE array, is a mixed-radix -* number with N! states. The least significant digit, with a radix of -* 1, is in ISTATE(1). The next digit, in ISTATE(2), has a radix of 2, -* and so on. - -* Increment the least-significant digit of the state number. - ISTATE(1) = ISTATE(1)+1 - -* Digit by digit starting with the least significant. - DO I=1,N - -* Carry? - IF (ISTATE(I).GE.I) THEN - -* Yes: reset the current digit. - ISTATE(I) = 0 - -* Overflow? - IF (I.GE.N) THEN - -* Yes: there are no more permutations. - J = 1 - ELSE - -* No: carry. - IP1 = I+1 - ISTATE(IP1) = ISTATE(IP1)+1 - END IF - END IF - END DO - -* ------------------------------------------------------------------- -* Translate the state number into the corresponding permutation order -* ------------------------------------------------------------------- - -* Initialize the order array. All but one element will be overwritten. - DO I=1,N - IORDER(I) = 1 - END DO - -* Look at each state number digit, starting with the most significant. - DO I=N,2,-1 - -* Initialize the position where the new number will go. - ISLOT = 0 - -* The state number digit says which unfilled slot is to be used. - DO ISKIP=0,ISTATE(I) - -* Increment the slot number until an unused slot is found. - ISLOT = ISLOT+1 - DO WHILE (IORDER(ISLOT).GT.1) - ISLOT = ISLOT+1 - END DO - END DO - -* Store the number in the permutation order array. - IORDER(ISLOT) = I - END DO - - 9999 CONTINUE - - END diff --git a/src/slalib/pertel.f b/src/slalib/pertel.f deleted file mode 100644 index 5cd46f58b..000000000 --- a/src/slalib/pertel.f +++ /dev/null @@ -1,181 +0,0 @@ - SUBROUTINE sla_PERTEL (JFORM, DATE0, DATE1, - : EPOCH0, ORBI0, ANODE0, PERIH0, AORQ0, E0, AM0, - : EPOCH1, ORBI1, ANODE1, PERIH1, AORQ1, E1, AM1, - : JSTAT) -*+ -* - - - - - - - -* P E R T E L -* - - - - - - - -* -* Update the osculating orbital elements of an asteroid or comet by -* applying planetary perturbations. -* -* Given (format and dates): -* JFORM i choice of element set (2 or 3; Note 1) -* DATE0 d date of osculation (TT MJD) for the given elements -* DATE1 d date of osculation (TT MJD) for the updated elements -* -* Given (the unperturbed elements): -* EPOCH0 d epoch (TT MJD) of the given element set (Note 2) -* ORBI0 d inclination (radians) -* ANODE0 d longitude of the ascending node (radians) -* PERIH0 d argument of perihelion (radians) -* AORQ0 d mean distance or perihelion distance (AU) -* E0 d eccentricity -* AM0 d mean anomaly (radians, JFORM=2 only) -* -* Returned (the updated elements): -* EPOCH1 d epoch (TT MJD) of the updated element set (Note 2) -* ORBI1 d inclination (radians) -* ANODE1 d longitude of the ascending node (radians) -* PERIH1 d argument of perihelion (radians) -* AORQ1 d mean distance or perihelion distance (AU) -* E1 d eccentricity -* AM1 d mean anomaly (radians, JFORM=2 only) -* -* Returned (status flag): -* JSTAT i status: +102 = warning, distant epoch -* +101 = warning, large timespan ( > 100 years) -* +1 to +10 = coincident with planet (Note 6) -* 0 = OK -* -1 = illegal JFORM -* -2 = illegal E0 -* -3 = illegal AORQ0 -* -4 = internal error -* -5 = numerical error -* -* Notes: -* -* 1 Two different element-format options are available: -* -* Option JFORM=2, suitable for minor planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBI = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e -* AM = mean anomaly M (radians) -* -* Option JFORM=3, suitable for comets: -* -* EPOCH = epoch of perihelion (TT MJD) -* ORBI = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = perihelion distance, q (AU) -* E = eccentricity, e -* -* 2 DATE0, DATE1, EPOCH0 and EPOCH1 are all instants of time in -* the TT timescale (formerly Ephemeris Time, ET), expressed -* as Modified Julian Dates (JD-2400000.5). -* -* DATE0 is the instant at which the given (i.e. unperturbed) -* osculating elements are correct. -* -* DATE1 is the specified instant at which the updated osculating -* elements are correct. -* -* EPOCH0 and EPOCH1 will be the same as DATE0 and DATE1 -* (respectively) for the JFORM=2 case, normally used for minor -* planets. For the JFORM=3 case, the two epochs will refer to -* perihelion passage and so will not, in general, be the same as -* DATE0 and/or DATE1 though they may be similar to one another. -* -* 3 The elements are with respect to the J2000 ecliptic and equinox. -* -* 4 Unused elements (AM0 and AM1 for JFORM=3) are not accessed. -* -* 5 See the sla_PERTUE routine for details of the algorithm used. -* -* 6 This routine is not intended to be used for major planets, which -* is why JFORM=1 is not available and why there is no opportunity -* to specify either the longitude of perihelion or the daily -* motion. However, if JFORM=2 elements are somehow obtained for a -* major planet and supplied to the routine, sensible results will, -* in fact, be produced. This happens because the sla_PERTUE routine -* that is called to perform the calculations checks the separation -* between the body and each of the planets and interprets a -* suspiciously small value (0.001 AU) as an attempt to apply it to -* the planet concerned. If this condition is detected, the -* contribution from that planet is ignored, and the status is set to -* the planet number (1-10 = Mercury, Venus, EMB, Mars, Jupiter, -* Saturn, Uranus, Neptune, Earth, Moon) as a warning. -* -* Reference: -* -* Sterne, Theodore E., "An Introduction to Celestial Mechanics", -* Interscience Publishers Inc., 1960. Section 6.7, p199. -* -* Called: sla_EL2UE, sla_PERTUE, sla_UE2EL -* -* This revision: 19 June 2004 -* -* Copyright (C) 2004 P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - INTEGER JFORM - DOUBLE PRECISION DATE0,DATE1, - : EPOCH0,ORBI0,ANODE0,PERIH0,AORQ0,E0,AM0, - : EPOCH1,ORBI1,ANODE1,PERIH1,AORQ1,E1,AM1 - INTEGER JSTAT - - DOUBLE PRECISION U(13),DM - INTEGER J,JF - - - -* Check that the elements are either minor-planet or comet format. - IF (JFORM.LT.2.OR.JFORM.GT.3) THEN - JSTAT = -1 - GO TO 9999 - ELSE - -* Provisionally set the status to OK. - JSTAT = 0 - END IF - -* Transform the elements from conventional to universal form. - CALL sla_EL2UE(DATE0,JFORM,EPOCH0,ORBI0,ANODE0,PERIH0, - : AORQ0,E0,AM0,0D0,U,J) - IF (J.NE.0) THEN - JSTAT = J - GO TO 9999 - END IF - -* Update the universal elements. - CALL sla_PERTUE(DATE1,U,J) - IF (J.GT.0) THEN - JSTAT = J - ELSE IF (J.LT.0) THEN - JSTAT = -5 - GO TO 9999 - END IF - -* Transform from universal to conventional elements. - CALL sla_UE2EL(U,JFORM, - : JF, EPOCH1, ORBI1, ANODE1, PERIH1, - : AORQ1, E1, AM1, DM, J) - IF (JF.NE.JFORM.OR.J.NE.0) JSTAT=-5 - - 9999 CONTINUE - END diff --git a/src/slalib/pertue.f b/src/slalib/pertue.f deleted file mode 100644 index de775d5f3..000000000 --- a/src/slalib/pertue.f +++ /dev/null @@ -1,642 +0,0 @@ - SUBROUTINE sla_PERTUE (DATE, U, JSTAT) -*+ -* - - - - - - - -* P E R T U E -* - - - - - - - -* -* Update the universal elements of an asteroid or comet by applying -* planetary perturbations. -* -* Given: -* DATE d final epoch (TT MJD) for the updated elements -* -* Given and returned: -* U d(13) universal elements (updated in place) -* -* (1) combined mass (M+m) -* (2) total energy of the orbit (alpha) -* (3) reference (osculating) epoch (t0) -* (4-6) position at reference epoch (r0) -* (7-9) velocity at reference epoch (v0) -* (10) heliocentric distance at reference epoch -* (11) r0.v0 -* (12) date (t) -* (13) universal eccentric anomaly (psi) of date, approx -* -* Returned: -* JSTAT i status: -* +102 = warning, distant epoch -* +101 = warning, large timespan ( > 100 years) -* +1 to +10 = coincident with major planet (Note 5) -* 0 = OK -* -1 = numerical error -* -* Called: sla_EPJ, sla_PLANET, sla_PV2UE, sla_UE2PV, sla_EPV, -* sla_PREC, sla_DMOON, sla_DMXV -* -* Notes: -* -* 1 The "universal" elements are those which define the orbit for the -* purposes of the method of universal variables (see reference 2). -* They consist of the combined mass of the two bodies, an epoch, -* and the position and velocity vectors (arbitrary reference frame) -* at that epoch. The parameter set used here includes also various -* quantities that can, in fact, be derived from the other -* information. This approach is taken to avoiding unnecessary -* computation and loss of accuracy. The supplementary quantities -* are (i) alpha, which is proportional to the total energy of the -* orbit, (ii) the heliocentric distance at epoch, (iii) the -* outwards component of the velocity at the given epoch, (iv) an -* estimate of psi, the "universal eccentric anomaly" at a given -* date and (v) that date. -* -* 2 The universal elements are with respect to the J2000 equator and -* equinox. -* -* 3 The epochs DATE, U(3) and U(12) are all Modified Julian Dates -* (JD-2400000.5). -* -* 4 The algorithm is a simplified form of Encke's method. It takes as -* a basis the unperturbed motion of the body, and numerically -* integrates the perturbing accelerations from the major planets. -* The expression used is essentially Sterne's 6.7-2 (reference 1). -* Everhart and Pitkin (reference 2) suggest rectifying the orbit at -* each integration step by propagating the new perturbed position -* and velocity as the new universal variables. In the present -* routine the orbit is rectified less frequently than this, in order -* to gain a slight speed advantage. However, the rectification is -* done directly in terms of position and velocity, as suggested by -* Everhart and Pitkin, bypassing the use of conventional orbital -* elements. -* -* The f(q) part of the full Encke method is not used. The purpose -* of this part is to avoid subtracting two nearly equal quantities -* when calculating the "indirect member", which takes account of the -* small change in the Sun's attraction due to the slightly displaced -* position of the perturbed body. A simpler, direct calculation in -* double precision proves to be faster and not significantly less -* accurate. -* -* Apart from employing a variable timestep, and occasionally -* "rectifying the orbit" to keep the indirect member small, the -* integration is done in a fairly straightforward way. The -* acceleration estimated for the middle of the timestep is assumed -* to apply throughout that timestep; it is also used in the -* extrapolation of the perturbations to the middle of the next -* timestep, to predict the new disturbed position. There is no -* iteration within a timestep. -* -* Measures are taken to reach a compromise between execution time -* and accuracy. The starting-point is the goal of achieving -* arcsecond accuracy for ordinary minor planets over a ten-year -* timespan. This goal dictates how large the timesteps can be, -* which in turn dictates how frequently the unperturbed motion has -* to be recalculated from the osculating elements. -* -* Within predetermined limits, the timestep for the numerical -* integration is varied in length in inverse proportion to the -* magnitude of the net acceleration on the body from the major -* planets. -* -* The numerical integration requires estimates of the major-planet -* motions. Approximate positions for the major planets (Pluto -* alone is omitted) are obtained from the routine sla_PLANET. Two -* levels of interpolation are used, to enhance speed without -* significantly degrading accuracy. At a low frequency, the routine -* sla_PLANET is called to generate updated position+velocity "state -* vectors". The only task remaining to be carried out at the full -* frequency (i.e. at each integration step) is to use the state -* vectors to extrapolate the planetary positions. In place of a -* strictly linear extrapolation, some allowance is made for the -* curvature of the orbit by scaling back the radius vector as the -* linear extrapolation goes off at a tangent. -* -* Various other approximations are made. For example, perturbations -* by Pluto and the minor planets are neglected and relativistic -* effects are not taken into account. -* -* In the interests of simplicity, the background calculations for -* the major planets are carried out en masse. The mean elements and -* state vectors for all the planets are refreshed at the same time, -* without regard for orbit curvature, mass or proximity. -* -* The Earth-Moon system is treated as a single body when the body is -* distant but as separate bodies when closer to the EMB than the -* parameter RNE, which incurs a time penalty but improves accuracy -* for near-Earth objects. -* -* 5 This routine is not intended to be used for major planets. -* However, if major-planet elements are supplied, sensible results -* will, in fact, be produced. This happens because the routine -* checks the separation between the body and each of the planets and -* interprets a suspiciously small value (0.001 AU) as an attempt to -* apply the routine to the planet concerned. If this condition is -* detected, the contribution from that planet is ignored, and the -* status is set to the planet number (1-10 = Mercury, Venus, EMB, -* Mars, Jupiter, Saturn, Uranus, Neptune, Earth, Moon) as a warning. -* -* References: -* -* 1 Sterne, Theodore E., "An Introduction to Celestial Mechanics", -* Interscience Publishers Inc., 1960. Section 6.7, p199. -* -* 2 Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983. -* -* Last revision: 27 December 2004 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - DOUBLE PRECISION DATE,U(13) - INTEGER JSTAT - -* Distance from EMB at which Earth and Moon are treated separately - DOUBLE PRECISION RNE - PARAMETER (RNE=1D0) - -* Coincidence with major planet distance - DOUBLE PRECISION COINC - PARAMETER (COINC=0.0001D0) - -* Coefficient relating timestep to perturbing force - DOUBLE PRECISION TSC - PARAMETER (TSC=1D-4) - -* Minimum and maximum timestep (days) - DOUBLE PRECISION TSMIN,TSMAX - PARAMETER (TSMIN=0.01D0,TSMAX=10D0) - -* Age limit for major-planet state vector (days) - DOUBLE PRECISION AGEPMO - PARAMETER (AGEPMO=5D0) - -* Age limit for major-planet mean elements (days) - DOUBLE PRECISION AGEPEL - PARAMETER (AGEPEL=50D0) - -* Margin for error when deciding whether to renew the planetary data - DOUBLE PRECISION TINY - PARAMETER (TINY=1D-6) - -* Age limit for the body's osculating elements (before rectification) - DOUBLE PRECISION AGEBEL - PARAMETER (AGEBEL=100D0) - -* Gaussian gravitational constant (exact) and square - DOUBLE PRECISION GCON,GCON2 - PARAMETER (GCON=0.01720209895D0,GCON2=GCON*GCON) - -* The final epoch - DOUBLE PRECISION TFINAL - -* The body's current universal elements - DOUBLE PRECISION UL(13) - -* Current reference epoch - DOUBLE PRECISION T0 - -* Timespan from latest orbit rectification to final epoch (days) - DOUBLE PRECISION TSPAN - -* Time left to go before integration is complete - DOUBLE PRECISION TLEFT - -* Time direction flag: +1=forwards, -1=backwards - DOUBLE PRECISION FB - -* First-time flag - LOGICAL FIRST - -* -* The current perturbations -* -* Epoch (days relative to current reference epoch) - DOUBLE PRECISION RTN -* Position (AU) - DOUBLE PRECISION PERP(3) -* Velocity (AU/d) - DOUBLE PRECISION PERV(3) -* Acceleration (AU/d/d) - DOUBLE PRECISION PERA(3) -* - -* Length of current timestep (days), and half that - DOUBLE PRECISION TS,HTS - -* Epoch of middle of timestep - DOUBLE PRECISION T - -* Epoch of planetary mean elements - DOUBLE PRECISION TPEL - -* Planet number (1=Mercury, 2=Venus, 3=EMB...8=Neptune) - INTEGER NP - -* Planetary universal orbital elements - DOUBLE PRECISION UP(13,8) - -* Epoch of planetary state vectors - DOUBLE PRECISION TPMO - -* State vectors for the major planets (AU,AU/s) - DOUBLE PRECISION PVIN(6,8) - -* Earth velocity and position vectors (AU,AU/s) - DOUBLE PRECISION VB(3),PB(3),VH(3),PE(3) - -* Moon geocentric state vector (AU,AU/s) and position part - DOUBLE PRECISION PVM(6),PM(3) - -* Date to J2000 de-precession matrix - DOUBLE PRECISION PMAT(3,3) - -* -* Correction terms for extrapolated major planet vectors -* -* Sun-to-planet distances squared multiplied by 3 - DOUBLE PRECISION R2X3(8) -* Sunward acceleration terms, G/2R^3 - DOUBLE PRECISION GC(8) -* Tangential-to-circular correction factor - DOUBLE PRECISION FC -* Radial correction factor due to Sunwards acceleration - DOUBLE PRECISION FG -* - -* The body's unperturbed and perturbed state vectors (AU,AU/s) - DOUBLE PRECISION PV0(6),PV(6) - -* The body's perturbed and unperturbed heliocentric distances (AU) cubed - DOUBLE PRECISION R03,R3 - -* The perturbating accelerations, indirect and direct - DOUBLE PRECISION FI(3),FD(3) - -* Sun-to-planet vector, and distance cubed - DOUBLE PRECISION RHO(3),RHO3 - -* Body-to-planet vector, and distance cubed - DOUBLE PRECISION DELTA(3),DELTA3 - -* Miscellaneous - INTEGER I,J - DOUBLE PRECISION R2,W,DT,DT2,R,FT - LOGICAL NE - - DOUBLE PRECISION sla_EPJ - -* Planetary inverse masses, Mercury through Neptune then Earth and Moon - DOUBLE PRECISION AMAS(10) - DATA AMAS / 6023600D0, 408523.5D0, 328900.5D0, 3098710D0, - : 1047.355D0, 3498.5D0, 22869D0, 19314D0, - : 332946.038D0, 27068709D0 / - -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*----------------------------------------------------------------------* - - -* Preset the status to OK. - JSTAT = 0 - -* Copy the final epoch. - TFINAL = DATE - -* Copy the elements (which will be periodically updated). - DO I=1,13 - UL(I) = U(I) - END DO - -* Initialize the working reference epoch. - T0=UL(3) - -* Total timespan (days) and hence time left. - TSPAN = TFINAL-T0 - TLEFT = TSPAN - -* Warn if excessive. - IF (ABS(TSPAN).GT.36525D0) JSTAT=101 - -* Time direction: +1 for forwards, -1 for backwards. - FB = SIGN(1D0,TSPAN) - -* Initialize relative epoch for start of current timestep. - RTN = 0D0 - -* Reset the perturbations (position, velocity, acceleration). - DO I=1,3 - PERP(I) = 0D0 - PERV(I) = 0D0 - PERA(I) = 0D0 - END DO - -* Set "first iteration" flag. - FIRST = .TRUE. - -* Step through the time left. - DO WHILE (FB*TLEFT.GT.0D0) - -* Magnitude of current acceleration due to planetary attractions. - IF (FIRST) THEN - TS = TSMIN - ELSE - R2 = 0D0 - DO I=1,3 - W = FD(I) - R2 = R2+W*W - END DO - W = SQRT(R2) - -* Use the acceleration to decide how big a timestep can be tolerated. - IF (W.NE.0D0) THEN - TS = MIN(TSMAX,MAX(TSMIN,TSC/W)) - ELSE - TS = TSMAX - END IF - END IF - TS = TS*FB - -* Override if final epoch is imminent. - TLEFT = TSPAN-RTN - IF (ABS(TS).GT.ABS(TLEFT)) TS=TLEFT - -* Epoch of middle of timestep. - HTS = TS/2D0 - T = T0+RTN+HTS - -* Is it time to recompute the major-planet elements? - IF (FIRST.OR.ABS(T-TPEL)-AGEPEL.GE.TINY) THEN - -* Yes: go forward in time by just under the maximum allowed. - TPEL = T+FB*AGEPEL - -* Compute the state vector for the new epoch. - DO NP=1,8 - CALL sla_PLANET(TPEL,NP,PV,J) - -* Warning if remote epoch, abort if error. - IF (J.EQ.1) THEN - JSTAT = 102 - ELSE IF (J.NE.0) THEN - GO TO 9010 - END IF - -* Transform the vector into universal elements. - CALL sla_PV2UE(PV,TPEL,0D0,UP(1,NP),J) - IF (J.NE.0) GO TO 9010 - END DO - END IF - -* Is it time to recompute the major-planet motions? - IF (FIRST.OR.ABS(T-TPMO)-AGEPMO.GE.TINY) THEN - -* Yes: look ahead. - TPMO = T+FB*AGEPMO - -* Compute the motions of each planet (AU,AU/d). - DO NP=1,8 - -* The planet's position and velocity (AU,AU/s). - CALL sla_UE2PV(TPMO,UP(1,NP),PVIN(1,NP),J) - IF (J.NE.0) GO TO 9010 - -* Scale velocity to AU/d. - DO J=4,6 - PVIN(J,NP) = PVIN(J,NP)*86400D0 - END DO - -* Precompute also the extrapolation correction terms. - R2 = 0D0 - DO I=1,3 - W = PVIN(I,NP) - R2 = R2+W*W - END DO - R2X3(NP) = R2*3D0 - GC(NP) = GCON2/(2D0*R2*SQRT(R2)) - END DO - END IF - -* Reset the first-time flag. - FIRST = .FALSE. - -* Unperturbed motion of the body at middle of timestep (AU,AU/s). - CALL sla_UE2PV(T,UL,PV0,J) - IF (J.NE.0) GO TO 9010 - -* Perturbed position of the body (AU) and heliocentric distance cubed. - R2 = 0D0 - DO I=1,3 - W = PV0(I)+PERP(I)+(PERV(I)+PERA(I)*HTS/2D0)*HTS - PV(I) = W - R2 = R2+W*W - END DO - R3 = R2*SQRT(R2) - -* The body's unperturbed heliocentric distance cubed. - R2 = 0D0 - DO I=1,3 - W = PV0(I) - R2 = R2+W*W - END DO - R03 = R2*SQRT(R2) - -* Compute indirect and initialize direct parts of the perturbation. - DO I=1,3 - FI(I) = PV0(I)/R03-PV(I)/R3 - FD(I) = 0D0 - END DO - -* Ready to compute the direct planetary effects. - -* Reset the "near-Earth" flag. - NE = .FALSE. - -* Interval from state-vector epoch to middle of current timestep. - DT = T-TPMO - DT2 = DT*DT - -* Planet by planet, including separate Earth and Moon. - DO NP=1,10 - -* Which perturbing body? - IF (NP.LE.8) THEN - -* Planet: compute the extrapolation in longitude (squared). - R2 = 0D0 - DO J=4,6 - W = PVIN(J,NP)*DT - R2 = R2+W*W - END DO - -* Hence the tangential-to-circular correction factor. - FC = 1D0+R2/R2X3(NP) - -* The radial correction factor due to the inwards acceleration. - FG = 1D0-GC(NP)*DT2 - -* Planet's position. - DO I=1,3 - RHO(I) = FG*(PVIN(I,NP)+FC*PVIN(I+3,NP)*DT) - END DO - - ELSE IF (NE) THEN - -* Near-Earth and either Earth or Moon. - - IF (NP.EQ.9) THEN - -* Earth: position. - CALL sla_EPV(T,PE,VH,PB,VB) - DO I=1,3 - RHO(I) = PE(I) - END DO - - ELSE - -* Moon: position. - CALL sla_PREC(sla_EPJ(T),2000D0,PMAT) - CALL sla_DMOON(T,PVM) - CALL sla_DMXV(PMAT,PVM,PM) - DO I=1,3 - RHO(I) = PM(I)+PE(I) - END DO - END IF - END IF - -* Proceed unless Earth or Moon and not the near-Earth case. - IF (NP.LE.8.OR.NE) THEN - -* Heliocentric distance cubed. - R2 = 0D0 - DO I=1,3 - W = RHO(I) - R2 = R2+W*W - END DO - R = SQRT(R2) - RHO3 = R2*R - -* Body-to-planet vector, and distance. - R2 = 0D0 - DO I=1,3 - W = RHO(I)-PV(I) - DELTA(I) = W - R2 = R2+W*W - END DO - R = SQRT(R2) - -* If this is the EMB, set the near-Earth flag appropriately. - IF (NP.EQ.3.AND.R.LT.RNE) NE = .TRUE. - -* Proceed unless EMB and this is the near-Earth case. - IF (.NOT.(NE.AND.NP.EQ.3)) THEN - -* If too close, ignore this planet and set a warning. - IF (R.LT.COINC) THEN - JSTAT = NP - - ELSE - -* Accumulate "direct" part of perturbation acceleration. - DELTA3 = R2*R - W = AMAS(NP) - DO I=1,3 - FD(I) = FD(I)+(DELTA(I)/DELTA3-RHO(I)/RHO3)/W - END DO - END IF - END IF - END IF - END DO - -* Update the perturbations to the end of the timestep. - RTN = RTN+TS - DO I=1,3 - W = (FI(I)+FD(I))*GCON2 - FT = W*TS - PERP(I) = PERP(I)+(PERV(I)+FT/2D0)*TS - PERV(I) = PERV(I)+FT - PERA(I) = W - END DO - -* Time still to go. - TLEFT = TSPAN-RTN - -* Is it either time to rectify the orbit or the last time through? - IF (ABS(RTN).GE.AGEBEL.OR.FB*TLEFT.LE.0D0) THEN - -* Yes: update to the end of the current timestep. - T0 = T0+RTN - RTN = 0D0 - -* The body's unperturbed motion (AU,AU/s). - CALL sla_UE2PV(T0,UL,PV0,J) - IF (J.NE.0) GO TO 9010 - -* Add and re-initialize the perturbations. - DO I=1,3 - J = I+3 - PV(I) = PV0(I)+PERP(I) - PV(J) = PV0(J)+PERV(I)/86400D0 - PERP(I) = 0D0 - PERV(I) = 0D0 - PERA(I) = FD(I)*GCON2 - END DO - -* Use the position and velocity to set up new universal elements. - CALL sla_PV2UE(PV,T0,0D0,UL,J) - IF (J.NE.0) GO TO 9010 - -* Adjust the timespan and time left. - TSPAN = TFINAL-T0 - TLEFT = TSPAN - END IF - -* Next timestep. - END DO - -* Return the updated universal-element set. - DO I=1,13 - U(I) = UL(I) - END DO - -* Finished. - GO TO 9999 - -* Miscellaneous numerical error. - 9010 CONTINUE - JSTAT = -1 - - 9999 CONTINUE - END diff --git a/src/slalib/planel.f b/src/slalib/planel.f deleted file mode 100644 index 31d4a8bab..000000000 --- a/src/slalib/planel.f +++ /dev/null @@ -1,183 +0,0 @@ - SUBROUTINE sla_PLANEL (DATE, JFORM, EPOCH, ORBINC, ANODE, PERIH, - : AORQ, E, AORL, DM, PV, JSTAT) -*+ -* - - - - - - - -* P L A N E L -* - - - - - - - -* -* Heliocentric position and velocity of a planet, asteroid or comet, -* starting from orbital elements. -* -* Given: -* DATE d date, Modified Julian Date (JD - 2400000.5, Note 1) -* JFORM i choice of element set (1-3; Note 3) -* EPOCH d epoch of elements (TT MJD, Note 4) -* ORBINC d inclination (radians) -* ANODE d longitude of the ascending node (radians) -* PERIH d longitude or argument of perihelion (radians) -* AORQ d mean distance or perihelion distance (AU) -* E d eccentricity -* AORL d mean anomaly or longitude (radians, JFORM=1,2 only) -* DM d daily motion (radians, JFORM=1 only) -* -* Returned: -* PV d(6) heliocentric x,y,z,xdot,ydot,zdot of date, -* J2000 equatorial triad (AU,AU/s) -* JSTAT i status: 0 = OK -* -1 = illegal JFORM -* -2 = illegal E -* -3 = illegal AORQ -* -4 = illegal DM -* -5 = numerical error -* -* Called: sla_EL2UE, sla_UE2PV -* -* Notes -* -* 1 DATE is the instant for which the prediction is required. It is -* in the TT timescale (formerly Ephemeris Time, ET) and is a -* Modified Julian Date (JD-2400000.5). -* -* 2 The elements are with respect to the J2000 ecliptic and equinox. -* -* 3 A choice of three different element-set options is available: -* -* Option JFORM = 1, suitable for the major planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = longitude of perihelion, curly pi (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e (range 0 to <1) -* AORL = mean longitude L (radians) -* DM = daily motion (radians) -* -* Option JFORM = 2, suitable for minor planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e (range 0 to <1) -* AORL = mean anomaly M (radians) -* -* Option JFORM = 3, suitable for comets: -* -* EPOCH = epoch of elements and perihelion (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = perihelion distance, q (AU) -* E = eccentricity, e (range 0 to 10) -* -* Unused arguments (DM for JFORM=2, AORL and DM for JFORM=3) are not -* accessed. -* -* 4 Each of the three element sets defines an unperturbed heliocentric -* orbit. For a given epoch of observation, the position of the body -* in its orbit can be predicted from these elements, which are -* called "osculating elements", using standard two-body analytical -* solutions. However, due to planetary perturbations, a given set -* of osculating elements remains usable for only as long as the -* unperturbed orbit that it describes is an adequate approximation -* to reality. Attached to such a set of elements is a date called -* the "osculating epoch", at which the elements are, momentarily, -* a perfect representation of the instantaneous position and -* velocity of the body. -* -* Therefore, for any given problem there are up to three different -* epochs in play, and it is vital to distinguish clearly between -* them: -* -* . The epoch of observation: the moment in time for which the -* position of the body is to be predicted. -* -* . The epoch defining the position of the body: the moment in time -* at which, in the absence of purturbations, the specified -* position (mean longitude, mean anomaly, or perihelion) is -* reached. -* -* . The osculating epoch: the moment in time at which the given -* elements are correct. -* -* For the major-planet and minor-planet cases it is usual to make -* the epoch that defines the position of the body the same as the -* epoch of osculation. Thus, only two different epochs are -* involved: the epoch of the elements and the epoch of observation. -* -* For comets, the epoch of perihelion fixes the position in the -* orbit and in general a different epoch of osculation will be -* chosen. Thus, all three types of epoch are involved. -* -* For the present routine: -* -* . The epoch of observation is the argument DATE. -* -* . The epoch defining the position of the body is the argument -* EPOCH. -* -* . The osculating epoch is not used and is assumed to be close -* enough to the epoch of observation to deliver adequate accuracy. -* If not, a preliminary call to sla_PERTEL may be used to update -* the element-set (and its associated osculating epoch) by -* applying planetary perturbations. -* -* 5 The reference frame for the result is with respect to the mean -* equator and equinox of epoch J2000. -* -* 6 The algorithm was originally adapted from the EPHSLA program of -* D.H.P.Jones (private communication, 1996). The method is based -* on Stumpff's Universal Variables. -* -* Reference: Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983. -* -* P.T.Wallace Starlink 31 December 2002 -* -* Copyright (C) 2002 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - INTEGER JFORM - DOUBLE PRECISION EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM,PV(6) - INTEGER JSTAT - - DOUBLE PRECISION U(13) - INTEGER J - - - -* Validate elements and convert to "universal variables" parameters. - CALL sla_EL2UE(DATE,JFORM, - : EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM,U,J) - -* Determine the position and velocity. - IF (J.EQ.0) THEN - CALL sla_UE2PV(DATE,U,PV,J) - IF (J.NE.0) J=-5 - END IF - -* Wrap up. - JSTAT = J - - END diff --git a/src/slalib/planet.f b/src/slalib/planet.f deleted file mode 100644 index fcbe6f6f4..000000000 --- a/src/slalib/planet.f +++ /dev/null @@ -1,724 +0,0 @@ - SUBROUTINE sla_PLANET (DATE, NP, PV, JSTAT) -*+ -* - - - - - - - -* P L A N E T -* - - - - - - - -* -* Approximate heliocentric position and velocity of a specified -* major planet. -* -* Given: -* DATE d Modified Julian Date (JD - 2400000.5) -* NP i planet (1=Mercury, 2=Venus, 3=EMB ... 9=Pluto) -* -* Returned: -* PV d(6) heliocentric x,y,z,xdot,ydot,zdot, J2000 -* equatorial triad (AU,AU/s) -* JSTAT i status: +1 = warning: date out of range -* 0 = OK -* -1 = illegal NP (outside 1-9) -* -2 = solution didn't converge -* -* Called: sla_PLANEL -* -* Notes -* -* 1 The epoch, DATE, is in the TDB timescale and is a Modified -* Julian Date (JD-2400000.5). -* -* 2 The reference frame is equatorial and is with respect to the -* mean equinox and ecliptic of epoch J2000. -* -* 3 If an NP value outside the range 1-9 is supplied, an error -* status (JSTAT = -1) is returned and the PV vector set to zeroes. -* -* 4 The algorithm for obtaining the mean elements of the planets -* from Mercury to Neptune is due to J.L. Simon, P. Bretagnon, -* J. Chapront, M. Chapront-Touze, G. Francou and J. Laskar -* (Bureau des Longitudes, Paris). The (completely different) -* algorithm for calculating the ecliptic coordinates of Pluto -* is by Meeus. -* -* 5 Comparisons of the present routine with the JPL DE200 ephemeris -* give the following RMS errors over the interval 1960-2025: -* -* position (km) speed (metre/sec) -* -* Mercury 334 0.437 -* Venus 1060 0.855 -* EMB 2010 0.815 -* Mars 7690 1.98 -* Jupiter 71700 7.70 -* Saturn 199000 19.4 -* Uranus 564000 16.4 -* Neptune 158000 14.4 -* Pluto 36400 0.137 -* -* From comparisons with DE102, Simon et al quote the following -* longitude accuracies over the interval 1800-2200: -* -* Mercury 4" -* Venus 5" -* EMB 6" -* Mars 17" -* Jupiter 71" -* Saturn 81" -* Uranus 86" -* Neptune 11" -* -* In the case of Pluto, Meeus quotes an accuracy of 0.6 arcsec -* in longitude and 0.2 arcsec in latitude for the period -* 1885-2099. -* -* For all except Pluto, over the period 1000-3000 the accuracy -* is better than 1.5 times that over 1800-2200. Outside the -* period 1000-3000 the accuracy declines. For Pluto the -* accuracy declines rapidly outside the period 1885-2099. -* Outside these ranges (1885-2099 for Pluto, 1000-3000 for -* the rest) a "date out of range" warning status (JSTAT=+1) -* is returned. -* -* 6 The algorithms for (i) Mercury through Neptune and (ii) Pluto -* are completely independent. In the Mercury through Neptune -* case, the present SLALIB implementation differs from the -* original Simon et al Fortran code in the following respects. -* -* * The date is supplied as a Modified Julian Date rather -* than a Julian Date (MJD = JD - 2400000.5). -* -* * The result is returned only in equatorial Cartesian form; -* the ecliptic longitude, latitude and radius vector are not -* returned. -* -* * The velocity is in AU per second, not AU per day. -* -* * Different error/warning status values are used. -* -* * Kepler's equation is not solved inline. -* -* * Polynomials in T are nested to minimize rounding errors. -* -* * Explicit double-precision constants are used to avoid -* mixed-mode expressions. -* -* * There are other, cosmetic, changes to comply with -* Starlink/SLALIB style guidelines. -* -* None of the above changes affects the result significantly. -* -* 7 For NP=3 the result is for the Earth-Moon Barycentre. To -* obtain the heliocentric position and velocity of the Earth, -* either use the SLALIB routine sla_EVP (or sla_EPV) or call -* sla_DMOON and subtract 0.012150581 times the geocentric Moon -* vector from the EMB vector produced by the present routine. -* (The Moon vector should be precessed to J2000 first, but this -* can be omitted for modern epochs without introducing significant -* inaccuracy.) -* -* References: Simon et al., Astron. Astrophys. 282, 663 (1994). -* Meeus, Astronomical Algorithms, Willmann-Bell (1991). -* -* This revision: 19 June 2004 -* -* Copyright (C) 2004 P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - INTEGER NP - DOUBLE PRECISION PV(6) - INTEGER JSTAT - -* 2Pi, deg to radians, arcsec to radians - DOUBLE PRECISION D2PI,D2R,AS2R - PARAMETER (D2PI=6.283185307179586476925286766559D0, - : D2R=0.017453292519943295769236907684886D0, - : AS2R=4.848136811095359935899141023579D-6) - -* Gaussian gravitational constant (exact) - DOUBLE PRECISION GCON - PARAMETER (GCON=0.01720209895D0) - -* Seconds per Julian century - DOUBLE PRECISION SPC - PARAMETER (SPC=36525D0*86400D0) - -* Sin and cos of J2000 mean obliquity (IAU 1976) - DOUBLE PRECISION SE,CE - PARAMETER (SE=0.3977771559319137D0, - : CE=0.9174820620691818D0) - - INTEGER I,J,IJSP(3,43) - DOUBLE PRECISION AMAS(8),A(3,8),DLM(3,8),E(3,8), - : PI(3,8),DINC(3,8),OMEGA(3,8), - : DKP(9,8),CA(9,8),SA(9,8), - : DKQ(10,8),CLO(10,8),SLO(10,8), - : T,DA,DE,DPE,DI,DO,DMU,ARGA,ARGL,DM, - : AB(2,3,43),DJ0,DS0,DP0,DL0,DLD0,DB0,DR0, - : DJ,DS,DP,DJD,DSD,DPD,WLBR(3),WLBRD(3), - : WJ,WS,WP,AL,ALD,SAL,CAL, - : AC,BC,DL,DLD,DB,DBD,DR,DRD, - : SL,CL,SB,CB,SLCB,CLCB,X,Y,Z,XD,YD,ZD - -* ----------------------- -* Mercury through Neptune -* ----------------------- - -* Planetary inverse masses - DATA AMAS / 6023600D0,408523.5D0,328900.5D0,3098710D0, - : 1047.355D0,3498.5D0,22869D0,19314D0 / - -* -* Tables giving the mean Keplerian elements, limited to T**2 terms: -* -* A semi-major axis (AU) -* DLM mean longitude (degree and arcsecond) -* E eccentricity -* PI longitude of the perihelion (degree and arcsecond) -* DINC inclination (degree and arcsecond) -* OMEGA longitude of the ascending node (degree and arcsecond) -* - DATA A / - : 0.3870983098D0, 0D0, 0D0, - : 0.7233298200D0, 0D0, 0D0, - : 1.0000010178D0, 0D0, 0D0, - : 1.5236793419D0, 3D-10, 0D0, - : 5.2026032092D0, 19132D-10, -39D-10, - : 9.5549091915D0, -0.0000213896D0, 444D-10, - : 19.2184460618D0, -3716D-10, 979D-10, - : 30.1103868694D0, -16635D-10, 686D-10 / -* - DATA DLM / - : 252.25090552D0, 5381016286.88982D0, -1.92789D0, - : 181.97980085D0, 2106641364.33548D0, 0.59381D0, - : 100.46645683D0, 1295977422.83429D0, -2.04411D0, - : 355.43299958D0, 689050774.93988D0, 0.94264D0, - : 34.35151874D0, 109256603.77991D0, -30.60378D0, - : 50.07744430D0, 43996098.55732D0, 75.61614D0, - : 314.05500511D0, 15424811.93933D0, -1.75083D0, - : 304.34866548D0, 7865503.20744D0, 0.21103D0/ -* - DATA E / - : 0.2056317526D0, 0.0002040653D0, -28349D-10, - : 0.0067719164D0, -0.0004776521D0, 98127D-10, - : 0.0167086342D0, -0.0004203654D0, -0.0000126734D0, - : 0.0934006477D0, 0.0009048438D0, -80641D-10, - : 0.0484979255D0, 0.0016322542D0, -0.0000471366D0, - : 0.0555481426D0, -0.0034664062D0, -0.0000643639D0, - : 0.0463812221D0, -0.0002729293D0, 0.0000078913D0, - : 0.0094557470D0, 0.0000603263D0, 0D0 / -* - DATA PI / - : 77.45611904D0, 5719.11590D0, -4.83016D0, - : 131.56370300D0, 175.48640D0, -498.48184D0, - : 102.93734808D0, 11612.35290D0, 53.27577D0, - : 336.06023395D0, 15980.45908D0, -62.32800D0, - : 14.33120687D0, 7758.75163D0, 259.95938D0, - : 93.05723748D0, 20395.49439D0, 190.25952D0, - : 173.00529106D0, 3215.56238D0, -34.09288D0, - : 48.12027554D0, 1050.71912D0, 27.39717D0 / -* - DATA DINC / - : 7.00498625D0, -214.25629D0, 0.28977D0, - : 3.39466189D0, -30.84437D0, -11.67836D0, - : 0D0, 469.97289D0, -3.35053D0, - : 1.84972648D0, -293.31722D0, -8.11830D0, - : 1.30326698D0, -71.55890D0, 11.95297D0, - : 2.48887878D0, 91.85195D0, -17.66225D0, - : 0.77319689D0, -60.72723D0, 1.25759D0, - : 1.76995259D0, 8.12333D0, 0.08135D0 / -* - DATA OMEGA / - : 48.33089304D0, -4515.21727D0, -31.79892D0, - : 76.67992019D0, -10008.48154D0, -51.32614D0, - : 174.87317577D0, -8679.27034D0, 15.34191D0, - : 49.55809321D0, -10620.90088D0, -230.57416D0, - : 100.46440702D0, 6362.03561D0, 326.52178D0, - : 113.66550252D0, -9240.19942D0, -66.23743D0, - : 74.00595701D0, 2669.15033D0, 145.93964D0, - : 131.78405702D0, -221.94322D0, -0.78728D0 / -* -* Tables for trigonometric terms to be added to the mean elements -* of the semi-major axes. -* - DATA DKP / - : 69613, 75645, 88306, 59899, 15746, 71087, 142173, 3086, 0, - : 21863, 32794, 26934, 10931, 26250, 43725, 53867, 28939, 0, - : 16002, 21863, 32004, 10931, 14529, 16368, 15318, 32794, 0, - : 6345, 7818, 15636, 7077, 8184, 14163, 1107, 4872, 0, - : 1760, 1454, 1167, 880, 287, 2640, 19, 2047, 1454, - : 574, 0, 880, 287, 19, 1760, 1167, 306, 574, - : 204, 0, 177, 1265, 4, 385, 200, 208, 204, - : 0, 102, 106, 4, 98, 1367, 487, 204, 0 / -* - DATA CA / - : 4, -13, 11, -9, -9, -3, -1, 4, 0, - : -156, 59, -42, 6, 19, -20, -10, -12, 0, - : 64, -152, 62, -8, 32, -41, 19, -11, 0, - : 124, 621, -145, 208, 54, -57, 30, 15, 0, - : -23437, -2634, 6601, 6259, -1507, -1821, 2620, -2115,-1489, - : 62911,-119919, 79336, 17814,-24241, 12068, 8306, -4893, 8902, - : 389061,-262125,-44088, 8387,-22976, -2093, -615, -9720, 6633, - :-412235,-157046,-31430, 37817, -9740, -13, -7449, 9644, 0 / -* - DATA SA / - : -29, -1, 9, 6, -6, 5, 4, 0, 0, - : -48, -125, -26, -37, 18, -13, -20, -2, 0, - : -150, -46, 68, 54, 14, 24, -28, 22, 0, - : -621, 532, -694, -20, 192, -94, 71, -73, 0, - : -14614,-19828, -5869, 1881, -4372, -2255, 782, 930, 913, - : 139737, 0, 24667, 51123, -5102, 7429, -4095, -1976,-9566, - : -138081, 0, 37205,-49039,-41901,-33872,-27037,-12474,18797, - : 0, 28492,133236, 69654, 52322,-49577,-26430, -3593, 0 / -* -* Tables giving the trigonometric terms to be added to the mean -* elements of the mean longitudes. -* - DATA DKQ / - : 3086, 15746, 69613, 59899, 75645, 88306, 12661, 2658, 0, 0, - : 21863, 32794, 10931, 73, 4387, 26934, 1473, 2157, 0, 0, - : 10, 16002, 21863, 10931, 1473, 32004, 4387, 73, 0, 0, - : 10, 6345, 7818, 1107, 15636, 7077, 8184, 532, 10, 0, - : 19, 1760, 1454, 287, 1167, 880, 574, 2640, 19,1454, - : 19, 574, 287, 306, 1760, 12, 31, 38, 19, 574, - : 4, 204, 177, 8, 31, 200, 1265, 102, 4, 204, - : 4, 102, 106, 8, 98, 1367, 487, 204, 4, 102 / -* - DATA CLO / - : 21, -95, -157, 41, -5, 42, 23, 30, 0, 0, - : -160, -313, -235, 60, -74, -76, -27, 34, 0, 0, - : -325, -322, -79, 232, -52, 97, 55, -41, 0, 0, - : 2268, -979, 802, 602, -668, -33, 345, 201, -55, 0, - : 7610, -4997,-7689,-5841,-2617, 1115, -748, -607, 6074, 354, - : -18549, 30125,20012, -730, 824, 23, 1289, -352,-14767,-2062, - :-135245,-14594, 4197,-4030,-5630,-2898, 2540, -306, 2939, 1986, - : 89948, 2103, 8963, 2695, 3682, 1648, 866, -154, -1963, -283 / -* - DATA SLO / - : -342, 136, -23, 62, 66, -52, -33, 17, 0, 0, - : 524, -149, -35, 117, 151, 122, -71, -62, 0, 0, - : -105, -137, 258, 35, -116, -88, -112, -80, 0, 0, - : 854, -205, -936, -240, 140, -341, -97, -232, 536, 0, - : -56980, 8016, 1012, 1448,-3024,-3710, 318, 503, 3767, 577, - : 138606,-13478,-4964, 1441,-1319,-1482, 427, 1236, -9167,-1918, - : 71234,-41116, 5334,-4935,-1848, 66, 434,-1748, 3780, -701, - : -47645, 11647, 2166, 3194, 679, 0, -244, -419, -2531, 48 / - -* ----- -* Pluto -* ----- - -* -* Coefficients for fundamental arguments: mean longitudes -* (degrees) and mean rate of change of longitude (degrees per -* Julian century) for Jupiter, Saturn and Pluto -* - DATA DJ0, DJD / 34.35D0, 3034.9057D0 / - DATA DS0, DSD / 50.08D0, 1222.1138D0 / - DATA DP0, DPD / 238.96D0, 144.9600D0 / - -* Coefficients for latitude, longitude, radius vector - DATA DL0,DLD0 / 238.956785D0, 144.96D0 / - DATA DB0 / -3.908202D0 / - DATA DR0 / 40.7247248D0 / - -* -* Coefficients for periodic terms (Meeus's Table 36.A) -* -* The coefficients for term n in the series are: -* -* IJSP(1,n) J -* IJSP(2,n) S -* IJSP(3,n) P -* AB(1,1,n) longitude sine (degrees) -* AB(2,1,n) longitude cosine (degrees) -* AB(1,2,n) latitude sine (degrees) -* AB(2,2,n) latitude cosine (degrees) -* AB(1,3,n) radius vector sine (AU) -* AB(2,3,n) radius vector cosine (AU) -* - DATA (IJSP(I, 1),I=1,3),((AB(J,I, 1),J=1,2),I=1,3) / - : 0, 0, 1, - : -19798886D-6, 19848454D-6, - : -5453098D-6, -14974876D-6, - : 66867334D-7, 68955876D-7 / - DATA (IJSP(I, 2),I=1,3),((AB(J,I, 2),J=1,2),I=1,3) / - : 0, 0, 2, - : 897499D-6, -4955707D-6, - : 3527363D-6, 1672673D-6, - : -11826086D-7, -333765D-7 / - DATA (IJSP(I, 3),I=1,3),((AB(J,I, 3),J=1,2),I=1,3) / - : 0, 0, 3, - : 610820D-6, 1210521D-6, - : -1050939D-6, 327763D-6, - : 1593657D-7, -1439953D-7 / - DATA (IJSP(I, 4),I=1,3),((AB(J,I, 4),J=1,2),I=1,3) / - : 0, 0, 4, - : -341639D-6, -189719D-6, - : 178691D-6, -291925D-6, - : -18948D-7, 482443D-7 / - DATA (IJSP(I, 5),I=1,3),((AB(J,I, 5),J=1,2),I=1,3) / - : 0, 0, 5, - : 129027D-6, -34863D-6, - : 18763D-6, 100448D-6, - : -66634D-7, -85576D-7 / - DATA (IJSP(I, 6),I=1,3),((AB(J,I, 6),J=1,2),I=1,3) / - : 0, 0, 6, - : -38215D-6, 31061D-6, - : -30594D-6, -25838D-6, - : 30841D-7, -5765D-7 / - DATA (IJSP(I, 7),I=1,3),((AB(J,I, 7),J=1,2),I=1,3) / - : 0, 1, -1, - : 20349D-6, -9886D-6, - : 4965D-6, 11263D-6, - : -6140D-7, 22254D-7 / - DATA (IJSP(I, 8),I=1,3),((AB(J,I, 8),J=1,2),I=1,3) / - : 0, 1, 0, - : -4045D-6, -4904D-6, - : 310D-6, -132D-6, - : 4434D-7, 4443D-7 / - DATA (IJSP(I, 9),I=1,3),((AB(J,I, 9),J=1,2),I=1,3) / - : 0, 1, 1, - : -5885D-6, -3238D-6, - : 2036D-6, -947D-6, - : -1518D-7, 641D-7 / - DATA (IJSP(I,10),I=1,3),((AB(J,I,10),J=1,2),I=1,3) / - : 0, 1, 2, - : -3812D-6, 3011D-6, - : -2D-6, -674D-6, - : -5D-7, 792D-7 / - DATA (IJSP(I,11),I=1,3),((AB(J,I,11),J=1,2),I=1,3) / - : 0, 1, 3, - : -601D-6, 3468D-6, - : -329D-6, -563D-6, - : 518D-7, 518D-7 / - DATA (IJSP(I,12),I=1,3),((AB(J,I,12),J=1,2),I=1,3) / - : 0, 2, -2, - : 1237D-6, 463D-6, - : -64D-6, 39D-6, - : -13D-7, -221D-7 / - DATA (IJSP(I,13),I=1,3),((AB(J,I,13),J=1,2),I=1,3) / - : 0, 2, -1, - : 1086D-6, -911D-6, - : -94D-6, 210D-6, - : 837D-7, -494D-7 / - DATA (IJSP(I,14),I=1,3),((AB(J,I,14),J=1,2),I=1,3) / - : 0, 2, 0, - : 595D-6, -1229D-6, - : -8D-6, -160D-6, - : -281D-7, 616D-7 / - DATA (IJSP(I,15),I=1,3),((AB(J,I,15),J=1,2),I=1,3) / - : 1, -1, 0, - : 2484D-6, -485D-6, - : -177D-6, 259D-6, - : 260D-7, -395D-7 / - DATA (IJSP(I,16),I=1,3),((AB(J,I,16),J=1,2),I=1,3) / - : 1, -1, 1, - : 839D-6, -1414D-6, - : 17D-6, 234D-6, - : -191D-7, -396D-7 / - DATA (IJSP(I,17),I=1,3),((AB(J,I,17),J=1,2),I=1,3) / - : 1, 0, -3, - : -964D-6, 1059D-6, - : 582D-6, -285D-6, - : -3218D-7, 370D-7 / - DATA (IJSP(I,18),I=1,3),((AB(J,I,18),J=1,2),I=1,3) / - : 1, 0, -2, - : -2303D-6, -1038D-6, - : -298D-6, 692D-6, - : 8019D-7, -7869D-7 / - DATA (IJSP(I,19),I=1,3),((AB(J,I,19),J=1,2),I=1,3) / - : 1, 0, -1, - : 7049D-6, 747D-6, - : 157D-6, 201D-6, - : 105D-7, 45637D-7 / - DATA (IJSP(I,20),I=1,3),((AB(J,I,20),J=1,2),I=1,3) / - : 1, 0, 0, - : 1179D-6, -358D-6, - : 304D-6, 825D-6, - : 8623D-7, 8444D-7 / - DATA (IJSP(I,21),I=1,3),((AB(J,I,21),J=1,2),I=1,3) / - : 1, 0, 1, - : 393D-6, -63D-6, - : -124D-6, -29D-6, - : -896D-7, -801D-7 / - DATA (IJSP(I,22),I=1,3),((AB(J,I,22),J=1,2),I=1,3) / - : 1, 0, 2, - : 111D-6, -268D-6, - : 15D-6, 8D-6, - : 208D-7, -122D-7 / - DATA (IJSP(I,23),I=1,3),((AB(J,I,23),J=1,2),I=1,3) / - : 1, 0, 3, - : -52D-6, -154D-6, - : 7D-6, 15D-6, - : -133D-7, 65D-7 / - DATA (IJSP(I,24),I=1,3),((AB(J,I,24),J=1,2),I=1,3) / - : 1, 0, 4, - : -78D-6, -30D-6, - : 2D-6, 2D-6, - : -16D-7, 1D-7 / - DATA (IJSP(I,25),I=1,3),((AB(J,I,25),J=1,2),I=1,3) / - : 1, 1, -3, - : -34D-6, -26D-6, - : 4D-6, 2D-6, - : -22D-7, 7D-7 / - DATA (IJSP(I,26),I=1,3),((AB(J,I,26),J=1,2),I=1,3) / - : 1, 1, -2, - : -43D-6, 1D-6, - : 3D-6, 0D-6, - : -8D-7, 16D-7 / - DATA (IJSP(I,27),I=1,3),((AB(J,I,27),J=1,2),I=1,3) / - : 1, 1, -1, - : -15D-6, 21D-6, - : 1D-6, -1D-6, - : 2D-7, 9D-7 / - DATA (IJSP(I,28),I=1,3),((AB(J,I,28),J=1,2),I=1,3) / - : 1, 1, 0, - : -1D-6, 15D-6, - : 0D-6, -2D-6, - : 12D-7, 5D-7 / - DATA (IJSP(I,29),I=1,3),((AB(J,I,29),J=1,2),I=1,3) / - : 1, 1, 1, - : 4D-6, 7D-6, - : 1D-6, 0D-6, - : 1D-7, -3D-7 / - DATA (IJSP(I,30),I=1,3),((AB(J,I,30),J=1,2),I=1,3) / - : 1, 1, 3, - : 1D-6, 5D-6, - : 1D-6, -1D-6, - : 1D-7, 0D-7 / - DATA (IJSP(I,31),I=1,3),((AB(J,I,31),J=1,2),I=1,3) / - : 2, 0, -6, - : 8D-6, 3D-6, - : -2D-6, -3D-6, - : 9D-7, 5D-7 / - DATA (IJSP(I,32),I=1,3),((AB(J,I,32),J=1,2),I=1,3) / - : 2, 0, -5, - : -3D-6, 6D-6, - : 1D-6, 2D-6, - : 2D-7, -1D-7 / - DATA (IJSP(I,33),I=1,3),((AB(J,I,33),J=1,2),I=1,3) / - : 2, 0, -4, - : 6D-6, -13D-6, - : -8D-6, 2D-6, - : 14D-7, 10D-7 / - DATA (IJSP(I,34),I=1,3),((AB(J,I,34),J=1,2),I=1,3) / - : 2, 0, -3, - : 10D-6, 22D-6, - : 10D-6, -7D-6, - : -65D-7, 12D-7 / - DATA (IJSP(I,35),I=1,3),((AB(J,I,35),J=1,2),I=1,3) / - : 2, 0, -2, - : -57D-6, -32D-6, - : 0D-6, 21D-6, - : 126D-7, -233D-7 / - DATA (IJSP(I,36),I=1,3),((AB(J,I,36),J=1,2),I=1,3) / - : 2, 0, -1, - : 157D-6, -46D-6, - : 8D-6, 5D-6, - : 270D-7, 1068D-7 / - DATA (IJSP(I,37),I=1,3),((AB(J,I,37),J=1,2),I=1,3) / - : 2, 0, 0, - : 12D-6, -18D-6, - : 13D-6, 16D-6, - : 254D-7, 155D-7 / - DATA (IJSP(I,38),I=1,3),((AB(J,I,38),J=1,2),I=1,3) / - : 2, 0, 1, - : -4D-6, 8D-6, - : -2D-6, -3D-6, - : -26D-7, -2D-7 / - DATA (IJSP(I,39),I=1,3),((AB(J,I,39),J=1,2),I=1,3) / - : 2, 0, 2, - : -5D-6, 0D-6, - : 0D-6, 0D-6, - : 7D-7, 0D-7 / - DATA (IJSP(I,40),I=1,3),((AB(J,I,40),J=1,2),I=1,3) / - : 2, 0, 3, - : 3D-6, 4D-6, - : 0D-6, 1D-6, - : -11D-7, 4D-7 / - DATA (IJSP(I,41),I=1,3),((AB(J,I,41),J=1,2),I=1,3) / - : 3, 0, -2, - : -1D-6, -1D-6, - : 0D-6, 1D-6, - : 4D-7, -14D-7 / - DATA (IJSP(I,42),I=1,3),((AB(J,I,42),J=1,2),I=1,3) / - : 3, 0, -1, - : 6D-6, -3D-6, - : 0D-6, 0D-6, - : 18D-7, 35D-7 / - DATA (IJSP(I,43),I=1,3),((AB(J,I,43),J=1,2),I=1,3) / - : 3, 0, 0, - : -1D-6, -2D-6, - : 0D-6, 1D-6, - : 13D-7, 3D-7 / - - -* Validate the planet number. - IF (NP.LT.1.OR.NP.GT.9) THEN - JSTAT=-1 - DO I=1,6 - PV(I)=0D0 - END DO - ELSE - -* Separate algorithms for Pluto and the rest. - IF (NP.NE.9) THEN - -* ----------------------- -* Mercury through Neptune -* ----------------------- - -* Time: Julian millennia since J2000. - T=(DATE-51544.5D0)/365250D0 - -* OK status unless remote epoch. - IF (ABS(T).LE.1D0) THEN - JSTAT=0 - ELSE - JSTAT=1 - END IF - -* Compute the mean elements. - DA=A(1,NP)+(A(2,NP)+A(3,NP)*T)*T - DL=(3600D0*DLM(1,NP)+(DLM(2,NP)+DLM(3,NP)*T)*T)*AS2R - DE=E(1,NP)+(E(2,NP)+E(3,NP)*T)*T - DPE=MOD((3600D0*PI(1,NP)+(PI(2,NP)+PI(3,NP)*T)*T)*AS2R,D2PI) - DI=(3600D0*DINC(1,NP)+(DINC(2,NP)+DINC(3,NP)*T)*T)*AS2R - DO=MOD((3600D0*OMEGA(1,NP) - : +(OMEGA(2,NP)+OMEGA(3,NP)*T)*T)*AS2R,D2PI) - -* Apply the trigonometric terms. - DMU=0.35953620D0*T - DO J=1,8 - ARGA=DKP(J,NP)*DMU - ARGL=DKQ(J,NP)*DMU - DA=DA+(CA(J,NP)*COS(ARGA)+SA(J,NP)*SIN(ARGA))*1D-7 - DL=DL+(CLO(J,NP)*COS(ARGL)+SLO(J,NP)*SIN(ARGL))*1D-7 - END DO - ARGA=DKP(9,NP)*DMU - DA=DA+T*(CA(9,NP)*COS(ARGA)+SA(9,NP)*SIN(ARGA))*1D-7 - DO J=9,10 - ARGL=DKQ(J,NP)*DMU - DL=DL+T*(CLO(J,NP)*COS(ARGL)+SLO(J,NP)*SIN(ARGL))*1D-7 - END DO - DL=MOD(DL,D2PI) - -* Daily motion. - DM=GCON*SQRT((1D0+1D0/AMAS(NP))/(DA*DA*DA)) - -* Make the prediction. - CALL sla_PLANEL(DATE,1,DATE,DI,DO,DPE,DA,DE,DL,DM,PV,J) - IF (J.LT.0) JSTAT=-2 - - ELSE - -* ----- -* Pluto -* ----- - -* Time: Julian centuries since J2000. - T=(DATE-51544.5D0)/36525D0 - -* OK status unless remote epoch. - IF (T.GE.-1.15D0.AND.T.LE.1D0) THEN - JSTAT=0 - ELSE - JSTAT=1 - END IF - -* Fundamental arguments (radians). - DJ=(DJ0+DJD*T)*D2R - DS=(DS0+DSD*T)*D2R - DP=(DP0+DPD*T)*D2R - -* Initialize coefficients and derivatives. - DO I=1,3 - WLBR(I)=0D0 - WLBRD(I)=0D0 - END DO - -* Term by term through Meeus Table 36.A. - DO J=1,43 - -* Argument and derivative (radians, radians per century). - WJ=DBLE(IJSP(1,J)) - WS=DBLE(IJSP(2,J)) - WP=DBLE(IJSP(3,J)) - AL=WJ*DJ+WS*DS+WP*DP - ALD=(WJ*DJD+WS*DSD+WP*DPD)*D2R - -* Functions of argument. - SAL=SIN(AL) - CAL=COS(AL) - -* Periodic terms in longitude, latitude, radius vector. - DO I=1,3 - -* A and B coefficients (deg, AU). - AC=AB(1,I,J) - BC=AB(2,I,J) - -* Periodic terms (deg, AU, deg/Jc, AU/Jc). - WLBR(I)=WLBR(I)+AC*SAL+BC*CAL - WLBRD(I)=WLBRD(I)+(AC*CAL-BC*SAL)*ALD - END DO - END DO - -* Heliocentric longitude and derivative (radians, radians/sec). - DL=(DL0+DLD0*T+WLBR(1))*D2R - DLD=(DLD0+WLBRD(1))*D2R/SPC - -* Heliocentric latitude and derivative (radians, radians/sec). - DB=(DB0+WLBR(2))*D2R - DBD=WLBRD(2)*D2R/SPC - -* Heliocentric radius vector and derivative (AU, AU/sec). - DR=DR0+WLBR(3) - DRD=WLBRD(3)/SPC - -* Functions of latitude, longitude, radius vector. - SL=SIN(DL) - CL=COS(DL) - SB=SIN(DB) - CB=COS(DB) - SLCB=SL*CB - CLCB=CL*CB - -* Heliocentric vector and derivative, J2000 ecliptic and equinox. - X=DR*CLCB - Y=DR*SLCB - Z=DR*SB - XD=DRD*CLCB-DR*(CL*SB*DBD+SLCB*DLD) - YD=DRD*SLCB+DR*(-SL*SB*DBD+CLCB*DLD) - ZD=DRD*SB+DR*CB*DBD - -* Transform to J2000 equator and equinox. - PV(1)=X - PV(2)=Y*CE-Z*SE - PV(3)=Y*SE+Z*CE - PV(4)=XD - PV(5)=YD*CE-ZD*SE - PV(6)=YD*SE+ZD*CE - END IF - END IF - - END diff --git a/src/slalib/plante.f b/src/slalib/plante.f deleted file mode 100644 index 13cea3b0f..000000000 --- a/src/slalib/plante.f +++ /dev/null @@ -1,250 +0,0 @@ - SUBROUTINE sla_PLANTE (DATE, ELONG, PHI, JFORM, EPOCH, - : ORBINC, ANODE, PERIH, AORQ, E, - : AORL, DM, RA, DEC, R, JSTAT) -*+ -* - - - - - - - -* P L A N T E -* - - - - - - - -* -* Topocentric apparent RA,Dec of a Solar-System object whose -* heliocentric orbital elements are known. -* -* Given: -* DATE d MJD of observation (JD - 2400000.5, Notes 1,5) -* ELONG d observer's east longitude (radians, Note 2) -* PHI d observer's geodetic latitude (radians, Note 2) -* JFORM i choice of element set (1-3; Notes 3-6) -* EPOCH d epoch of elements (TT MJD, Note 5) -* ORBINC d inclination (radians) -* ANODE d longitude of the ascending node (radians) -* PERIH d longitude or argument of perihelion (radians) -* AORQ d mean distance or perihelion distance (AU) -* E d eccentricity -* AORL d mean anomaly or longitude (radians, JFORM=1,2 only) -* DM d daily motion (radians, JFORM=1 only ) -* -* Returned: -* RA,DEC d RA, Dec (topocentric apparent, radians) -* R d distance from observer (AU) -* JSTAT i status: 0 = OK -* -1 = illegal JFORM -* -2 = illegal E -* -3 = illegal AORQ -* -4 = illegal DM -* -5 = numerical error -* -* Called: sla_EL2UE, sla_PLANTU -* -* Notes: -* -* 1 DATE is the instant for which the prediction is required. It is -* in the TT timescale (formerly Ephemeris Time, ET) and is a -* Modified Julian Date (JD-2400000.5). -* -* 2 The longitude and latitude allow correction for geocentric -* parallax. This is usually a small effect, but can become -* important for near-Earth asteroids. Geocentric positions can be -* generated by appropriate use of routines sla_EVP (or sla_EPV) and -* sla_PLANEL. -* -* 3 The elements are with respect to the J2000 ecliptic and equinox. -* -* 4 A choice of three different element-set options is available: -* -* Option JFORM = 1, suitable for the major planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = longitude of perihelion, curly pi (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e (range 0 to <1) -* AORL = mean longitude L (radians) -* DM = daily motion (radians) -* -* Option JFORM = 2, suitable for minor planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e (range 0 to <1) -* AORL = mean anomaly M (radians) -* -* Option JFORM = 3, suitable for comets: -* -* EPOCH = epoch of elements and perihelion (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = perihelion distance, q (AU) -* E = eccentricity, e (range 0 to 10) -* -* Unused arguments (DM for JFORM=2, AORL and DM for JFORM=3) are not -* accessed. -* -* 5 Each of the three element sets defines an unperturbed heliocentric -* orbit. For a given epoch of observation, the position of the body -* in its orbit can be predicted from these elements, which are -* called "osculating elements", using standard two-body analytical -* solutions. However, due to planetary perturbations, a given set -* of osculating elements remains usable for only as long as the -* unperturbed orbit that it describes is an adequate approximation -* to reality. Attached to such a set of elements is a date called -* the "osculating epoch", at which the elements are, momentarily, -* a perfect representation of the instantaneous position and -* velocity of the body. -* -* Therefore, for any given problem there are up to three different -* epochs in play, and it is vital to distinguish clearly between -* them: -* -* . The epoch of observation: the moment in time for which the -* position of the body is to be predicted. -* -* . The epoch defining the position of the body: the moment in time -* at which, in the absence of purturbations, the specified -* position (mean longitude, mean anomaly, or perihelion) is -* reached. -* -* . The osculating epoch: the moment in time at which the given -* elements are correct. -* -* For the major-planet and minor-planet cases it is usual to make -* the epoch that defines the position of the body the same as the -* epoch of osculation. Thus, only two different epochs are -* involved: the epoch of the elements and the epoch of observation. -* -* For comets, the epoch of perihelion fixes the position in the -* orbit and in general a different epoch of osculation will be -* chosen. Thus, all three types of epoch are involved. -* -* For the present routine: -* -* . The epoch of observation is the argument DATE. -* -* . The epoch defining the position of the body is the argument -* EPOCH. -* -* . The osculating epoch is not used and is assumed to be close -* enough to the epoch of observation to deliver adequate accuracy. -* If not, a preliminary call to sla_PERTEL may be used to update -* the element-set (and its associated osculating epoch) by -* applying planetary perturbations. -* -* 6 Two important sources for orbital elements are Horizons, operated -* by the Jet Propulsion Laboratory, Pasadena, and the Minor Planet -* Center, operated by the Center for Astrophysics, Harvard. -* -* The JPL Horizons elements (heliocentric, J2000 ecliptic and -* equinox) correspond to SLALIB arguments as follows. -* -* Major planets: -* -* JFORM = 1 -* EPOCH = JDCT-2400000.5D0 -* ORBINC = IN (in radians) -* ANODE = OM (in radians) -* PERIH = OM+W (in radians) -* AORQ = A -* E = EC -* AORL = MA+OM+W (in radians) -* DM = N (in radians) -* -* Epoch of osculation = JDCT-2400000.5D0 -* -* Minor planets: -* -* JFORM = 2 -* EPOCH = JDCT-2400000.5D0 -* ORBINC = IN (in radians) -* ANODE = OM (in radians) -* PERIH = W (in radians) -* AORQ = A -* E = EC -* AORL = MA (in radians) -* -* Epoch of osculation = JDCT-2400000.5D0 -* -* Comets: -* -* JFORM = 3 -* EPOCH = Tp-2400000.5D0 -* ORBINC = IN (in radians) -* ANODE = OM (in radians) -* PERIH = W (in radians) -* AORQ = QR -* E = EC -* -* Epoch of osculation = JDCT-2400000.5D0 -* -* The MPC elements correspond to SLALIB arguments as follows. -* -* Minor planets: -* -* JFORM = 2 -* EPOCH = Epoch-2400000.5D0 -* ORBINC = Incl. (in radians) -* ANODE = Node (in radians) -* PERIH = Perih. (in radians) -* AORQ = a -* E = e -* AORL = M (in radians) -* -* Epoch of osculation = Epoch-2400000.5D0 -* -* Comets: -* -* JFORM = 3 -* EPOCH = T-2400000.5D0 -* ORBINC = Incl. (in radians) -* ANODE = Node. (in radians) -* PERIH = Perih. (in radians) -* AORQ = q -* E = e -* -* Epoch of osculation = Epoch-2400000.5D0 -* -* This revision: 19 June 2004 -* -* Copyright (C) 2004 P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,ELONG,PHI - INTEGER JFORM - DOUBLE PRECISION EPOCH,ORBINC,ANODE,PERIH,AORQ,E, - : AORL,DM,RA,DEC,R - INTEGER JSTAT - - DOUBLE PRECISION U(13) - - -* Transform conventional elements to universal elements. - CALL sla_EL2UE(DATE, - : JFORM,EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM, - : U,JSTAT) - -* If successful, make the prediction. - IF (JSTAT.EQ.0) CALL sla_PLANTU(DATE,ELONG,PHI,U,RA,DEC,R,JSTAT) - - END diff --git a/src/slalib/plantu.f b/src/slalib/plantu.f deleted file mode 100644 index dee48de06..000000000 --- a/src/slalib/plantu.f +++ /dev/null @@ -1,155 +0,0 @@ - SUBROUTINE sla_PLANTU (DATE, ELONG, PHI, U, RA, DEC, R, JSTAT) -*+ -* - - - - - - - -* P L A N T U -* - - - - - - - -* -* Topocentric apparent RA,Dec of a Solar-System object whose -* heliocentric universal elements are known. -* -* Given: -* DATE d TT MJD of observation (JD - 2400000.5) -* ELONG d observer's east longitude (radians) -* PHI d observer's geodetic latitude (radians) -* U d(13) universal elements -* -* (1) combined mass (M+m) -* (2) total energy of the orbit (alpha) -* (3) reference (osculating) epoch (t0) -* (4-6) position at reference epoch (r0) -* (7-9) velocity at reference epoch (v0) -* (10) heliocentric distance at reference epoch -* (11) r0.v0 -* (12) date (t) -* (13) universal eccentric anomaly (psi) of date, approx -* -* Returned: -* RA,DEC d RA, Dec (topocentric apparent, radians) -* R d distance from observer (AU) -* JSTAT i status: 0 = OK -* -1 = radius vector zero -* -2 = failed to converge -* -* Called: sla_GMST, sla_DT, sla_EPJ, sla_EPV, sla_UE2PV, sla_PRENUT, -* sla_DMXV, sla_PVOBS, sla_DCC2S, sla_DRANRM -* -* Notes: -* -* 1 DATE is the instant for which the prediction is required. It is -* in the TT timescale (formerly Ephemeris Time, ET) and is a -* Modified Julian Date (JD-2400000.5). -* -* 2 The longitude and latitude allow correction for geocentric -* parallax. This is usually a small effect, but can become -* important for near-Earth asteroids. Geocentric positions can be -* generated by appropriate use of routines sla_EPV (or sla_EVP) and -* sla_UE2PV. -* -* 3 The "universal" elements are those which define the orbit for the -* purposes of the method of universal variables (see reference 2). -* They consist of the combined mass of the two bodies, an epoch, -* and the position and velocity vectors (arbitrary reference frame) -* at that epoch. The parameter set used here includes also various -* quantities that can, in fact, be derived from the other -* information. This approach is taken to avoiding unnecessary -* computation and loss of accuracy. The supplementary quantities -* are (i) alpha, which is proportional to the total energy of the -* orbit, (ii) the heliocentric distance at epoch, (iii) the -* outwards component of the velocity at the given epoch, (iv) an -* estimate of psi, the "universal eccentric anomaly" at a given -* date and (v) that date. -* -* 4 The universal elements are with respect to the J2000 equator and -* equinox. -* -* 1 Sterne, Theodore E., "An Introduction to Celestial Mechanics", -* Interscience Publishers Inc., 1960. Section 6.7, p199. -* -* 2 Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983. -* -* Last revision: 19 February 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,ELONG,PHI,U(13),RA,DEC,R - INTEGER JSTAT - -* Light time for unit distance (sec) - DOUBLE PRECISION TAU - PARAMETER (TAU=499.004782D0) - - INTEGER I - DOUBLE PRECISION DVB(3),DPB(3),VSG(6),VSP(6),V(6),RMAT(3,3), - : VGP(6),STL,VGO(6),DX,DY,DZ,D,TL - DOUBLE PRECISION sla_GMST,sla_DT,sla_EPJ,sla_DRANRM - - - -* Sun to geocentre (J2000, velocity in AU/s). - CALL sla_EPV(DATE,VSG,VSG(4),DPB,DVB) - DO I=4,6 - VSG(I)=VSG(I)/86400D0 - END DO - -* Sun to planet (J2000). - CALL sla_UE2PV(DATE,U,VSP,JSTAT) - -* Geocentre to planet (J2000). - DO I=1,6 - V(I)=VSP(I)-VSG(I) - END DO - -* Precession and nutation to date. - CALL sla_PRENUT(2000D0,DATE,RMAT) - CALL sla_DMXV(RMAT,V,VGP) - CALL sla_DMXV(RMAT,V(4),VGP(4)) - -* Geocentre to observer (date). - STL=sla_GMST(DATE-sla_DT(sla_EPJ(DATE))/86400D0)+ELONG - CALL sla_PVOBS(PHI,0D0,STL,VGO) - -* Observer to planet (date). - DO I=1,6 - V(I)=VGP(I)-VGO(I) - END DO - -* Geometric distance (AU). - DX=V(1) - DY=V(2) - DZ=V(3) - D=SQRT(DX*DX+DY*DY+DZ*DZ) - -* Light time (sec). - TL=TAU*D - -* Correct position for planetary aberration - DO I=1,3 - V(I)=V(I)-TL*V(I+3) - END DO - -* To RA,Dec. - CALL sla_DCC2S(V,RA,DEC) - RA=sla_DRANRM(RA) - R=D - - END diff --git a/src/slalib/pm.f b/src/slalib/pm.f deleted file mode 100644 index ecc19b6f7..000000000 --- a/src/slalib/pm.f +++ /dev/null @@ -1,97 +0,0 @@ - SUBROUTINE sla_PM (R0, D0, PR, PD, PX, RV, EP0, EP1, R1, D1) -*+ -* - - - -* P M -* - - - -* -* Apply corrections for proper motion to a star RA,Dec -* (double precision) -* -* References: -* 1984 Astronomical Almanac, pp B39-B41. -* (also Lederle & Schwan, Astron. Astrophys. 134, -* 1-6, 1984) -* -* Given: -* R0,D0 dp RA,Dec at epoch EP0 (rad) -* PR,PD dp proper motions: RA,Dec changes per year of epoch -* PX dp parallax (arcsec) -* RV dp radial velocity (km/sec, +ve if receding) -* EP0 dp start epoch in years (e.g. Julian epoch) -* EP1 dp end epoch in years (same system as EP0) -* -* Returned: -* R1,D1 dp RA,Dec at epoch EP1 (rad) -* -* Called: -* sla_DCS2C spherical to Cartesian -* sla_DCC2S Cartesian to spherical -* sla_DRANRM normalize angle 0-2Pi -* -* Notes: -* -* 1 The proper motions in RA are dRA/dt rather than cos(Dec)*dRA/dt, -* and are in the same coordinate system as R0,D0. -* -* 2 If the available proper motions are pre-FK5 they will be per -* tropical year rather than per Julian year, and so the epochs -* must both be Besselian rather than Julian. In such cases, a -* scaling factor of 365.2422D0/365.25D0 should be applied to the -* radial velocity before use. -* -* P.T.Wallace Starlink 19 January 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION R0,D0,PR,PD,PX,RV,EP0,EP1,R1,D1 - -* Km/s to AU/year multiplied by arcseconds to radians - DOUBLE PRECISION VFR - PARAMETER (VFR=(365.25D0*86400D0/149597870D0)*4.8481368111D-6) - - INTEGER I - DOUBLE PRECISION sla_DRANRM - DOUBLE PRECISION W,EM(3),T,P(3) - - - -* Spherical to Cartesian - CALL sla_DCS2C(R0,D0,P) - -* Space motion (radians per year) - W=VFR*RV*PX - EM(1)=-PR*P(2)-PD*COS(R0)*SIN(D0)+W*P(1) - EM(2)= PR*P(1)-PD*SIN(R0)*SIN(D0)+W*P(2) - EM(3)= PD*COS(D0) +W*P(3) - -* Apply the motion - T=EP1-EP0 - DO I=1,3 - P(I)=P(I)+T*EM(I) - END DO - -* Cartesian to spherical - CALL sla_DCC2S(P,R1,D1) - R1=sla_DRANRM(R1) - - END diff --git a/src/slalib/polmo.f b/src/slalib/polmo.f deleted file mode 100644 index bda1b5b45..000000000 --- a/src/slalib/polmo.f +++ /dev/null @@ -1,158 +0,0 @@ - SUBROUTINE sla_POLMO ( ELONGM, PHIM, XP, YP, ELONG, PHI, DAZ ) -*+ -* - - - - - - -* P O L M O -* - - - - - - -* -* Polar motion: correct site longitude and latitude for polar -* motion and calculate azimuth difference between celestial and -* terrestrial poles. -* -* Given: -* ELONGM d mean longitude of the observer (radians, east +ve) -* PHIM d mean geodetic latitude of the observer (radians) -* XP d polar motion x-coordinate (radians) -* YP d polar motion y-coordinate (radians) -* -* Returned: -* ELONG d true longitude of the observer (radians, east +ve) -* PHI d true geodetic latitude of the observer (radians) -* DAZ d azimuth correction (terrestrial-celestial, radians) -* -* Notes: -* -* 1) "Mean" longitude and latitude are the (fixed) values for the -* site's location with respect to the IERS terrestrial reference -* frame; the latitude is geodetic. TAKE CARE WITH THE LONGITUDE -* SIGN CONVENTION. The longitudes used by the present routine -* are east-positive, in accordance with geographical convention -* (and right-handed). In particular, note that the longitudes -* returned by the sla_OBS routine are west-positive, following -* astronomical usage, and must be reversed in sign before use in -* the present routine. -* -* 2) XP and YP are the (changing) coordinates of the Celestial -* Ephemeris Pole with respect to the IERS Reference Pole. -* XP is positive along the meridian at longitude 0 degrees, -* and YP is positive along the meridian at longitude -* 270 degrees (i.e. 90 degrees west). Values for XP,YP can -* be obtained from IERS circulars and equivalent publications; -* the maximum amplitude observed so far is about 0.3 arcseconds. -* -* 3) "True" longitude and latitude are the (moving) values for -* the site's location with respect to the celestial ephemeris -* pole and the meridian which corresponds to the Greenwich -* apparent sidereal time. The true longitude and latitude -* link the terrestrial coordinates with the standard celestial -* models (for precession, nutation, sidereal time etc). -* -* 4) The azimuths produced by sla_AOP and sla_AOPQK are with -* respect to due north as defined by the Celestial Ephemeris -* Pole, and can therefore be called "celestial azimuths". -* However, a telescope fixed to the Earth measures azimuth -* essentially with respect to due north as defined by the -* IERS Reference Pole, and can therefore be called "terrestrial -* azimuth". Uncorrected, this would manifest itself as a -* changing "azimuth zero-point error". The value DAZ is the -* correction to be added to a celestial azimuth to produce -* a terrestrial azimuth. -* -* 5) The present routine is rigorous. For most practical -* purposes, the following simplified formulae provide an -* adequate approximation: -* -* ELONG = ELONGM+XP*COS(ELONGM)-YP*SIN(ELONGM) -* PHI = PHIM+(XP*SIN(ELONGM)+YP*COS(ELONGM))*TAN(PHIM) -* DAZ = -SQRT(XP*XP+YP*YP)*COS(ELONGM-ATAN2(XP,YP))/COS(PHIM) -* -* An alternative formulation for DAZ is: -* -* X = COS(ELONGM)*COS(PHIM) -* Y = SIN(ELONGM)*COS(PHIM) -* DAZ = ATAN2(-X*YP-Y*XP,X*X+Y*Y) -* -* Reference: Seidelmann, P.K. (ed), 1992. "Explanatory Supplement -* to the Astronomical Almanac", ISBN 0-935702-68-7, -* sections 3.27, 4.25, 4.52. -* -* P.T.Wallace Starlink 30 November 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION ELONGM,PHIM,XP,YP,ELONG,PHI,DAZ - - DOUBLE PRECISION SEL,CEL,SPH,CPH,XM,YM,ZM,XNM,YNM,ZNM, - : SXP,CXP,SYP,CYP,ZW,XT,YT,ZT,XNT,YNT - - - -* Site mean longitude and mean geodetic latitude as a Cartesian vector - SEL=SIN(ELONGM) - CEL=COS(ELONGM) - SPH=SIN(PHIM) - CPH=COS(PHIM) - - XM=CEL*CPH - YM=SEL*CPH - ZM=SPH - -* Rotate site vector by polar motion, Y-component then X-component - SXP=SIN(XP) - CXP=COS(XP) - SYP=SIN(YP) - CYP=COS(YP) - - ZW=(-YM*SYP+ZM*CYP) - - XT=XM*CXP-ZW*SXP - YT=YM*CYP+ZM*SYP - ZT=XM*SXP+ZW*CXP - -* Rotate also the geocentric direction of the terrestrial pole (0,0,1) - XNM=-SXP*CYP - YNM=SYP - ZNM=CXP*CYP - - CPH=SQRT(XT*XT+YT*YT) - IF (CPH.EQ.0D0) XT=1D0 - SEL=YT/CPH - CEL=XT/CPH - -* Return true longitude and true geodetic latitude of site - IF (XT.NE.0D0.OR.YT.NE.0D0) THEN - ELONG=ATAN2(YT,XT) - ELSE - ELONG=0D0 - END IF - PHI=ATAN2(ZT,CPH) - -* Return current azimuth of terrestrial pole seen from site position - XNT=(XNM*CEL+YNM*SEL)*ZT-ZNM*CPH - YNT=-XNM*SEL+YNM*CEL - IF (XNT.NE.0D0.OR.YNT.NE.0D0) THEN - DAZ=ATAN2(-YNT,-XNT) - ELSE - DAZ=0D0 - END IF - - END diff --git a/src/slalib/prebn.f b/src/slalib/prebn.f deleted file mode 100644 index 71fb73b72..000000000 --- a/src/slalib/prebn.f +++ /dev/null @@ -1,79 +0,0 @@ - SUBROUTINE sla_PREBN (BEP0, BEP1, RMATP) -*+ -* - - - - - - -* P R E B N -* - - - - - - -* -* Generate the matrix of precession between two epochs, -* using the old, pre-IAU1976, Bessel-Newcomb model, using -* Kinoshita's formulation (double precision) -* -* Given: -* BEP0 dp beginning Besselian epoch -* BEP1 dp ending Besselian epoch -* -* Returned: -* RMATP dp(3,3) precession matrix -* -* The matrix is in the sense V(BEP1) = RMATP * V(BEP0) -* -* Reference: -* Kinoshita, H. (1975) 'Formulas for precession', SAO Special -* Report No. 364, Smithsonian Institution Astrophysical -* Observatory, Cambridge, Massachusetts. -* -* Called: sla_DEULER -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION BEP0,BEP1,RMATP(3,3) - -* Arc seconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - - DOUBLE PRECISION BIGT,T,TAS2R,W,ZETA,Z,THETA - - - -* Interval between basic epoch B1850.0 and beginning epoch in TC - BIGT = (BEP0-1850D0)/100D0 - -* Interval over which precession required, in tropical centuries - T = (BEP1-BEP0)/100D0 - -* Euler angles - TAS2R = T*AS2R - W = 2303.5548D0+(1.39720D0+0.000059D0*BIGT)*BIGT - - ZETA = (W+(0.30242D0-0.000269D0*BIGT+0.017996D0*T)*T)*TAS2R - Z = (W+(1.09478D0+0.000387D0*BIGT+0.018324D0*T)*T)*TAS2R - THETA = (2005.1125D0+(-0.85294D0-0.000365D0*BIGT)*BIGT+ - : (-0.42647D0-0.000365D0*BIGT-0.041802D0*T)*T)*TAS2R - -* Rotation matrix - CALL sla_DEULER('ZYZ',-ZETA,THETA,-Z,RMATP) - - END diff --git a/src/slalib/prec.f b/src/slalib/prec.f deleted file mode 100644 index 34804dde0..000000000 --- a/src/slalib/prec.f +++ /dev/null @@ -1,96 +0,0 @@ - SUBROUTINE sla_PREC (EP0, EP1, RMATP) -*+ -* - - - - - -* P R E C -* - - - - - -* -* Form the matrix of precession between two epochs (IAU 1976, FK5) -* (double precision) -* -* Given: -* EP0 dp beginning epoch -* EP1 dp ending epoch -* -* Returned: -* RMATP dp(3,3) precession matrix -* -* Notes: -* -* 1) The epochs are TDB (loosely ET) Julian epochs. -* -* 2) The matrix is in the sense V(EP1) = RMATP * V(EP0) -* -* 3) Though the matrix method itself is rigorous, the precession -* angles are expressed through canonical polynomials which are -* valid only for a limited time span. There are also known -* errors in the IAU precession rate. The absolute accuracy -* of the present formulation is better than 0.1 arcsec from -* 1960AD to 2040AD, better than 1 arcsec from 1640AD to 2360AD, -* and remains below 3 arcsec for the whole of the period -* 500BC to 3000AD. The errors exceed 10 arcsec outside the -* range 1200BC to 3900AD, exceed 100 arcsec outside 4200BC to -* 5600AD and exceed 1000 arcsec outside 6800BC to 8200AD. -* The SLALIB routine sla_PRECL implements a more elaborate -* model which is suitable for problems spanning several -* thousand years. -* -* References: -* Lieske,J.H., 1979. Astron.Astrophys.,73,282. -* equations (6) & (7), p283. -* Kaplan,G.H., 1981. USNO circular no. 163, pA2. -* -* Called: sla_DEULER -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EP0,EP1,RMATP(3,3) - -* Arc seconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - - DOUBLE PRECISION T0,T,TAS2R,W,ZETA,Z,THETA - - - -* Interval between basic epoch J2000.0 and beginning epoch (JC) - T0 = (EP0-2000D0)/100D0 - -* Interval over which precession required (JC) - T = (EP1-EP0)/100D0 - -* Euler angles - TAS2R = T*AS2R - W = 2306.2181D0+(1.39656D0-0.000139D0*T0)*T0 - - ZETA = (W+((0.30188D0-0.000344D0*T0)+0.017998D0*T)*T)*TAS2R - Z = (W+((1.09468D0+0.000066D0*T0)+0.018203D0*T)*T)*TAS2R - THETA = ((2004.3109D0+(-0.85330D0-0.000217D0*T0)*T0) - : +((-0.42665D0-0.000217D0*T0)-0.041833D0*T)*T)*TAS2R - -* Rotation matrix - CALL sla_DEULER('ZYZ',-ZETA,THETA,-Z,RMATP) - - END diff --git a/src/slalib/preces.f b/src/slalib/preces.f deleted file mode 100644 index 1f27349cc..000000000 --- a/src/slalib/preces.f +++ /dev/null @@ -1,101 +0,0 @@ - SUBROUTINE sla_PRECES (SYSTEM, EP0, EP1, RA, DC) -*+ -* - - - - - - - -* P R E C E S -* - - - - - - - -* -* Precession - either FK4 (Bessel-Newcomb, pre IAU 1976) or -* FK5 (Fricke, post IAU 1976) as required. -* -* Given: -* SYSTEM char precession to be applied: 'FK4' or 'FK5' -* EP0,EP1 dp starting and ending epoch -* RA,DC dp RA,Dec, mean equator & equinox of epoch EP0 -* -* Returned: -* RA,DC dp RA,Dec, mean equator & equinox of epoch EP1 -* -* Called: sla_DRANRM, sla_PREBN, sla_PREC, sla_DCS2C, -* sla_DMXV, sla_DCC2S -* -* Notes: -* -* 1) Lowercase characters in SYSTEM are acceptable. -* -* 2) The epochs are Besselian if SYSTEM='FK4' and Julian if 'FK5'. -* For example, to precess coordinates in the old system from -* equinox 1900.0 to 1950.0 the call would be: -* CALL sla_PRECES ('FK4', 1900D0, 1950D0, RA, DC) -* -* 3) This routine will NOT correctly convert between the old and -* the new systems - for example conversion from B1950 to J2000. -* For these purposes see sla_FK425, sla_FK524, sla_FK45Z and -* sla_FK54Z. -* -* 4) If an invalid SYSTEM is supplied, values of -99D0,-99D0 will -* be returned for both RA and DC. -* -* P.T.Wallace Starlink 20 April 1990 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER SYSTEM*(*) - DOUBLE PRECISION EP0,EP1,RA,DC - - DOUBLE PRECISION PM(3,3),V1(3),V2(3) - CHARACTER SYSUC*3 - - DOUBLE PRECISION sla_DRANRM - - - - -* Convert to uppercase and validate SYSTEM - SYSUC=SYSTEM - IF (SYSUC(1:1).EQ.'f') SYSUC(1:1)='F' - IF (SYSUC(2:2).EQ.'k') SYSUC(2:2)='K' - IF (SYSUC.NE.'FK4'.AND.SYSUC.NE.'FK5') THEN - RA=-99D0 - DC=-99D0 - ELSE - -* Generate appropriate precession matrix - IF (SYSUC.EQ.'FK4') THEN - CALL sla_PREBN(EP0,EP1,PM) - ELSE - CALL sla_PREC(EP0,EP1,PM) - END IF - -* Convert RA,Dec to x,y,z - CALL sla_DCS2C(RA,DC,V1) - -* Precess - CALL sla_DMXV(PM,V1,V2) - -* Back to RA,Dec - CALL sla_DCC2S(V2,RA,DC) - RA=sla_DRANRM(RA) - - END IF - - END diff --git a/src/slalib/precl.f b/src/slalib/precl.f deleted file mode 100644 index 411afaade..000000000 --- a/src/slalib/precl.f +++ /dev/null @@ -1,142 +0,0 @@ - SUBROUTINE sla_PRECL (EP0, EP1, RMATP) -*+ -* - - - - - - -* P R E C L -* - - - - - - -* -* Form the matrix of precession between two epochs, using the -* model of Simon et al (1994), which is suitable for long -* periods of time. -* -* (double precision) -* -* Given: -* EP0 dp beginning epoch -* EP1 dp ending epoch -* -* Returned: -* RMATP dp(3,3) precession matrix -* -* Notes: -* -* 1) The epochs are TDB Julian epochs. -* -* 2) The matrix is in the sense V(EP1) = RMATP * V(EP0) -* -* 3) The absolute accuracy of the model is limited by the -* uncertainty in the general precession, about 0.3 arcsec per -* 1000 years. The remainder of the formulation provides a -* precision of 1 mas over the interval from 1000AD to 3000AD, -* 0.1 arcsec from 1000BC to 5000AD and 1 arcsec from -* 4000BC to 8000AD. -* -* Reference: -* Simon, J.L. et al., 1994. Astron.Astrophys., 282, 663-683. -* -* Called: sla_DEULER -* -* P.T.Wallace Starlink 23 August 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EP0,EP1,RMATP(3,3) - -* Arc seconds to radians - DOUBLE PRECISION AS2R - PARAMETER (AS2R=0.484813681109535994D-5) - - DOUBLE PRECISION T0,T,TAS2R,W,ZETA,Z,THETA - - - -* Interval between basic epoch J2000.0 and beginning epoch (1000JY) - T0 = (EP0-2000D0)/1000D0 - -* Interval over which precession required (1000JY) - T = (EP1-EP0)/1000D0 - -* Euler angles - TAS2R = T*AS2R - W = 23060.9097D0+ - : (139.7459D0+ - : (-0.0038D0+ - : (-0.5918D0+ - : (-0.0037D0+ - : 0.0007D0*T0)*T0)*T0)*T0)*T0 - - ZETA = (W+(30.2226D0+ - : (-0.2523D0+ - : (-0.3840D0+ - : (-0.0014D0+ - : 0.0007D0*T0)*T0)*T0)*T0+ - : (18.0183D0+ - : (-0.1326D0+ - : (0.0006D0+ - : 0.0005D0*T0)*T0)*T0+ - : (-0.0583D0+ - : (-0.0001D0+ - : 0.0007D0*T0)*T0+ - : (-0.0285D0+ - : (-0.0002D0)*T)*T)*T)*T)*T)*TAS2R - - Z = (W+(109.5270D0+ - : (0.2446D0+ - : (-1.3913D0+ - : (-0.0134D0+ - : 0.0026D0*T0)*T0)*T0)*T0+ - : (18.2667D0+ - : (-1.1400D0+ - : (-0.0173D0+ - : 0.0044D0*T0)*T0)*T0+ - : (-0.2821D0+ - : (-0.0093D0+ - : 0.0032D0*T0)*T0+ - : (-0.0301D0+ - : 0.0006D0*T0 - : -0.0001D0*T)*T)*T)*T)*T)*TAS2R - - THETA = (20042.0207D0+ - : (-85.3131D0+ - : (-0.2111D0+ - : (0.3642D0+ - : (0.0008D0+ - : (-0.0005D0)*T0)*T0)*T0)*T0)*T0+ - : (-42.6566D0+ - : (-0.2111D0+ - : (0.5463D0+ - : (0.0017D0+ - : (-0.0012D0)*T0)*T0)*T0)*T0+ - : (-41.8238D0+ - : (0.0359D0+ - : (0.0027D0+ - : (-0.0001D0)*T0)*T0)*T0+ - : (-0.0731D0+ - : (0.0019D0+ - : 0.0009D0*T0)*T0+ - : (-0.0127D0+ - : 0.0011D0*T0+0.0004D0*T)*T)*T)*T)*T)*TAS2R - -* Rotation matrix - CALL sla_DEULER('ZYZ',-ZETA,THETA,-Z,RMATP) - - END diff --git a/src/slalib/prenut.f b/src/slalib/prenut.f deleted file mode 100644 index 81696063e..000000000 --- a/src/slalib/prenut.f +++ /dev/null @@ -1,66 +0,0 @@ - SUBROUTINE sla_PRENUT (EPOCH, DATE, RMATPN) -*+ -* - - - - - - - -* P R E N U T -* - - - - - - - -* -* Form the matrix of precession and nutation (SF2001) -* (double precision) -* -* Given: -* EPOCH dp Julian Epoch for mean coordinates -* DATE dp Modified Julian Date (JD-2400000.5) -* for true coordinates -* -* Returned: -* RMATPN dp(3,3) combined precession/nutation matrix -* -* Called: sla_PREC, sla_EPJ, sla_NUT, sla_DMXM -* -* Notes: -* -* 1) The epoch and date are TDB (loosely ET). TT will do, or even -* UTC. -* -* 2) The matrix is in the sense V(true) = RMATPN * V(mean) -* -* Last revision: 3 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION EPOCH,DATE,RMATPN(3,3) - - DOUBLE PRECISION RMATP(3,3),RMATN(3,3),sla_EPJ - - - -* Precession - CALL sla_PREC(EPOCH,sla_EPJ(DATE),RMATP) - -* Nutation - CALL sla_NUT(DATE,RMATN) - -* Combine the matrices: PN = N x P - CALL sla_DMXM(RMATN,RMATP,RMATPN) - - END diff --git a/src/slalib/pv2el.f b/src/slalib/pv2el.f deleted file mode 100644 index 1ad6ca504..000000000 --- a/src/slalib/pv2el.f +++ /dev/null @@ -1,379 +0,0 @@ - SUBROUTINE sla_PV2EL (PV, DATE, PMASS, JFORMR, - : JFORM, EPOCH, ORBINC, ANODE, PERIH, - : AORQ, E, AORL, DM, JSTAT) -*+ -* - - - - - - -* P V 2 E L -* - - - - - - -* -* Heliocentric osculating elements obtained from instantaneous position -* and velocity. -* -* Given: -* PV d(6) heliocentric x,y,z,xdot,ydot,zdot of date, -* J2000 equatorial triad (AU,AU/s; Note 1) -* DATE d date (TT Modified Julian Date = JD-2400000.5) -* PMASS d mass of the planet (Sun=1; Note 2) -* JFORMR i requested element set (1-3; Note 3) -* -* Returned: -* JFORM d element set actually returned (1-3; Note 4) -* EPOCH d epoch of elements (TT MJD) -* ORBINC d inclination (radians) -* ANODE d longitude of the ascending node (radians) -* PERIH d longitude or argument of perihelion (radians) -* AORQ d mean distance or perihelion distance (AU) -* E d eccentricity -* AORL d mean anomaly or longitude (radians, JFORM=1,2 only) -* DM d daily motion (radians, JFORM=1 only) -* JSTAT i status: 0 = OK -* -1 = illegal PMASS -* -2 = illegal JFORMR -* -3 = position/velocity out of range -* -* Notes -* -* 1 The PV 6-vector is with respect to the mean equator and equinox of -* epoch J2000. The orbital elements produced are with respect to -* the J2000 ecliptic and mean equinox. -* -* 2 The mass, PMASS, is important only for the larger planets. For -* most purposes (e.g. asteroids) use 0D0. Values less than zero -* are illegal. -* -* 3 Three different element-format options are supported: -* -* Option JFORM=1, suitable for the major planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = longitude of perihelion, curly pi (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e -* AORL = mean longitude L (radians) -* DM = daily motion (radians) -* -* Option JFORM=2, suitable for minor planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e -* AORL = mean anomaly M (radians) -* -* Option JFORM=3, suitable for comets: -* -* EPOCH = epoch of perihelion (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = perihelion distance, q (AU) -* E = eccentricity, e -* -* 4 It may not be possible to generate elements in the form -* requested through JFORMR. The caller is notified of the form -* of elements actually returned by means of the JFORM argument: -* -* JFORMR JFORM meaning -* -* 1 1 OK - elements are in the requested format -* 1 2 never happens -* 1 3 orbit not elliptical -* -* 2 1 never happens -* 2 2 OK - elements are in the requested format -* 2 3 orbit not elliptical -* -* 3 1 never happens -* 3 2 never happens -* 3 3 OK - elements are in the requested format -* -* 5 The arguments returned for each value of JFORM (cf Note 5: JFORM -* may not be the same as JFORMR) are as follows: -* -* JFORM 1 2 3 -* EPOCH t0 t0 T -* ORBINC i i i -* ANODE Omega Omega Omega -* PERIH curly pi omega omega -* AORQ a a q -* E e e e -* AORL L M - -* DM n - - -* -* where: -* -* t0 is the epoch of the elements (MJD, TT) -* T " epoch of perihelion (MJD, TT) -* i " inclination (radians) -* Omega " longitude of the ascending node (radians) -* curly pi " longitude of perihelion (radians) -* omega " argument of perihelion (radians) -* a " mean distance (AU) -* q " perihelion distance (AU) -* e " eccentricity -* L " longitude (radians, 0-2pi) -* M " mean anomaly (radians, 0-2pi) -* n " daily motion (radians) -* - means no value is set -* -* 6 At very small inclinations, the longitude of the ascending node -* ANODE becomes indeterminate and under some circumstances may be -* set arbitrarily to zero. Similarly, if the orbit is close to -* circular, the true anomaly becomes indeterminate and under some -* circumstances may be set arbitrarily to zero. In such cases, -* the other elements are automatically adjusted to compensate, -* and so the elements remain a valid description of the orbit. -* -* 7 The osculating epoch for the returned elements is the argument -* DATE. -* -* Reference: Sterne, Theodore E., "An Introduction to Celestial -* Mechanics", Interscience Publishers, 1960 -* -* Called: sla_DRANRM -* -* Last revision: 8 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION PV(6),DATE,PMASS - INTEGER JFORMR,JFORM - DOUBLE PRECISION EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM - INTEGER JSTAT - -* Seconds to days - DOUBLE PRECISION DAY - PARAMETER (DAY=86400D0) - -* Gaussian gravitational constant (exact) - DOUBLE PRECISION GCON - PARAMETER (GCON=0.01720209895D0) - -* Sin and cos of J2000 mean obliquity (IAU 1976) - DOUBLE PRECISION SE,CE - PARAMETER (SE=0.3977771559319137D0, - : CE=0.9174820620691818D0) - -* Minimum allowed distance (AU) and speed (AU/day) - DOUBLE PRECISION RMIN,VMIN - PARAMETER (RMIN=1D-3,VMIN=1D-8) - -* How close to unity the eccentricity has to be to call it a parabola - DOUBLE PRECISION PARAB - PARAMETER (PARAB=1D-8) - - DOUBLE PRECISION X,Y,Z,XD,YD,ZD,R,V2,V,RDV,GMU,HX,HY,HZ, - : HX2PY2,H2,H,OI,BIGOM,AR,ECC,S,C,AT,U,OM, - : GAR3,EM1,EP1,HAT,SHAT,CHAT,AE,AM,DN,PL, - : EL,Q,TP,THAT,THHF,F - - INTEGER JF - - DOUBLE PRECISION sla_DRANRM - - -* Validate arguments PMASS and JFORMR. - IF (PMASS.LT.0D0) THEN - JSTAT = -1 - GO TO 999 - END IF - IF (JFORMR.LT.1.OR.JFORMR.GT.3) THEN - JSTAT = -2 - GO TO 999 - END IF - -* Provisionally assume the elements will be in the chosen form. - JF = JFORMR - -* Rotate the position from equatorial to ecliptic coordinates. - X = PV(1) - Y = PV(2)*CE+PV(3)*SE - Z = -PV(2)*SE+PV(3)*CE - -* Rotate the velocity similarly, scaling to AU/day. - XD = DAY*PV(4) - YD = DAY*(PV(5)*CE+PV(6)*SE) - ZD = DAY*(-PV(5)*SE+PV(6)*CE) - -* Distance and speed. - R = SQRT(X*X+Y*Y+Z*Z) - V2 = XD*XD+YD*YD+ZD*ZD - V = SQRT(V2) - -* Reject unreasonably small values. - IF (R.LT.RMIN.OR.V.LT.VMIN) THEN - JSTAT = -3 - GO TO 999 - END IF - -* R dot V. - RDV = X*XD+Y*YD+Z*ZD - -* Mu. - GMU = (1D0+PMASS)*GCON*GCON - -* Vector angular momentum per unit reduced mass. - HX = Y*ZD-Z*YD - HY = Z*XD-X*ZD - HZ = X*YD-Y*XD - -* Areal constant. - HX2PY2 = HX*HX+HY*HY - H2 = HX2PY2+HZ*HZ - H = SQRT(H2) - -* Inclination. - OI = ATAN2(SQRT(HX2PY2),HZ) - -* Longitude of ascending node. - IF (HX.NE.0D0.OR.HY.NE.0D0) THEN - BIGOM = ATAN2(HX,-HY) - ELSE - BIGOM=0D0 - END IF - -* Reciprocal of mean distance etc. - AR = 2D0/R-V2/GMU - -* Eccentricity. - ECC = SQRT(MAX(1D0-AR*H2/GMU,0D0)) - -* True anomaly. - S = H*RDV - C = H2-R*GMU - IF (S.NE.0D0.OR.C.NE.0D0) THEN - AT = ATAN2(S,C) - ELSE - AT = 0D0 - END IF - -* Argument of the latitude. - S = SIN(BIGOM) - C = COS(BIGOM) - U = ATAN2((-X*S+Y*C)*COS(OI)+Z*SIN(OI),X*C+Y*S) - -* Argument of perihelion. - OM = U-AT - -* Capture near-parabolic cases. - IF (ABS(ECC-1D0).LT.PARAB) ECC=1D0 - -* Comply with JFORMR = 1 or 2 only if orbit is elliptical. - IF (ECC.GE.1D0) JF=3 - -* Functions. - GAR3 = GMU*AR*AR*AR - EM1 = ECC-1D0 - EP1 = ECC+1D0 - HAT = AT/2D0 - SHAT = SIN(HAT) - CHAT = COS(HAT) - -* Variable initializations to avoid compiler warnings. - AM = 0D0 - DN = 0D0 - PL = 0D0 - EL = 0D0 - Q = 0D0 - TP = 0D0 - -* Ellipse? - IF (ECC.LT.1D0 ) THEN - -* Eccentric anomaly. - AE = 2D0*ATAN2(SQRT(-EM1)*SHAT,SQRT(EP1)*CHAT) - -* Mean anomaly. - AM = AE-ECC*SIN(AE) - -* Daily motion. - DN = SQRT(GAR3) - END IF - -* "Major planet" element set? - IF (JF.EQ.1) THEN - -* Longitude of perihelion. - PL = BIGOM+OM - -* Longitude at epoch. - EL = PL+AM - END IF - -* "Comet" element set? - IF (JF.EQ.3) THEN - -* Perihelion distance. - Q = H2/(GMU*EP1) - -* Ellipse, parabola, hyperbola? - IF (ECC.LT.1D0) THEN - -* Ellipse: epoch of perihelion. - TP = DATE-AM/DN - ELSE - -* Parabola or hyperbola: evaluate tan ( ( true anomaly ) / 2 ) - THAT = SHAT/CHAT - IF (ECC.EQ.1D0) THEN - -* Parabola: epoch of perihelion. - TP = DATE-THAT*(1D0+THAT*THAT/3D0)*H*H2/(2D0*GMU*GMU) - ELSE - -* Hyperbola: epoch of perihelion. - THHF = SQRT(EM1/EP1)*THAT - F = LOG(1D0+THHF)-LOG(1D0-THHF) - TP = DATE-(ECC*SINH(F)-F)/SQRT(-GAR3) - END IF - END IF - END IF - -* Return the appropriate set of elements. - JFORM = JF - ORBINC = OI - ANODE = sla_DRANRM(BIGOM) - E = ECC - IF (JF.EQ.1) THEN - PERIH = sla_DRANRM(PL) - AORL = sla_DRANRM(EL) - DM = DN - ELSE - PERIH = sla_DRANRM(OM) - IF (JF.EQ.2) AORL = sla_DRANRM(AM) - END IF - IF (JF.NE.3) THEN - EPOCH = DATE - AORQ = 1D0/AR - ELSE - EPOCH = TP - AORQ = Q - END IF - JSTAT = 0 - - 999 CONTINUE - END diff --git a/src/slalib/pv2ue.f b/src/slalib/pv2ue.f deleted file mode 100644 index ff6366697..000000000 --- a/src/slalib/pv2ue.f +++ /dev/null @@ -1,167 +0,0 @@ - SUBROUTINE sla_PV2UE (PV, DATE, PMASS, U, JSTAT) -*+ -* - - - - - - -* P V 2 U E -* - - - - - - -* -* Construct a universal element set based on an instantaneous position -* and velocity. -* -* Given: -* PV d(6) heliocentric x,y,z,xdot,ydot,zdot of date, -* (AU,AU/s; Note 1) -* DATE d date (TT Modified Julian Date = JD-2400000.5) -* PMASS d mass of the planet (Sun=1; Note 2) -* -* Returned: -* U d(13) universal orbital elements (Note 3) -* -* (1) combined mass (M+m) -* (2) total energy of the orbit (alpha) -* (3) reference (osculating) epoch (t0) -* (4-6) position at reference epoch (r0) -* (7-9) velocity at reference epoch (v0) -* (10) heliocentric distance at reference epoch -* (11) r0.v0 -* (12) date (t) -* (13) universal eccentric anomaly (psi) of date, approx -* -* JSTAT i status: 0 = OK -* -1 = illegal PMASS -* -2 = too close to Sun -* -3 = too slow -* -* Notes -* -* 1 The PV 6-vector can be with respect to any chosen inertial frame, -* and the resulting universal-element set will be with respect to -* the same frame. A common choice will be mean equator and ecliptic -* of epoch J2000. -* -* 2 The mass, PMASS, is important only for the larger planets. For -* most purposes (e.g. asteroids) use 0D0. Values less than zero -* are illegal. -* -* 3 The "universal" elements are those which define the orbit for the -* purposes of the method of universal variables (see reference). -* They consist of the combined mass of the two bodies, an epoch, -* and the position and velocity vectors (arbitrary reference frame) -* at that epoch. The parameter set used here includes also various -* quantities that can, in fact, be derived from the other -* information. This approach is taken to avoiding unnecessary -* computation and loss of accuracy. The supplementary quantities -* are (i) alpha, which is proportional to the total energy of the -* orbit, (ii) the heliocentric distance at epoch, (iii) the -* outwards component of the velocity at the given epoch, (iv) an -* estimate of psi, the "universal eccentric anomaly" at a given -* date and (v) that date. -* -* Reference: Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983. -* -* P.T.Wallace Starlink 18 March 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION PV(6),DATE,PMASS,U(13) - INTEGER JSTAT - -* Gaussian gravitational constant (exact) - DOUBLE PRECISION GCON - PARAMETER (GCON=0.01720209895D0) - -* Canonical days to seconds - DOUBLE PRECISION CD2S - PARAMETER (CD2S=GCON/86400D0) - -* Minimum allowed distance (AU) and speed (AU per canonical day) - DOUBLE PRECISION RMIN,VMIN - PARAMETER (RMIN=1D-3,VMIN=1D-3) - - DOUBLE PRECISION T0,CM,X,Y,Z,XD,YD,ZD,R,V2,V,ALPHA,RDV - - -* Reference epoch. - T0 = DATE - -* Combined mass (mu=M+m). - IF (PMASS.LT.0D0) GO TO 9010 - CM = 1D0+PMASS - -* Unpack the state vector, expressing velocity in AU per canonical day. - X = PV(1) - Y = PV(2) - Z = PV(3) - XD = PV(4)/CD2S - YD = PV(5)/CD2S - ZD = PV(6)/CD2S - -* Heliocentric distance, and speed. - R = SQRT(X*X+Y*Y+Z*Z) - V2 = XD*XD+YD*YD+ZD*ZD - V = SQRT(V2) - -* Reject unreasonably small values. - IF (R.LT.RMIN) GO TO 9020 - IF (V.LT.VMIN) GO TO 9030 - -* Total energy of the orbit. - ALPHA = V2-2D0*CM/R - -* Outward component of velocity. - RDV = X*XD+Y*YD+Z*ZD - -* Construct the universal-element set. - U(1) = CM - U(2) = ALPHA - U(3) = T0 - U(4) = X - U(5) = Y - U(6) = Z - U(7) = XD - U(8) = YD - U(9) = ZD - U(10) = R - U(11) = RDV - U(12) = T0 - U(13) = 0D0 - -* Exit. - JSTAT = 0 - GO TO 9999 - -* Negative PMASS. - 9010 CONTINUE - JSTAT = -1 - GO TO 9999 - -* Too close. - 9020 CONTINUE - JSTAT = -2 - GO TO 9999 - -* Too slow. - 9030 CONTINUE - JSTAT = -3 - - 9999 CONTINUE - END diff --git a/src/slalib/pvobs.f b/src/slalib/pvobs.f deleted file mode 100644 index 55305ed5e..000000000 --- a/src/slalib/pvobs.f +++ /dev/null @@ -1,76 +0,0 @@ - SUBROUTINE sla_PVOBS (P, H, STL, PV) -*+ -* - - - - - - -* P V O B S -* - - - - - - -* -* Position and velocity of an observing station (double precision) -* -* Given: -* P dp latitude (geodetic, radians) -* H dp height above reference spheroid (geodetic, metres) -* STL dp local apparent sidereal time (radians) -* -* Returned: -* PV dp(6) position/velocity 6-vector (AU, AU/s, true equator -* and equinox of date) -* -* Called: sla_GEOC -* -* IAU 1976 constants are used. -* -* P.T.Wallace Starlink 14 November 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION P,H,STL,PV(6) - - DOUBLE PRECISION R,Z,S,C,V - -* Mean sidereal rate (at J2000) in radians per (UT1) second - DOUBLE PRECISION SR - PARAMETER (SR=7.292115855306589D-5) - - - -* Geodetic to geocentric conversion - CALL sla_GEOC(P,H,R,Z) - -* Functions of ST - S=SIN(STL) - C=COS(STL) - -* Speed - V=SR*R - -* Position - PV(1)=R*C - PV(2)=R*S - PV(3)=Z - -* Velocity - PV(4)=-V*S - PV(5)=V*C - PV(6)=0D0 - - END diff --git a/src/slalib/pxy.f b/src/slalib/pxy.f deleted file mode 100644 index f768a1a31..000000000 --- a/src/slalib/pxy.f +++ /dev/null @@ -1,109 +0,0 @@ - SUBROUTINE sla_PXY (NP,XYE,XYM,COEFFS,XYP,XRMS,YRMS,RRMS) -*+ -* - - - - -* P X Y -* - - - - -* -* Given arrays of "expected" and "measured" [X,Y] coordinates, and a -* linear model relating them (as produced by sla_FITXY), compute -* the array of "predicted" coordinates and the RMS residuals. -* -* Given: -* NP i number of samples -* XYE d(2,np) expected [X,Y] for each sample -* XYM d(2,np) measured [X,Y] for each sample -* COEFFS d(6) coefficients of model (see below) -* -* Returned: -* XYP d(2,np) predicted [X,Y] for each sample -* XRMS d RMS in X -* YRMS d RMS in Y -* RRMS d total RMS (vector sum of XRMS and YRMS) -* -* The model is supplied in the array COEFFS. Naming the -* elements of COEFF as follows: -* -* COEFFS(1) = A -* COEFFS(2) = B -* COEFFS(3) = C -* COEFFS(4) = D -* COEFFS(5) = E -* COEFFS(6) = F -* -* the model is applied thus: -* -* XP = A + B*XM + C*YM -* YP = D + E*XM + F*YM -* -* The residuals are (XP-XE) and (YP-YE). -* -* If NP is less than or equal to zero, no coordinates are -* transformed, and the RMS residuals are all zero. -* -* See also sla_FITXY, sla_INVF, sla_XY2XY, sla_DCMPF -* -* Called: sla_XY2XY -* -* P.T.Wallace Starlink 22 May 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER NP - DOUBLE PRECISION XYE(2,NP),XYM(2,NP),COEFFS(6), - : XYP(2,NP),XRMS,YRMS,RRMS - - INTEGER I - DOUBLE PRECISION SDX2,SDY2,XP,YP,DX,DY,DX2,DY2,P - - - -* Initialize summations - SDX2=0D0 - SDY2=0D0 - -* Loop by sample - DO I=1,NP - -* Transform "measured" [X,Y] to "predicted" [X,Y] - CALL sla_XY2XY(XYM(1,I),XYM(2,I),COEFFS,XP,YP) - XYP(1,I)=XP - XYP(2,I)=YP - -* Compute residuals in X and Y, and update summations - DX=XYE(1,I)-XP - DY=XYE(2,I)-YP - DX2=DX*DX - DY2=DY*DY - SDX2=SDX2+DX2 - SDY2=SDY2+DY2 - -* Next sample - END DO - -* Compute RMS values - P=MAX(1D0,DBLE(NP)) - XRMS=SQRT(SDX2/P) - YRMS=SQRT(SDY2/P) - RRMS=SQRT(XRMS*XRMS+YRMS*YRMS) - - END diff --git a/src/slalib/random.F b/src/slalib/random.F deleted file mode 100644 index 0d5bd74ed..000000000 --- a/src/slalib/random.F +++ /dev/null @@ -1,87 +0,0 @@ -#include - REAL FUNCTION sla_RANDOM (SEED) -*+ -* - - - - - - - -* R A N D O M -* - - - - - - - -* -* Generate pseudo-random real number in the range 0 <= X < 1. -* (single precision) -* -* -* Given: -* SEED real an arbitrary real number -* -* Notes: -* -* 1) The result is a pseudo-random REAL number in the range -* 0 <= sla_RANDOM < 1. -* -* 2) SEED is used first time through only. -* -* Called: RAN or RAND (a REAL function returning a random variate -- -* the precise function which is called depends on which functions -* are available when the library is built). If neither of these -* is available, we use the local substitute RANDOM defined -* in rtl_random.c -* -* P.T.Wallace Starlink 14 October 1991 -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -*- - - IMPLICIT NONE - - REAL SEED - -#if HAVE_RAND - REAL RAND -#elif HAVE_RANDOM - REAL RANDOM -#else - error "Can't find random-number function" -#endif - - REAL AS - INTEGER ISEED - LOGICAL FIRST - SAVE FIRST - DATA FIRST /.TRUE./ - - - -* If first time, turn SEED into a large, odd integer - IF (FIRST) THEN - AS=ABS(SEED)+1.0 - ISEED=NINT(AS/10.0**(NINT(ALOG10(AS))-6)) - IF (MOD(ISEED,2).EQ.0) ISEED=ISEED+1 - FIRST=.FALSE. -#if HAVE_RAND - AS = RAND(ISEED) -#endif - ELSE - ISEED=0 - END IF - -* Next pseudo-random number -#if HAVE_RAND - sla_RANDOM=RAND(0) -#elif HAVE_RANDOM - sla_RANDOM=RANDOM(ISEED) -#endif - - END diff --git a/src/slalib/range.f b/src/slalib/range.f deleted file mode 100644 index ff5a70288..000000000 --- a/src/slalib/range.f +++ /dev/null @@ -1,50 +0,0 @@ - REAL FUNCTION sla_RANGE (ANGLE) -*+ -* - - - - - - -* R A N G E -* - - - - - - -* -* Normalize angle into range +/- pi (single precision) -* -* Given: -* ANGLE dp the angle in radians -* -* The result is ANGLE expressed in the +/- pi (single -* precision). -* -* P.T.Wallace Starlink 23 November 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL ANGLE - - REAL API,A2PI - PARAMETER (API=3.141592653589793238462643) - PARAMETER (A2PI=6.283185307179586476925287) - - - sla_RANGE=MOD(ANGLE,A2PI) - IF (ABS(sla_RANGE).GE.API) - : sla_RANGE=sla_RANGE-SIGN(A2PI,ANGLE) - - END diff --git a/src/slalib/ranorm.f b/src/slalib/ranorm.f deleted file mode 100644 index 963e71c6d..000000000 --- a/src/slalib/ranorm.f +++ /dev/null @@ -1,48 +0,0 @@ - REAL FUNCTION sla_RANORM (ANGLE) -*+ -* - - - - - - - -* R A N O R M -* - - - - - - - -* -* Normalize angle into range 0-2 pi (single precision) -* -* Given: -* ANGLE dp the angle in radians -* -* The result is ANGLE expressed in the range 0-2 pi (single -* precision). -* -* P.T.Wallace Starlink 23 November 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL ANGLE - - REAL A2PI - PARAMETER (A2PI=6.283185307179586476925287) - - - sla_RANORM=MOD(ANGLE,A2PI) - IF (sla_RANORM.LT.0.0) sla_RANORM=sla_RANORM+A2PI - - END diff --git a/src/slalib/rcc.f b/src/slalib/rcc.f deleted file mode 100644 index 013777dd8..000000000 --- a/src/slalib/rcc.f +++ /dev/null @@ -1,1109 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_RCC (TDB, UT1, WL, U, V) -*+ -* - - - - -* R C C -* - - - - -* -* Relativistic clock correction: the difference between proper time at -* a point on the surface of the Earth and coordinate time in the Solar -* System barycentric space-time frame of reference. -* -* The proper time is terrestrial time, TT; the coordinate time is an -* implementation of barycentric dynamical time, TDB. -* -* Given: -* TDB d TDB (MJD: JD-2400000.5) -* UT1 d universal time (fraction of one day) -* WL d clock longitude (radians west) -* U d clock distance from Earth spin axis (km) -* V d clock distance north of Earth equatorial plane (km) -* -* Returned: -* The clock correction, TDB-TT, in seconds: -* -* . TDB is coordinate time in the solar system barycentre frame -* of reference, in units chosen to eliminate the scale difference -* with respect to terrestrial time. -* -* . TT is the proper time for clocks at mean sea level on the -* Earth. -* -* Notes: -* -* 1 The argument TDB is, strictly, the barycentric coordinate time; -* however, the terrestrial time TT can in practice be used without -* any significant loss of accuracy. -* -* 2 The result returned by sla_RCC comprises a main (annual) -* sinusoidal term of amplitude approximately 0.00166 seconds, plus -* planetary and lunar terms up to about 20 microseconds, and diurnal -* terms up to 2 microseconds. The variation arises from the -* transverse Doppler effect and the gravitational red-shift as the -* observer varies in speed and moves through different gravitational -* potentials. -* -* 3 The geocentric model is that of Fairhead & Bretagnon (1990), in -* its full form. It was supplied by Fairhead (private -* communication) as a FORTRAN subroutine. The original Fairhead -* routine used explicit formulae, in such large numbers that -* problems were experienced with certain compilers (Microsoft -* Fortran on PC aborted with stack overflow, Convex compiled -* successfully but extremely slowly). The present implementation is -* a complete recoding, with the original Fairhead coefficients held -* in a table. To optimise arithmetic precision, the terms are -* accumulated in reverse order, smallest first. A number of other -* coding changes were made, in order to match the calling sequence -* of previous versions of the present routine, and to comply with -* Starlink programming standards. The numerical results compared -* with those from the Fairhead form are essentially unaffected by -* the changes, the differences being at the 10^-20 sec level. -* -* 4 The topocentric part of the model is from Moyer (1981) and -* Murray (1983). It is an approximation to the expression -* ( v / c ) . ( r / c ), where v is the barycentric velocity of -* the Earth, r is the geocentric position of the observer and -* c is the speed of light. -* -* 5 During the interval 1950-2050, the absolute accuracy of is better -* than +/- 3 nanoseconds relative to direct numerical integrations -* using the JPL DE200/LE200 solar system ephemeris. -* -* 6 The IAU definition of TDB was that it must differ from TT only by -* periodic terms. Though practical, this is an imprecise definition -* which ignores the existence of very long-period and secular -* effects in the dynamics of the solar system. As a consequence, -* different implementations of TDB will, in general, differ in zero- -* point and will drift linearly relative to one other. -* -* 7 TDB was, in principle, superseded by new coordinate timescales -* which the IAU introduced in 1991: geocentric coordinate time, -* TCG, and barycentric coordinate time, TCB. However, sla_RCC -* can be used to implement the periodic part of TCB-TCG. -* -* References: -* -* 1 Fairhead, L., & Bretagnon, P., Astron.Astrophys., 229, 240-247 -* (1990). -* -* 2 Moyer, T.D., Cel.Mech., 23, 33 (1981). -* -* 3 Murray, C.A., Vectorial Astrometry, Adam Hilger (1983). -* -* 4 Seidelmann, P.K. et al, Explanatory Supplement to the -* Astronomical Almanac, Chapter 2, University Science Books -* (1992). -* -* 5 Simon J.L., Bretagnon P., Chapront J., Chapront-Touze M., -* Francou G. & Laskar J., Astron.Astrophys., 282, 663-683 (1994). -* -* P.T.Wallace Starlink 7 May 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION TDB,UT1,WL,U,V - - DOUBLE PRECISION D2PI,D2R - PARAMETER (D2PI=6.283185307179586476925287D0, - : D2R=0.0174532925199432957692369D0) - - DOUBLE PRECISION T,TSOL,W,ELSUN,EMSUN,D,ELJ,ELS, - : WT,W0,W1,W2,W3,W4,WF,WJ - -* ----------------------------------------------------------------------- -* -* Fairhead and Bretagnon canonical coefficients -* -* 787 sets of three coefficients. -* -* Each set is amplitude (microseconds) -* frequency (radians per Julian millennium since J2000), -* phase (radians). -* -* Sets 1-474 are the T**0 terms, -* " 475-679 " " T**1 " -* " 680-764 " " T**2 " -* " 765-784 " " T**3 " -* " 785-787 " " T**4 " . -* - DOUBLE PRECISION FAIRHD(3,787) - INTEGER I,J - DATA ((FAIRHD(I,J),I=1,3),J= 1, 10) / - : 1656.674564D-6, 6283.075849991D0, 6.240054195D0, - : 22.417471D-6, 5753.384884897D0, 4.296977442D0, - : 13.839792D-6, 12566.151699983D0, 6.196904410D0, - : 4.770086D-6, 529.690965095D0, 0.444401603D0, - : 4.676740D-6, 6069.776754553D0, 4.021195093D0, - : 2.256707D-6, 213.299095438D0, 5.543113262D0, - : 1.694205D-6, -3.523118349D0, 5.025132748D0, - : 1.554905D-6, 77713.771467920D0, 5.198467090D0, - : 1.276839D-6, 7860.419392439D0, 5.988822341D0, - : 1.193379D-6, 5223.693919802D0, 3.649823730D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 11, 20) / - : 1.115322D-6, 3930.209696220D0, 1.422745069D0, - : 0.794185D-6, 11506.769769794D0, 2.322313077D0, - : 0.447061D-6, 26.298319800D0, 3.615796498D0, - : 0.435206D-6, -398.149003408D0, 4.349338347D0, - : 0.600309D-6, 1577.343542448D0, 2.678271909D0, - : 0.496817D-6, 6208.294251424D0, 5.696701824D0, - : 0.486306D-6, 5884.926846583D0, 0.520007179D0, - : 0.432392D-6, 74.781598567D0, 2.435898309D0, - : 0.468597D-6, 6244.942814354D0, 5.866398759D0, - : 0.375510D-6, 5507.553238667D0, 4.103476804D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 21, 30) / - : 0.243085D-6, -775.522611324D0, 3.651837925D0, - : 0.173435D-6, 18849.227549974D0, 6.153743485D0, - : 0.230685D-6, 5856.477659115D0, 4.773852582D0, - : 0.203747D-6, 12036.460734888D0, 4.333987818D0, - : 0.143935D-6, -796.298006816D0, 5.957517795D0, - : 0.159080D-6, 10977.078804699D0, 1.890075226D0, - : 0.119979D-6, 38.133035638D0, 4.551585768D0, - : 0.118971D-6, 5486.777843175D0, 1.914547226D0, - : 0.116120D-6, 1059.381930189D0, 0.873504123D0, - : 0.137927D-6, 11790.629088659D0, 1.135934669D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 31, 40) / - : 0.098358D-6, 2544.314419883D0, 0.092793886D0, - : 0.101868D-6, -5573.142801634D0, 5.984503847D0, - : 0.080164D-6, 206.185548437D0, 2.095377709D0, - : 0.079645D-6, 4694.002954708D0, 2.949233637D0, - : 0.062617D-6, 20.775395492D0, 2.654394814D0, - : 0.075019D-6, 2942.463423292D0, 4.980931759D0, - : 0.064397D-6, 5746.271337896D0, 1.280308748D0, - : 0.063814D-6, 5760.498431898D0, 4.167901731D0, - : 0.048042D-6, 2146.165416475D0, 1.495846011D0, - : 0.048373D-6, 155.420399434D0, 2.251573730D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 41, 50) / - : 0.058844D-6, 426.598190876D0, 4.839650148D0, - : 0.046551D-6, -0.980321068D0, 0.921573539D0, - : 0.054139D-6, 17260.154654690D0, 3.411091093D0, - : 0.042411D-6, 6275.962302991D0, 2.869567043D0, - : 0.040184D-6, -7.113547001D0, 3.565975565D0, - : 0.036564D-6, 5088.628839767D0, 3.324679049D0, - : 0.040759D-6, 12352.852604545D0, 3.981496998D0, - : 0.036507D-6, 801.820931124D0, 6.248866009D0, - : 0.036955D-6, 3154.687084896D0, 5.071801441D0, - : 0.042732D-6, 632.783739313D0, 5.720622217D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 51, 60) / - : 0.042560D-6, 161000.685737473D0, 1.270837679D0, - : 0.040480D-6, 15720.838784878D0, 2.546610123D0, - : 0.028244D-6, -6286.598968340D0, 5.069663519D0, - : 0.033477D-6, 6062.663207553D0, 4.144987272D0, - : 0.034867D-6, 522.577418094D0, 5.210064075D0, - : 0.032438D-6, 6076.890301554D0, 0.749317412D0, - : 0.030215D-6, 7084.896781115D0, 3.389610345D0, - : 0.029247D-6, -71430.695617928D0, 4.183178762D0, - : 0.033529D-6, 9437.762934887D0, 2.404714239D0, - : 0.032423D-6, 8827.390269875D0, 5.541473556D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 61, 70) / - : 0.027567D-6, 6279.552731642D0, 5.040846034D0, - : 0.029862D-6, 12139.553509107D0, 1.770181024D0, - : 0.022509D-6, 10447.387839604D0, 1.460726241D0, - : 0.020937D-6, 8429.241266467D0, 0.652303414D0, - : 0.020322D-6, 419.484643875D0, 3.735430632D0, - : 0.024816D-6, -1194.447010225D0, 1.087136918D0, - : 0.025196D-6, 1748.016413067D0, 2.901883301D0, - : 0.021691D-6, 14143.495242431D0, 5.952658009D0, - : 0.017673D-6, 6812.766815086D0, 3.186129845D0, - : 0.022567D-6, 6133.512652857D0, 3.307984806D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 71, 80) / - : 0.016155D-6, 10213.285546211D0, 1.331103168D0, - : 0.014751D-6, 1349.867409659D0, 4.308933301D0, - : 0.015949D-6, -220.412642439D0, 4.005298270D0, - : 0.015974D-6, -2352.866153772D0, 6.145309371D0, - : 0.014223D-6, 17789.845619785D0, 2.104551349D0, - : 0.017806D-6, 73.297125859D0, 3.475975097D0, - : 0.013671D-6, -536.804512095D0, 5.971672571D0, - : 0.011942D-6, 8031.092263058D0, 2.053414715D0, - : 0.014318D-6, 16730.463689596D0, 3.016058075D0, - : 0.012462D-6, 103.092774219D0, 1.737438797D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 81, 90) / - : 0.010962D-6, 3.590428652D0, 2.196567739D0, - : 0.015078D-6, 19651.048481098D0, 3.969480770D0, - : 0.010396D-6, 951.718406251D0, 5.717799605D0, - : 0.011707D-6, -4705.732307544D0, 2.654125618D0, - : 0.010453D-6, 5863.591206116D0, 1.913704550D0, - : 0.012420D-6, 4690.479836359D0, 4.734090399D0, - : 0.011847D-6, 5643.178563677D0, 5.489005403D0, - : 0.008610D-6, 3340.612426700D0, 3.661698944D0, - : 0.011622D-6, 5120.601145584D0, 4.863931876D0, - : 0.010825D-6, 553.569402842D0, 0.842715011D0 / - DATA ((FAIRHD(I,J),I=1,3),J= 91,100) / - : 0.008666D-6, -135.065080035D0, 3.293406547D0, - : 0.009963D-6, 149.563197135D0, 4.870690598D0, - : 0.009858D-6, 6309.374169791D0, 1.061816410D0, - : 0.007959D-6, 316.391869657D0, 2.465042647D0, - : 0.010099D-6, 283.859318865D0, 1.942176992D0, - : 0.007147D-6, -242.728603974D0, 3.661486981D0, - : 0.007505D-6, 5230.807466803D0, 4.920937029D0, - : 0.008323D-6, 11769.853693166D0, 1.229392026D0, - : 0.007490D-6, -6256.777530192D0, 3.658444681D0, - : 0.009370D-6, 149854.400134205D0, 0.673880395D0 / - DATA ((FAIRHD(I,J),I=1,3),J=101,110) / - : 0.007117D-6, 38.027672636D0, 5.294249518D0, - : 0.007857D-6, 12168.002696575D0, 0.525733528D0, - : 0.007019D-6, 6206.809778716D0, 0.837688810D0, - : 0.006056D-6, 955.599741609D0, 4.194535082D0, - : 0.008107D-6, 13367.972631107D0, 3.793235253D0, - : 0.006731D-6, 5650.292110678D0, 5.639906583D0, - : 0.007332D-6, 36.648562930D0, 0.114858677D0, - : 0.006366D-6, 4164.311989613D0, 2.262081818D0, - : 0.006858D-6, 5216.580372801D0, 0.642063318D0, - : 0.006919D-6, 6681.224853400D0, 6.018501522D0 / - DATA ((FAIRHD(I,J),I=1,3),J=111,120) / - : 0.006826D-6, 7632.943259650D0, 3.458654112D0, - : 0.005308D-6, -1592.596013633D0, 2.500382359D0, - : 0.005096D-6, 11371.704689758D0, 2.547107806D0, - : 0.004841D-6, 5333.900241022D0, 0.437078094D0, - : 0.005582D-6, 5966.683980335D0, 2.246174308D0, - : 0.006304D-6, 11926.254413669D0, 2.512929171D0, - : 0.006603D-6, 23581.258177318D0, 5.393136889D0, - : 0.005123D-6, -1.484472708D0, 2.999641028D0, - : 0.004648D-6, 1589.072895284D0, 1.275847090D0, - : 0.005119D-6, 6438.496249426D0, 1.486539246D0 / - DATA ((FAIRHD(I,J),I=1,3),J=121,130) / - : 0.004521D-6, 4292.330832950D0, 6.140635794D0, - : 0.005680D-6, 23013.539539587D0, 4.557814849D0, - : 0.005488D-6, -3.455808046D0, 0.090675389D0, - : 0.004193D-6, 7234.794256242D0, 4.869091389D0, - : 0.003742D-6, 7238.675591600D0, 4.691976180D0, - : 0.004148D-6, -110.206321219D0, 3.016173439D0, - : 0.004553D-6, 11499.656222793D0, 5.554998314D0, - : 0.004892D-6, 5436.993015240D0, 1.475415597D0, - : 0.004044D-6, 4732.030627343D0, 1.398784824D0, - : 0.004164D-6, 12491.370101415D0, 5.650931916D0 / - DATA ((FAIRHD(I,J),I=1,3),J=131,140) / - : 0.004349D-6, 11513.883316794D0, 2.181745369D0, - : 0.003919D-6, 12528.018664345D0, 5.823319737D0, - : 0.003129D-6, 6836.645252834D0, 0.003844094D0, - : 0.004080D-6, -7058.598461315D0, 3.690360123D0, - : 0.003270D-6, 76.266071276D0, 1.517189902D0, - : 0.002954D-6, 6283.143160294D0, 4.447203799D0, - : 0.002872D-6, 28.449187468D0, 1.158692983D0, - : 0.002881D-6, 735.876513532D0, 0.349250250D0, - : 0.003279D-6, 5849.364112115D0, 4.893384368D0, - : 0.003625D-6, 6209.778724132D0, 1.473760578D0 / - DATA ((FAIRHD(I,J),I=1,3),J=141,150) / - : 0.003074D-6, 949.175608970D0, 5.185878737D0, - : 0.002775D-6, 9917.696874510D0, 1.030026325D0, - : 0.002646D-6, 10973.555686350D0, 3.918259169D0, - : 0.002575D-6, 25132.303399966D0, 6.109659023D0, - : 0.003500D-6, 263.083923373D0, 1.892100742D0, - : 0.002740D-6, 18319.536584880D0, 4.320519510D0, - : 0.002464D-6, 202.253395174D0, 4.698203059D0, - : 0.002409D-6, 2.542797281D0, 5.325009315D0, - : 0.003354D-6, -90955.551694697D0, 1.942656623D0, - : 0.002296D-6, 6496.374945429D0, 5.061810696D0 / - DATA ((FAIRHD(I,J),I=1,3),J=151,160) / - : 0.003002D-6, 6172.869528772D0, 2.797822767D0, - : 0.003202D-6, 27511.467873537D0, 0.531673101D0, - : 0.002954D-6, -6283.008539689D0, 4.533471191D0, - : 0.002353D-6, 639.897286314D0, 3.734548088D0, - : 0.002401D-6, 16200.772724501D0, 2.605547070D0, - : 0.003053D-6, 233141.314403759D0, 3.029030662D0, - : 0.003024D-6, 83286.914269554D0, 2.355556099D0, - : 0.002863D-6, 17298.182327326D0, 5.240963796D0, - : 0.002103D-6, -7079.373856808D0, 5.756641637D0, - : 0.002303D-6, 83996.847317911D0, 2.013686814D0 / - DATA ((FAIRHD(I,J),I=1,3),J=161,170) / - : 0.002303D-6, 18073.704938650D0, 1.089100410D0, - : 0.002381D-6, 63.735898303D0, 0.759188178D0, - : 0.002493D-6, 6386.168624210D0, 0.645026535D0, - : 0.002366D-6, 3.932153263D0, 6.215885448D0, - : 0.002169D-6, 11015.106477335D0, 4.845297676D0, - : 0.002397D-6, 6243.458341645D0, 3.809290043D0, - : 0.002183D-6, 1162.474704408D0, 6.179611691D0, - : 0.002353D-6, 6246.427287062D0, 4.781719760D0, - : 0.002199D-6, -245.831646229D0, 5.956152284D0, - : 0.001729D-6, 3894.181829542D0, 1.264976635D0 / - DATA ((FAIRHD(I,J),I=1,3),J=171,180) / - : 0.001896D-6, -3128.388765096D0, 4.914231596D0, - : 0.002085D-6, 35.164090221D0, 1.405158503D0, - : 0.002024D-6, 14712.317116458D0, 2.752035928D0, - : 0.001737D-6, 6290.189396992D0, 5.280820144D0, - : 0.002229D-6, 491.557929457D0, 1.571007057D0, - : 0.001602D-6, 14314.168113050D0, 4.203664806D0, - : 0.002186D-6, 454.909366527D0, 1.402101526D0, - : 0.001897D-6, 22483.848574493D0, 4.167932508D0, - : 0.001825D-6, -3738.761430108D0, 0.545828785D0, - : 0.001894D-6, 1052.268383188D0, 5.817167450D0 / - DATA ((FAIRHD(I,J),I=1,3),J=181,190) / - : 0.001421D-6, 20.355319399D0, 2.419886601D0, - : 0.001408D-6, 10984.192351700D0, 2.732084787D0, - : 0.001847D-6, 10873.986030480D0, 2.903477885D0, - : 0.001391D-6, -8635.942003763D0, 0.593891500D0, - : 0.001388D-6, -7.046236698D0, 1.166145902D0, - : 0.001810D-6, -88860.057071188D0, 0.487355242D0, - : 0.001288D-6, -1990.745017041D0, 3.913022880D0, - : 0.001297D-6, 23543.230504682D0, 3.063805171D0, - : 0.001335D-6, -266.607041722D0, 3.995764039D0, - : 0.001376D-6, 10969.965257698D0, 5.152914309D0 / - DATA ((FAIRHD(I,J),I=1,3),J=191,200) / - : 0.001745D-6, 244287.600007027D0, 3.626395673D0, - : 0.001649D-6, 31441.677569757D0, 1.952049260D0, - : 0.001416D-6, 9225.539273283D0, 4.996408389D0, - : 0.001238D-6, 4804.209275927D0, 5.503379738D0, - : 0.001472D-6, 4590.910180489D0, 4.164913291D0, - : 0.001169D-6, 6040.347246017D0, 5.841719038D0, - : 0.001039D-6, 5540.085789459D0, 2.769753519D0, - : 0.001004D-6, -170.672870619D0, 0.755008103D0, - : 0.001284D-6, 10575.406682942D0, 5.306538209D0, - : 0.001278D-6, 71.812653151D0, 4.713486491D0 / - DATA ((FAIRHD(I,J),I=1,3),J=201,210) / - : 0.001321D-6, 18209.330263660D0, 2.624866359D0, - : 0.001297D-6, 21228.392023546D0, 0.382603541D0, - : 0.000954D-6, 6282.095528923D0, 0.882213514D0, - : 0.001145D-6, 6058.731054289D0, 1.169483931D0, - : 0.000979D-6, 5547.199336460D0, 5.448375984D0, - : 0.000987D-6, -6262.300454499D0, 2.656486959D0, - : 0.001070D-6, -154717.609887482D0, 1.827624012D0, - : 0.000991D-6, 4701.116501708D0, 4.387001801D0, - : 0.001155D-6, -14.227094002D0, 3.042700750D0, - : 0.001176D-6, 277.034993741D0, 3.335519004D0 / - DATA ((FAIRHD(I,J),I=1,3),J=211,220) / - : 0.000890D-6, 13916.019109642D0, 5.601498297D0, - : 0.000884D-6, -1551.045222648D0, 1.088831705D0, - : 0.000876D-6, 5017.508371365D0, 3.969902609D0, - : 0.000806D-6, 15110.466119866D0, 5.142876744D0, - : 0.000773D-6, -4136.910433516D0, 0.022067765D0, - : 0.001077D-6, 175.166059800D0, 1.844913056D0, - : 0.000954D-6, -6284.056171060D0, 0.968480906D0, - : 0.000737D-6, 5326.786694021D0, 4.923831588D0, - : 0.000845D-6, -433.711737877D0, 4.749245231D0, - : 0.000819D-6, 8662.240323563D0, 5.991247817D0 / - DATA ((FAIRHD(I,J),I=1,3),J=221,230) / - : 0.000852D-6, 199.072001436D0, 2.189604979D0, - : 0.000723D-6, 17256.631536341D0, 6.068719637D0, - : 0.000940D-6, 6037.244203762D0, 6.197428148D0, - : 0.000885D-6, 11712.955318231D0, 3.280414875D0, - : 0.000706D-6, 12559.038152982D0, 2.824848947D0, - : 0.000732D-6, 2379.164473572D0, 2.501813417D0, - : 0.000764D-6, -6127.655450557D0, 2.236346329D0, - : 0.000908D-6, 131.541961686D0, 2.521257490D0, - : 0.000907D-6, 35371.887265976D0, 3.370195967D0, - : 0.000673D-6, 1066.495477190D0, 3.876512374D0 / - DATA ((FAIRHD(I,J),I=1,3),J=231,240) / - : 0.000814D-6, 17654.780539750D0, 4.627122566D0, - : 0.000630D-6, 36.027866677D0, 0.156368499D0, - : 0.000798D-6, 515.463871093D0, 5.151962502D0, - : 0.000798D-6, 148.078724426D0, 5.909225055D0, - : 0.000806D-6, 309.278322656D0, 6.054064447D0, - : 0.000607D-6, -39.617508346D0, 2.839021623D0, - : 0.000601D-6, 412.371096874D0, 3.984225404D0, - : 0.000646D-6, 11403.676995575D0, 3.852959484D0, - : 0.000704D-6, 13521.751441591D0, 2.300991267D0, - : 0.000603D-6, -65147.619767937D0, 4.140083146D0 / - DATA ((FAIRHD(I,J),I=1,3),J=241,250) / - : 0.000609D-6, 10177.257679534D0, 0.437122327D0, - : 0.000631D-6, 5767.611978898D0, 4.026532329D0, - : 0.000576D-6, 11087.285125918D0, 4.760293101D0, - : 0.000674D-6, 14945.316173554D0, 6.270510511D0, - : 0.000726D-6, 5429.879468239D0, 6.039606892D0, - : 0.000710D-6, 28766.924424484D0, 5.672617711D0, - : 0.000647D-6, 11856.218651625D0, 3.397132627D0, - : 0.000678D-6, -5481.254918868D0, 6.249666675D0, - : 0.000618D-6, 22003.914634870D0, 2.466427018D0, - : 0.000738D-6, 6134.997125565D0, 2.242668890D0 / - DATA ((FAIRHD(I,J),I=1,3),J=251,260) / - : 0.000660D-6, 625.670192312D0, 5.864091907D0, - : 0.000694D-6, 3496.032826134D0, 2.668309141D0, - : 0.000531D-6, 6489.261398429D0, 1.681888780D0, - : 0.000611D-6, -143571.324284214D0, 2.424978312D0, - : 0.000575D-6, 12043.574281889D0, 4.216492400D0, - : 0.000553D-6, 12416.588502848D0, 4.772158039D0, - : 0.000689D-6, 4686.889407707D0, 6.224271088D0, - : 0.000495D-6, 7342.457780181D0, 3.817285811D0, - : 0.000567D-6, 3634.621024518D0, 1.649264690D0, - : 0.000515D-6, 18635.928454536D0, 3.945345892D0 / - DATA ((FAIRHD(I,J),I=1,3),J=261,270) / - : 0.000486D-6, -323.505416657D0, 4.061673868D0, - : 0.000662D-6, 25158.601719765D0, 1.794058369D0, - : 0.000509D-6, 846.082834751D0, 3.053874588D0, - : 0.000472D-6, -12569.674818332D0, 5.112133338D0, - : 0.000461D-6, 6179.983075773D0, 0.513669325D0, - : 0.000641D-6, 83467.156352816D0, 3.210727723D0, - : 0.000520D-6, 10344.295065386D0, 2.445597761D0, - : 0.000493D-6, 18422.629359098D0, 1.676939306D0, - : 0.000478D-6, 1265.567478626D0, 5.487314569D0, - : 0.000472D-6, -18.159247265D0, 1.999707589D0 / - DATA ((FAIRHD(I,J),I=1,3),J=271,280) / - : 0.000559D-6, 11190.377900137D0, 5.783236356D0, - : 0.000494D-6, 9623.688276691D0, 3.022645053D0, - : 0.000463D-6, 5739.157790895D0, 1.411223013D0, - : 0.000432D-6, 16858.482532933D0, 1.179256434D0, - : 0.000574D-6, 72140.628666286D0, 1.758191830D0, - : 0.000484D-6, 17267.268201691D0, 3.290589143D0, - : 0.000550D-6, 4907.302050146D0, 0.864024298D0, - : 0.000399D-6, 14.977853527D0, 2.094441910D0, - : 0.000491D-6, 224.344795702D0, 0.878372791D0, - : 0.000432D-6, 20426.571092422D0, 6.003829241D0 / - DATA ((FAIRHD(I,J),I=1,3),J=281,290) / - : 0.000481D-6, 5749.452731634D0, 4.309591964D0, - : 0.000480D-6, 5757.317038160D0, 1.142348571D0, - : 0.000485D-6, 6702.560493867D0, 0.210580917D0, - : 0.000426D-6, 6055.549660552D0, 4.274476529D0, - : 0.000480D-6, 5959.570433334D0, 5.031351030D0, - : 0.000466D-6, 12562.628581634D0, 4.959581597D0, - : 0.000520D-6, 39302.096962196D0, 4.788002889D0, - : 0.000458D-6, 12132.439962106D0, 1.880103788D0, - : 0.000470D-6, 12029.347187887D0, 1.405611197D0, - : 0.000416D-6, -7477.522860216D0, 1.082356330D0 / - DATA ((FAIRHD(I,J),I=1,3),J=291,300) / - : 0.000449D-6, 11609.862544012D0, 4.179989585D0, - : 0.000465D-6, 17253.041107690D0, 0.353496295D0, - : 0.000362D-6, -4535.059436924D0, 1.583849576D0, - : 0.000383D-6, 21954.157609398D0, 3.747376371D0, - : 0.000389D-6, 17.252277143D0, 1.395753179D0, - : 0.000331D-6, 18052.929543158D0, 0.566790582D0, - : 0.000430D-6, 13517.870106233D0, 0.685827538D0, - : 0.000368D-6, -5756.908003246D0, 0.731374317D0, - : 0.000330D-6, 10557.594160824D0, 3.710043680D0, - : 0.000332D-6, 20199.094959633D0, 1.652901407D0 / - DATA ((FAIRHD(I,J),I=1,3),J=301,310) / - : 0.000384D-6, 11933.367960670D0, 5.827781531D0, - : 0.000387D-6, 10454.501386605D0, 2.541182564D0, - : 0.000325D-6, 15671.081759407D0, 2.178850542D0, - : 0.000318D-6, 138.517496871D0, 2.253253037D0, - : 0.000305D-6, 9388.005909415D0, 0.578340206D0, - : 0.000352D-6, 5749.861766548D0, 3.000297967D0, - : 0.000311D-6, 6915.859589305D0, 1.693574249D0, - : 0.000297D-6, 24072.921469776D0, 1.997249392D0, - : 0.000363D-6, -640.877607382D0, 5.071820966D0, - : 0.000323D-6, 12592.450019783D0, 1.072262823D0 / - DATA ((FAIRHD(I,J),I=1,3),J=311,320) / - : 0.000341D-6, 12146.667056108D0, 4.700657997D0, - : 0.000290D-6, 9779.108676125D0, 1.812320441D0, - : 0.000342D-6, 6132.028180148D0, 4.322238614D0, - : 0.000329D-6, 6268.848755990D0, 3.033827743D0, - : 0.000374D-6, 17996.031168222D0, 3.388716544D0, - : 0.000285D-6, -533.214083444D0, 4.687313233D0, - : 0.000338D-6, 6065.844601290D0, 0.877776108D0, - : 0.000276D-6, 24.298513841D0, 0.770299429D0, - : 0.000336D-6, -2388.894020449D0, 5.353796034D0, - : 0.000290D-6, 3097.883822726D0, 4.075291557D0 / - DATA ((FAIRHD(I,J),I=1,3),J=321,330) / - : 0.000318D-6, 709.933048357D0, 5.941207518D0, - : 0.000271D-6, 13095.842665077D0, 3.208912203D0, - : 0.000331D-6, 6073.708907816D0, 4.007881169D0, - : 0.000292D-6, 742.990060533D0, 2.714333592D0, - : 0.000362D-6, 29088.811415985D0, 3.215977013D0, - : 0.000280D-6, 12359.966151546D0, 0.710872502D0, - : 0.000267D-6, 10440.274292604D0, 4.730108488D0, - : 0.000262D-6, 838.969287750D0, 1.327720272D0, - : 0.000250D-6, 16496.361396202D0, 0.898769761D0, - : 0.000325D-6, 20597.243963041D0, 0.180044365D0 / - DATA ((FAIRHD(I,J),I=1,3),J=331,340) / - : 0.000268D-6, 6148.010769956D0, 5.152666276D0, - : 0.000284D-6, 5636.065016677D0, 5.655385808D0, - : 0.000301D-6, 6080.822454817D0, 2.135396205D0, - : 0.000294D-6, -377.373607916D0, 3.708784168D0, - : 0.000236D-6, 2118.763860378D0, 1.733578756D0, - : 0.000234D-6, 5867.523359379D0, 5.575209112D0, - : 0.000268D-6, -226858.238553767D0, 0.069432392D0, - : 0.000265D-6, 167283.761587465D0, 4.369302826D0, - : 0.000280D-6, 28237.233459389D0, 5.304829118D0, - : 0.000292D-6, 12345.739057544D0, 4.096094132D0 / - DATA ((FAIRHD(I,J),I=1,3),J=341,350) / - : 0.000223D-6, 19800.945956225D0, 3.069327406D0, - : 0.000301D-6, 43232.306658416D0, 6.205311188D0, - : 0.000264D-6, 18875.525869774D0, 1.417263408D0, - : 0.000304D-6, -1823.175188677D0, 3.409035232D0, - : 0.000301D-6, 109.945688789D0, 0.510922054D0, - : 0.000260D-6, 813.550283960D0, 2.389438934D0, - : 0.000299D-6, 316428.228673312D0, 5.384595078D0, - : 0.000211D-6, 5756.566278634D0, 3.789392838D0, - : 0.000209D-6, 5750.203491159D0, 1.661943545D0, - : 0.000240D-6, 12489.885628707D0, 5.684549045D0 / - DATA ((FAIRHD(I,J),I=1,3),J=351,360) / - : 0.000216D-6, 6303.851245484D0, 3.862942261D0, - : 0.000203D-6, 1581.959348283D0, 5.549853589D0, - : 0.000200D-6, 5642.198242609D0, 1.016115785D0, - : 0.000197D-6, -70.849445304D0, 4.690702525D0, - : 0.000227D-6, 6287.008003254D0, 2.911891613D0, - : 0.000197D-6, 533.623118358D0, 1.048982898D0, - : 0.000205D-6, -6279.485421340D0, 1.829362730D0, - : 0.000209D-6, -10988.808157535D0, 2.636140084D0, - : 0.000208D-6, -227.526189440D0, 4.127883842D0, - : 0.000191D-6, 415.552490612D0, 4.401165650D0 / - DATA ((FAIRHD(I,J),I=1,3),J=361,370) / - : 0.000190D-6, 29296.615389579D0, 4.175658539D0, - : 0.000264D-6, 66567.485864652D0, 4.601102551D0, - : 0.000256D-6, -3646.350377354D0, 0.506364778D0, - : 0.000188D-6, 13119.721102825D0, 2.032195842D0, - : 0.000185D-6, -209.366942175D0, 4.694756586D0, - : 0.000198D-6, 25934.124331089D0, 3.832703118D0, - : 0.000195D-6, 4061.219215394D0, 3.308463427D0, - : 0.000234D-6, 5113.487598583D0, 1.716090661D0, - : 0.000188D-6, 1478.866574064D0, 5.686865780D0, - : 0.000222D-6, 11823.161639450D0, 1.942386641D0 / - DATA ((FAIRHD(I,J),I=1,3),J=371,380) / - : 0.000181D-6, 10770.893256262D0, 1.999482059D0, - : 0.000171D-6, 6546.159773364D0, 1.182807992D0, - : 0.000206D-6, 70.328180442D0, 5.934076062D0, - : 0.000169D-6, 20995.392966449D0, 2.169080622D0, - : 0.000191D-6, 10660.686935042D0, 5.405515999D0, - : 0.000228D-6, 33019.021112205D0, 4.656985514D0, - : 0.000184D-6, -4933.208440333D0, 3.327476868D0, - : 0.000220D-6, -135.625325010D0, 1.765430262D0, - : 0.000166D-6, 23141.558382925D0, 3.454132746D0, - : 0.000191D-6, 6144.558353121D0, 5.020393445D0 / - DATA ((FAIRHD(I,J),I=1,3),J=381,390) / - : 0.000180D-6, 6084.003848555D0, 0.602182191D0, - : 0.000163D-6, 17782.732072784D0, 4.960593133D0, - : 0.000225D-6, 16460.333529525D0, 2.596451817D0, - : 0.000222D-6, 5905.702242076D0, 3.731990323D0, - : 0.000204D-6, 227.476132789D0, 5.636192701D0, - : 0.000159D-6, 16737.577236597D0, 3.600691544D0, - : 0.000200D-6, 6805.653268085D0, 0.868220961D0, - : 0.000187D-6, 11919.140866668D0, 2.629456641D0, - : 0.000161D-6, 127.471796607D0, 2.862574720D0, - : 0.000205D-6, 6286.666278643D0, 1.742882331D0 / - DATA ((FAIRHD(I,J),I=1,3),J=391,400) / - : 0.000189D-6, 153.778810485D0, 4.812372643D0, - : 0.000168D-6, 16723.350142595D0, 0.027860588D0, - : 0.000149D-6, 11720.068865232D0, 0.659721876D0, - : 0.000189D-6, 5237.921013804D0, 5.245313000D0, - : 0.000143D-6, 6709.674040867D0, 4.317625647D0, - : 0.000146D-6, 4487.817406270D0, 4.815297007D0, - : 0.000144D-6, -664.756045130D0, 5.381366880D0, - : 0.000175D-6, 5127.714692584D0, 4.728443327D0, - : 0.000162D-6, 6254.626662524D0, 1.435132069D0, - : 0.000187D-6, 47162.516354635D0, 1.354371923D0 / - DATA ((FAIRHD(I,J),I=1,3),J=401,410) / - : 0.000146D-6, 11080.171578918D0, 3.369695406D0, - : 0.000180D-6, -348.924420448D0, 2.490902145D0, - : 0.000148D-6, 151.047669843D0, 3.799109588D0, - : 0.000157D-6, 6197.248551160D0, 1.284375887D0, - : 0.000167D-6, 146.594251718D0, 0.759969109D0, - : 0.000133D-6, -5331.357443741D0, 5.409701889D0, - : 0.000154D-6, 95.979227218D0, 3.366890614D0, - : 0.000148D-6, -6418.140930027D0, 3.384104996D0, - : 0.000128D-6, -6525.804453965D0, 3.803419985D0, - : 0.000130D-6, 11293.470674356D0, 0.939039445D0 / - DATA ((FAIRHD(I,J),I=1,3),J=411,420) / - : 0.000152D-6, -5729.506447149D0, 0.734117523D0, - : 0.000138D-6, 210.117701700D0, 2.564216078D0, - : 0.000123D-6, 6066.595360816D0, 4.517099537D0, - : 0.000140D-6, 18451.078546566D0, 0.642049130D0, - : 0.000126D-6, 11300.584221356D0, 3.485280663D0, - : 0.000119D-6, 10027.903195729D0, 3.217431161D0, - : 0.000151D-6, 4274.518310832D0, 4.404359108D0, - : 0.000117D-6, 6072.958148291D0, 0.366324650D0, - : 0.000165D-6, -7668.637425143D0, 4.298212528D0, - : 0.000117D-6, -6245.048177356D0, 5.379518958D0 / - DATA ((FAIRHD(I,J),I=1,3),J=421,430) / - : 0.000130D-6, -5888.449964932D0, 4.527681115D0, - : 0.000121D-6, -543.918059096D0, 6.109429504D0, - : 0.000162D-6, 9683.594581116D0, 5.720092446D0, - : 0.000141D-6, 6219.339951688D0, 0.679068671D0, - : 0.000118D-6, 22743.409379516D0, 4.881123092D0, - : 0.000129D-6, 1692.165669502D0, 0.351407289D0, - : 0.000126D-6, 5657.405657679D0, 5.146592349D0, - : 0.000114D-6, 728.762966531D0, 0.520791814D0, - : 0.000120D-6, 52.596639600D0, 0.948516300D0, - : 0.000115D-6, 65.220371012D0, 3.504914846D0 / - DATA ((FAIRHD(I,J),I=1,3),J=431,440) / - : 0.000126D-6, 5881.403728234D0, 5.577502482D0, - : 0.000158D-6, 163096.180360983D0, 2.957128968D0, - : 0.000134D-6, 12341.806904281D0, 2.598576764D0, - : 0.000151D-6, 16627.370915377D0, 3.985702050D0, - : 0.000109D-6, 1368.660252845D0, 0.014730471D0, - : 0.000131D-6, 6211.263196841D0, 0.085077024D0, - : 0.000146D-6, 5792.741760812D0, 0.708426604D0, - : 0.000146D-6, -77.750543984D0, 3.121576600D0, - : 0.000107D-6, 5341.013788022D0, 0.288231904D0, - : 0.000138D-6, 6281.591377283D0, 2.797450317D0 / - DATA ((FAIRHD(I,J),I=1,3),J=441,450) / - : 0.000113D-6, -6277.552925684D0, 2.788904128D0, - : 0.000115D-6, -525.758811831D0, 5.895222200D0, - : 0.000138D-6, 6016.468808270D0, 6.096188999D0, - : 0.000139D-6, 23539.707386333D0, 2.028195445D0, - : 0.000146D-6, -4176.041342449D0, 4.660008502D0, - : 0.000107D-6, 16062.184526117D0, 4.066520001D0, - : 0.000142D-6, 83783.548222473D0, 2.936315115D0, - : 0.000128D-6, 9380.959672717D0, 3.223844306D0, - : 0.000135D-6, 6205.325306007D0, 1.638054048D0, - : 0.000101D-6, 2699.734819318D0, 5.481603249D0 / - DATA ((FAIRHD(I,J),I=1,3),J=451,460) / - : 0.000104D-6, -568.821874027D0, 2.205734493D0, - : 0.000103D-6, 6321.103522627D0, 2.440421099D0, - : 0.000119D-6, 6321.208885629D0, 2.547496264D0, - : 0.000138D-6, 1975.492545856D0, 2.314608466D0, - : 0.000121D-6, 137.033024162D0, 4.539108237D0, - : 0.000123D-6, 19402.796952817D0, 4.538074405D0, - : 0.000119D-6, 22805.735565994D0, 2.869040566D0, - : 0.000133D-6, 64471.991241142D0, 6.056405489D0, - : 0.000129D-6, -85.827298831D0, 2.540635083D0, - : 0.000131D-6, 13613.804277336D0, 4.005732868D0 / - DATA ((FAIRHD(I,J),I=1,3),J=461,470) / - : 0.000104D-6, 9814.604100291D0, 1.959967212D0, - : 0.000112D-6, 16097.679950283D0, 3.589026260D0, - : 0.000123D-6, 2107.034507542D0, 1.728627253D0, - : 0.000121D-6, 36949.230808424D0, 6.072332087D0, - : 0.000108D-6, -12539.853380183D0, 3.716133846D0, - : 0.000113D-6, -7875.671863624D0, 2.725771122D0, - : 0.000109D-6, 4171.425536614D0, 4.033338079D0, - : 0.000101D-6, 6247.911759770D0, 3.441347021D0, - : 0.000113D-6, 7330.728427345D0, 0.656372122D0, - : 0.000113D-6, 51092.726050855D0, 2.791483066D0 / - DATA ((FAIRHD(I,J),I=1,3),J=471,480) / - : 0.000106D-6, 5621.842923210D0, 1.815323326D0, - : 0.000101D-6, 111.430161497D0, 5.711033677D0, - : 0.000103D-6, 909.818733055D0, 2.812745443D0, - : 0.000101D-6, 1790.642637886D0, 1.965746028D0, - -* T - : 102.156724D-6, 6283.075849991D0, 4.249032005D0, - : 1.706807D-6, 12566.151699983D0, 4.205904248D0, - : 0.269668D-6, 213.299095438D0, 3.400290479D0, - : 0.265919D-6, 529.690965095D0, 5.836047367D0, - : 0.210568D-6, -3.523118349D0, 6.262738348D0, - : 0.077996D-6, 5223.693919802D0, 4.670344204D0 / - DATA ((FAIRHD(I,J),I=1,3),J=481,490) / - : 0.054764D-6, 1577.343542448D0, 4.534800170D0, - : 0.059146D-6, 26.298319800D0, 1.083044735D0, - : 0.034420D-6, -398.149003408D0, 5.980077351D0, - : 0.032088D-6, 18849.227549974D0, 4.162913471D0, - : 0.033595D-6, 5507.553238667D0, 5.980162321D0, - : 0.029198D-6, 5856.477659115D0, 0.623811863D0, - : 0.027764D-6, 155.420399434D0, 3.745318113D0, - : 0.025190D-6, 5746.271337896D0, 2.980330535D0, - : 0.022997D-6, -796.298006816D0, 1.174411803D0, - : 0.024976D-6, 5760.498431898D0, 2.467913690D0 / - DATA ((FAIRHD(I,J),I=1,3),J=491,500) / - : 0.021774D-6, 206.185548437D0, 3.854787540D0, - : 0.017925D-6, -775.522611324D0, 1.092065955D0, - : 0.013794D-6, 426.598190876D0, 2.699831988D0, - : 0.013276D-6, 6062.663207553D0, 5.845801920D0, - : 0.011774D-6, 12036.460734888D0, 2.292832062D0, - : 0.012869D-6, 6076.890301554D0, 5.333425680D0, - : 0.012152D-6, 1059.381930189D0, 6.222874454D0, - : 0.011081D-6, -7.113547001D0, 5.154724984D0, - : 0.010143D-6, 4694.002954708D0, 4.044013795D0, - : 0.009357D-6, 5486.777843175D0, 3.416081409D0 / - DATA ((FAIRHD(I,J),I=1,3),J=501,510) / - : 0.010084D-6, 522.577418094D0, 0.749320262D0, - : 0.008587D-6, 10977.078804699D0, 2.777152598D0, - : 0.008628D-6, 6275.962302991D0, 4.562060226D0, - : 0.008158D-6, -220.412642439D0, 5.806891533D0, - : 0.007746D-6, 2544.314419883D0, 1.603197066D0, - : 0.007670D-6, 2146.165416475D0, 3.000200440D0, - : 0.007098D-6, 74.781598567D0, 0.443725817D0, - : 0.006180D-6, -536.804512095D0, 1.302642751D0, - : 0.005818D-6, 5088.628839767D0, 4.827723531D0, - : 0.004945D-6, -6286.598968340D0, 0.268305170D0 / - DATA ((FAIRHD(I,J),I=1,3),J=511,520) / - : 0.004774D-6, 1349.867409659D0, 5.808636673D0, - : 0.004687D-6, -242.728603974D0, 5.154890570D0, - : 0.006089D-6, 1748.016413067D0, 4.403765209D0, - : 0.005975D-6, -1194.447010225D0, 2.583472591D0, - : 0.004229D-6, 951.718406251D0, 0.931172179D0, - : 0.005264D-6, 553.569402842D0, 2.336107252D0, - : 0.003049D-6, 5643.178563677D0, 1.362634430D0, - : 0.002974D-6, 6812.766815086D0, 1.583012668D0, - : 0.003403D-6, -2352.866153772D0, 2.552189886D0, - : 0.003030D-6, 419.484643875D0, 5.286473844D0 / - DATA ((FAIRHD(I,J),I=1,3),J=521,530) / - : 0.003210D-6, -7.046236698D0, 1.863796539D0, - : 0.003058D-6, 9437.762934887D0, 4.226420633D0, - : 0.002589D-6, 12352.852604545D0, 1.991935820D0, - : 0.002927D-6, 5216.580372801D0, 2.319951253D0, - : 0.002425D-6, 5230.807466803D0, 3.084752833D0, - : 0.002656D-6, 3154.687084896D0, 2.487447866D0, - : 0.002445D-6, 10447.387839604D0, 2.347139160D0, - : 0.002990D-6, 4690.479836359D0, 6.235872050D0, - : 0.002890D-6, 5863.591206116D0, 0.095197563D0, - : 0.002498D-6, 6438.496249426D0, 2.994779800D0 / - DATA ((FAIRHD(I,J),I=1,3),J=531,540) / - : 0.001889D-6, 8031.092263058D0, 3.569003717D0, - : 0.002567D-6, 801.820931124D0, 3.425611498D0, - : 0.001803D-6, -71430.695617928D0, 2.192295512D0, - : 0.001782D-6, 3.932153263D0, 5.180433689D0, - : 0.001694D-6, -4705.732307544D0, 4.641779174D0, - : 0.001704D-6, -1592.596013633D0, 3.997097652D0, - : 0.001735D-6, 5849.364112115D0, 0.417558428D0, - : 0.001643D-6, 8429.241266467D0, 2.180619584D0, - : 0.001680D-6, 38.133035638D0, 4.164529426D0, - : 0.002045D-6, 7084.896781115D0, 0.526323854D0 / - DATA ((FAIRHD(I,J),I=1,3),J=541,550) / - : 0.001458D-6, 4292.330832950D0, 1.356098141D0, - : 0.001437D-6, 20.355319399D0, 3.895439360D0, - : 0.001738D-6, 6279.552731642D0, 0.087484036D0, - : 0.001367D-6, 14143.495242431D0, 3.987576591D0, - : 0.001344D-6, 7234.794256242D0, 0.090454338D0, - : 0.001438D-6, 11499.656222793D0, 0.974387904D0, - : 0.001257D-6, 6836.645252834D0, 1.509069366D0, - : 0.001358D-6, 11513.883316794D0, 0.495572260D0, - : 0.001628D-6, 7632.943259650D0, 4.968445721D0, - : 0.001169D-6, 103.092774219D0, 2.838496795D0 / - DATA ((FAIRHD(I,J),I=1,3),J=551,560) / - : 0.001162D-6, 4164.311989613D0, 3.408387778D0, - : 0.001092D-6, 6069.776754553D0, 3.617942651D0, - : 0.001008D-6, 17789.845619785D0, 0.286350174D0, - : 0.001008D-6, 639.897286314D0, 1.610762073D0, - : 0.000918D-6, 10213.285546211D0, 5.532798067D0, - : 0.001011D-6, -6256.777530192D0, 0.661826484D0, - : 0.000753D-6, 16730.463689596D0, 3.905030235D0, - : 0.000737D-6, 11926.254413669D0, 4.641956361D0, - : 0.000694D-6, 3340.612426700D0, 2.111120332D0, - : 0.000701D-6, 3894.181829542D0, 2.760823491D0 / - DATA ((FAIRHD(I,J),I=1,3),J=561,570) / - : 0.000689D-6, -135.065080035D0, 4.768800780D0, - : 0.000700D-6, 13367.972631107D0, 5.760439898D0, - : 0.000664D-6, 6040.347246017D0, 1.051215840D0, - : 0.000654D-6, 5650.292110678D0, 4.911332503D0, - : 0.000788D-6, 6681.224853400D0, 4.699648011D0, - : 0.000628D-6, 5333.900241022D0, 5.024608847D0, - : 0.000755D-6, -110.206321219D0, 4.370971253D0, - : 0.000628D-6, 6290.189396992D0, 3.660478857D0, - : 0.000635D-6, 25132.303399966D0, 4.121051532D0, - : 0.000534D-6, 5966.683980335D0, 1.173284524D0 / - DATA ((FAIRHD(I,J),I=1,3),J=571,580) / - : 0.000543D-6, -433.711737877D0, 0.345585464D0, - : 0.000517D-6, -1990.745017041D0, 5.414571768D0, - : 0.000504D-6, 5767.611978898D0, 2.328281115D0, - : 0.000485D-6, 5753.384884897D0, 1.685874771D0, - : 0.000463D-6, 7860.419392439D0, 5.297703006D0, - : 0.000604D-6, 515.463871093D0, 0.591998446D0, - : 0.000443D-6, 12168.002696575D0, 4.830881244D0, - : 0.000570D-6, 199.072001436D0, 3.899190272D0, - : 0.000465D-6, 10969.965257698D0, 0.476681802D0, - : 0.000424D-6, -7079.373856808D0, 1.112242763D0 / - DATA ((FAIRHD(I,J),I=1,3),J=581,590) / - : 0.000427D-6, 735.876513532D0, 1.994214480D0, - : 0.000478D-6, -6127.655450557D0, 3.778025483D0, - : 0.000414D-6, 10973.555686350D0, 5.441088327D0, - : 0.000512D-6, 1589.072895284D0, 0.107123853D0, - : 0.000378D-6, 10984.192351700D0, 0.915087231D0, - : 0.000402D-6, 11371.704689758D0, 4.107281715D0, - : 0.000453D-6, 9917.696874510D0, 1.917490952D0, - : 0.000395D-6, 149.563197135D0, 2.763124165D0, - : 0.000371D-6, 5739.157790895D0, 3.112111866D0, - : 0.000350D-6, 11790.629088659D0, 0.440639857D0 / - DATA ((FAIRHD(I,J),I=1,3),J=591,600) / - : 0.000356D-6, 6133.512652857D0, 5.444568842D0, - : 0.000344D-6, 412.371096874D0, 5.676832684D0, - : 0.000383D-6, 955.599741609D0, 5.559734846D0, - : 0.000333D-6, 6496.374945429D0, 0.261537984D0, - : 0.000340D-6, 6055.549660552D0, 5.975534987D0, - : 0.000334D-6, 1066.495477190D0, 2.335063907D0, - : 0.000399D-6, 11506.769769794D0, 5.321230910D0, - : 0.000314D-6, 18319.536584880D0, 2.313312404D0, - : 0.000424D-6, 1052.268383188D0, 1.211961766D0, - : 0.000307D-6, 63.735898303D0, 3.169551388D0 / - DATA ((FAIRHD(I,J),I=1,3),J=601,610) / - : 0.000329D-6, 29.821438149D0, 6.106912080D0, - : 0.000357D-6, 6309.374169791D0, 4.223760346D0, - : 0.000312D-6, -3738.761430108D0, 2.180556645D0, - : 0.000301D-6, 309.278322656D0, 1.499984572D0, - : 0.000268D-6, 12043.574281889D0, 2.447520648D0, - : 0.000257D-6, 12491.370101415D0, 3.662331761D0, - : 0.000290D-6, 625.670192312D0, 1.272834584D0, - : 0.000256D-6, 5429.879468239D0, 1.913426912D0, - : 0.000339D-6, 3496.032826134D0, 4.165930011D0, - : 0.000283D-6, 3930.209696220D0, 4.325565754D0 / - DATA ((FAIRHD(I,J),I=1,3),J=611,620) / - : 0.000241D-6, 12528.018664345D0, 3.832324536D0, - : 0.000304D-6, 4686.889407707D0, 1.612348468D0, - : 0.000259D-6, 16200.772724501D0, 3.470173146D0, - : 0.000238D-6, 12139.553509107D0, 1.147977842D0, - : 0.000236D-6, 6172.869528772D0, 3.776271728D0, - : 0.000296D-6, -7058.598461315D0, 0.460368852D0, - : 0.000306D-6, 10575.406682942D0, 0.554749016D0, - : 0.000251D-6, 17298.182327326D0, 0.834332510D0, - : 0.000290D-6, 4732.030627343D0, 4.759564091D0, - : 0.000261D-6, 5884.926846583D0, 0.298259862D0 / - DATA ((FAIRHD(I,J),I=1,3),J=621,630) / - : 0.000249D-6, 5547.199336460D0, 3.749366406D0, - : 0.000213D-6, 11712.955318231D0, 5.415666119D0, - : 0.000223D-6, 4701.116501708D0, 2.703203558D0, - : 0.000268D-6, -640.877607382D0, 0.283670793D0, - : 0.000209D-6, 5636.065016677D0, 1.238477199D0, - : 0.000193D-6, 10177.257679534D0, 1.943251340D0, - : 0.000182D-6, 6283.143160294D0, 2.456157599D0, - : 0.000184D-6, -227.526189440D0, 5.888038582D0, - : 0.000182D-6, -6283.008539689D0, 0.241332086D0, - : 0.000228D-6, -6284.056171060D0, 2.657323816D0 / - DATA ((FAIRHD(I,J),I=1,3),J=631,640) / - : 0.000166D-6, 7238.675591600D0, 5.930629110D0, - : 0.000167D-6, 3097.883822726D0, 5.570955333D0, - : 0.000159D-6, -323.505416657D0, 5.786670700D0, - : 0.000154D-6, -4136.910433516D0, 1.517805532D0, - : 0.000176D-6, 12029.347187887D0, 3.139266834D0, - : 0.000167D-6, 12132.439962106D0, 3.556352289D0, - : 0.000153D-6, 202.253395174D0, 1.463313961D0, - : 0.000157D-6, 17267.268201691D0, 1.586837396D0, - : 0.000142D-6, 83996.847317911D0, 0.022670115D0, - : 0.000152D-6, 17260.154654690D0, 0.708528947D0 / - DATA ((FAIRHD(I,J),I=1,3),J=641,650) / - : 0.000144D-6, 6084.003848555D0, 5.187075177D0, - : 0.000135D-6, 5756.566278634D0, 1.993229262D0, - : 0.000134D-6, 5750.203491159D0, 3.457197134D0, - : 0.000144D-6, 5326.786694021D0, 6.066193291D0, - : 0.000160D-6, 11015.106477335D0, 1.710431974D0, - : 0.000133D-6, 3634.621024518D0, 2.836451652D0, - : 0.000134D-6, 18073.704938650D0, 5.453106665D0, - : 0.000134D-6, 1162.474704408D0, 5.326898811D0, - : 0.000128D-6, 5642.198242609D0, 2.511652591D0, - : 0.000160D-6, 632.783739313D0, 5.628785365D0 / - DATA ((FAIRHD(I,J),I=1,3),J=651,660) / - : 0.000132D-6, 13916.019109642D0, 0.819294053D0, - : 0.000122D-6, 14314.168113050D0, 5.677408071D0, - : 0.000125D-6, 12359.966151546D0, 5.251984735D0, - : 0.000121D-6, 5749.452731634D0, 2.210924603D0, - : 0.000136D-6, -245.831646229D0, 1.646502367D0, - : 0.000120D-6, 5757.317038160D0, 3.240883049D0, - : 0.000134D-6, 12146.667056108D0, 3.059480037D0, - : 0.000137D-6, 6206.809778716D0, 1.867105418D0, - : 0.000141D-6, 17253.041107690D0, 2.069217456D0, - : 0.000129D-6, -7477.522860216D0, 2.781469314D0 / - DATA ((FAIRHD(I,J),I=1,3),J=661,670) / - : 0.000116D-6, 5540.085789459D0, 4.281176991D0, - : 0.000116D-6, 9779.108676125D0, 3.320925381D0, - : 0.000129D-6, 5237.921013804D0, 3.497704076D0, - : 0.000113D-6, 5959.570433334D0, 0.983210840D0, - : 0.000122D-6, 6282.095528923D0, 2.674938860D0, - : 0.000140D-6, -11.045700264D0, 4.957936982D0, - : 0.000108D-6, 23543.230504682D0, 1.390113589D0, - : 0.000106D-6, -12569.674818332D0, 0.429631317D0, - : 0.000110D-6, -266.607041722D0, 5.501340197D0, - : 0.000115D-6, 12559.038152982D0, 4.691456618D0 / - DATA ((FAIRHD(I,J),I=1,3),J=671,680) / - : 0.000134D-6, -2388.894020449D0, 0.577313584D0, - : 0.000109D-6, 10440.274292604D0, 6.218148717D0, - : 0.000102D-6, -543.918059096D0, 1.477842615D0, - : 0.000108D-6, 21228.392023546D0, 2.237753948D0, - : 0.000101D-6, -4535.059436924D0, 3.100492232D0, - : 0.000103D-6, 76.266071276D0, 5.594294322D0, - : 0.000104D-6, 949.175608970D0, 5.674287810D0, - : 0.000101D-6, 13517.870106233D0, 2.196632348D0, - : 0.000100D-6, 11933.367960670D0, 4.056084160D0, - : 4.322990D-6, 6283.075849991D0, 2.642893748D0 / - DATA ((FAIRHD(I,J),I=1,3),J=681,690) / - : 0.406495D-6, 0.000000000D0, 4.712388980D0, - : 0.122605D-6, 12566.151699983D0, 2.438140634D0, - : 0.019476D-6, 213.299095438D0, 1.642186981D0, - : 0.016916D-6, 529.690965095D0, 4.510959344D0, - : 0.013374D-6, -3.523118349D0, 1.502210314D0, - : 0.008042D-6, 26.298319800D0, 0.478549024D0, - : 0.007824D-6, 155.420399434D0, 5.254710405D0, - : 0.004894D-6, 5746.271337896D0, 4.683210850D0, - : 0.004875D-6, 5760.498431898D0, 0.759507698D0, - : 0.004416D-6, 5223.693919802D0, 6.028853166D0 / - DATA ((FAIRHD(I,J),I=1,3),J=691,700) / - : 0.004088D-6, -7.113547001D0, 0.060926389D0, - : 0.004433D-6, 77713.771467920D0, 3.627734103D0, - : 0.003277D-6, 18849.227549974D0, 2.327912542D0, - : 0.002703D-6, 6062.663207553D0, 1.271941729D0, - : 0.003435D-6, -775.522611324D0, 0.747446224D0, - : 0.002618D-6, 6076.890301554D0, 3.633715689D0, - : 0.003146D-6, 206.185548437D0, 5.647874613D0, - : 0.002544D-6, 1577.343542448D0, 6.232904270D0, - : 0.002218D-6, -220.412642439D0, 1.309509946D0, - : 0.002197D-6, 5856.477659115D0, 2.407212349D0 / - DATA ((FAIRHD(I,J),I=1,3),J=701,710) / - : 0.002897D-6, 5753.384884897D0, 5.863842246D0, - : 0.001766D-6, 426.598190876D0, 0.754113147D0, - : 0.001738D-6, -796.298006816D0, 2.714942671D0, - : 0.001695D-6, 522.577418094D0, 2.629369842D0, - : 0.001584D-6, 5507.553238667D0, 1.341138229D0, - : 0.001503D-6, -242.728603974D0, 0.377699736D0, - : 0.001552D-6, -536.804512095D0, 2.904684667D0, - : 0.001370D-6, -398.149003408D0, 1.265599125D0, - : 0.001889D-6, -5573.142801634D0, 4.413514859D0, - : 0.001722D-6, 6069.776754553D0, 2.445966339D0 / - DATA ((FAIRHD(I,J),I=1,3),J=711,720) / - : 0.001124D-6, 1059.381930189D0, 5.041799657D0, - : 0.001258D-6, 553.569402842D0, 3.849557278D0, - : 0.000831D-6, 951.718406251D0, 2.471094709D0, - : 0.000767D-6, 4694.002954708D0, 5.363125422D0, - : 0.000756D-6, 1349.867409659D0, 1.046195744D0, - : 0.000775D-6, -11.045700264D0, 0.245548001D0, - : 0.000597D-6, 2146.165416475D0, 4.543268798D0, - : 0.000568D-6, 5216.580372801D0, 4.178853144D0, - : 0.000711D-6, 1748.016413067D0, 5.934271972D0, - : 0.000499D-6, 12036.460734888D0, 0.624434410D0 / - DATA ((FAIRHD(I,J),I=1,3),J=721,730) / - : 0.000671D-6, -1194.447010225D0, 4.136047594D0, - : 0.000488D-6, 5849.364112115D0, 2.209679987D0, - : 0.000621D-6, 6438.496249426D0, 4.518860804D0, - : 0.000495D-6, -6286.598968340D0, 1.868201275D0, - : 0.000456D-6, 5230.807466803D0, 1.271231591D0, - : 0.000451D-6, 5088.628839767D0, 0.084060889D0, - : 0.000435D-6, 5643.178563677D0, 3.324456609D0, - : 0.000387D-6, 10977.078804699D0, 4.052488477D0, - : 0.000547D-6, 161000.685737473D0, 2.841633844D0, - : 0.000522D-6, 3154.687084896D0, 2.171979966D0 / - DATA ((FAIRHD(I,J),I=1,3),J=731,740) / - : 0.000375D-6, 5486.777843175D0, 4.983027306D0, - : 0.000421D-6, 5863.591206116D0, 4.546432249D0, - : 0.000439D-6, 7084.896781115D0, 0.522967921D0, - : 0.000309D-6, 2544.314419883D0, 3.172606705D0, - : 0.000347D-6, 4690.479836359D0, 1.479586566D0, - : 0.000317D-6, 801.820931124D0, 3.553088096D0, - : 0.000262D-6, 419.484643875D0, 0.606635550D0, - : 0.000248D-6, 6836.645252834D0, 3.014082064D0, - : 0.000245D-6, -1592.596013633D0, 5.519526220D0, - : 0.000225D-6, 4292.330832950D0, 2.877956536D0 / - DATA ((FAIRHD(I,J),I=1,3),J=741,750) / - : 0.000214D-6, 7234.794256242D0, 1.605227587D0, - : 0.000205D-6, 5767.611978898D0, 0.625804796D0, - : 0.000180D-6, 10447.387839604D0, 3.499954526D0, - : 0.000229D-6, 199.072001436D0, 5.632304604D0, - : 0.000214D-6, 639.897286314D0, 5.960227667D0, - : 0.000175D-6, -433.711737877D0, 2.162417992D0, - : 0.000209D-6, 515.463871093D0, 2.322150893D0, - : 0.000173D-6, 6040.347246017D0, 2.556183691D0, - : 0.000184D-6, 6309.374169791D0, 4.732296790D0, - : 0.000227D-6, 149854.400134205D0, 5.385812217D0 / - DATA ((FAIRHD(I,J),I=1,3),J=751,760) / - : 0.000154D-6, 8031.092263058D0, 5.120720920D0, - : 0.000151D-6, 5739.157790895D0, 4.815000443D0, - : 0.000197D-6, 7632.943259650D0, 0.222827271D0, - : 0.000197D-6, 74.781598567D0, 3.910456770D0, - : 0.000138D-6, 6055.549660552D0, 1.397484253D0, - : 0.000149D-6, -6127.655450557D0, 5.333727496D0, - : 0.000137D-6, 3894.181829542D0, 4.281749907D0, - : 0.000135D-6, 9437.762934887D0, 5.979971885D0, - : 0.000139D-6, -2352.866153772D0, 4.715630782D0, - : 0.000142D-6, 6812.766815086D0, 0.513330157D0 / - DATA ((FAIRHD(I,J),I=1,3),J=761,770) / - : 0.000120D-6, -4705.732307544D0, 0.194160689D0, - : 0.000131D-6, -71430.695617928D0, 0.000379226D0, - : 0.000124D-6, 6279.552731642D0, 2.122264908D0, - : 0.000108D-6, -6256.777530192D0, 0.883445696D0, - : 0.143388D-6, 6283.075849991D0, 1.131453581D0, - : 0.006671D-6, 12566.151699983D0, 0.775148887D0, - : 0.001480D-6, 155.420399434D0, 0.480016880D0, - : 0.000934D-6, 213.299095438D0, 6.144453084D0, - : 0.000795D-6, 529.690965095D0, 2.941595619D0, - : 0.000673D-6, 5746.271337896D0, 0.120415406D0 / - DATA ((FAIRHD(I,J),I=1,3),J=771,780) / - : 0.000672D-6, 5760.498431898D0, 5.317009738D0, - : 0.000389D-6, -220.412642439D0, 3.090323467D0, - : 0.000373D-6, 6062.663207553D0, 3.003551964D0, - : 0.000360D-6, 6076.890301554D0, 1.918913041D0, - : 0.000316D-6, -21.340641002D0, 5.545798121D0, - : 0.000315D-6, -242.728603974D0, 1.884932563D0, - : 0.000278D-6, 206.185548437D0, 1.266254859D0, - : 0.000238D-6, -536.804512095D0, 4.532664830D0, - : 0.000185D-6, 522.577418094D0, 4.578313856D0, - : 0.000245D-6, 18849.227549974D0, 0.587467082D0 / - DATA ((FAIRHD(I,J),I=1,3),J=781,787) / - : 0.000180D-6, 426.598190876D0, 5.151178553D0, - : 0.000200D-6, 553.569402842D0, 5.355983739D0, - : 0.000141D-6, 5223.693919802D0, 1.336556009D0, - : 0.000104D-6, 5856.477659115D0, 4.239842759D0, - : 0.003826D-6, 6283.075849991D0, 5.705257275D0, - : 0.000303D-6, 12566.151699983D0, 5.407132842D0, - : 0.000209D-6, 155.420399434D0, 1.989815753D0 / -* ----------------------------------------------------------------------- - - - -* Time since J2000.0 in Julian millennia. - T=(TDB-51544.5D0)/365250D0 - -* -------------------- Topocentric terms ------------------------------- - -* Convert UT1 to local solar time in radians. - TSOL = MOD(UT1,1D0)*D2PI - WL - -* FUNDAMENTAL ARGUMENTS: Simon et al 1994 - -* Combine time argument (millennia) with deg/arcsec factor. - W = T / 3600D0 - -* Sun Mean Longitude. - ELSUN = MOD(280.46645683D0+1296027711.03429D0*W,360D0)*D2R - -* Sun Mean Anomaly. - EMSUN = MOD(357.52910918D0+1295965810.481D0*W,360D0)*D2R - -* Mean Elongation of Moon from Sun. - D = MOD(297.85019547D0+16029616012.090D0*W,360D0)*D2R - -* Mean Longitude of Jupiter. - ELJ = MOD(34.35151874D0+109306899.89453D0*W,360D0)*D2R - -* Mean Longitude of Saturn. - ELS = MOD(50.07744430D0+44046398.47038D0*W,360D0)*D2R - -* TOPOCENTRIC TERMS: Moyer 1981 and Murray 1983. - WT = +0.00029D-10*U*SIN(TSOL+ELSUN-ELS) - : +0.00100D-10*U*SIN(TSOL-2D0*EMSUN) - : +0.00133D-10*U*SIN(TSOL-D) - : +0.00133D-10*U*SIN(TSOL+ELSUN-ELJ) - : -0.00229D-10*U*SIN(TSOL+2D0*ELSUN+EMSUN) - : -0.0220 D-10*V*COS(ELSUN+EMSUN) - : +0.05312D-10*U*SIN(TSOL-EMSUN) - : -0.13677D-10*U*SIN(TSOL+2D0*ELSUN) - : -1.3184 D-10*V*COS(ELSUN) - : +3.17679D-10*U*SIN(TSOL) - -* --------------- Fairhead model --------------------------------------- - -* T**0 - W0=0D0 - DO I=474,1,-1 - W0=W0+FAIRHD(1,I)*SIN(FAIRHD(2,I)*T+FAIRHD(3,I)) - END DO - -* T**1 - W1=0D0 - DO I=679,475,-1 - W1=W1+FAIRHD(1,I)*SIN(FAIRHD(2,I)*T+FAIRHD(3,I)) - END DO - -* T**2 - W2=0D0 - DO I=764,680,-1 - W2=W2+FAIRHD(1,I)*SIN(FAIRHD(2,I)*T+FAIRHD(3,I)) - END DO - -* T**3 - W3=0D0 - DO I=784,765,-1 - W3=W3+FAIRHD(1,I)*SIN(FAIRHD(2,I)*T+FAIRHD(3,I)) - END DO - -* T**4 - W4=0D0 - DO I=787,785,-1 - W4=W4+FAIRHD(1,I)*SIN(FAIRHD(2,I)*T+FAIRHD(3,I)) - END DO - -* Multiply by powers of T and combine. - WF=T*(T*(T*(T*W4+W3)+W2)+W1)+W0 - -* Adjustments to use JPL planetary masses instead of IAU. - WJ= 0.00065D-6 * SIN( 6069.776754D0 *T + 4.021194D0 ) + - : 0.00033D-6 * SIN( 213.299095D0 *T + 5.543132D0 ) + - : (-0.00196D-6 * SIN( 6208.294251D0 *T + 5.696701D0 ))+ - : (-0.00173D-6 * SIN( 74.781599D0 *T + 2.435900D0 ))+ - : 0.03638D-6*T*T - -* ----------------------------------------------------------------------- - -* Final result: TDB-TT in seconds. - sla_RCC=WT+WF+WJ - - END diff --git a/src/slalib/rdplan.f b/src/slalib/rdplan.f deleted file mode 100644 index 5c49861f1..000000000 --- a/src/slalib/rdplan.f +++ /dev/null @@ -1,200 +0,0 @@ - SUBROUTINE sla_RDPLAN (DATE, NP, ELONG, PHI, RA, DEC, DIAM) -*+ -* - - - - - - - -* R D P L A N -* - - - - - - - -* -* Approximate topocentric apparent RA,Dec of a planet, and its -* angular diameter. -* -* Given: -* DATE d MJD of observation (JD - 2400000.5) -* NP i planet: 1 = Mercury -* 2 = Venus -* 3 = Moon -* 4 = Mars -* 5 = Jupiter -* 6 = Saturn -* 7 = Uranus -* 8 = Neptune -* 9 = Pluto -* else = Sun -* ELONG,PHI d observer's east longitude and geodetic -* latitude (radians) -* -* Returned: -* RA,DEC d RA, Dec (topocentric apparent, radians) -* DIAM d angular diameter (equatorial, radians) -* -* Notes: -* -* 1 The date is in a dynamical timescale (TDB, formerly ET) and is -* in the form of a Modified Julian Date (JD-2400000.5). For all -* practical purposes, TT can be used instead of TDB, and for many -* applications UT will do (except for the Moon). -* -* 2 The longitude and latitude allow correction for geocentric -* parallax. This is a major effect for the Moon, but in the -* context of the limited accuracy of the present routine its -* effect on planetary positions is small (negligible for the -* outer planets). Geocentric positions can be generated by -* appropriate use of the routines sla_DMOON and sla_PLANET. -* -* 3 The direction accuracy (arcsec, 1000-3000AD) is of order: -* -* Sun 5 -* Mercury 2 -* Venus 10 -* Moon 30 -* Mars 50 -* Jupiter 90 -* Saturn 90 -* Uranus 90 -* Neptune 10 -* Pluto 1 (1885-2099AD only) -* -* The angular diameter accuracy is about 0.4% for the Moon, -* and 0.01% or better for the Sun and planets. -* -* See the sla_PLANET routine for references. -* -* Called: sla_GMST, sla_DT, sla_EPJ, sla_DMOON, sla_PVOBS, sla_PRENUT, -* sla_PLANET, sla_DMXV, sla_DCC2S, sla_DRANRM -* -* P.T.Wallace Starlink 26 May 1997 -* -* Copyright (C) 1997 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE - INTEGER NP - DOUBLE PRECISION ELONG,PHI,RA,DEC,DIAM - -* AU in km - DOUBLE PRECISION AUKM - PARAMETER (AUKM=1.49597870D8) - -* Light time for unit distance (sec) - DOUBLE PRECISION TAU - PARAMETER (TAU=499.004782D0) - - INTEGER IP,J,I - DOUBLE PRECISION EQRAU(0:9),STL,VGM(6),V(6),RMAT(3,3), - : VSE(6),VSG(6),VSP(6),VGO(6),DX,DY,DZ,R,TL - DOUBLE PRECISION sla_GMST,sla_DT,sla_EPJ,sla_DRANRM - -* Equatorial radii (km) - DATA EQRAU / 696000D0,2439.7D0,6051.9D0,1738D0,3397D0,71492D0, - : 60268D0,25559D0,24764D0,1151D0 / - - - -* Classify NP - IP=NP - IF (IP.LT.0.OR.IP.GT.9) IP=0 - -* Approximate local ST - STL=sla_GMST(DATE-sla_DT(sla_EPJ(DATE))/86400D0)+ELONG - -* Geocentre to Moon (mean of date) - CALL sla_DMOON(DATE,V) - -* Nutation to true of date - CALL sla_NUT(DATE,RMAT) - CALL sla_DMXV(RMAT,V,VGM) - CALL sla_DMXV(RMAT,V(4),VGM(4)) - -* Moon? - IF (IP.EQ.3) THEN - -* Yes: geocentre to Moon (true of date) - DO I=1,6 - V(I)=VGM(I) - END DO - ELSE - -* No: precession/nutation matrix, J2000 to date - CALL sla_PRENUT(2000D0,DATE,RMAT) - -* Sun to Earth-Moon Barycentre (J2000) - CALL sla_PLANET(DATE,3,V,J) - -* Precession and nutation to date - CALL sla_DMXV(RMAT,V,VSE) - CALL sla_DMXV(RMAT,V(4),VSE(4)) - -* Sun to geocentre (true of date) - DO I=1,6 - VSG(I)=VSE(I)-0.012150581D0*VGM(I) - END DO - -* Sun? - IF (IP.EQ.0) THEN - -* Yes: geocentre to Sun - DO I=1,6 - V(I)=-VSG(I) - END DO - ELSE - -* No: Sun to Planet (J2000) - CALL sla_PLANET(DATE,IP,V,J) - -* Precession and nutation to date - CALL sla_DMXV(RMAT,V,VSP) - CALL sla_DMXV(RMAT,V(4),VSP(4)) - -* Geocentre to planet - DO I=1,6 - V(I)=VSP(I)-VSG(I) - END DO - END IF - END IF - -* Refer to origin at the observer - CALL sla_PVOBS(PHI,0D0,STL,VGO) - DO I=1,6 - V(I)=V(I)-VGO(I) - END DO - -* Geometric distance (AU) - DX=V(1) - DY=V(2) - DZ=V(3) - R=SQRT(DX*DX+DY*DY+DZ*DZ) - -* Light time (sec) - TL=TAU*R - -* Correct position for planetary aberration - DO I=1,3 - V(I)=V(I)-TL*V(I+3) - END DO - -* To RA,Dec - CALL sla_DCC2S(V,RA,DEC) - RA=sla_DRANRM(RA) - -* Angular diameter (radians) - DIAM=2D0*ASIN(EQRAU(IP)/(R*AUKM)) - - END diff --git a/src/slalib/refco.f b/src/slalib/refco.f deleted file mode 100644 index c6cb37f1e..000000000 --- a/src/slalib/refco.f +++ /dev/null @@ -1,87 +0,0 @@ - SUBROUTINE sla_REFCO ( HM, TDK, PMB, RH, WL, PHI, TLR, EPS, - : REFA, REFB ) -*+ -* - - - - - - -* R E F C O -* - - - - - - -* -* Determine the constants A and B in the atmospheric refraction -* model dZ = A tan Z + B tan**3 Z. -* -* Z is the "observed" zenith distance (i.e. affected by refraction) -* and dZ is what to add to Z to give the "topocentric" (i.e. in vacuo) -* zenith distance. -* -* Given: -* HM d height of the observer above sea level (metre) -* TDK d ambient temperature at the observer (K) -* PMB d pressure at the observer (millibar) -* RH d relative humidity at the observer (range 0-1) -* WL d effective wavelength of the source (micrometre) -* PHI d latitude of the observer (radian, astronomical) -* TLR d temperature lapse rate in the troposphere (K/metre) -* EPS d precision required to terminate iteration (radian) -* -* Returned: -* REFA d tan Z coefficient (radian) -* REFB d tan**3 Z coefficient (radian) -* -* Called: sla_REFRO -* -* Notes: -* -* 1 Typical values for the TLR and EPS arguments might be 0.0065D0 and -* 1D-10 respectively. -* -* 2 The radio refraction is chosen by specifying WL > 100 micrometres. -* -* 3 The routine is a slower but more accurate alternative to the -* sla_REFCOQ routine. The constants it produces give perfect -* agreement with sla_REFRO at zenith distances arctan(1) (45 deg) -* and arctan(4) (about 76 deg). It achieves 0.5 arcsec accuracy -* for ZD < 80 deg, 0.01 arcsec accuracy for ZD < 60 deg, and -* 0.001 arcsec accuracy for ZD < 45 deg. -* -* P.T.Wallace Starlink 22 May 2004 -* -* Copyright (C) 2004 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION HM,TDK,PMB,RH,WL,PHI,TLR,EPS,REFA,REFB - - DOUBLE PRECISION ATN1,ATN4,R1,R2 - -* Sample zenith distances: arctan(1) and arctan(4) - PARAMETER (ATN1=0.7853981633974483D0, - : ATN4=1.325817663668033D0) - - - -* Determine refraction for the two sample zenith distances - CALL sla_REFRO(ATN1,HM,TDK,PMB,RH,WL,PHI,TLR,EPS,R1) - CALL sla_REFRO(ATN4,HM,TDK,PMB,RH,WL,PHI,TLR,EPS,R2) - -* Solve for refraction constants - REFA = (64D0*R1-R2)/60D0 - REFB = (R2-4D0*R1)/60D0 - - END diff --git a/src/slalib/refcoq.f b/src/slalib/refcoq.f deleted file mode 100644 index 9e615fcfa..000000000 --- a/src/slalib/refcoq.f +++ /dev/null @@ -1,226 +0,0 @@ - SUBROUTINE sla_REFCOQ ( TDK, PMB, RH, WL, REFA, REFB ) -*+ -* - - - - - - - -* R E F C O Q -* - - - - - - - -* -* Determine the constants A and B in the atmospheric refraction -* model dZ = A tan Z + B tan**3 Z. This is a fast alternative -* to the sla_REFCO routine - see notes. -* -* Z is the "observed" zenith distance (i.e. affected by refraction) -* and dZ is what to add to Z to give the "topocentric" (i.e. in vacuo) -* zenith distance. -* -* Given: -* TDK d ambient temperature at the observer (K) -* PMB d pressure at the observer (millibar) -* RH d relative humidity at the observer (range 0-1) -* WL d effective wavelength of the source (micrometre) -* -* Returned: -* REFA d tan Z coefficient (radian) -* REFB d tan**3 Z coefficient (radian) -* -* The radio refraction is chosen by specifying WL > 100 micrometres. -* -* Notes: -* -* 1 The model is an approximation, for moderate zenith distances, -* to the predictions of the sla_REFRO routine. The approximation -* is maintained across a range of conditions, and applies to -* both optical/IR and radio. -* -* 2 The algorithm is a fast alternative to the sla_REFCO routine. -* The latter calls the sla_REFRO routine itself: this involves -* integrations through a model atmosphere, and is costly in -* processor time. However, the model which is produced is precisely -* correct for two zenith distance (45 degrees and about 76 degrees) -* and at other zenith distances is limited in accuracy only by the -* A tan Z + B tan**3 Z formulation itself. The present routine -* is not as accurate, though it satisfies most practical -* requirements. -* -* 3 The model omits the effects of (i) height above sea level (apart -* from the reduced pressure itself), (ii) latitude (i.e. the -* flattening of the Earth) and (iii) variations in tropospheric -* lapse rate. -* -* The model was tested using the following range of conditions: -* -* lapse rates 0.0055, 0.0065, 0.0075 K/metre -* latitudes 0, 25, 50, 75 degrees -* heights 0, 2500, 5000 metres ASL -* pressures mean for height -10% to +5% in steps of 5% -* temperatures -10 deg to +20 deg with respect to 280 deg at SL -* relative humidity 0, 0.5, 1 -* wavelengths 0.4, 0.6, ... 2 micron, + radio -* zenith distances 15, 45, 75 degrees -* -* The accuracy with respect to direct use of the sla_REFRO routine -* was as follows: -* -* worst RMS -* -* optical/IR 62 mas 8 mas -* radio 319 mas 49 mas -* -* For this particular set of conditions: -* -* lapse rate 0.0065 K/metre -* latitude 50 degrees -* sea level -* pressure 1005 mb -* temperature 280.15 K -* humidity 80% -* wavelength 5740 Angstroms -* -* the results were as follows: -* -* ZD sla_REFRO sla_REFCOQ Saastamoinen -* -* 10 10.27 10.27 10.27 -* 20 21.19 21.20 21.19 -* 30 33.61 33.61 33.60 -* 40 48.82 48.83 48.81 -* 45 58.16 58.18 58.16 -* 50 69.28 69.30 69.27 -* 55 82.97 82.99 82.95 -* 60 100.51 100.54 100.50 -* 65 124.23 124.26 124.20 -* 70 158.63 158.68 158.61 -* 72 177.32 177.37 177.31 -* 74 200.35 200.38 200.32 -* 76 229.45 229.43 229.42 -* 78 267.44 267.29 267.41 -* 80 319.13 318.55 319.10 -* -* deg arcsec arcsec arcsec -* -* The values for Saastamoinen's formula (which includes terms -* up to tan^5) are taken from Hohenkerk and Sinclair (1985). -* -* The results from the much slower but more accurate sla_REFCO -* routine have not been included in the tabulation as they are -* identical to those in the sla_REFRO column to the 0.01 arcsec -* resolution used. -* -* 4 Outlandish input parameters are silently limited to mathematically -* safe values. Zero pressure is permissible, and causes zeroes to -* be returned. -* -* 5 The algorithm draws on several sources, as follows: -* -* a) The formula for the saturation vapour pressure of water as -* a function of temperature and temperature is taken from -* expressions A4.5-A4.7 of Gill (1982). -* -* b) The formula for the water vapour pressure, given the -* saturation pressure and the relative humidity, is from -* Crane (1976), expression 2.5.5. -* -* c) The refractivity of air is a function of temperature, -* total pressure, water-vapour pressure and, in the case -* of optical/IR but not radio, wavelength. The formulae -* for the two cases are developed from Hohenkerk & Sinclair -* (1985) and Rueger (2002). -* -* The above three items are as used in the sla_REFRO routine. -* -* d) The formula for beta, the ratio of the scale height of the -* atmosphere to the geocentric distance of the observer, is -* an adaption of expression 9 from Stone (1996). The -* adaptations, arrived at empirically, consist of (i) a -* small adjustment to the coefficient and (ii) a humidity -* term for the radio case only. -* -* e) The formulae for the refraction constants as a function of -* n-1 and beta are from Green (1987), expression 4.31. -* -* References: -* -* Crane, R.K., Meeks, M.L. (ed), "Refraction Effects in the Neutral -* Atmosphere", Methods of Experimental Physics: Astrophysics 12B, -* Academic Press, 1976. -* -* Gill, Adrian E., "Atmosphere-Ocean Dynamics", Academic Press, 1982. -* -* Green, R.M., "Spherical Astronomy", Cambridge University Press, 1987. -* -* Hohenkerk, C.Y., & Sinclair, A.T., NAO Technical Note No. 63, 1985. -* -* Rueger, J.M., "Refractive Index Formulae for Electronic Distance -* Measurement with Radio and Millimetre Waves", in Unisurv Report -* S-68, School of Surveying and Spatial Information Systems, -* University of New South Wales, Sydney, Australia, 2002. -* -* Stone, Ronald C., P.A.S.P. 108 1051-1058, 1996. -* -* Last revision: 2 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION TDK,PMB,RH,WL,REFA,REFB - - LOGICAL OPTIC - DOUBLE PRECISION T,P,R,W,TDC,PS,PW,WLSQ,GAMMA,BETA - - - -* Decide whether optical/IR or radio case: switch at 100 microns. - OPTIC = WL.LE.100D0 - -* Restrict parameters to safe values. - T = MIN(MAX(TDK,100D0),500D0) - P = MIN(MAX(PMB,0D0),10000D0) - R = MIN(MAX(RH,0D0),1D0) - W = MIN(MAX(WL,0.1D0),1D6) - -* Water vapour pressure at the observer. - IF (P.GT.0D0) THEN - TDC = T-273.15D0 - PS = 10D0**((0.7859D0+0.03477D0*TDC)/(1D0+0.00412D0*TDC))* - : (1D0+P*(4.5D-6+6D-10*TDC*TDC)) - PW = R*PS/(1D0-(1D0-R)*PS/P) - ELSE - PW = 0D0 - END IF - -* Refractive index minus 1 at the observer. - IF (OPTIC) THEN - WLSQ = W*W - GAMMA = ((77.53484D-6+(4.39108D-7+3.666D-9/WLSQ)/WLSQ)*P - : -11.2684D-6*PW)/T - ELSE - GAMMA = (77.6890D-6*P-(6.3938D-6-0.375463D0/T)*PW)/T - END IF - -* Formula for beta adapted from Stone, with empirical adjustments. - BETA=4.4474D-6*T - IF (.NOT.OPTIC) BETA=BETA-0.0074D0*PW*BETA - -* Refraction constants from Green. - REFA = GAMMA*(1D0-BETA) - REFB = -GAMMA*(BETA-GAMMA/2D0) - - END diff --git a/src/slalib/refro.f b/src/slalib/refro.f deleted file mode 100644 index fc9f35d5a..000000000 --- a/src/slalib/refro.f +++ /dev/null @@ -1,401 +0,0 @@ - SUBROUTINE sla_REFRO ( ZOBS, HM, TDK, PMB, RH, WL, PHI, TLR, - : EPS, REF ) -*+ -* - - - - - - -* R E F R O -* - - - - - - -* -* Atmospheric refraction for radio and optical/IR wavelengths. -* -* Given: -* ZOBS d observed zenith distance of the source (radian) -* HM d height of the observer above sea level (metre) -* TDK d ambient temperature at the observer (K) -* PMB d pressure at the observer (millibar) -* RH d relative humidity at the observer (range 0-1) -* WL d effective wavelength of the source (micrometre) -* PHI d latitude of the observer (radian, astronomical) -* TLR d temperature lapse rate in the troposphere (K/metre) -* EPS d precision required to terminate iteration (radian) -* -* Returned: -* REF d refraction: in vacuo ZD minus observed ZD (radian) -* -* Notes: -* -* 1 A suggested value for the TLR argument is 0.0065D0. The -* refraction is significantly affected by TLR, and if studies -* of the local atmosphere have been carried out a better TLR -* value may be available. The sign of the supplied TLR value -* is ignored. -* -* 2 A suggested value for the EPS argument is 1D-8. The result is -* usually at least two orders of magnitude more computationally -* precise than the supplied EPS value. -* -* 3 The routine computes the refraction for zenith distances up -* to and a little beyond 90 deg using the method of Hohenkerk -* and Sinclair (NAO Technical Notes 59 and 63, subsequently adopted -* in the Explanatory Supplement, 1992 edition - see section 3.281). -* -* 4 The code is a development of the optical/IR refraction subroutine -* AREF of C.Hohenkerk (HMNAO, September 1984), with extensions to -* support the radio case. Apart from merely cosmetic changes, the -* following modifications to the original HMNAO optical/IR refraction -* code have been made: -* -* . The angle arguments have been changed to radians. -* -* . Any value of ZOBS is allowed (see note 6, below). -* -* . Other argument values have been limited to safe values. -* -* . Murray's values for the gas constants have been used -* (Vectorial Astrometry, Adam Hilger, 1983). -* -* . The numerical integration phase has been rearranged for -* extra clarity. -* -* . A better model for Ps(T) has been adopted (taken from -* Gill, Atmosphere-Ocean Dynamics, Academic Press, 1982). -* -* . More accurate expressions for Pwo have been adopted -* (again from Gill 1982). -* -* . The formula for the water vapour pressure, given the -* saturation pressure and the relative humidity, is from -* Crane (1976), expression 2.5.5. -* -* . Provision for radio wavelengths has been added using -* expressions devised by A.T.Sinclair, RGO (private -* communication 1989). The refractivity model currently -* used is from J.M.Rueger, "Refractive Index Formulae for -* Electronic Distance Measurement with Radio and Millimetre -* Waves", in Unisurv Report S-68 (2002), School of Surveying -* and Spatial Information Systems, University of New South -* Wales, Sydney, Australia. -* -* . The optical refractivity for dry air is from Resolution 3 of -* the International Association of Geodesy adopted at the XXIIth -* General Assembly in Birmingham, UK, 1999. -* -* . Various small changes have been made to gain speed. -* -* 5 The radio refraction is chosen by specifying WL > 100 micrometres. -* Because the algorithm takes no account of the ionosphere, the -* accuracy deteriorates at low frequencies, below about 30 MHz. -* -* 6 Before use, the value of ZOBS is expressed in the range +/- pi. -* If this ranged ZOBS is -ve, the result REF is computed from its -* absolute value before being made -ve to match. In addition, if -* it has an absolute value greater than 93 deg, a fixed REF value -* equal to the result for ZOBS = 93 deg is returned, appropriately -* signed. -* -* 7 As in the original Hohenkerk and Sinclair algorithm, fixed values -* of the water vapour polytrope exponent, the height of the -* tropopause, and the height at which refraction is negligible are -* used. -* -* 8 The radio refraction has been tested against work done by -* Iain Coulson, JACH, (private communication 1995) for the -* James Clerk Maxwell Telescope, Mauna Kea. For typical conditions, -* agreement at the 0.1 arcsec level is achieved for moderate ZD, -* worsening to perhaps 0.5-1.0 arcsec at ZD 80 deg. At hot and -* humid sea-level sites the accuracy will not be as good. -* -* 9 It should be noted that the relative humidity RH is formally -* defined in terms of "mixing ratio" rather than pressures or -* densities as is often stated. It is the mass of water per unit -* mass of dry air divided by that for saturated air at the same -* temperature and pressure (see Gill 1982). -* -* 10 The algorithm is designed for observers in the troposphere. The -* supplied temperature, pressure and lapse rate are assumed to be -* for a point in the troposphere and are used to define a model -* atmosphere with the tropopause at 11km altitude and a constant -* temperature above that. However, in practice, the refraction -* values returned for stratospheric observers, at altitudes up to -* 25km, are quite usable. -* -* Called: sla_DRANGE, sla__ATMT, sla__ATMS -* -* Last revision: 5 December 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION ZOBS,HM,TDK,PMB,RH,WL,PHI,TLR,EPS,REF - -* -* Fixed parameters -* - DOUBLE PRECISION D93,GCR,DMD,DMW,S,DELTA,HT,HS - INTEGER ISMAX -* 93 degrees in radians - PARAMETER (D93=1.623156204D0) -* Universal gas constant - PARAMETER (GCR=8314.32D0) -* Molecular weight of dry air - PARAMETER (DMD=28.9644D0) -* Molecular weight of water vapour - PARAMETER (DMW=18.0152D0) -* Mean Earth radius (metre) - PARAMETER (S=6378120D0) -* Exponent of temperature dependence of water vapour pressure - PARAMETER (DELTA=18.36D0) -* Height of tropopause (metre) - PARAMETER (HT=11000D0) -* Upper limit for refractive effects (metre) - PARAMETER (HS=80000D0) -* Numerical integration: maximum number of strips. - PARAMETER (ISMAX=16384) - - INTEGER IS,K,N,I,J - LOGICAL OPTIC,LOOP - DOUBLE PRECISION ZOBS1,ZOBS2,HMOK,TDKOK,PMBOK,RHOK,WLOK,ALPHA, - : TOL,WLSQ,GB,A,GAMAL,GAMMA,GAMM2,DELM2, - : TDC,PSAT,PWO,W, - : C1,C2,C3,C4,C5,C6,R0,TEMPO,DN0,RDNDR0,SK0,F0, - : RT,TT,DNT,RDNDRT,SINE,ZT,FT,DNTS,RDNDRP,ZTS,FTS, - : RS,DNS,RDNDRS,ZS,FS,REFOLD,Z0,ZRANGE,FB,FF,FO,FE, - : H,R,SZ,RG,DR,TG,DN,RDNDR,T,F,REFP,REFT - - DOUBLE PRECISION sla_DRANGE - -* The refraction integrand - DOUBLE PRECISION REFI - REFI(DN,RDNDR) = RDNDR/(DN+RDNDR) - - - -* Transform ZOBS into the normal range. - ZOBS1 = sla_DRANGE(ZOBS) - ZOBS2 = MIN(ABS(ZOBS1),D93) - -* Keep other arguments within safe bounds. - HMOK = MIN(MAX(HM,-1D3),HS) - TDKOK = MIN(MAX(TDK,100D0),500D0) - PMBOK = MIN(MAX(PMB,0D0),10000D0) - RHOK = MIN(MAX(RH,0D0),1D0) - WLOK = MAX(WL,0.1D0) - ALPHA = MIN(MAX(ABS(TLR),0.001D0),0.01D0) - -* Tolerance for iteration. - TOL = MIN(MAX(ABS(EPS),1D-12),0.1D0)/2D0 - -* Decide whether optical/IR or radio case - switch at 100 microns. - OPTIC = WLOK.LE.100D0 - -* Set up model atmosphere parameters defined at the observer. - WLSQ = WLOK*WLOK - GB = 9.784D0*(1D0-0.0026D0*COS(PHI+PHI)-0.00000028D0*HMOK) - IF (OPTIC) THEN - A = (287.6155D0+(1.62887D0+0.01360D0/WLSQ)/WLSQ) - : *273.15D-6/1013.25D0 - ELSE - A = 77.6890D-6 - END IF - GAMAL = (GB*DMD)/GCR - GAMMA = GAMAL/ALPHA - GAMM2 = GAMMA-2D0 - DELM2 = DELTA-2D0 - TDC = TDKOK-273.15D0 - PSAT = 10D0**((0.7859D0+0.03477D0*TDC)/(1D0+0.00412D0*TDC))* - : (1D0+PMBOK*(4.5D-6+6D-10*TDC*TDC)) - IF (PMBOK.GT.0D0) THEN - PWO = RHOK*PSAT/(1D0-(1D0-RHOK)*PSAT/PMBOK) - ELSE - PWO = 0D0 - END IF - W = PWO*(1D0-DMW/DMD)*GAMMA/(DELTA-GAMMA) - C1 = A*(PMBOK+W)/TDKOK - IF (OPTIC) THEN - C2 = (A*W+11.2684D-6*PWO)/TDKOK - ELSE - C2 = (A*W+6.3938D-6*PWO)/TDKOK - END IF - C3 = (GAMMA-1D0)*ALPHA*C1/TDKOK - C4 = (DELTA-1D0)*ALPHA*C2/TDKOK - IF (OPTIC) THEN - C5 = 0D0 - C6 = 0D0 - ELSE - C5 = 375463D-6*PWO/TDKOK - C6 = C5*DELM2*ALPHA/(TDKOK*TDKOK) - END IF - -* Conditions at the observer. - R0 = S+HMOK - CALL sla__ATMT(R0,TDKOK,ALPHA,GAMM2,DELM2,C1,C2,C3,C4,C5,C6, - : R0,TEMPO,DN0,RDNDR0) - SK0 = DN0*R0*SIN(ZOBS2) - F0 = REFI(DN0,RDNDR0) - -* Conditions in the troposphere at the tropopause. - RT = S+MAX(HT,HMOK) - CALL sla__ATMT(R0,TDKOK,ALPHA,GAMM2,DELM2,C1,C2,C3,C4,C5,C6, - : RT,TT,DNT,RDNDRT) - SINE = SK0/(RT*DNT) - ZT = ATAN2(SINE,SQRT(MAX(1D0-SINE*SINE,0D0))) - FT = REFI(DNT,RDNDRT) - -* Conditions in the stratosphere at the tropopause. - CALL sla__ATMS(RT,TT,DNT,GAMAL,RT,DNTS,RDNDRP) - SINE = SK0/(RT*DNTS) - ZTS = ATAN2(SINE,SQRT(MAX(1D0-SINE*SINE,0D0))) - FTS = REFI(DNTS,RDNDRP) - -* Conditions at the stratosphere limit. - RS = S+HS - CALL sla__ATMS(RT,TT,DNT,GAMAL,RS,DNS,RDNDRS) - SINE = SK0/(RS*DNS) - ZS = ATAN2(SINE,SQRT(MAX(1D0-SINE*SINE,0D0))) - FS = REFI(DNS,RDNDRS) - -* Variable initialization to avoid compiler warning. - REFT = 0D0 - -* Integrate the refraction integral in two parts; first in the -* troposphere (K=1), then in the stratosphere (K=2). - - DO K = 1,2 - -* Initialize previous refraction to ensure at least two iterations. - REFOLD = 1D0 - -* Start off with 8 strips. - IS = 8 - -* Start Z, Z range, and start and end values. - IF (K.EQ.1) THEN - Z0 = ZOBS2 - ZRANGE = ZT-Z0 - FB = F0 - FF = FT - ELSE - Z0 = ZTS - ZRANGE = ZS-Z0 - FB = FTS - FF = FS - END IF - -* Sums of odd and even values. - FO = 0D0 - FE = 0D0 - -* First time through the loop we have to do every point. - N = 1 - -* Start of iteration loop (terminates at specified precision). - LOOP = .TRUE. - DO WHILE (LOOP) - -* Strip width. - H = ZRANGE/DBLE(IS) - -* Initialize distance from Earth centre for quadrature pass. - IF (K.EQ.1) THEN - R = R0 - ELSE - R = RT - END IF - -* One pass (no need to compute evens after first time). - DO I=1,IS-1,N - -* Sine of observed zenith distance. - SZ = SIN(Z0+H*DBLE(I)) - -* Find R (to the nearest metre, maximum four iterations). - IF (SZ.GT.1D-20) THEN - W = SK0/SZ - RG = R - DR = 1D6 - J = 0 - DO WHILE (ABS(DR).GT.1D0.AND.J.LT.4) - J=J+1 - IF (K.EQ.1) THEN - CALL sla__ATMT(R0,TDKOK,ALPHA,GAMM2,DELM2, - : C1,C2,C3,C4,C5,C6,RG,TG,DN,RDNDR) - ELSE - CALL sla__ATMS(RT,TT,DNT,GAMAL,RG,DN,RDNDR) - END IF - DR = (RG*DN-W)/(DN+RDNDR) - RG = RG-DR - END DO - R = RG - END IF - -* Find the refractive index and integrand at R. - IF (K.EQ.1) THEN - CALL sla__ATMT(R0,TDKOK,ALPHA,GAMM2,DELM2, - : C1,C2,C3,C4,C5,C6,R,T,DN,RDNDR) - ELSE - CALL sla__ATMS(RT,TT,DNT,GAMAL,R,DN,RDNDR) - END IF - F = REFI(DN,RDNDR) - -* Accumulate odd and (first time only) even values. - IF (N.EQ.1.AND.MOD(I,2).EQ.0) THEN - FE = FE+F - ELSE - FO = FO+F - END IF - END DO - -* Evaluate the integrand using Simpson's Rule. - REFP = H*(FB+4D0*FO+2D0*FE+FF)/3D0 - -* Has the required precision been achieved (or can't be)? - IF (ABS(REFP-REFOLD).GT.TOL.AND.IS.LT.ISMAX) THEN - -* No: prepare for next iteration. - -* Save current value for convergence test. - REFOLD = REFP - -* Double the number of strips. - IS = IS+IS - -* Sum of all current values = sum of next pass's even values. - FE = FE+FO - -* Prepare for new odd values. - FO = 0D0 - -* Skip even values next time. - N = 2 - ELSE - -* Yes: save troposphere component and terminate the loop. - IF (K.EQ.1) REFT = REFP - LOOP = .FALSE. - END IF - END DO - END DO - -* Result. - REF = REFT+REFP - IF (ZOBS1.LT.0D0) REF = -REF - - END diff --git a/src/slalib/refv.f b/src/slalib/refv.f deleted file mode 100644 index 7d005c32c..000000000 --- a/src/slalib/refv.f +++ /dev/null @@ -1,128 +0,0 @@ - SUBROUTINE sla_REFV (VU, REFA, REFB, VR) -*+ -* - - - - - -* R E F V -* - - - - - -* -* Adjust an unrefracted Cartesian vector to include the effect of -* atmospheric refraction, using the simple A tan Z + B tan**3 Z -* model. -* -* Given: -* VU dp unrefracted position of the source (Az/El 3-vector) -* REFA dp tan Z coefficient (radian) -* REFB dp tan**3 Z coefficient (radian) -* -* Returned: -* VR dp refracted position of the source (Az/El 3-vector) -* -* Notes: -* -* 1 This routine applies the adjustment for refraction in the -* opposite sense to the usual one - it takes an unrefracted -* (in vacuo) position and produces an observed (refracted) -* position, whereas the A tan Z + B tan**3 Z model strictly -* applies to the case where an observed position is to have the -* refraction removed. The unrefracted to refracted case is -* harder, and requires an inverted form of the text-book -* refraction models; the algorithm used here is equivalent to -* one iteration of the Newton-Raphson method applied to the above -* formula. -* -* 2 Though optimized for speed rather than precision, the present -* routine achieves consistency with the refracted-to-unrefracted -* A tan Z + B tan**3 Z model at better than 1 microarcsecond within -* 30 degrees of the zenith and remains within 1 milliarcsecond to -* beyond ZD 70 degrees. The inherent accuracy of the model is, of -* course, far worse than this - see the documentation for sla_REFCO -* for more information. -* -* 3 At low elevations (below about 3 degrees) the refraction -* correction is held back to prevent arithmetic problems and -* wildly wrong results. For optical/IR wavelengths, over a wide -* range of observer heights and corresponding temperatures and -* pressures, the following levels of accuracy (arcsec, worst case) -* are achieved, relative to numerical integration through a model -* atmosphere: -* -* ZD error -* -* 80 0.7 -* 81 1.3 -* 82 2.5 -* 83 5 -* 84 10 -* 85 20 -* 86 55 -* 87 160 -* 88 360 -* 89 640 -* 90 1100 -* 91 1700 } relevant only to -* 92 2600 } high-elevation sites -* -* The results for radio are slightly worse over most of the range, -* becoming significantly worse below ZD=88 and unusable beyond -* ZD=90. -* -* 4 See also the routine sla_REFZ, which performs the adjustment to -* the zenith distance rather than in Cartesian Az/El coordinates. -* The present routine is faster than sla_REFZ and, except very low down, -* is equally accurate for all practical purposes. However, beyond -* about ZD 84 degrees sla_REFZ should be used, and for the utmost -* accuracy iterative use of sla_REFRO should be considered. -* -* P.T.Wallace Starlink 10 April 2004 -* -* Copyright (C) 2004 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION VU(3),REFA,REFB,VR(3) - - DOUBLE PRECISION X,Y,Z1,Z,ZSQ,RSQ,R,WB,WT,D,CD,F - - - -* Initial estimate = unrefracted vector - X = VU(1) - Y = VU(2) - Z1 = VU(3) - -* Keep correction approximately constant below about 3 deg elevation - Z = MAX(Z1,0.05D0) - -* One Newton-Raphson iteration - ZSQ = Z*Z - RSQ = X*X+Y*Y - R = SQRT(RSQ) - WB = REFB*RSQ/ZSQ - WT = (REFA+WB)/(1D0+(REFA+3D0*WB)*(ZSQ+RSQ)/ZSQ) - D = WT*R/Z - CD = 1D0-D*D/2D0 - F = CD*(1D0-WT) - -* Post-refraction x,y,z - VR(1) = X*F - VR(2) = Y*F - VR(3) = CD*(Z+D*R)+(Z1-Z) - - END diff --git a/src/slalib/refz.f b/src/slalib/refz.f deleted file mode 100644 index 15322ba03..000000000 --- a/src/slalib/refz.f +++ /dev/null @@ -1,169 +0,0 @@ - SUBROUTINE sla_REFZ (ZU, REFA, REFB, ZR) -*+ -* - - - - - -* R E F Z -* - - - - - -* -* Adjust an unrefracted zenith distance to include the effect of -* atmospheric refraction, using the simple A tan Z + B tan**3 Z -* model (plus special handling for large ZDs). -* -* Given: -* ZU dp unrefracted zenith distance of the source (radian) -* REFA dp tan Z coefficient (radian) -* REFB dp tan**3 Z coefficient (radian) -* -* Returned: -* ZR dp refracted zenith distance (radian) -* -* Notes: -* -* 1 This routine applies the adjustment for refraction in the -* opposite sense to the usual one - it takes an unrefracted -* (in vacuo) position and produces an observed (refracted) -* position, whereas the A tan Z + B tan**3 Z model strictly -* applies to the case where an observed position is to have the -* refraction removed. The unrefracted to refracted case is -* harder, and requires an inverted form of the text-book -* refraction models; the formula used here is based on the -* Newton-Raphson method. For the utmost numerical consistency -* with the refracted to unrefracted model, two iterations are -* carried out, achieving agreement at the 1D-11 arcseconds level -* for a ZD of 80 degrees. The inherent accuracy of the model -* is, of course, far worse than this - see the documentation for -* sla_REFCO for more information. -* -* 2 At ZD 83 degrees, the rapidly-worsening A tan Z + B tan^3 Z -* model is abandoned and an empirical formula takes over. For -* optical/IR wavelengths, over a wide range of observer heights and -* corresponding temperatures and pressures, the following levels of -* accuracy (arcsec, worst case) are achieved, relative to numerical -* integration through a model atmosphere: -* -* ZR error -* -* 80 0.7 -* 81 1.3 -* 82 2.4 -* 83 4.7 -* 84 6.2 -* 85 6.4 -* 86 8 -* 87 10 -* 88 15 -* 89 30 -* 90 60 -* 91 150 } relevant only to -* 92 400 } high-elevation sites -* -* For radio wavelengths the errors are typically 50% larger than -* the optical figures and by ZD 85 deg are twice as bad, worsening -* rapidly below that. To maintain 1 arcsec accuracy down to ZD=85 -* at the Green Bank site, Condon (2004) has suggested amplifying -* the amount of refraction predicted by sla_REFZ below 10.8 deg -* elevation by the factor (1+0.00195*(10.8-E_t)), where E_t is the -* unrefracted elevation in degrees. -* -* The high-ZD model is scaled to match the normal model at the -* transition point; there is no glitch. -* -* 3 Beyond 93 deg zenith distance, the refraction is held at its -* 93 deg value. -* -* 4 See also the routine sla_REFV, which performs the adjustment in -* Cartesian Az/El coordinates, and with the emphasis on speed -* rather than numerical accuracy. -* -* Reference: -* -* Condon,J.J., Refraction Corrections for the GBT, PTCS/PN/35.2, -* NRAO Green Bank, 2004. -* -* P.T.Wallace Starlink 9 April 2004 -* -* Copyright (C) 2004 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION ZU,REFA,REFB,ZR - -* Radians to degrees - DOUBLE PRECISION R2D - PARAMETER (R2D=57.29577951308232D0) - -* Largest usable ZD (deg) - DOUBLE PRECISION D93 - PARAMETER (D93=93D0) - -* Coefficients for high ZD model (used beyond ZD 83 deg) - DOUBLE PRECISION C1,C2,C3,C4,C5 - PARAMETER (C1=+0.55445D0, - : C2=-0.01133D0, - : C3=+0.00202D0, - : C4=+0.28385D0, - : C5=+0.02390D0) - -* ZD at which one model hands over to the other (radians) - DOUBLE PRECISION Z83 - PARAMETER (Z83=83D0/R2D) - -* High-ZD-model prediction (deg) for that point - DOUBLE PRECISION REF83 - PARAMETER (REF83=(C1+C2*7D0+C3*49D0)/(1D0+C4*7D0+C5*49D0)) - - DOUBLE PRECISION ZU1,ZL,S,C,T,TSQ,TCU,REF,E,E2 - - - -* Perform calculations for ZU or 83 deg, whichever is smaller - ZU1 = MIN(ZU,Z83) - -* Functions of ZD - ZL = ZU1 - S = SIN(ZL) - C = COS(ZL) - T = S/C - TSQ = T*T - TCU = T*TSQ - -* Refracted ZD (mathematically to better than 1 mas at 70 deg) - ZL = ZL-(REFA*T+REFB*TCU)/(1D0+(REFA+3D0*REFB*TSQ)/(C*C)) - -* Further iteration - S = SIN(ZL) - C = COS(ZL) - T = S/C - TSQ = T*T - TCU = T*TSQ - REF = ZU1-ZL+ - : (ZL-ZU1+REFA*T+REFB*TCU)/(1D0+(REFA+3D0*REFB*TSQ)/(C*C)) - -* Special handling for large ZU - IF (ZU.GT.ZU1) THEN - E = 90D0-MIN(D93,ZU*R2D) - E2 = E*E - REF = (REF/REF83)*(C1+C2*E+C3*E2)/(1D0+C4*E+C5*E2) - END IF - -* Return refracted ZD - ZR = ZU-REF - - END diff --git a/src/slalib/rverot.f b/src/slalib/rverot.f deleted file mode 100644 index fccd08c1f..000000000 --- a/src/slalib/rverot.f +++ /dev/null @@ -1,65 +0,0 @@ - REAL FUNCTION sla_RVEROT (PHI, RA, DA, ST) -*+ -* - - - - - - - -* R V E R O T -* - - - - - - - -* -* Velocity component in a given direction due to Earth rotation -* (single precision) -* -* Given: -* PHI real latitude of observing station (geodetic) -* RA,DA real apparent RA,DEC -* ST real local apparent sidereal time -* -* PHI, RA, DEC and ST are all in radians. -* -* Result: -* Component of Earth rotation in direction RA,DA (km/s) -* -* Sign convention: -* The result is +ve when the observatory is receding from the -* given point on the sky. -* -* Accuracy: -* The simple algorithm used assumes a spherical Earth, of -* a radius chosen to give results accurate to about 0.0005 km/s -* for observing stations at typical latitudes and heights. For -* applications requiring greater precision, use the routine -* sla_PVOBS. -* -* P.T.Wallace Starlink 20 July 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL PHI,RA,DA,ST - -* Nominal mean sidereal speed of Earth equator in km/s (the actual -* value is about 0.4651) - REAL ESPEED - PARAMETER (ESPEED=0.4655) - - - sla_RVEROT=ESPEED*COS(PHI)*SIN(ST-RA)*COS(DA) - - END diff --git a/src/slalib/rvgalc.f b/src/slalib/rvgalc.f deleted file mode 100644 index 77c953fc1..000000000 --- a/src/slalib/rvgalc.f +++ /dev/null @@ -1,86 +0,0 @@ - REAL FUNCTION sla_RVGALC (R2000, D2000) -*+ -* - - - - - - - -* R V G A L C -* - - - - - - - -* -* Velocity component in a given direction due to the rotation -* of the Galaxy (single precision) -* -* Given: -* R2000,D2000 real J2000.0 mean RA,Dec (radians) -* -* Result: -* Component of dynamical LSR motion in direction R2000,D2000 (km/s) -* -* Sign convention: -* The result is +ve when the dynamical LSR is receding from the -* given point on the sky. -* -* Note: The Local Standard of Rest used here is a point in the -* vicinity of the Sun which is in a circular orbit around -* the Galactic centre. Sometimes called the "dynamical" LSR, -* it is not to be confused with a "kinematical" LSR, which -* is the mean standard of rest of star catalogues or stellar -* populations. -* -* Reference: The orbital speed of 220 km/s used here comes from -* Kerr & Lynden-Bell (1986), MNRAS, 221, p1023. -* -* Called: -* sla_CS2C, sla_VDV -* -* P.T.Wallace Starlink 23 March 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL R2000,D2000 - - REAL VA(3), VB(3) - - REAL sla_VDV - -* -* LSR velocity due to Galactic rotation -* -* Speed = 220 km/s -* Apex = L2,B2 90deg, 0deg -* = RA,Dec 21 12 01.1 +48 19 47 J2000.0 -* -* This is expressed in the form of a J2000.0 x,y,z vector: -* -* VA(1) = X = -SPEED*COS(RA)*COS(DEC) -* VA(2) = Y = -SPEED*SIN(RA)*COS(DEC) -* VA(3) = Z = -SPEED*SIN(DEC) - - DATA VA / -108.70408, +97.86251, -164.33610 / - - - -* Convert given J2000 RA,Dec to x,y,z - CALL sla_CS2C(R2000,D2000,VB) - -* Compute dot product with LSR motion vector - sla_RVGALC=sla_VDV(VA,VB) - - END diff --git a/src/slalib/rvlg.f b/src/slalib/rvlg.f deleted file mode 100644 index f7fa091bf..000000000 --- a/src/slalib/rvlg.f +++ /dev/null @@ -1,81 +0,0 @@ - REAL FUNCTION sla_RVLG (R2000, D2000) -*+ -* - - - - - -* R V L G -* - - - - - -* -* Velocity component in a given direction due to the combination -* of the rotation of the Galaxy and the motion of the Galaxy -* relative to the mean motion of the local group (single precision) -* -* Given: -* R2000,D2000 real J2000.0 mean RA,Dec (radians) -* -* Result: -* Component of SOLAR motion in direction R2000,D2000 (km/s) -* -* Sign convention: -* The result is +ve when the Sun is receding from the -* given point on the sky. -* -* Reference: -* IAU Trans 1976, 168, p201. -* -* Called: -* sla_CS2C, sla_VDV -* -* P.T.Wallace Starlink June 1985 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL R2000,D2000 - - REAL VA(3), VB(3) - - REAL sla_VDV - -* -* Solar velocity due to Galactic rotation and translation -* -* Speed = 300 km/s -* -* Apex = L2,B2 90deg, 0deg -* = RA,Dec 21 12 01.1 +48 19 47 J2000.0 -* -* This is expressed in the form of a J2000.0 x,y,z vector: -* -* VA(1) = X = -SPEED*COS(RA)*COS(DEC) -* VA(2) = Y = -SPEED*SIN(RA)*COS(DEC) -* VA(3) = Z = -SPEED*SIN(DEC) - - DATA VA / -148.23284, +133.44888, -224.09467 / - - - -* Convert given J2000 RA,Dec to x,y,z - CALL sla_CS2C(R2000,D2000,VB) - -* Compute dot product with Solar motion vector - sla_RVLG=sla_VDV(VA,VB) - - END diff --git a/src/slalib/rvlsrd.f b/src/slalib/rvlsrd.f deleted file mode 100644 index 08f995531..000000000 --- a/src/slalib/rvlsrd.f +++ /dev/null @@ -1,95 +0,0 @@ - REAL FUNCTION sla_RVLSRD (R2000, D2000) -*+ -* - - - - - - - -* R V L S R D -* - - - - - - - -* -* Velocity component in a given direction due to the Sun's motion -* with respect to the dynamical Local Standard of Rest. -* -* (single precision) -* -* Given: -* R2000,D2000 r J2000.0 mean RA,Dec (radians) -* -* Result: -* Component of "peculiar" solar motion in direction R2000,D2000 (km/s) -* -* Sign convention: -* The result is +ve when the Sun is receding from the given point on -* the sky. -* -* Note: The Local Standard of Rest used here is the "dynamical" LSR, -* a point in the vicinity of the Sun which is in a circular -* orbit around the Galactic centre. The Sun's motion with -* respect to the dynamical LSR is called the "peculiar" solar -* motion. -* -* There is another type of LSR, called a "kinematical" LSR. A -* kinematical LSR is the mean standard of rest of specified star -* catalogues or stellar populations, and several slightly -* different kinematical LSRs are in use. The Sun's motion with -* respect to an agreed kinematical LSR is known as the "standard" -* solar motion. To obtain a radial velocity correction with -* respect to an adopted kinematical LSR use the routine sla_RVLSRK. -* -* Reference: Delhaye (1965), in "Stars and Stellar Systems", vol 5, -* p73. -* -* Called: -* sla_CS2C, sla_VDV -* -* P.T.Wallace Starlink 9 March 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL R2000,D2000 - - REAL VA(3), VB(3) - - REAL sla_VDV - -* -* Peculiar solar motion from Delhaye 1965: in Galactic Cartesian -* coordinates (+9,+12,+7) km/s. This corresponds to about 16.6 km/s -* towards Galactic coordinates L2 = 53 deg, B2 = +25 deg, or RA,Dec -* 17 49 58.7 +28 07 04 J2000. -* -* The solar motion is expressed here in the form of a J2000.0 -* equatorial Cartesian vector: -* -* VA(1) = X = -SPEED*COS(RA)*COS(DEC) -* VA(2) = Y = -SPEED*SIN(RA)*COS(DEC) -* VA(3) = Z = -SPEED*SIN(DEC) - - DATA VA / +0.63823, +14.58542, -7.80116 / - - - -* Convert given J2000 RA,Dec to x,y,z - CALL sla_CS2C(R2000,D2000,VB) - -* Compute dot product with solar motion vector - sla_RVLSRD=sla_VDV(VA,VB) - - END diff --git a/src/slalib/rvlsrk.f b/src/slalib/rvlsrk.f deleted file mode 100644 index b513e0530..000000000 --- a/src/slalib/rvlsrk.f +++ /dev/null @@ -1,94 +0,0 @@ - REAL FUNCTION sla_RVLSRK (R2000, D2000) -*+ -* - - - - - - - -* R V L S R K -* - - - - - - - -* -* Velocity component in a given direction due to the Sun's motion -* with respect to an adopted kinematic Local Standard of Rest. -* -* (single precision) -* -* Given: -* R2000,D2000 r J2000.0 mean RA,Dec (radians) -* -* Result: -* Component of "standard" solar motion in direction R2000,D2000 (km/s) -* -* Sign convention: -* The result is +ve when the Sun is receding from the given point on -* the sky. -* -* Note: The Local Standard of Rest used here is one of several -* "kinematical" LSRs in common use. A kinematical LSR is the -* mean standard of rest of specified star catalogues or stellar -* populations. The Sun's motion with respect to a kinematical -* LSR is known as the "standard" solar motion. -* -* There is another sort of LSR, the "dynamical" LSR, which is a -* point in the vicinity of the Sun which is in a circular orbit -* around the Galactic centre. The Sun's motion with respect to -* the dynamical LSR is called the "peculiar" solar motion. To -* obtain a radial velocity correction with respect to the -* dynamical LSR use the routine sla_RVLSRD. -* -* Reference: Delhaye (1965), in "Stars and Stellar Systems", vol 5, -* p73. -* -* Called: -* sla_CS2C, sla_VDV -* -* P.T.Wallace Starlink 11 March 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL R2000,D2000 - - REAL VA(3), VB(3) - - REAL sla_VDV - -* -* Standard solar motion (from Methods of Experimental Physics, ed Meeks, -* vol 12, part C, sec 6.1.5.2, p281): -* -* 20 km/s towards RA 18h Dec +30d (1900). -* -* The solar motion is expressed here in the form of a J2000.0 -* equatorial Cartesian vector: -* -* VA(1) = X = -SPEED*COS(RA)*COS(DEC) -* VA(2) = Y = -SPEED*SIN(RA)*COS(DEC) -* VA(3) = Z = -SPEED*SIN(DEC) - - DATA VA / -0.29000, +17.31726, -10.00141 / - - - -* Convert given J2000 RA,Dec to x,y,z - CALL sla_CS2C(R2000,D2000,VB) - -* Compute dot product with solar motion vector - sla_RVLSRK=sla_VDV(VA,VB) - - END diff --git a/src/slalib/s2tp.f b/src/slalib/s2tp.f deleted file mode 100644 index 1a550d131..000000000 --- a/src/slalib/s2tp.f +++ /dev/null @@ -1,84 +0,0 @@ - SUBROUTINE sla_S2TP (RA, DEC, RAZ, DECZ, XI, ETA, J) -*+ -* - - - - - -* S 2 T P -* - - - - - -* -* Projection of spherical coordinates onto tangent plane: -* "gnomonic" projection - "standard coordinates" -* (single precision) -* -* Given: -* RA,DEC real spherical coordinates of point to be projected -* RAZ,DECZ real spherical coordinates of tangent point -* -* Returned: -* XI,ETA real rectangular coordinates on tangent plane -* J int status: 0 = OK, star on tangent plane -* 1 = error, star too far from axis -* 2 = error, antistar on tangent plane -* 3 = error, antistar too far from axis -* -* P.T.Wallace Starlink 18 July 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL RA,DEC,RAZ,DECZ,XI,ETA - INTEGER J - - REAL SDECZ,SDEC,CDECZ,CDEC,RADIF,SRADIF,CRADIF,DENOM - - REAL TINY - PARAMETER (TINY=1E-6) - - -* Trig functions - SDECZ=SIN(DECZ) - SDEC=SIN(DEC) - CDECZ=COS(DECZ) - CDEC=COS(DEC) - RADIF=RA-RAZ - SRADIF=SIN(RADIF) - CRADIF=COS(RADIF) - -* Reciprocal of star vector length to tangent plane - DENOM=SDEC*SDECZ+CDEC*CDECZ*CRADIF - -* Handle vectors too far from axis - IF (DENOM.GT.TINY) THEN - J=0 - ELSE IF (DENOM.GE.0.0) THEN - J=1 - DENOM=TINY - ELSE IF (DENOM.GT.-TINY) THEN - J=2 - DENOM=-TINY - ELSE - J=3 - END IF - -* Compute tangent plane coordinates (even in dubious cases) - XI=CDEC*SRADIF/DENOM - ETA=(SDEC*CDECZ-CDEC*SDECZ*CRADIF)/DENOM - - END diff --git a/src/slalib/sep.f b/src/slalib/sep.f deleted file mode 100644 index 3fe044b58..000000000 --- a/src/slalib/sep.f +++ /dev/null @@ -1,55 +0,0 @@ - REAL FUNCTION sla_SEP (A1, B1, A2, B2) -*+ -* - - - - -* S E P -* - - - - -* -* Angle between two points on a sphere. -* -* (single precision) -* -* Given: -* A1,B1 r spherical coordinates of one point -* A2,B2 r spherical coordinates of the other point -* -* (The spherical coordinates are [RA,Dec], [Long,Lat] etc, in radians.) -* -* The result is the angle, in radians, between the two points. It -* is always positive. -* -* Called: sla_DSEP -* -* Last revision: 7 May 2000 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL A1,B1,A2,B2 - - DOUBLE PRECISION sla_DSEP - - - -* Use double precision version. - sla_SEP = REAL(sla_DSEP(DBLE(A1),DBLE(B1),DBLE(A2),DBLE(B2))) - - END diff --git a/src/slalib/sepv.f b/src/slalib/sepv.f deleted file mode 100644 index 711012283..000000000 --- a/src/slalib/sepv.f +++ /dev/null @@ -1,70 +0,0 @@ - REAL FUNCTION sla_SEPV (V1, V2) -*+ -* - - - - - -* S E P V -* - - - - - -* -* Angle between two vectors. -* -* (single precision) -* -* Given: -* V1 r(3) first vector -* V2 r(3) second vector -* -* The result is the angle, in radians, between the two vectors. It -* is always positive. -* -* Notes: -* -* 1 There is no requirement for the vectors to be unit length. -* -* 2 If either vector is null, zero is returned. -* -* 3 The simplest formulation would use dot product alone. However, -* this would reduce the accuracy for angles near zero and pi. The -* algorithm uses both cross product and dot product, which maintains -* accuracy for all sizes of angle. -* -* Called: sla_DSEPV -* -* Last revision: 7 May 2000 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL V1(3),V2(3) - - INTEGER I - DOUBLE PRECISION DV1(3),DV2(3) - DOUBLE PRECISION sla_DSEPV - - - -* Use double precision version. - DO I=1,3 - DV1(I) = DBLE(V1(I)) - DV2(I) = DBLE(V2(I)) - END DO - sla_SEPV = REAL(sla_DSEPV(DV1,DV2)) - - END diff --git a/src/slalib/sla_config.h b/src/slalib/sla_config.h deleted file mode 100644 index c34cbdd2f..000000000 --- a/src/slalib/sla_config.h +++ /dev/null @@ -1,69 +0,0 @@ -/* config.h. Generated by configure. */ -/* config.h.in. Generated from configure.ac by autoheader. */ - -/* Define to alternate name for `main' routine that is called from a `main' in - the Fortran libraries. */ -#define FC_MAIN MAIN__ - -/* Define to 1 if you have the header file. */ -#define HAVE_DLFCN_H 1 - -/* True when Fortran main isn't C main */ -#define HAVE_FC_MAIN 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_INTTYPES_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_MEMORY_H 1 - -/* Define to 1 if you have the `rand' function. */ -#define HAVE_RAND 1 - -/* Define to 1 if you have the `random' function. */ -#define HAVE_RANDOM 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDINT_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDLIB_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRINGS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRING_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_STAT_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_TYPES_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_UNISTD_H 1 - -/* Name of package */ -#define PACKAGE "sla" - -/* Define to the address where bug reports for this package should be sent. */ -#define PACKAGE_BUGREPORT "ussc@star.rl.ac.uk" - -/* Define to the full name of this package. */ -#define PACKAGE_NAME "sla" - -/* Define to the full name and version of this package. */ -#define PACKAGE_STRING "sla 2.5-4" - -/* Define to the one symbol short name of this package. */ -#define PACKAGE_TARNAME "sla" - -/* Define to the version of this package. */ -#define PACKAGE_VERSION "2.5-4" - -/* Define to 1 if you have the ANSI C header files. */ -#define STDC_HEADERS 1 - -/* Version number of package */ -#define VERSION "2.5-4" diff --git a/src/slalib/sla_test.f b/src/slalib/sla_test.f deleted file mode 100644 index d35342cbd..000000000 --- a/src/slalib/sla_test.f +++ /dev/null @@ -1,6567 +0,0 @@ - PROGRAM SLA_TEST -*+ -* - - - - - - - - - -* S L A _ T E S T -* - - - - - - - - - -* -* Validate the slalib library. -* -* Each slalib function is tested to some useful but in most cases -* not exhaustive level. Successful completion is signalled by an -* absence of output messages. Failure of a given function or -* group of functions results in error messages. -* -* Any messages go to standard output. -* -* Adapted from original C code by P.T.Wallace. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink and P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - INTEGER EXITSTATUS - - -* Preset the status to success. - STATUS = .TRUE. - -* Test all the slalib functions. - CALL T_ADDET ( STATUS ) - CALL T_AFIN ( STATUS ) - CALL T_AIRMAS ( STATUS ) - CALL T_ALTAZ ( STATUS ) - CALL T_AMP ( STATUS ) - CALL T_AOP ( STATUS ) - CALL T_BEAR ( STATUS ) - CALL T_CAF2R ( STATUS ) - CALL T_CALDJ ( STATUS ) - CALL T_CALYD ( STATUS ) - CALL T_CC2S ( STATUS ) - CALL T_CC62S ( STATUS ) - CALL T_CD2TF ( STATUS ) - CALL T_CLDJ ( STATUS ) - CALL T_CR2AF ( STATUS ) - CALL T_CR2TF ( STATUS ) - CALL T_CS2C6 ( STATUS ) - CALL T_CTF2D ( STATUS ) - CALL T_CTF2R ( STATUS ) - CALL T_DAT ( STATUS ) - CALL T_DBJIN ( STATUS ) - CALL T_DJCAL ( STATUS ) - CALL T_DMAT ( STATUS ) - CALL T_E2H ( STATUS ) - CALL T_EARTH ( STATUS ) - CALL T_ECLEQ ( STATUS ) - CALL T_ECMAT ( STATUS ) - CALL T_ECOR ( STATUS ) - CALL T_EG50 ( STATUS ) - CALL T_EPB ( STATUS ) - CALL T_EPB2D ( STATUS ) - CALL T_EPCO ( STATUS ) - CALL T_EPJ ( STATUS ) - CALL T_EPJ2D ( STATUS ) - CALL T_EQECL ( STATUS ) - CALL T_EQEQX ( STATUS ) - CALL T_EQGAL ( STATUS ) - CALL T_ETRMS ( STATUS ) - CALL T_EVP ( STATUS ) - CALL T_FITXY ( STATUS ) - CALL T_FK425 ( STATUS ) - CALL T_FK45Z ( STATUS ) - CALL T_FK524 ( STATUS ) - CALL T_FK52H ( STATUS ) - CALL T_FK54Z ( STATUS ) - CALL T_FLOTIN ( STATUS ) - CALL T_GALEQ ( STATUS ) - CALL T_GALSUP ( STATUS ) - CALL T_GE50 ( STATUS ) - CALL T_GMST ( STATUS ) - CALL T_INTIN ( STATUS ) - CALL T_KBJ ( STATUS ) - CALL T_MAP ( STATUS ) - CALL T_MOON ( STATUS ) - CALL T_NUT ( STATUS ) - CALL T_OBS ( STATUS ) - CALL T_PA ( STATUS ) - CALL T_PCD ( STATUS ) - CALL T_PDA2H ( STATUS ) - CALL T_PDQ2H ( STATUS ) - CALL T_PERCOM ( STATUS ) - CALL T_PLANET ( STATUS ) - CALL T_PM ( STATUS ) - CALL T_POLMO ( STATUS ) - CALL T_PREBN ( STATUS ) - CALL T_PREC ( STATUS ) - CALL T_PRECES ( STATUS ) - CALL T_PRENUT ( STATUS ) - CALL T_PVOBS ( STATUS ) - CALL T_RANGE ( STATUS ) - CALL T_RANORM ( STATUS ) - CALL T_RCC ( STATUS ) - CALL T_REF ( STATUS ) - CALL T_RV ( STATUS ) - CALL T_SEP ( STATUS ) - CALL T_SMAT ( STATUS ) - CALL T_SUPGAL ( STATUS ) - CALL T_SVD ( STATUS ) - CALL T_TP ( STATUS ) - CALL T_TPV ( STATUS ) - CALL T_VECMAT ( STATUS ) - CALL T_ZD ( STATUS ) - -* Report any errors and set up an appropriate exit status. Set the -* EXITSTATUS to 0 on success, 1 on any error -- Unix-style. The -* EXIT intrinsic is non-standard but common (which is portable enough -* for a regression test). - - IF ( STATUS ) THEN - WRITE (*,'(1X,''SLALIB validation OK!'')') - EXITSTATUS = 0 - ELSE - WRITE (*,'(1X,''SLALIB validation failed!'')') - EXITSTATUS = 1 - ENDIF - - CALL EXIT(EXITSTATUS) - - END - - SUBROUTINE VCS ( S, SOK, FUNC, TEST, STATUS ) -*+ -* - - - - -* V C S -* - - - - -* -* Validate a character string result. -* -* Internal routine used by sla_TEST program. -* -* Given: -* S CHARACTER string produced by routine under test -* SOK CHARACTER correct value -* FUNC CHARACTER name of routine under test -* TEST CHARACTER name of individual test (or ' ') -* -* Given and returned: -* STATUS LOGICAL set to .FALSE. if test fails -* -* Called: ERR -* -* Last revision: 25 May 2002 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) S, SOK, FUNC, TEST - LOGICAL STATUS - - - IF ( S .NE. SOK ) THEN - CALL ERR ( FUNC, TEST, STATUS ) - WRITE (*,'(1X,'' expected ='',6X,''"'',A,''"'')') SOK - WRITE (*,'(1X,'' actual = '',6X,''"'',A,''"'')') S - END IF - - END - - SUBROUTINE VIV ( IVAL, IVALOK, FUNC, TEST, STATUS ) -*+ -* - - - - -* V I V -* - - - - -* -* Validate an integer result. -* -* Internal routine used by sla_TEST program. -* -* Given: -* IVAL INTEGER value computed by routine under test -* IVALOK INTEGER correct value -* FUNC CHARACTER name of routine under test -* TEST CHARACTER name of individual test (or ' ') -* -* Given and returned: -* STATUS LOGICAL set to .FALSE. if test fails -* -* Called: ERR -* -* Last revision: 25 May 2002 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER IVAL, IVALOK - CHARACTER*(*) FUNC, TEST - LOGICAL STATUS - - - IF ( IVAL .NE. IVALOK ) THEN - CALL ERR ( FUNC, TEST, STATUS ) - WRITE (*,'(1X,'' expected ='',I10)') IVALOK - WRITE (*,'(1X,'' actual = '',I10)') IVAL - END IF - - END - - SUBROUTINE VLV ( IVAL, IVALOK, FUNC, TEST, STATUS ) -*+ -* - - - - -* V L V -* - - - - -* -* Validate a long result. -* -* Internal routine used by sla_TEST program. -* -* Given: -* IVAL INTEGER*4 value computed by routine under test -* IVALOK INTEGER*4 correct value -* FUNC CHARACTER name of routine under test -* TEST CHARACTER name of individual test (or ' ') -* -* Given and returned: -* STATUS LOGICAL set to .FALSE. if test fails -* -* Called: ERR -* -* Last revision: 25 May 2002 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER*4 IVAL, IVALOK - CHARACTER*(*) FUNC, TEST - LOGICAL STATUS - - - IF ( IVAL .NE. IVALOK ) THEN - CALL ERR ( FUNC, TEST, STATUS ) - WRITE (*,'(1X,'' expected ='',I10)') IVALOK - WRITE (*,'(1X,'' actual = '',I10)') IVAL - END IF - - END - - SUBROUTINE VVD ( VAL, VALOK, DVAL, FUNC, TEST, STATUS ) -*+ -* - - - - -* V V D -* - - - - -* -* Validate a double result. -* -* Internal routine used by sla_TEST program. -* -* Given: -* VAL DOUBLE value computed by routine under test -* VALOK DOUBLE correct value -* DVAL DOUBLE maximum allowable error -* FUNC CHARACTER name of routine under test -* TEST CHARACTER name of individual test (or ' ') -* -* Given and returned: -* STATUS LOGICAL set to .FALSE. if test fails -* -* Called: ERR -* -* Last revision: 25 May 2002 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION VAL, VALOK, DVAL - CHARACTER*(*) FUNC, TEST - LOGICAL STATUS - - - IF ( DABS ( VAL - VALOK ) .GT. DVAL ) THEN - CALL ERR ( FUNC, TEST, STATUS ) - WRITE (*,'(1X,'' expected ='',G30.19)') VALOK - WRITE (*,'(1X,'' actual = '',G30.19)') VAL - END IF - - END - - SUBROUTINE ERR ( FUNC, TEST, STATUS ) -*+ -* - - - - -* E R R -* - - - - -* -* Report a failed test. -* -* Internal routine used by sla_TEST program. -* -* Given: -* FUNC CHARACTER name of routine under test -* TEST CHARACTER name of individual test (or ' ') -* -* Given and returned: -* STATUS LOGICAL set to .FALSE. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER*(*) FUNC, TEST - LOGICAL STATUS - - - WRITE (*,'(1X,A,'' test '',A,'' fails:'')') FUNC, TEST - STATUS = .FALSE. - - END - - SUBROUTINE T_ADDET ( STATUS ) -*+ -* - - - - - - - - -* T _ A D D E T -* - - - - - - - - -* -* Test sla_ADDET, sla_SUBET routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_ADDET, VVD, sla_SUBET. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RM, DM, EQ, R1, D1, R2, D2 - - RM = 2D0 - DM = -1D0 - EQ = 1975D0 - - CALL sla_ADDET ( RM, DM, EQ, R1, D1 ) - CALL VVD ( R1 - RM, 2.983864874295250D-6, 1D-12, 'sla_ADDET', - : 'R', STATUS ) - CALL VVD ( D1 - DM, 2.379650804185118D-7, 1D-12, 'sla_ADDET', - : 'D', STATUS ) - - CALL sla_SUBET ( R1, D1, EQ, R2, D2 ) - CALL VVD ( R2 - RM, 0D0, 1D-12, 'sla_SUBET', 'R', STATUS ) - CALL VVD ( D2 - DM, 0D0, 1D-12, 'sla_SUBET', 'D', STATUS ) - - END - - SUBROUTINE T_AFIN ( STATUS ) -*+ -* - - - - - - - -* T _ A F I N -* - - - - - - - -* -* Test sla_AFIN and sla_DAFIN routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_AFIN, VIV, VVD, sla_DAFIN. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I, J - REAL F - DOUBLE PRECISION D - CHARACTER*12 S - DATA S /'12 34 56.7 |'/ - - - I = 1 - CALL sla_AFIN (S, I, F, J) - CALL VIV ( I, 12, 'sla_AFIN', 'I', STATUS ) - CALL VVD ( DBLE( F ), 0.2196045986911432D0, 1D-6, 'sla_AFIN', - : 'A', STATUS ) - CALL VIV ( J, 0, 'sla_AFIN', 'J', STATUS ) - - I = 1 - CALL sla_DAFIN (S, I, D, J) - CALL VIV ( I, 12, 'sla_DAFIN', 'I', STATUS ) - CALL VVD ( D, 0.2196045986911432D0, 1D-12, 'sla_DAFIN', 'A', - : STATUS ) - CALL VIV ( J, 0, 'sla_DAFIN', 'J', STATUS ) - - END - - SUBROUTINE T_AIRMAS ( STATUS ) -*+ -* - - - - - - - - - -* T _ A I R M A S -* - - - - - - - - - -* -* Test sla_AIRMAS routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: VVD, sla_AIRMAS. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_AIRMAS - - - CALL VVD ( sla_AIRMAS ( 1.2354D0 ), 3.015698990074724D0, - : 1D-12, 'sla_AIRMAS', ' ', STATUS ) - - END - - SUBROUTINE T_ALTAZ ( STATUS ) -*+ -* - - - - - - - - -* T _ A L T A Z -* - - - - - - - - -* -* Test sla_ALTAZ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_ALTAZ, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION AZ, AZD, AZDD, EL, ELD, ELDD, PA, PAD, PADD - - CALL sla_ALTAZ ( 0.7D0, -0.7D0, -0.65D0, - : AZ, AZD, AZDD, EL, ELD, ELDD, PA, PAD, PADD ) - - CALL VVD ( AZ, 4.400560746660174D0, 1D-12, 'sla_ALTAZ', - : 'AZ', STATUS ) - CALL VVD ( AZD, -0.2015438937145421D0, 1D-13, 'sla_ALTAZ', - : 'AZD', STATUS ) - CALL VVD ( AZDD, -0.4381266949668748D0, 1D-13, 'sla_ALTAZ', - : 'AZDD', STATUS ) - CALL VVD ( EL, 1.026646506651396D0, 1D-12, 'sla_ALTAZ', - : 'EL', STATUS ) - CALL VVD ( ELD, -0.7576920683826450D0, 1D-13, 'sla_ALTAZ', - : 'ELD', STATUS ) - CALL VVD ( ELDD, 0.04922465406857453D0, 1D-14, 'sla_ALTAZ', - : 'ELDD', STATUS ) - CALL VVD ( PA, 1.707639969653937D0, 1D-12, 'sla_ALTAZ', - : 'PA', STATUS ) - CALL VVD ( PAD, 0.4717832355365627D0, 1D-13, 'sla_ALTAZ', - : 'PAD', STATUS ) - CALL VVD ( PADD, -0.2957914128185515D0, 1D-13, 'sla_ALTAZ', - : 'PADD', STATUS ) - - END - - SUBROUTINE T_AMP ( STATUS ) -*+ -* - - - - - - -* T _ A M P -* - - - - - - -* -* Test sla_AMP, sla_MAPPA, sla_AMPQK routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_AMP, VVD. -* -* Last revision: 16 November 2001 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RM, DM - - CALL sla_AMP ( 2.345D0, -1.234D0, 50100D0, 1990D0, RM, DM ) - CALL VVD ( RM, 2.344472180027961D0, 1D-11, 'sla_AMP', 'R', - : STATUS ) - CALL VVD ( DM, -1.233573099847705D0, 1D-11, 'sla_AMP', 'D', - : STATUS ) - - END - - SUBROUTINE T_AOP ( STATUS ) -*+ -* - - - - - - -* T _ A O P -* - - - - - - -* -* Test sla_AOP, sla_AOPPA, sla_AOPQK, sla_OAP, sla_OAPQK, -* sla_AOPPAT routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_AOP, VVD, sla_AOPPA, sla_AOPQK, sla_OAP, sla_OAPQK, -* sla_AOPPAT. -* -* Defined in slamac.h: DS2R -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I - DOUBLE PRECISION DS2R - DOUBLE PRECISION RAP, DAP, DATE, DUT, ELONGM, PHIM, HM, XP, YP, - : TDK, PMB, RH, WL, TLR, AOB, ZOB, HOB, DOB, ROB, AOPRMS(14) - - PARAMETER (DS2R = - : 7.2722052166430399038487115353692196393452995355905D-5) - - DAP = -0.1234D0 - DATE = 51000.1D0 - DUT = 25D0 - ELONGM = 2.1D0 - PHIM = 0.5D0 - HM = 3000D0 - XP = -0.5D-6 - YP = 1D-6 - TDK = 280D0 - PMB = 550D0 - RH = 0.6D0 - TLR = 0.006D0 - - DO I = 1, 3 - - IF ( I .EQ. 1 ) THEN - RAP = 2.7D0 - WL = 0.45D0 - ELSE IF ( I .EQ. 2 ) THEN - RAP = 2.345D0 - ELSE - WL = 1D6 - END IF - - CALL sla_AOP ( RAP, DAP, DATE, DUT, ELONGM, PHIM, HM, XP, YP, - : TDK, PMB, RH, WL, TLR, AOB, ZOB, HOB, DOB, ROB ) - - IF ( I .EQ. 1 ) THEN - CALL VVD ( AOB, 1.812817787123283034D0, 1D-10, 'sla_AOP', - : 'lo aob', STATUS ) - CALL VVD ( ZOB, 1.393860816635714034D0, 1D-10, 'sla_AOP', - : 'lo zob', STATUS ) - CALL VVD ( HOB, -1.297808009092456683D0, 1D-10, 'sla_AOP', - : 'lo hob', STATUS ) - CALL VVD ( DOB, -0.122967060534561D0, 1D-10, 'sla_AOP', - : 'lo dob', STATUS ) - CALL VVD ( ROB, 2.699270287872084D0, 1D-10, 'sla_AOP', - : 'lo rob', STATUS ) - ELSE IF ( I .EQ. 2 ) THEN - CALL VVD ( AOB, 2.019928026670621442D0, 1D-10, 'sla_AOP', - : 'aob/o', STATUS ) - CALL VVD ( ZOB, 1.101316172427482466D0, 1D-10, 'sla_AOP', - : 'zob/o', STATUS ) - CALL VVD ( HOB, -0.9432923558497740862D0, 1D-10, 'sla_AOP', - : 'hob/o', STATUS ) - CALL VVD ( DOB, -0.1232144708194224D0, 1D-10, 'sla_AOP', - : 'dob/o', STATUS ) - CALL VVD ( ROB, 2.344754634629428D0, 1D-10, 'sla_AOP', - : 'rob/o', STATUS ) - ELSE - CALL VVD ( AOB, 2.019928026670621442D0, 1D-10, 'sla_AOP', - : 'aob/r', STATUS ) - CALL VVD ( ZOB, 1.101267532198003760D0, 1D-10, 'sla_AOP', - : 'zob/r', STATUS ) - CALL VVD ( HOB, -0.9432533138143315937D0, 1D-10, 'sla_AOP', - : 'hob/r', STATUS ) - CALL VVD ( DOB, -0.1231850665614878D0, 1D-10, 'sla_AOP', - : 'dob/r', STATUS ) - CALL VVD ( ROB, 2.344715592593984D0, 1D-10, 'sla_AOP', - : 'rob/r', STATUS ) - END IF - END DO - - DATE = 48000.3D0 - WL = 0.45D0 - - CALL sla_AOPPA ( DATE, DUT, ELONGM, PHIM, HM, XP, YP, TDK, - : PMB, RH, WL, TLR, AOPRMS ) - CALL VVD ( AOPRMS(1), 0.4999993892136306D0, 1D-13, 'sla_AOPPA', - : '1', STATUS ) - CALL VVD ( AOPRMS(2), 0.4794250025886467D0, 1D-13, 'sla_AOPPA', - : '2', STATUS ) - CALL VVD ( AOPRMS(3), 0.8775828547167932D0, 1D-13, 'sla_AOPPA', - : '3', STATUS ) - CALL VVD ( AOPRMS(4), 1.363180872136126D-6, 1D-13, 'sla_AOPPA', - : '4', STATUS ) - CALL VVD ( AOPRMS(5), 3000D0, 1D-10, 'sla_AOPPA', '5', - : STATUS ) - CALL VVD ( AOPRMS(6), 280D0, 1D-11, 'sla_AOPPA', '6', - : STATUS ) - CALL VVD ( AOPRMS(7), 550D0, 1D-11, 'sla_AOPPA', '7', - : STATUS ) - CALL VVD ( AOPRMS(8), 0.6D0, 1D-13, 'sla_AOPPA', '8', - : STATUS ) - CALL VVD ( AOPRMS(9), 0.45D0, 1D-13, 'sla_AOPPA', '9', - : STATUS ) - CALL VVD ( AOPRMS(10), 0.006D0, 1D-15, 'sla_AOPPA', '10', - : STATUS ) - CALL VVD ( AOPRMS(11), 0.0001562803328459898D0, 1D-13, - : 'sla_AOPPA', '11', STATUS ) - CALL VVD ( AOPRMS(12), -1.792293660141D-7, 1D-13, - : 'sla_AOPPA', '12', STATUS ) - CALL VVD ( AOPRMS(13), 2.101874231495843D0, 1D-13, - : 'sla_AOPPA', '13', STATUS ) - CALL VVD ( AOPRMS(14), 7.601916802079765D0, 1D-8, - : 'sla_AOPPA', '14', STATUS ) - - CALL sla_OAP ( 'R', 1.6D0, -1.01D0, DATE, DUT, ELONGM, PHIM, - : HM, XP, YP, TDK, PMB, RH, WL, TLR, RAP, DAP ) - CALL VVD ( RAP, 1.601197569844787D0, 1D-10, 'sla_OAP', - : 'Rr', STATUS ) - CALL VVD ( DAP, -1.012528566544262D0, 1D-10, 'sla_OAP', - : 'Rd', STATUS ) - CALL sla_OAP ( 'H', -1.234D0, 2.34D0, DATE, DUT, ELONGM, PHIM, - : HM, XP, YP, TDK, PMB, RH, WL, TLR, RAP, DAP ) - CALL VVD ( RAP, 5.693087688154886463D0, 1D-10, 'sla_OAP', - : 'Hr', STATUS ) - CALL VVD ( DAP, 0.8010281167405444D0, 1D-10, 'sla_OAP', - : 'Hd', STATUS ) - CALL sla_OAP ( 'A', 6.1D0, 1.1D0, DATE, DUT, ELONGM, PHIM, - : HM, XP, YP, TDK, PMB, RH, WL, TLR, RAP, DAP ) - CALL VVD ( RAP, 5.894305175192448940D0, 1D-10, 'sla_OAP', - : 'Ar', STATUS ) - CALL VVD ( DAP, 1.406150707974922D0, 1D-10, 'sla_OAP', - : 'Ad', STATUS ) - - CALL sla_OAPQK ( 'R', 2.1D0, -0.345D0, AOPRMS, RAP, DAP ) - CALL VVD ( RAP, 2.10023962776202D0, 1D-10, 'sla_OAPQK', - : 'Rr', STATUS ) - CALL VVD ( DAP, -0.3452428692888919D0, 1D-10, 'sla_OAPQK', - : 'Rd', STATUS ) - CALL sla_OAPQK ( 'H', -0.01D0, 1.03D0, AOPRMS, RAP, DAP ) - CALL VVD ( RAP, 1.328731933634564995D0, 1D-10, 'sla_OAPQK', - : 'Hr', STATUS ) - CALL VVD ( DAP, 1.030091538647746D0, 1D-10, 'sla_OAPQK', - : 'Hd', STATUS ) - CALL sla_OAPQK ( 'A', 4.321D0, 0.987D0, AOPRMS, RAP, DAP ) - CALL VVD ( RAP, 0.4375507112075065923D0, 1D-10, 'sla_OAPQK', - : 'Ar', STATUS ) - CALL VVD ( DAP, -0.01520898480744436D0, 1D-10, 'sla_OAPQK', - : 'Ad', STATUS ) - - CALL sla_AOPPAT ( DATE + DS2R, AOPRMS ) - CALL VVD ( AOPRMS(14), 7.602374979243502D0, 1D-8, 'sla_AOPPAT', - : ' ', STATUS ) - - END - - SUBROUTINE T_BEAR ( STATUS ) -*+ -* - - - - - - - -* T _ B E A R -* - - - - - - - -* -* Test sla_BEAR, sla_DBEAR, sla_DPAV, sla_PAV routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: VVD, sla_BEAR, sla_DBEAR, -* sla_DCS2C, sla_PAV, sla_DPAV. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I - REAL F1(3), F2(3) - REAL sla_BEAR, sla_PAV - DOUBLE PRECISION D1(3), D2(3) - DOUBLE PRECISION A1, B1, A2, B2 - DOUBLE PRECISION sla_DBEAR, sla_DPAV - - - A1 = 1.234D0 - B1 = -0.123D0 - A2 = 2.345D0 - B2 = 0.789D0 - - CALL VVD ( DBLE( sla_BEAR ( SNGL( A1 ), SNGL( B1 ), SNGL( A2 ), - : SNGL( B2 ) ) ), 0.7045970341781791D0, 1D-6, - : 'sla_BEAR', ' ', STATUS ) - CALL VVD ( sla_DBEAR ( A1, B1, A2, B2 ), 0.7045970341781791D0, - : 1D-12, 'sla_DBEAR', ' ', STATUS ) - CALL sla_DCS2C ( A1, B1, D1 ) - CALL sla_DCS2C ( A2, B2, D2 ) - - DO I = 1, 3 - F1(I) = SNGL( D1(I) ) - F2(I) = SNGL( D2(I) ) - END DO - - CALL VVD ( DBLE( sla_PAV ( F1, F2 ) ), 0.7045970341781791D0, - : 1D-6, 'sla_PAV', ' ', STATUS ) - CALL VVD ( sla_DPAV ( D1, D2 ), 0.7045970341781791D0, - : 1D-12, 'sla_DPAV', ' ', STATUS ) - - END - - SUBROUTINE T_CAF2R ( STATUS ) -*+ -* - - - - - - - - -* T _ C A F 2 R -* - - - - - - - - -* -* Test sla_CAF2R, sla_DAF2R routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CAF2R, VVD, VIV, sla_DAF2R. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - REAL R - DOUBLE PRECISION DR - - CALL sla_CAF2R ( 76, 54, 32.1E0, R, J ) - CALL VVD ( DBLE( R ), 1.342313819975276D0, 1D-6, 'sla_CAF2R', - : 'R', STATUS ) - CALL VIV ( J, 0, 'sla_CAF2R', 'J', STATUS ) - CALL sla_DAF2R ( 76, 54, 32.1D0, DR, J ) - CALL VVD ( DR, 1.342313819975276D0, 1D-12, 'sla_DAF2R', - : 'R', STATUS ) - CALL VIV ( J, 0, 'sla_CAF2R', 'J', STATUS ) - - END - - SUBROUTINE T_CALDJ ( STATUS ) -*+ -* - - - - - - - - -* T _ C A L D J -* - - - - - - - - -* -* Test sla_CALDJ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CALDJ, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - DOUBLE PRECISION DJM - - CALL sla_CALDJ ( 1999, 12, 31, DJM, J ) - CALL VVD ( DJM, 51543D0, 0D0, 'sla_CALDJ', ' ', STATUS ) - - END - - SUBROUTINE T_CALYD ( STATUS ) -*+ -* - - - - - - - - -* T _ C A L Y D -* - - - - - - - - -* -* Test sla_CALYD and sla_CLYD routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CALYD, sla_CLYD, VIV. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER NY, ND, J - - CALL sla_CALYD ( 46, 4, 30, NY, ND, J ) - CALL VIV ( NY, 2046, 'sla_CALYD', 'Y', STATUS ) - CALL VIV ( ND, 120, 'sla_CALYD', 'D', STATUS ) - CALL VIV ( J, 0, 'sla_CALYD', 'J', STATUS ) - CALL sla_CLYD ( -5000, 1, 1, NY, ND, J ) - CALL VIV ( J, 1, 'sla_CLYD', 'illegal year', STATUS ) - CALL sla_CLYD ( 1900, 0, 1, NY, ND, J ) - CALL VIV ( J, 2, 'sla_CLYD', 'illegal month', STATUS ) - CALL sla_CLYD ( 1900, 2, 29, NY, ND, J) - CALL VIV ( NY, 1900, 'sla_CLYD', 'illegal day (Y)', STATUS ) - CALL VIV ( ND, 61, 'sla_CLYD', 'illegal day (D)', STATUS ) - CALL VIV ( J, 3, 'sla_CLYD', 'illegal day (J)', STATUS ) - CALL sla_CLYD ( 2000, 2, 29, NY, ND, J ) - CALL VIV ( NY, 2000, 'sla_CLYD', 'Y', STATUS ) - CALL VIV ( ND, 60, 'sla_CLYD', 'D', STATUS ) - CALL VIV ( J, 0, 'sla_CLYD', 'J', STATUS ) - - END - - SUBROUTINE T_CC2S ( STATUS ) -*+ -* - - - - - - - -* T _ C C 2 S -* - - - - - - - -* -* Test sla_CC2S, sla_DCC2S routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CC2S, VVD, sla_DCC2S. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL V(3), A, B - DOUBLE PRECISION DV(3), DA, DB - - DATA V/100.0, -50.0, 25.0/ - DATA DV/100D0, -50D0, 25D0/ - - CALL sla_CC2S ( V, A, B ) - CALL VVD ( DBLE( A), -0.4636476090008061D0, 1D-6, 'sla_CC2S', - : 'A', STATUS ) - CALL VVD ( DBLE( B ), 0.2199879773954594D0, 1D-6, 'sla_CC2S', - : 'B', STATUS ) - - CALL sla_DCC2S ( DV, DA, DB ) - CALL VVD ( DA, -0.4636476090008061D0, 1D-12, 'sla_DCC2S', - : 'A', STATUS ) - CALL VVD ( DB, 0.2199879773954594D0, 1D-12, 'sla_DCC2S', - : 'B', STATUS ) - - END - - SUBROUTINE T_CC62S ( STATUS ) -*+ -* - - - - - - - - -* T _ C C 6 2 S -* - - - - - - - - -* -* Test sla_CC62S, sla_DC62S routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CC62S, VVD, sla_DC62S. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL V(6), A, B, R, AD, BD, RD - DOUBLE PRECISION DV(6), DA, DB, DR, DAD, DBD, DRD - - DATA V/100.0, -50.0, 25.0, -0.1, 0.2, 0.7/ - DATA DV/100D0, -50D0, 25D0, -0.1D0, 0.2D0, 0.7D0/ - - CALL sla_CC62S ( V, A, B, R, AD, BD, RD ) - CALL VVD ( DBLE( A ), -0.4636476090008061D0, 1D-6, 'sla_CC62S', - : 'A', STATUS ) - CALL VVD ( DBLE( B ), 0.2199879773954594D0, 1D-6, 'sla_CC62S', - : 'B', STATUS ) - CALL VVD ( DBLE( R ), 114.564392373896D0, 1D-3, 'sla_CC62S', - : 'R', STATUS ) - CALL VVD ( DBLE( AD ), 0.001200000000000000D0, 1D-9, 'sla_CC62S', - : 'AD', STATUS ) - CALL VVD ( DBLE( BD ), 0.006303582107999407D0, 1D-8, 'sla_CC62S', - : 'BD', STATUS ) - CALL VVD ( DBLE( RD ), -0.02182178902359925D0, 1D-7, 'sla_CC62S', - : 'RD', STATUS ) - - CALL sla_DC62S ( DV, DA, DB, DR, DAD, DBD, DRD ) - CALL VVD ( DA, -0.4636476090008061D0, 1D-6, 'sla_DC62S', - : 'A', STATUS ) - CALL VVD ( DB, 0.2199879773954594D0, 1D-6, 'sla_DC62S', - : 'B', STATUS ) - CALL VVD ( DR, 114.564392373896D0, 1D-9, 'sla_DC62S', - : 'R', STATUS ) - CALL VVD ( DAD, 0.001200000000000000D0, 1D-15, 'sla_DC62S', - : 'AD', STATUS ) - CALL VVD ( DBD, 0.006303582107999407D0, 1D-14, 'sla_DC62S', - : 'BD', STATUS ) - CALL VVD ( DRD, -0.02182178902359925D0, 1D-13, 'sla_DC62S', - : 'RD', STATUS ) - - END - - SUBROUTINE T_CD2TF ( STATUS ) -*+ -* - - - - - - - - -* T _ C D 2 T F -* - - - - - - - - -* -* Test sla_CD2TF, sla_DD2TF routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CD2TF, VIV, VVD, sla_DD2TF. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER IHMSF(4) - CHARACTER S - - CALL sla_CD2TF ( 4, -0.987654321E0, S, IHMSF ) - CALL VIV ( ICHAR( S ), ICHAR( '-' ), 'sla_CD2TF', 'S', STATUS ) - CALL VIV ( IHMSF(1), 23, 'sla_CD2TF', '(1)', STATUS ) - CALL VIV ( IHMSF(2), 42, 'sla_CD2TF', '(2)', STATUS ) - CALL VIV ( IHMSF(3), 13, 'sla_CD2TF', '(3)', STATUS ) - CALL VVD ( DFLOAT( IHMSF(4) ), 3333D0, 1000D0, 'sla_CD2TF', - : '(4)', STATUS ) - - CALL sla_DD2TF ( 4, -0.987654321D0, S, IHMSF ) - CALL VIV ( ICHAR( S ), ICHAR( '-' ), 'sla_DD2TF', 'S', STATUS ) - CALL VIV ( IHMSF(1), 23, 'sla_DD2TF', '(1)', STATUS ) - CALL VIV ( IHMSF(2), 42, 'sla_DD2TF', '(2)', STATUS ) - CALL VIV ( IHMSF(3), 13, 'sla_DD2TF', '(3)', STATUS ) - CALL VIV ( IHMSF(4), 3333, 'sla_DD2TF', '(4)', STATUS ) - - END - - SUBROUTINE T_CLDJ ( STATUS ) -*+ -* - - - - - - - -* T _ C L D J -* - - - - - - - -* -* Test sla_CLDJ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CLDJ, VVD, VIV. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - DOUBLE PRECISION D - - CALL sla_CLDJ ( 1899, 12, 31, D, J ) - CALL VVD ( D, 15019D0, 0D0, 'sla_CLDJ', 'D', STATUS ) - CALL VIV ( J, 0, 'sla_CLDJ', 'J', STATUS ) - - END - - SUBROUTINE T_CR2AF ( STATUS ) -*+ -* - - - - - - - - -* T _ C R 2 A F -* - - - - - - - - -* -* Test sla_CR2AF, sla_DR2AF routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CR2AF, VIV, VVD, sla_DR2AF. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER IDMSF(4) - CHARACTER S - - CALL sla_CR2AF ( 4, 2.345E0, S, IDMSF ) - CALL VIV ( ICHAR( S ), ICHAR( '+' ), 'sla_CR2AF', 'S', STATUS ) - CALL VIV ( IDMSF(1), 134, 'sla_CR2AF', '(1)', STATUS ) - CALL VIV ( IDMSF(2), 21, 'sla_CR2AF', '(2)', STATUS ) - CALL VIV ( IDMSF(3), 30, 'sla_CR2AF', '(3)', STATUS ) - CALL VVD ( DBLE( IDMSF(4) ), 9706D0, 1000D0, 'sla_CR2AF', - : '(4)', STATUS ) - - CALL sla_DR2AF ( 4, 2.345D0, S, IDMSF ) - CALL VIV ( ICHAR( S ), ICHAR( '+' ), 'sla_DR2AF', 'S', STATUS ) - CALL VIV ( IDMSF(1), 134, 'sla_DR2AF', '(1)', STATUS ) - CALL VIV ( IDMSF(2), 21, 'sla_DR2AF', '(2)', STATUS ) - CALL VIV ( IDMSF(3), 30, 'sla_DR2AF', '(3)', STATUS ) - CALL VIV ( IDMSF(4), 9706, 'sla_DR2AF', '(4)', STATUS ) - - END - - SUBROUTINE T_CR2TF ( STATUS ) -*+ -* - - - - - - - - -* T _ C R 2 T F -* - - - - - - - - -* -* Test sla_CR2TF, sla_DR2TF routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CR2TF, VIV, VVD, sla_DR2TF. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER IHMSF(4) - CHARACTER S - - CALL sla_CR2TF ( 4, -3.01234E0, S, IHMSF ) - CALL VIV ( ICHAR( S ), ICHAR( '-' ), 'sla_CR2TF', 'S', STATUS ) - CALL VIV ( IHMSF(1), 11, 'sla_CR2TF', '(1)', STATUS ) - CALL VIV ( IHMSF(2), 30, 'sla_CR2TF', '(2)', STATUS ) - CALL VIV ( IHMSF(3), 22, 'sla_CR2TF', '(3)', STATUS ) - CALL VVD ( DBLE( IHMSF(4) ), 6484D0, 1000D0, 'sla_CR2TF', - : '(4)', STATUS ) - - CALL sla_DR2TF ( 4, -3.01234D0, S, IHMSF ) - CALL VIV ( ICHAR( S ), ICHAR( '-' ), 'sla_DR2TF', 'S', STATUS ) - CALL VIV ( IHMSF(1), 11, 'sla_DR2TF', '(1)', STATUS ) - CALL VIV ( IHMSF(2), 30, 'sla_DR2TF', '(2)', STATUS ) - CALL VIV ( IHMSF(3), 22, 'sla_DR2TF', '(3)', STATUS ) - CALL VIV ( IHMSF(4), 6484, 'sla_DR2TF', '(4)', STATUS ) - - END - - SUBROUTINE T_CS2C6 ( STATUS ) -*+ -* - - - - - - - - -* T _ C S 2 C 6 -* - - - - - - - - -* -* Test sla_CS2C6, sla_DS2C6 routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CS2C6, VVD, sla_DS2C6. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL V(6) - DOUBLE PRECISION DV(6) - - CALL sla_CS2C6( -3.21E0, 0.123E0, 0.456E0, -7.8E-6, 9.01E-6, - : -1.23E-5, V ) - CALL VVD ( DBLE( V(1) ), -0.4514964673880165D0, - : 1D-6, 'sla_CS2C6', 'X', STATUS ) - CALL VVD ( DBLE( V(2) ), 0.03093394277342585D0, - : 1D-6, 'sla_CS2C6', 'Y', STATUS ) - CALL VVD ( DBLE( V(3) ), 0.05594668105108779D0, - : 1D-6, 'sla_CS2C6', 'Z', STATUS ) - CALL VVD ( DBLE( V(4) ), 1.292270850663260D-5, - : 1D-6, 'sla_CS2C6', 'XD', STATUS ) - CALL VVD ( DBLE( V(5) ), 2.652814182060692D-6, - : 1D-6, 'sla_CS2C6', 'YD', STATUS ) - CALL VVD ( DBLE( V(6) ), 2.568431853930293D-6, - : 1D-6, 'sla_CS2C6', 'ZD', STATUS ) - - CALL sla_DS2C6( -3.21D0, 0.123D0, 0.456D0, -7.8D-6, 9.01D-6, - : -1.23D-5, DV ) - CALL VVD ( DV(1), -0.4514964673880165D0, 1D-12, 'sla_DS2C6', - : 'X', STATUS ) - CALL VVD ( DV(2), 0.03093394277342585D0, 1D-12, 'sla_DS2C6', - : 'Y', STATUS ) - CALL VVD ( DV(3), 0.05594668105108779D0, 1D-12, 'sla_DS2C6', - : 'Z', STATUS ) - CALL VVD ( DV(4), 1.292270850663260D-5, 1D-12, 'sla_DS2C6', - : 'XD', STATUS ) - CALL VVD ( DV(5), 2.652814182060692D-6, 1D-12, 'sla_DS2C6', - : 'YD', STATUS ) - CALL VVD ( DV(6), 2.568431853930293D-6, 1D-12, 'sla_DS2C6', - : 'ZD', STATUS ) - - END - - SUBROUTINE T_CTF2D ( STATUS ) -*+ -* - - - - - - - - -* T _ C T F 2 D -* - - - - - - - - -* -* Test sla_CTF2D, sla_DTF2D routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CTF2D, VVD, VIV, sla_DTF2D. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - REAL D - DOUBLE PRECISION DD - - CALL sla_CTF2D (23, 56, 59.1E0, D, J) - CALL VVD ( DBLE( D ), 0.99790625D0, 1D-6, 'sla_CTF2D', - : 'D', STATUS ) - CALL VIV ( J, 0, 'sla_CTF2D', 'J', STATUS ) - - CALL sla_DTF2D (23, 56, 59.1D0, DD, J) - CALL VVD ( DD, 0.99790625D0, 1D-12, 'sla_DTF2D', 'D', STATUS ) - CALL VIV ( J, 0, 'sla_DTF2D', 'J', STATUS ) - - END - - SUBROUTINE T_CTF2R ( STATUS ) -*+ -* - - - - - - - - -* T _ C T F 2 R -* - - - - - - - - -* -* Test sla_CTF2R, sla_DTF2R routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_CTF2R, VVD, VIV, sla_DTF2R. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - REAL R - DOUBLE PRECISION DR - - CALL sla_CTF2R (23, 56, 59.1E0, R, J) - CALL VVD ( DBLE( R ), 6.270029887942679D0, 1D-6, 'sla_CTF2R', - : 'R', STATUS ) - CALL VIV ( J, 0, 'sla_CTF2R', 'J', STATUS ) - - CALL sla_DTF2R (23, 56, 59.1D0, DR, J) - CALL VVD ( DR, 6.270029887942679D0, 1D-12, 'sla_DTF2R', - : 'R', STATUS ) - CALL VIV ( J, 0, 'sla_DTF2R', 'J', STATUS ) - - END - - SUBROUTINE T_DAT ( STATUS ) -*+ -* - - - - - - -* T _ D A T -* - - - - - - -* -* Test sla_DAT, sla_DTT, sla_DT routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_DAT, sla_DTT, sla_DT, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_DAT, sla_DTT, sla_DT - - - CALL VVD ( sla_DAT ( 43900D0 ), 18D0, 0D0, 'sla_DAT', - : ' ', STATUS ) - CALL VVD ( sla_DTT ( 40404D0 ), 39.709746D0, 1D-12, 'sla_DTT', - : ' ', STATUS ) - CALL VVD ( sla_DT ( 500D0 ), 4686.7D0, 1D-10, 'sla_DT', - : '500', STATUS ) - CALL VVD ( sla_DT ( 1400D0 ), 408D0, 1D-11, 'sla_DT', - : '1400', STATUS ) - CALL VVD ( sla_DT ( 1950D0 ), 27.99145626D0, 1D-12, 'sla_DT', - : '1950', STATUS ) - - END - - SUBROUTINE T_DBJIN ( STATUS ) -*+ -* - - - - - - - - -* T _ D B J I N -* - - - - - - - - -* -* Test sla_DBJIN routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_DBJIN, VVD, VIV. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I, JA, JB - DOUBLE PRECISION D - CHARACTER*32 S - DATA S /' B1950, , J 2000, B1975 JE '/ - - I = 1 - D = 0D0 - - CALL sla_DBJIN ( S, I, D, JA, JB ) - CALL VIV ( I, 9, 'sla_DBJIN', 'I1', STATUS ) - CALL VVD ( D, 1950D0, 0D0, 'sla_DBJIN', 'D1', STATUS ) - CALL VIV ( JA, 0, 'sla_DBJIN', 'JA1', STATUS ) - CALL VIV ( JB, 1, 'sla_DBJIN', 'JB1', STATUS ) - - CALL sla_DBJIN ( S, I, D, JA, JB ) - CALL VIV ( I, 11, 'sla_DBJIN', 'I2', STATUS ) - CALL VVD ( D, 1950D0, 0D0, 'sla_DBJIN', 'D2', STATUS ) - CALL VIV ( JA, 1, 'sla_DBJIN', 'JA2', STATUS ) - CALL VIV ( JB, 0, 'sla_DBJIN', 'JB2', STATUS ) - - CALL sla_DBJIN ( S, I, D, JA, JB ) - CALL VIV ( I, 19, 'sla_DBJIN', 'I3', STATUS ) - CALL VVD ( D, 2000D0, 0D0, 'sla_DBJIN', 'D3', STATUS ) - CALL VIV ( JA, 0, 'sla_DBJIN', 'JA3', STATUS ) - CALL VIV ( JB, 2, 'sla_DBJIN', 'JB3', STATUS ) - - CALL sla_DBJIN ( S, I, D, JA, JB ) - CALL VIV ( I, 26, 'sla_DBJIN', 'I4', STATUS ) - CALL VVD ( D, 1975D0, 0D0, 'sla_DBJIN', 'D4', STATUS ) - CALL VIV ( JA, 0, 'sla_DBJIN', 'JA4', STATUS ) - CALL VIV ( JB, 1, 'sla_DBJIN', 'JB4', STATUS ) - - CALL sla_DBJIN ( S, I, D, JA, JB ) - CALL VIV ( I, 26, 'sla_DBJIN', 'I5', STATUS ) - CALL VVD ( D, 1975D0, 0D0, 'sla_DBJIN', 'D5', STATUS ) - CALL VIV ( JA, 1, 'sla_DBJIN', 'JA5', STATUS ) - CALL VIV ( JB, 0, 'sla_DBJIN', 'JB5', STATUS ) - - END - - SUBROUTINE T_DJCAL ( STATUS ) -*+ -* - - - - - - - - -* T _ D J C A L -* - - - - - - - - -* -* Test sla_DJCAL, sla_DJCL routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_DJCAL, VIV. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER IYDMF(4), J, IY, IM, ID - DOUBLE PRECISION DJM - DOUBLE PRECISION F - - DJM = 50123.9999D0 - - CALL sla_DJCAL ( 4, DJM, IYDMF, J ) - CALL VIV ( IYDMF(1), 1996, 'sla_DJCAL', 'Y', STATUS ) - CALL VIV ( IYDMF(2), 2, 'sla_DJCAL', 'M', STATUS ) - CALL VIV ( IYDMF(3), 10, 'sla_DJCAL', 'D', STATUS ) - CALL VIV ( IYDMF(4), 9999, 'sla_DJCAL', 'F', STATUS ) - CALL VIV ( J, 0, 'sla_DJCAL', 'J', STATUS ) - - CALL sla_DJCL ( DJM, IY, IM, ID, F, J ) - CALL VIV ( IY, 1996, 'sla_DJCL', 'Y', STATUS ) - CALL VIV ( IM, 2, 'sla_DJCL', 'M', STATUS ) - CALL VIV ( ID, 10, 'sla_DJCL', 'D', STATUS ) - CALL VVD ( F, 0.9999D0, 1D-7, 'sla_DJCL', 'F', STATUS ) - CALL VIV ( J, 0, 'sla_DJCL', 'J', STATUS ) - - END - - SUBROUTINE T_DMAT ( STATUS ) -*+ -* - - - - - - - -* T _ D M A T -* - - - - - - - -* -* Test sla_DMAT routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_DMAT, VVD, VIV. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J, IW(3) - DOUBLE PRECISION DA(3,3) - DOUBLE PRECISION DV(3) - DOUBLE PRECISION DD - - DATA DA/2.22D0, 1.6578D0, 1.380522D0, - : 1.6578D0, 1.380522D0, 1.22548578D0, - : 1.380522D0, 1.22548578D0, 1.1356276122D0/ - DATA DV/2.28625D0, 1.7128825D0, 1.429432225D0/ - - CALL sla_DMAT ( 3, DA, DV, DD, J, IW ) - - CALL VVD ( DA(1,1), 18.02550629769198D0, - : 1D-10, 'sla_DMAT', 'A(1,1)', STATUS ) - CALL VVD ( DA(1,2), -52.16386644917280607D0, - : 1D-10, 'sla_DMAT', 'A(1,2)', STATUS ) - CALL VVD ( DA(1,3), 34.37875949717850495D0, - : 1D-10, 'sla_DMAT', 'A(1,3)', STATUS ) - CALL VVD ( DA(2,1), -52.16386644917280607D0, - : 1D-10, 'sla_DMAT', 'A(2,1)', STATUS ) - CALL VVD ( DA(2,2), 168.1778099099805627D0, - : 1D-10, 'sla_DMAT', 'A(2,2)', STATUS ) - CALL VVD ( DA(2,3), -118.0722869694232670D0, - : 1D-10, 'sla_DMAT', 'A(2,3)', STATUS ) - CALL VVD ( DA(3,1), 34.37875949717850495D0, - : 1D-10, 'sla_DMAT', 'A(3,1)', STATUS ) - CALL VVD ( DA(3,2), -118.0722869694232670D0, - : 1D-10, 'sla_DMAT', 'A(3,2)', STATUS ) - CALL VVD ( DA(3,3), 86.50307003740151262D0, - : 1D-10, 'sla_DMAT', 'A(3,3)', STATUS ) - CALL VVD ( DV(1), 1.002346480763383D0, - : 1D-12, 'sla_DMAT', 'V(1)', STATUS ) - CALL VVD ( DV(2), 0.03285594016974583489D0, - : 1D-12, 'sla_DMAT', 'V(2)', STATUS ) - CALL VVD ( DV(3), 0.004760688414885247309D0, - : 1D-12, 'sla_DMAT', 'V(3)', STATUS ) - CALL VVD ( DD, 0.003658344147359863D0, - : 1D-12, 'sla_DMAT', 'D', STATUS ) - CALL VIV ( J, 0, 'sla_DMAT', 'J', STATUS ) - - END - - SUBROUTINE T_E2H ( STATUS ) -*+ -* - - - - - - - -* T _ E 2 H -* - - - - - - - -* -* Test sla_E2H, sla_DE2H, sla_H2E, sla_DH2E routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: All the above plus VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL H, D, P, A, E - DOUBLE PRECISION DH, DD, DP, DA, DE - - DH = -0.3D0 - DD = -1.1D0 - DP = -0.7D0 - - H = SNGL( DH ) - D = SNGL( DD ) - P = SNGL( DP ) - - CALL sla_DE2H ( DH, DD, DP, DA, DE ) - CALL VVD ( DA, 2.820087515852369D0, 1D-12, 'sla_DE2H', - : 'AZ', STATUS ) - CALL VVD ( DE, 1.132711866443304D0, 1D-12, 'sla_DE2H', - : 'El', STATUS ) - - CALL sla_E2H ( H, D, P, A, E ) - CALL VVD ( DBLE( A ), 2.820087515852369D0, 1D-6, 'sla_E2H', - : 'AZ', STATUS ) - CALL VVD ( DBLE( E ), 1.132711866443304D0, 1D-6, 'sla_E2H', - : 'El', STATUS ) - - CALL sla_DH2E ( DA, DE, DP, DH, DD ) - CALL VVD ( DH, -0.3D0, 1D-12, 'sla_DH2E', 'HA', STATUS ) - CALL VVD ( DD, -1.1D0, 1D-12, 'sla_DH2E', 'DEC', STATUS ) - - CALL sla_H2E ( A, E, P, H, D ) - CALL VVD ( DBLE( H ), -0.3D0, 1D-6, 'sla_H2E', - : 'HA', STATUS ) - CALL VVD ( DBLE( D ), -1.1D0, 1D-6, 'sla_H2E', - : 'DEC', STATUS ) - - END - - SUBROUTINE T_EARTH ( STATUS ) -*+ -* - - - - - - - - -* T _ E A R T H -* - - - - - - - - -* -* Test sla_EARTH routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EARTH, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL PV(6) - - CALL sla_EARTH ( 1978, 174, 0.87E0, PV ) - - CALL VVD ( DBLE( PV(1) ), 3.590867086D-2, 1D-6, 'sla_EARTH', - : 'PV(1)', STATUS ) - CALL VVD ( DBLE( PV(2) ), -9.319285116D-1, 1D-6, 'sla_EARTH', - : 'PV(2)', STATUS ) - CALL VVD ( DBLE( PV(3) ), -4.041039435D-1, 1D-6, 'sla_EARTH', - : 'PV(3)', STATUS ) - CALL VVD ( DBLE( PV(4) ), 1.956930055D-7, 1D-13, 'sla_EARTH', - : 'PV(4)', STATUS ) - CALL VVD ( DBLE( PV(5) ), 5.743797400D-9, 1D-13, 'sla_EARTH', - : 'PV(5)', STATUS ) - CALL VVD ( DBLE( PV(6) ), 2.512001677D-9, 1D-13, 'sla_EARTH', - : 'PV(6)', STATUS ) - - END - - SUBROUTINE T_ECLEQ ( STATUS ) -*+ -* - - - - - - - - -* T _ E C L E Q -* - - - - - - - - -* -* Test sla_ECLEQ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_ECLEQ, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R, D - - CALL sla_ECLEQ ( 1.234D0, -0.123D0, 43210D0, R, D ) - - CALL VVD ( R, 1.229910118208851D0, 1D-12, 'sla_ECLEQ', - : 'RA', STATUS ) - CALL VVD ( D, 0.2638461400411088D0, 1D-12, 'sla_ECLEQ', - : 'DEC', STATUS ) - - END - - SUBROUTINE T_ECMAT ( STATUS ) -*+ -* - - - - - - - - -* T _ E C M A T -* - - - - - - - - -* -* Test sla_ECMAT routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_ECMAT, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RM(3,3) - - CALL sla_ECMAT ( 41234D0, RM ) - - CALL VVD ( RM(1,1), 1D0, 1D-12, 'sla_ECMAT', - : '(1,1)', STATUS ) - CALL VVD ( RM(1,2), 0D0, 1D-12, 'sla_ECMAT', - : '(1,2)', STATUS ) - CALL VVD ( RM(1,3), 0D0, 1D-12, 'sla_ECMAT', - : '(1,3)', STATUS ) - CALL VVD ( RM(2,1), 0D0, 1D-12, 'sla_ECMAT', - : '(2,1)', STATUS ) - CALL VVD ( RM(2,2), 0.917456575085716D0, 1D-12, 'sla_ECMAT', - : '(2,2)', STATUS ) - CALL VVD ( RM(2,3), 0.397835937079581D0, 1D-12, 'sla_ECMAT', - : '(2,3)', STATUS ) - CALL VVD ( RM(3,1), 0D0, 1D-12, 'sla_ECMAT', - : '(3,1)', STATUS ) - CALL VVD ( RM(3,2), -0.397835937079581D0, 1D-12, 'sla_ECMAT', - : '(3,2)', STATUS ) - CALL VVD ( RM(3,3), 0.917456575085716D0, 1D-12, 'sla_ECMAT', - : '(3,3)', STATUS ) - - END - - SUBROUTINE T_ECOR ( STATUS ) -*+ -* - - - - - - - -* T _ E C O R -* - - - - - - - -* -* Test sla_ECOR routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_ECOR, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL RV, Tl - - CALL sla_ECOR ( 2.345E0, -0.567E0, 1995, 306, 0.037E0, RV, Tl ) - - CALL VVD ( DBLE( RV ), -19.182460D0, 1D-3, 'sla_ECOR', - : 'RV', STATUS ) - CALL VVD ( DBLE( Tl ), -120.36632D0, 1D-2, 'sla_ECOR', - : 'Tl', STATUS ) - - END - - SUBROUTINE T_EG50 ( STATUS ) -*+ -* - - - - - - - -* T _ E G 5 0 -* - - - - - - - -* -* Test sla_EG50 routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EG50, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DL, DB - - CALL sla_EG50 ( 3.012D0, 1.234D0, DL, DB ) - - CALL VVD ( DL, 2.305557953813397D0, 1D-12, 'sla_EG50', - : 'L', STATUS ) - CALL VVD ( DB, 0.7903600886585871D0, 1D-12, 'sla_EG50', - : 'B', STATUS ) - - END - - SUBROUTINE T_EPB ( STATUS ) - -*+ -* - - - - - - -* T _ E P B -* - - - - - - -* -* Test sla_EPB routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EPB, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_EPB - - - CALL VVD ( sla_EPB ( 45123D0 ), 1982.419793168669D0, 1D-8, - : 'sla_EPB', ' ', STATUS ) - - END - - SUBROUTINE T_EPB2D ( STATUS ) -*+ -* - - - - - - - -* T _ E P B 2 D -* - - - - - - - -* -* Test sla_EPB2D routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EPB2D, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_EPB2D - - - CALL VVD ( sla_EPB2D ( 1975.5D0 ), 42595.5995279655D0, 1D-7, - : 'sla_EPB2D', ' ', STATUS ) - - END - - SUBROUTINE T_EPCO ( STATUS ) -*+ -* - - - - - - - -* T _ E P C O -* - - - - - - - -* -* Test sla_EPCO routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EPCO, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_EPCO - - - CALL VVD ( sla_EPCO ( 'B', 'J', 2000D0 ), 2000.001277513665D0, - : 1D-7, 'sla_EPCO', 'BJ', STATUS ) - CALL VVD ( sla_EPCO ( 'J', 'B', 1950D0 ), 1949.999790442300D0, - : 1D-7, 'sla_EPCO', 'JB', STATUS ) - CALL VVD ( sla_EPCO ( 'J', 'J', 2000D0 ), 2000D0, - : 1D-7, 'sla_EPCO', 'JJ', STATUS ) - - END - - SUBROUTINE T_EPJ ( STATUS ) -*+ -* - - - - - - -* T _ E P J -* - - - - - - -* -* Test sla_EPJ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EPJ, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_EPJ - - - CALL VVD ( sla_EPJ ( 42999D0 ), 1976.603696098563D0, - : 1D-7, 'sla_EPJ', ' ', STATUS ) - - END - - SUBROUTINE T_EPJ2D ( STATUS ) -*+ -* - - - - - - - - -* T _ E P J 2 D -* - - - - - - - - -* -* Test sla_EPJ2D routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EPJ2D, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_EPJ2D - - - CALL VVD ( sla_EPJ2D ( 2010.077D0 ), 55225.124250D0, - : 1D-6, 'sla_EPJ2D', ' ', STATUS ) - - END - - SUBROUTINE T_EQECL ( STATUS ) -*+ -* - - - - - - - - -* T _ E Q E C L -* - - - - - - - - -* -* Test sla_EQECL routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EQECL, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DL, DB - - CALL sla_EQECL ( 0.789D0, -0.123D0, 46555D0, DL, DB ) - - CALL VVD ( DL, 0.7036566430349022D0, 1D-12, 'sla_EQECL', - : 'L', STATUS ) - CALL VVD ( DB, -0.4036047164116848D0, 1D-12, 'sla_EQECL', - : 'B', STATUS ) - - END - - SUBROUTINE T_EQEQX ( STATUS ) -*+ -* - - - - - - - - -* T _ E Q E Q X -* - - - - - - - - -* -* Test sla_EQEQX routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EQEQX, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_EQEQX - - - CALL VVD ( sla_EQEQX ( 41234D0 ), 5.376047445838358596D-5, - : 1D-17, 'sla_EQEQX', ' ', STATUS ) - - END - - SUBROUTINE T_EQGAL ( STATUS ) -*+ -* - - - - - - - - -* T _ E Q G A L -* - - - - - - - - -* -* Test sla_EQGAL routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EQGAL, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DL, DB - - CALL sla_EQGAL ( 5.67D0, -1.23D0, DL, DB ) - - CALL VVD ( DL, 5.612270780904526D0, 1D-12, 'sla_EQGAL', - : 'DL', STATUS ) - CALL VVD ( DB, -0.6800521449061520D0, 1D-12, 'sla_EQGAL', - : 'DB', STATUS ) - - END - - SUBROUTINE T_ETRMS ( STATUS ) -*+ -* - - - - - - - - -* T _ E T R M S -* - - - - - - - - -* -* Test sla_ETRMS routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_ETRMS, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION EV(3) - - CALL sla_ETRMS ( 1976.9D0, EV ) - - CALL VVD ( EV(1), -1.621617102537041D-6, 1D-18, 'sla_ETRMS', - : 'X', STATUS ) - CALL VVD ( EV(2), -3.310070088507914D-7, 1D-18, 'sla_ETRMS', - : 'Y', STATUS ) - CALL VVD ( EV(3), -1.435296627515719D-7, 1D-18, 'sla_ETRMS', - : 'Z', STATUS ) - - END - - SUBROUTINE T_EVP ( STATUS ) -*+ -* - - - - - - -* T _ E V P -* - - - - - - -* -* Test sla_EVP and sla_EPV routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EVP, sla_EPV, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DVB(3), DPB(3), DVH(3), DPH(3) - - CALL sla_EVP ( 50100D0, 1990D0, DVB, DPB, DVH, DPH ) - - CALL VVD ( DVB(1), -1.807210068604058436D-7, 1D-14, 'sla_EVP', - : 'DVB(X)', STATUS ) - CALL VVD ( DVB(2), -8.385891022440320D-8, 1D-14, 'sla_EVP', - : 'DVB(Y)', STATUS ) - CALL VVD ( DVB(3), -3.635846882638055D-8, 1D-14, 'sla_EVP', - : 'DVB(Z)', STATUS ) - CALL VVD ( DPB(1), -0.4515615297360333D0, 1D-7, 'sla_EVP', - : 'DPB(X)', STATUS ) - CALL VVD ( DPB(2), 0.8103788166239596D0, 1D-7, 'sla_EVP', - : 'DPB(Y)', STATUS ) - CALL VVD ( DPB(3), 0.3514505204144827D0, 1D-7, 'sla_EVP', - : 'DPB(Z)', STATUS ) - CALL VVD ( DVH(1), -1.806354061156890855D-7, 1D-14, 'sla_EVP', - : 'DVH(X)', STATUS ) - CALL VVD ( DVH(2), -8.383798678086174D-8, 1D-14, 'sla_EVP', - : 'DVH(Y)', STATUS ) - CALL VVD ( DVH(3), -3.635185843644782D-8, 1D-14, 'sla_EVP', - : 'DVH(Z)', STATUS ) - CALL VVD ( DPH(1), -0.4478571659918565D0, 1D-7, 'sla_EVP', - : 'DPH(X)', STATUS ) - CALL VVD ( DPH(2), 0.8036439916076232D0, 1D-7, 'sla_EVP', - : 'DPH(Y)', STATUS ) - CALL VVD ( DPH(3), 0.3484298459102053D0, 1D-7, 'sla_EVP', - : 'DPH(Z)', STATUS ) - - CALL sla_EPV ( 53411.52501161D0, DPH, DVH, DPB, DVB ) - - CALL VVD ( DPH(1), -0.7757238809297653D0, 1D-12, 'sla_EPV', - : 'DPH(X)', STATUS ) - CALL VVD ( DPH(2), +0.5598052241363390D0, 1D-12, 'sla_EPV', - : 'DPH(Y)', STATUS ) - CALL VVD ( DPH(3), +0.2426998466481708D0, 1D-12, 'sla_EPV', - : 'DPH(Z)', STATUS ) - CALL VVD ( DVH(1), -0.0109189182414732D0, 1D-12, 'sla_EPV', - : 'DVH(X)', STATUS ) - CALL VVD ( DVH(2), -0.0124718726844084D0, 1D-12, 'sla_EPV', - : 'DVH(Y)', STATUS ) - CALL VVD ( DVH(3), -0.0054075694180650D0, 1D-12, 'sla_EPV', - : 'DVH(Z)', STATUS ) - CALL VVD ( DPB(1), -0.7714104440491060D0, 1D-12, 'sla_EPV', - : 'DPB(X)', STATUS ) - CALL VVD ( DPB(2), +0.5598412061824225D0, 1D-12, 'sla_EPV', - : 'DPB(Y)', STATUS ) - CALL VVD ( DPB(3), +0.2425996277722475D0, 1D-12, 'sla_EPV', - : 'DPB(Z)', STATUS ) - CALL VVD ( DVB(1), -0.0109187426811683D0, 1D-12, 'sla_EPV', - : 'DVB(X)', STATUS ) - CALL VVD ( DVB(2), -0.0124652546173285D0, 1D-12, 'sla_EPV', - : 'DVB(Y)', STATUS ) - CALL VVD ( DVB(3), -0.0054047731809662D0, 1D-12, 'sla_EPV', - : 'DVB(Z)', STATUS ) - - END - - SUBROUTINE T_FITXY ( STATUS ) -*+ -* - - - - - - - - -* T _ F I T X Y -* - - - - - - - - -* -* Test sla_FITXY, sla_PXY, sla_INVF, sla_XY2XY, sla_DCMPF routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FITXY, VVD, VIV, sla_PXY, sla_INVF, sla_XY2XY, sla_DCMPF. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J, NPTS - - PARAMETER (NPTS = 8) - - DOUBLE PRECISION XYE(2,NPTS) - DOUBLE PRECISION XYM(2,NPTS) - DOUBLE PRECISION COEFFS(6), XYP(2,NPTS), XRMS, YRMS, RRMS, - : BKWDS(6), X2, Y2, XZ, YZ, XS, YS, PERP, ORIENT - - DATA XYE/-23.4D0, -12.1D0, 32D0, -15.3D0, - : 10.9D0, 23.7D0, -3D0, 16.1D0, - : 45D0, 32.5D0, 8.6D0, -17D0, - : 15.3D0, 10D0, 121.7D0, -3.8D0/ - DATA XYM/-23.41D0, 12.12D0, 32.03D0, 15.34D0, - : 10.93D0,-23.72D0, -3.01D0, -16.10D0, - : 44.90D0,-32.46D0, 8.55D0, 17.02D0, - : 15.31D0,-10.07D0, 120.92D0, 3.81D0/ - -* Fit a 4-coeff linear model to relate two sets of (x,y) coordinates. - - CALL sla_FITXY ( 4, NPTS, XYE, XYM, COEFFS, J ) - CALL VVD ( COEFFS(1), -7.938263381515947D-3, - : 1D-12, 'sla_FITXY', '4/1', STATUS ) - CALL VVD ( COEFFS(2), 1.004640925187200D0, - : 1D-12, 'sla_FITXY', '4/2', STATUS ) - CALL VVD ( COEFFS(3), 3.976948048238268D-4, - : 1D-12, 'sla_FITXY', '4/3', STATUS ) - CALL VVD ( COEFFS(4), -2.501031681585021D-2, - : 1D-12, 'sla_FITXY', '4/4', STATUS ) - CALL VVD ( COEFFS(5), 3.976948048238268D-4, - : 1D-12, 'sla_FITXY', '4/5', STATUS ) - CALL VVD ( COEFFS(6), -1.004640925187200D0, - : 1D-12, 'sla_FITXY', '4/6', STATUS ) - CALL VIV ( J, 0, 'sla_FITXY', '4/J', STATUS ) - -* Same but 6-coeff. - - CALL sla_FITXY ( 6, NPTS, XYE, XYM, COEFFS, J ) - CALL VVD ( COEFFS(1), -2.617232551841476D-2, - : 1D-12, 'sla_FITXY', '6/1', STATUS ) - CALL VVD ( COEFFS(2), 1.005634905041421D0, - : 1D-12, 'sla_FITXY', '6/2', STATUS ) - CALL VVD ( COEFFS(3), 2.133045023329208D-3, - : 1D-12, 'sla_FITXY', '6/3', STATUS ) - CALL VVD ( COEFFS(4), 3.846993364417779909D-3, - : 1D-12, 'sla_FITXY', '6/4', STATUS ) - CALL VVD ( COEFFS(5), 1.301671386431460D-4, - : 1D-12, 'sla_FITXY', '6/5', STATUS ) - CALL VVD ( COEFFS(6), -0.9994827065693964D0, - : 1D-12, 'sla_FITXY', '6/6', STATUS ) - CALL VIV ( J, 0, 'sla_FITXY', '6/J', STATUS ) - -* Compute predicted coordinates and residuals. - - CALL sla_PXY ( NPTS, XYE, XYM, COEFFS, XYP, XRMS, YRMS, RRMS ) - CALL VVD ( XYP(1,1), -23.542232946855340D0, - : 1D-12, 'sla_PXY', 'X1', STATUS ) - CALL VVD ( XYP(2,1), -12.11293062297230597D0, - : 1D-12, 'sla_PXY', 'Y1', STATUS ) - CALL VVD ( XYP(1,2), 32.217034593616180D0, - : 1D-12, 'sla_PXY', 'X2', STATUS ) - CALL VVD ( XYP(2,2), -15.324048471959370D0, - : 1D-12, 'sla_PXY', 'Y2', STATUS ) - CALL VVD ( XYP(1,3), 10.914821358630950D0, - : 1D-12, 'sla_PXY', 'X3', STATUS ) - CALL VVD ( XYP(2,3), 23.712999520015880D0, - : 1D-12, 'sla_PXY', 'Y3', STATUS ) - CALL VVD ( XYP(1,4), -3.087475414568693D0, - : 1D-12, 'sla_PXY', 'X4', STATUS ) - CALL VVD ( XYP(2,4), 16.09512676604438414D0, - : 1D-12, 'sla_PXY', 'Y4', STATUS ) - CALL VVD ( XYP(1,5), 45.05759626938414666D0, - : 1D-12, 'sla_PXY', 'X5', STATUS ) - CALL VVD ( XYP(2,5), 32.45290015313210889D0, - : 1D-12, 'sla_PXY', 'Y5', STATUS ) - CALL VVD ( XYP(1,6), 8.608310538882801D0, - : 1D-12, 'sla_PXY', 'X6', STATUS ) - CALL VVD ( XYP(2,6), -17.006235743411300D0, - : 1D-12, 'sla_PXY', 'Y6', STATUS ) - CALL VVD ( XYP(1,7), 15.348618307280820D0, - : 1D-12, 'sla_PXY', 'X7', STATUS ) - CALL VVD ( XYP(2,7), 10.07063070741086835D0, - : 1D-12, 'sla_PXY', 'Y7', STATUS ) - CALL VVD ( XYP(1,8), 121.5833272936291482D0, - : 1D-12, 'sla_PXY', 'X8', STATUS ) - CALL VVD ( XYP(2,8), -3.788442308260240D0, - : 1D-12, 'sla_PXY', 'Y8', STATUS ) - CALL VVD ( XRMS ,0.1087247110488075D0, - : 1D-13, 'sla_PXY', 'XRMS', STATUS ) - CALL VVD ( YRMS, 0.03224481175794666D0, - : 1D-13, 'sla_PXY', 'YRMS', STATUS ) - CALL VVD ( RRMS, 0.1134054261398109D0, - : 1D-13, 'sla_PXY', 'RRMS', STATUS ) - -* Invert the model. - - CALL sla_INVF ( COEFFS, BKWDS, J ) - CALL VVD ( BKWDS(1), 0.02601750208015891D0, - : 1D-12, 'sla_INVF', '1', status) - CALL VVD ( BKWDS(2), 0.9943963945040283D0, - : 1D-12, 'sla_INVF', '2', status) - CALL VVD ( BKWDS(3), 0.002122190075497872D0, - : 1D-12, 'sla_INVF', '3', status) - CALL VVD ( BKWDS(4), 0.003852372795357474353D0, - : 1D-12, 'sla_INVF', '4', status) - CALL VVD ( BKWDS(5), 0.0001295047252932767D0, - : 1D-12, 'sla_INVF', '5', status) - CALL VVD ( BKWDS(6), -1.000517284779212D0, - : 1D-12, 'sla_INVF', '6', status) - CALL VIV ( J, 0, 'sla_INVF', 'J', STATUS ) - -* Transform one x,y. - - CALL sla_XY2XY ( 44.5D0, 32.5D0, COEFFS, X2, Y2 ) - CALL VVD ( X2, 44.793904912083030D0, - : 1D-11, 'sla_XY2XY', 'X', status) - CALL VVD ( Y2, -32.473548532471330D0, - : 1D-11, 'sla_XY2XY', 'Y', status) - -* Decompose the fit into scales etc. - - CALL sla_DCMPF ( COEFFS, XZ, YZ, XS, YS, PERP, ORIENT ) - CALL VVD ( XZ, -0.0260175020801628646D0, - : 1D-12, 'sla_DCMPF', 'XZ', status) - CALL VVD ( YZ, -0.003852372795357474353D0, - : 1D-12, 'sla_DCMPF', 'YZ', status) - CALL VVD ( XS, -1.00563491346569D0, - : 1D-12, 'sla_DCMPF', 'XS', status) - CALL VVD ( YS, 0.999484982684761D0, - : 1D-12, 'sla_DCMPF', 'YS', status) - CALL VVD ( PERP,-0.002004707996156263D0, - : 1D-12, 'sla_DCMPF', 'P', status) - CALL VVD ( ORIENT, 3.14046086182333D0, - : 1D-12, 'sla_DCMPF', 'O', status) - - END - - SUBROUTINE T_FK425 ( STATUS ) -*+ -* - - - - - - - - -* T _ F K 4 2 5 -* - - - - - - - - -* -* Test sla_FK425 routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FK425. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R2000, D2000, DR2000, DD2000, P2000, V2000 - - CALL sla_FK425 ( 1.234D0, -0.123D0, -1D-5, 2D-6, 0.5D0, - : 20D0, R2000, D2000, DR2000, DD2000, P2000, - : V2000 ) - - CALL VVD ( R2000, 1.244117554618727D0, 1D-12, 'sla_FK425', - : 'R', STATUS ) - CALL VVD ( D2000, -0.1213164254458709D0, 1D-12, 'sla_FK425', - : 'D', STATUS ) - CALL VVD ( DR2000, -9.964265838268711D-6, 1D-17, 'sla_FK425', - : 'DR', STATUS ) - CALL VVD ( DD2000, 2.038065265773541D-6, 1D-17, 'sla_FK425', - : 'DD', STATUS ) - CALL VVD ( P2000, 0.4997443812415410D0, 1D-12, 'sla_FK425', - : 'P', STATUS ) - CALL VVD ( V2000, 20.010460915421010D0, 1D-11, 'sla_FK425', - : 'V', STATUS ) - - END - - SUBROUTINE T_FK45Z ( STATUS ) -*+ -* - - - - - - - - -* T _ F K 4 5 Z -* - - - - - - - - -* -* Test sla_FK45Z routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FK45Z. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R2000, D2000 - - CALL sla_FK45Z ( 1.234D0, -0.123D0, 1984D0, R2000, D2000 ) - - CALL VVD ( R2000, 1.244616510731691D0, 1D-12, 'sla_FK45Z', - : 'R', STATUS ) - CALL VVD ( D2000, -0.1214185839586555D0, 1D-12, 'sla_FK45Z', - : 'D', STATUS ) - - END - - SUBROUTINE T_FK524 ( STATUS ) -*+ -* - - - - - - - - -* T _ F K 5 2 4 -* - - - - - - - - -* -* Test sla_FK524 routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FK524. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R1950, D1950, DR1950, DD1950, P1950, V1950 - - CALL sla_FK524 ( 4.567D0, -1.23D0, -3D-5, 8D-6, 0.29D0, - : -35D0, R1950, D1950, DR1950, DD1950, P1950, - : V1950 ) - - CALL VVD ( R1950, 4.543778603272084D0, 1D-12, 'sla_FK524', - : 'R', STATUS ) - CALL VVD ( D1950, -1.229642790187574D0, 1D-12, 'sla_FK524', - : 'D', STATUS ) - CALL VVD ( DR1950, -2.957873121769244D-5, 1D-17, 'sla_FK524', - : 'DR', STATUS ) - CALL VVD ( DD1950, 8.117725309659079D-6, 1D-17, 'sla_FK524', - : 'DD', STATUS ) - CALL VVD ( P1950, 0.2898494999992917D0, 1D-12, 'sla_FK524', - : 'P', STATUS ) - CALL VVD ( V1950, -35.026862824252680D0, 1D-11, 'sla_FK524', - : 'V', STATUS ) - - END - - SUBROUTINE T_FK52H ( STATUS ) -*+ -* - - - - - - - - -* T _ F K 5 2 H -* - - - - - - - - -* -* Test sla_FK52H, sla_H2FK5, sla_FK5HZ, sla_HFK5Z routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FK524, sla_H2FK5. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R5, D5, DR5, DD5, RH, DH, DRH, DDH - - CALL sla_FK52H ( 1.234D0, -0.987D0, 1D-6, -2D-6, RH, DH, DRH, - : DDH ) - CALL VVD ( RH, 1.234000000272122558D0, 1D-13, 'sla_FK52H', - : 'R', STATUS ) - CALL VVD ( DH, -0.9869999235218543959D0, 1D-13, 'sla_FK52H', - : 'D', STATUS ) - CALL VVD ( DRH, 0.000000993178295D0, 1D-13, 'sla_FK52H', - : 'DR', STATUS ) - CALL VVD ( DDH, -0.000001997665915D0, 1D-13, 'sla_FK52H', - : 'DD', STATUS ) - CALL sla_H2FK5 ( RH, DH, DRH, DDH, r5, D5, DR5, DD5 ) - CALL VVD ( R5, 1.234D0, 1D-13, 'sla_H2FK5', 'R', STATUS ) - CALL VVD ( D5, -0.987D0, 1D-13, 'sla_H2FK5', 'D', STATUS ) - CALL VVD ( DR5, 1D-6, 1D-13, 'sla_H2FK5', 'DR', STATUS ) - CALL VVD ( DD5, -2D-6, 1D-13, 'sla_H2FK5', 'DD', STATUS ) - CALL sla_FK5HZ ( 1.234D0, -0.987D0, 1980D0, RH, DH ) - CALL VVD ( RH, 1.234000136713611301D0, 1D-13, 'sla_FK5HZ', - : 'R', STATUS ) - CALL VVD ( DH, -0.9869999702020807601D0, 1D-13, 'sla_FK5HZ', - : 'D', STATUS ) - CALL sla_HFK5Z ( RH, DH, 1980D0, R5, D5, DR5, DD5 ) - CALL VVD ( R5, 1.234D0, 1D-13, 'sla_HFK5Z', 'R', STATUS ) - CALL VVD ( D5, -0.987D0, 1D-13, 'sla_HFK5Z', 'D', STATUS ) - CALL VVD ( DR5, 0.000000006822074D0, 1D-13, 'sla_HFK5Z', - : 'DR', STATUS ) - CALL VVD ( DD5, -0.000000002334012D0, 1D-13, 'sla_HFK5Z', - : 'DD', STATUS ) - - END - - SUBROUTINE T_FK54Z ( STATUS ) -*+ -* - - - - - - - - -* T _ F K 5 4 Z -* - - - - - - - - -* -* Test sla_FK54Z routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FK54Z. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R1950, D1950, DR1950, DD1950 - - CALL sla_FK54Z ( 0.001D0, -1.55D0, 1900D0, R1950, D1950, - : DR1950, DD1950 ) - - CALL VVD ( R1950, 6.271585543439484D0, 1D-12, 'sla_FK54Z', - : 'R', STATUS ) - CALL VVD ( D1950, -1.554861715330319D0, 1D-12, 'sla_FK54Z', - : 'D', STATUS ) - CALL VVD ( DR1950, -4.175410876044916011D-8, 1D-20, 'sla_FK54Z', - : 'DR', STATUS ) - CALL VVD ( DD1950, 2.118595098308522D-8, 1D-20, 'sla_FK54Z', - : 'DD', STATUS ) - - END - - SUBROUTINE T_FLOTIN ( STATUS ) -*+ -* - - - - - - - - - -* T _ F L O T I N -* - - - - - - - - - -* -* Test sla_FLOTIN, sla_DFLTIN routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_FLOTIN, VVD, VIV, sla_DFLTIN. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I, J - REAL FV - DOUBLE PRECISION DV - CHARACTER*33 S - DATA S /' 12.345, , -0 1E3-4 2000 E '/ - - I = 1 - FV = 0.0 - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 10, 'sla_FLOTIN', 'V5', STATUS ) - CALL VVD ( DBLE( FV ), 12.345D0, 1D-5, 'sla_FLOTIN', - : 'V1', STATUS ) - CALL VIV ( J, 0, 'sla_FLOTIN', 'J1', STATUS ) - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 12, 'sla_FLOTIN', 'I2', STATUS ) - CALL VVD ( DBLE( FV ), 12.345D0, 1D-5, 'sla_FLOTIN', - : 'V2', STATUS ) - CALL VIV ( J, 1, 'sla_FLOTIN', 'J2', STATUS ) - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 16, 'sla_FLOTIN', 'I3', STATUS ) - CALL VVD ( DBLE( FV ), 0D0, 0D0, 'sla_FLOTIN', 'V3', STATUS ) - CALL VIV ( J, -1, 'sla_FLOTIN', 'J3', STATUS ) - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 19, 'sla_FLOTIN', 'I4', STATUS ) - CALL VVD ( DBLE( FV), 1000D0, 0D0, 'sla_FLOTIN', 'V4', STATUS ) - CALL VIV ( J, 0, 'sla_FLOTIN', 'J4', STATUS ) - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 22, 'sla_FLOTIN', 'I5', STATUS ) - CALL VVD ( DBLE( FV ), -4D0, 0D0, 'sla_FLOTIN', 'V5', STATUS ) - CALL VIV ( J, -1, 'sla_FLOTIN', 'J5', STATUS ) - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 28, 'sla_FLOTIN', 'I6', STATUS ) - CALL VVD ( DBLE( FV ), 2000D0, 0D0, 'sla_FLOTIN', - : 'V6', STATUS ) - CALL VIV ( J, 0, 'sla_FLOTIN', 'J6', STATUS ) - - CALL sla_FLOTIN ( S, I, FV, J ) - CALL VIV ( I, 34, 'sla_FLOTIN', 'I7', STATUS ) - CALL VVD ( DBLE( FV ), 2000D0, 0D0, 'sla_FLOTIN', - : 'V7', STATUS ) - CALL VIV ( J, 2, 'sla_FLOTIN', 'J7', STATUS ) - - I = 1 - DV = 0D0 - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 10, 'sla_DFLTIN', 'I1', STATUS ) - CALL VVD ( DV, 12.345D0, 1D-12, 'sla_DFLTIN', 'V1', STATUS ) - CALL VIV ( J, 0, 'sla_DFLTIN', 'J1', STATUS ) - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 12, 'sla_DFLTIN', 'I2', STATUS ) - CALL VVD ( DV, 12.345D0, 1D-12, 'sla_DFLTIN', 'V2', STATUS ) - CALL VIV ( J, 1, 'sla_DFLTIN', 'J2', STATUS ) - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 16, 'sla_DFLTIN', 'I3', STATUS ) - CALL VVD ( DV, 0D0, 0D0, 'sla_DFLTIN', 'V3', STATUS ) - CALL VIV ( J, -1, 'sla_DFLTIN', 'J3', STATUS ) - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 19, 'sla_DFLTIN', 'I4', STATUS ) - CALL VVD ( DV, 1000D0, 0D0, 'sla_DFLTIN', 'V4', STATUS ) - CALL VIV ( J, 0, 'sla_DFLTIN', 'J4', STATUS ) - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 22, 'sla_DFLTIN', 'I5', STATUS ) - CALL VVD ( DV, -4D0, 0D0, 'sla_DFLTIN', 'V5', STATUS ) - CALL VIV ( J, -1, 'sla_DFLTIN', 'J5', STATUS ) - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 28, 'sla_DFLTIN', 'I6', STATUS ) - CALL VVD ( DV, 2000D0, 0D0, 'sla_DFLTIN', 'V6', STATUS ) - CALL VIV ( J, 0, 'sla_DFLTIN', 'J6', STATUS ) - - CALL sla_DFLTIN ( S, I, DV, J ) - CALL VIV ( I, 34, 'sla_DFLTIN', 'I7', STATUS ) - CALL VVD ( DV, 2000D0, 0D0, 'sla_DFLTIN', 'V7', STATUS ) - CALL VIV ( J, 2, 'sla_DFLTIN', 'J7', STATUS ) - - END - - SUBROUTINE T_GALEQ ( STATUS ) -*+ -* - - - - - - - - -* T _ G A L E Q -* - - - - - - - - -* -* Test sla_GALEQ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_GALEQ, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DR, DD - - CALL sla_GALEQ ( 5.67D0, -1.23D0, DR, DD ) - - CALL VVD ( DR, 0.04729270418071426D0, 1D-12, 'sla_GALEQ', - : 'DR', STATUS ) - CALL VVD ( DD, -0.7834003666745548D0, 1D-12, 'sla_GALEQ', - : 'DD', STATUS ) - - END - - SUBROUTINE T_GALSUP ( STATUS ) -*+ -* - - - - - - - - - -* T _ G A L S U P -* - - - - - - - - - -* -* Test sla_GALSUP routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_GALSUP, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DSL, DSB - - CALL sla_GALSUP ( 6.1D0, -1.4D0, DSL, DSB ) - - CALL VVD ( DSL, 4.567933268859171D0, 1D-12, 'sla_GALSUP', - : 'DSL', STATUS ) - CALL VVD ( DSB, -0.01862369899731829D0, 1D-12, 'sla_GALSUP', - : 'DSB', STATUS ) - - END - - SUBROUTINE T_GE50 ( STATUS ) -*+ -* - - - - - - - -* T _ G E 5 0 -* - - - - - - - -* -* Test sla_GE50 routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_GE50, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DR, DD - - CALL sla_GE50 ( 6.1D0, -1.55D0, DR, DD ) - - CALL VVD ( DR, 0.1966825219934508D0, 1D-12, 'sla_GE50', - : 'DR', STATUS ) - CALL VVD ( DD, -0.4924752701678960D0, 1D-12, 'sla_GE50', - : 'DD', STATUS ) - - END - - SUBROUTINE T_GMST ( STATUS ) -*+ -* - - - - - - - -* T _ G M S T -* - - - - - - - -* -* Test sla_GMST and sla_GMSTA routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_GMST, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_GMST, sla_GMSTA - - - CALL VVD ( sla_GMST ( 43999.999D0 ), 3.9074971356487318D0, - : 1D-9, 'sla_GMST', ' ', STATUS ) - CALL VVD ( sla_GMSTA ( 43999D0, 0.999D0 ), - : 3.9074971356487318D0, 1D-12, 'sla_GMSTA', ' ', STATUS ) - - END - - SUBROUTINE T_INTIN ( STATUS ) -*+ -* - - - - - - - - -* T _ I N T I N -* - - - - - - - - -* -* Test sla_INTIN routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_INTIN, VIV. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER*4 N - INTEGER I, J - CHARACTER*28 S - DATA S /' -12345, , -0 2000 + '/ - - I = 1 - N = 0 - - CALL sla_INTIN ( S, I, N, J ) - CALL VIV ( I, 10, 'sla_INTIN', 'I1', STATUS ) - CALL VLV ( N, -12345, 'sla_INTIN', 'V1', STATUS ) - CALL VIV ( J, -1, 'sla_INTIN', 'J1', STATUS ) - - CALL sla_INTIN ( S, I, N, J ) - CALL VIV ( I, 12, 'sla_INTIN', 'I2', STATUS ) - CALL VLV ( N, -12345, 'sla_INTIN', 'V2', STATUS ) - CALL VIV ( J, 1, 'sla_INTIN', 'J2', STATUS ) - - CALL sla_INTIN ( S, I, N, J ) - CALL VIV ( I, 17, 'sla_INTIN', 'I3', STATUS ) - CALL VLV ( N, 0, 'sla_INTIN', 'V3', STATUS ) - CALL VIV ( J, -1, 'sla_INTIN', 'J3', STATUS ) - - CALL sla_INTIN ( S, I, N, J ) - CALL VIV ( I, 23, 'sla_INTIN', 'I4', STATUS ) - CALL VLV ( N, 2000, 'sla_INTIN', 'V4', STATUS ) - CALL VIV ( J, 0, 'sla_INTIN', 'J4', STATUS ) - - CALL sla_INTIN ( S, I, N, J ) - CALL VIV ( I, 29, 'sla_INTIN', 'I5', STATUS ) - CALL VLV ( N, 2000, 'sla_INTIN', 'V5', STATUS ) - CALL VIV ( J, 2, 'sla_INTIN', 'J5', STATUS ) - - END - - SUBROUTINE T_KBJ ( STATUS ) -*+ -* - - - - - - -* T _ K B J -* - - - - - - -* -* Test sla_KBJ routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_KBJ, VCS, VIV. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - DOUBLE PRECISION E - CHARACTER K - DATA K /'?'/ - - E = 1950D0 - CALL sla_KBJ ( -1, E, K, J ) - CALL VCS ( K, ' ', 'sla_KBJ', 'JB1', STATUS ) - CALL VIV ( J, 1, 'sla_KBJ', 'J1', STATUS ) - CALL sla_KBJ ( 0, E, K, J ) - CALL VCS ( K, 'B', 'sla_KBJ', 'JB2', STATUS ) - CALL VIV ( J, 0, 'sla_KBJ', 'J2', STATUS ) - CALL sla_KBJ ( 1, E, K, J ) - CALL VCS ( K, 'B', 'sla_KBJ', 'JB3', STATUS ) - CALL VIV ( J, 0, 'sla_KBJ', 'J3', STATUS ) - CALL sla_KBJ ( 2, E, K, J ) - CALL VCS ( K, 'J', 'sla_KBJ', 'JB4', STATUS ) - CALL VIV ( J, 0, 'sla_KBJ', 'J4', STATUS ) - CALL sla_KBJ ( 3, E, K, J ) - CALL VCS ( K, ' ', 'sla_KBJ', 'JB5', STATUS ) - CALL VIV ( J, 1, 'sla_KBJ', 'J5', STATUS ) - - E = 2000D0 - CALL sla_KBJ ( 0, E, K, J ) - CALL VCS ( K, 'J', 'sla_KBJ', 'JB6', STATUS ) - CALL VIV ( J, 0, 'sla_KBJ', 'J6', STATUS ) - CALL sla_KBJ ( 1, E, K, J ) - CALL VCS ( K, 'B', 'sla_KBJ', 'jB7', STATUS ) - CALL VIV ( J, 0, 'sla_KBJ', 'J7', STATUS ) - CALL sla_KBJ ( 2, E, K, J ) - CALL VCS ( K, 'J', 'sla_KBJ', 'JB8', STATUS ) - CALL VIV ( J, 0, 'sla_KBJ', 'J8', STATUS ) - - END - - SUBROUTINE T_MAP ( STATUS ) -*+ -* - - - - - - -* T _ M A P -* - - - - - - -* -* Test sla_MAP, sla_MAPPA, sla_MAPQK, sla_MAPQKZ routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_MAP, sla_MAPPA, sla_MAPQK, sla_MAPQKZ, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RA, DA, AMPRMS(21) - - CALL sla_MAP ( 6.123D0, -0.999D0, 1.23D-5, -0.987D-5, - : 0.123D0, 32.1D0, 1999D0, 43210.9D0, RA, DA ) - - CALL VVD ( RA, 6.117130429775647D0, 1D-12, 'sla_MAP', - : 'RA', STATUS ) - CALL VVD ( DA, -1.000880769038632D0, 1D-12, 'sla_MAP', - : 'DA', STATUS ) - - CALL sla_MAPPA ( 2020D0, 45012.3D0, AMPRMS ) - - CALL VVD ( AMPRMS(1), -37.884188911704310D0, - : 1D-11, 'sla_MAPPA', 'AMPRMS(1)', STATUS ) - CALL VVD ( AMPRMS(2), -0.7888341859486424D0, - : 1D-7, 'sla_MAPPA', 'AMPRMS(2)', STATUS ) - CALL VVD ( AMPRMS(3), 0.5405321789059870D0, - : 1D-7, 'sla_MAPPA', 'AMPRMS(3)', STATUS ) - CALL VVD ( AMPRMS(4), 0.2340784267119091D0, - : 1D-7, 'sla_MAPPA', 'AMPRMS(4)', STATUS ) - CALL VVD ( AMPRMS(5), -0.8067807553217332071D0, - : 1D-7, 'sla_MAPPA', 'AMPRMS(5)', STATUS ) - CALL VVD ( AMPRMS(6), 0.5420884771236513880D0, - : 1D-7, 'sla_MAPPA', 'AMPRMS(6)', STATUS ) - CALL VVD ( AMPRMS(7), 0.2350423277034460899D0, - : 1D-7, 'sla_MAPPA', 'AMPRMS(7)', STATUS ) - CALL VVD ( AMPRMS(8), 1.999729469227807D-8, - : 1D-12, 'sla_MAPPA', 'AMPRMS(8)', STATUS ) - CALL VVD ( AMPRMS(9), -6.035531043691568494D-5, - : 1D-12, 'sla_MAPPA', 'AMPRMS(9)', STATUS ) - CALL VVD ( AMPRMS(10), -7.381891582591552377D-5, - : 1D-11, 'sla_MAPPA', 'AMPRMS(10)', STATUS ) - CALL VVD ( AMPRMS(11), -3.200897749853207412D-5, - : 1D-11, 'sla_MAPPA', 'AMPRMS(11)', STATUS ) - CALL VVD ( AMPRMS(12), 0.9999999949417148D0, - : 1D-11, 'sla_MAPPA', 'AMPRMS(12)', STATUS ) - CALL VVD ( AMPRMS(13), 0.9999566751478850D0, - : 1D-11, 'sla_MAPPA', 'AMPRMS(13)', STATUS ) - CALL VVD ( AMPRMS(14), -8.537361890149777D-3, - : 1D-11, 'sla_MAPPA', 'AMPRMS(14)', STATUS ) - CALL VVD ( AMPRMS(15), -3.709619811228171D-3, - : 1D-11, 'sla_MAPPA', 'AMPRMS(15)', STATUS ) - CALL VVD ( AMPRMS(16), 8.537308717676752D-3, - : 1D-11, 'sla_MAPPA', 'AMPRMS(16)', STATUS ) - CALL VVD ( AMPRMS(17), 0.9999635560607690D0, - : 1D-11, 'sla_MAPPA', 'AMPRMS(17)', STATUS ) - CALL VVD ( AMPRMS(18), -3.016886324169151D-5, - : 1D-11, 'sla_MAPPA', 'AMPRMS(18)', STATUS ) - CALL VVD ( AMPRMS(19), 3.709742180572510D-3, - : 1D-11, 'sla_MAPPA', 'AMPRMS(19)', STATUS ) - CALL VVD ( AMPRMS(20), -1.502613373498668D-6, - : 1D-11, 'sla_MAPPA', 'AMPRMS(20)', STATUS ) - CALL VVD ( AMPRMS(21), 0.9999931188816729D0, - : 1D-11, 'sla_MAPPA', 'AMPRMS(21)', STATUS ) - - CALL sla_MAPQK ( 1.234D0, -0.987D0, -1.2D-5, -0.99D0, - : 0.75D0, -23.4D0, AMPRMS, RA, DA ) - - CALL VVD ( RA, 1.223337584930993D0, 1D-11, 'sla_MAPQK', - : 'RA', STATUS ) - CALL VVD ( DA, 0.5558838650379129D0, 1D-11, 'sla_MAPQK', - : 'DA', STATUS ) - - CALL sla_MAPQKZ ( 6.012D0, 1.234D0, AMPRMS, RA, DA ) - - CALL VVD ( RA, 6.006091119756597D0, 1D-11, 'sla_MAPQKZ', - : 'RA', STATUS ) - CALL VVD ( DA, 1.23045846622498D0, 1D-11, 'sla_MAPQKZ', - : 'DA', STATUS ) - - END - - SUBROUTINE T_MOON ( STATUS ) -*+ -* - - - - - - - -* T _ M O O N -* - - - - - - - -* -* Test sla_MOON and sla_DMOON routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_MOON, sla_DMOON, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL PV(6) - - CALL sla_MOON ( 1999, 365, 0.9E0, PV ) - - CALL VVD ( DBLE( PV(1) ), -2.155729505970773D-3, 1D-6, - : 'sla_MOON', '(1)', STATUS ) - CALL VVD ( DBLE( PV(2) ), -1.538107758633427D-3, 1D-6, - : 'sla_MOON', '(2)', STATUS ) - CALL VVD ( DBLE( PV(3) ), -4.003940552689305D-4, 1D-6 , - : 'sla_MOON', '(3)', STATUS ) - CALL VVD ( DBLE( PV(4) ), 3.629209419071314D-9, 1D-12, - : 'sla_MOON', '(4)', STATUS ) - CALL VVD ( DBLE( PV(5) ), -4.989667166259157D-9, 1D-12, - : 'sla_MOON', '(5)', STATUS ) - CALL VVD ( DBLE( PV(6) ), -2.160752457288307D-9, 1D-12, - : 'sla_MOON', '(6)', STATUS ) - - END - - SUBROUTINE T_NUT ( STATUS ) -*+ -* - - - - - - -* T _ N U T -* - - - - - - -* -* Test sla_NUT, sla_NUTC, sla_NUTC80 routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_NUT, sla_NUTC, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RMATN(3,3), DPSI, DEPS, EPS0 - - CALL sla_NUT ( 46012.34D0, RMATN ) - - CALL VVD ( RMATN(1,1), 9.999999969492166D-1, 1D-12, - : 'sla_NUT', '(1,1)', STATUS ) - CALL VVD ( RMATN(1,2), 7.166577986249302D-5, 1D-12, - : 'sla_NUT', '(1,2)', STATUS ) - CALL VVD ( RMATN(1,3), 3.107382973077677D-5, 1D-12, - : 'sla_NUT', '(1,3)', STATUS ) - CALL VVD ( RMATN(2,1), -7.166503970900504D-5, 1D-12, - : 'sla_NUT', '(2,1)', STATUS ) - CALL VVD ( RMATN(2,2), 9.999999971483732D-1, 1D-12, - : 'sla_NUT', '(2,2)', STATUS ) - CALL VVD ( RMATN(2,3), -2.381965032461830D-5, 1D-12, - : 'sla_NUT', '(2,3)', STATUS ) - CALL VVD ( RMATN(3,1), -3.107553669598237D-5, 1D-12, - : 'sla_NUT', '(3,1)', STATUS ) - CALL VVD ( RMATN(3,2), 2.381742334472628D-5, 1D-12, - : 'sla_NUT', '(3,2)', STATUS ) - CALL VVD ( RMATN(3,3), 9.999999992335206818D-1, 1D-12, - : 'sla_NUT', '(3,3)', STATUS ) - - CALL sla_NUTC ( 50123.4D0, DPSI, DEPS, EPS0 ) - - CALL VVD ( DPSI, 3.523550954747999709D-5, 1D-17, 'sla_NUTC', - : 'DPSI', STATUS ) - CALL VVD ( DEPS, -4.143371566683342D-5, 1D-17, 'sla_NUTC', - : 'DEPS', STATUS ) - CALL VVD ( EPS0, 0.4091014592901651D0, 1D-12, 'sla_NUTC', - : 'EPS0', STATUS ) - - CALL sla_NUTC80 ( 50123.4D0, DPSI, DEPS, EPS0 ) - - CALL VVD ( DPSI, 3.537714281665945321D-5, 1D-17, 'sla_NUTC80', - : 'DPSI', STATUS ) - CALL VVD ( DEPS, -4.140590085987148317D-5, 1D-17, 'sla_NUTC80', - : 'DEPS', STATUS ) - CALL VVD ( EPS0, 0.4091016349007751D0, 1D-12, 'sla_NUTC80', - : 'EPS0', STATUS ) - - END - - SUBROUTINE T_OBS ( STATUS ) -*+ -* - - - - - - -* T _ O B S -* - - - - - - -* -* Test sla_OBS routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_OBS, err, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER N - DOUBLE PRECISION W, P, H - CHARACTER*10 C - CHARACTER*40 NAME - - N = 0 - C = 'MMT' - CALL sla_OBS ( N, C, NAME, W, P, H ) - CALL VCS ( C, 'MMT', 'sla_OBS', '1/C', STATUS ) - CALL VCS ( NAME, 'MMT 6.5m, Mt Hopkins', 'sla_OBS', '1/NAME', - : STATUS ) - CALL VVD ( W, 1.935300584055477D0, 1D-8, 'sla_OBS', - : '1/W', STATUS ) - CALL VVD ( P, 0.5530735081550342238D0, 1D-10, 'sla_OBS', - : '1/P', STATUS ) - CALL VVD ( H, 2608D0, 1D-10, 'sla_OBS', - : '1/H', STATUS ) - - N = 61 - CALL sla_OBS ( N, C, NAME, W, P, H ) - CALL VCS ( C, 'KECK1', 'sla_OBS', '2/C', STATUS ) - CALL VCS ( NAME, 'Keck 10m Telescope #1', 'sla_OBS', - : '2/NAME', STATUS ) - CALL VVD ( W, 2.713545757918895D0, 1D-8, 'sla_OBS', - : '2/W', STATUS ) - CALL VVD ( P, 0.3460280563536619D0, 1D-8, 'sla_OBS', - : '2/P', STATUS ) - CALL VVD ( H, 4160D0, 1D-10, 'sla_OBS', - : '2/H', STATUS ) - - N = 83 - CALL sla_OBS ( N, C, NAME, W, P, H ) - CALL VCS ( C, 'MAGELLAN2', 'sla_OBS', '3/C', STATUS ) - CALL VCS ( NAME, 'Magellan 2, 6.5m, Las Campanas', - : 'sla_OBS', '3/NAME', STATUS ) - CALL VVD ( W, 1.233819305534497D0, 1D-8, 'sla_OBS', - : '3/W', STATUS ) - CALL VVD ( P, -0.506389344359954D0, 1D-8, 'sla_OBS', - : '3/P', STATUS ) - CALL VVD ( H, 2408D0, 1D-10, 'sla_OBS', - : '3/H', STATUS ) - - N = 85 - CALL sla_OBS ( N, C, NAME, W, P, H ) - CALL VCS ( NAME, '?', 'sla_OBS', '4/NAME', STATUS ) - - END - - SUBROUTINE T_PA ( STATUS ) -*+ -* - - - - - -* T _ P A -* - - - - - -* -* Test sla_PA routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PA, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_PA - - - CALL VVD ( sla_PA ( -1.567D0, 1.5123D0, 0.987D0 ), - : -1.486288540423851D0, 1D-12, 'sla_PA', ' ', STATUS ) - CALL VVD ( sla_PA ( 0D0, 0.789D0, 0.789D0 ), - : 0D0, 0D0, 'sla_PA', 'zenith', STATUS ) - - END - - SUBROUTINE T_PCD ( STATUS ) -*+ -* - - - - - - -* T _ P C D -* - - - - - - -* -* Test sla_PCD, sla_UNPCD routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PCD, VVD, sla_UNPCD. -* -* Last revision: 4 September 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DISCO, X, Y - - DISCO = 178.585D0 - X = 0.0123D0 - Y = -0.00987D0 - - CALL sla_PCD ( DISCO, X, Y ) - CALL VVD ( X, 0.01284630845735895D0, 1D-14, 'sla_PCD', - : 'X', STATUS ) - CALL VVD ( Y, -0.01030837922553926D0, 1D-14, 'sla_PCD', - : 'Y', STATUS ) - - CALL sla_UNPCD ( DISCO, X, Y ) - CALL VVD ( X, 0.0123D0, 1D-14, 'sla_UNPCD', - : 'X', STATUS ) - CALL VVD ( Y, -0.00987D0, 1D-14, 'sla_UNPCD', - : 'Y', STATUS ) - - END - - SUBROUTINE T_PDA2H ( STATUS ) -*+ -* - - - - - - - - -* T _ P D A 2 H -* - - - - - - - - -* -* Test sla_PDA2H routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PDA2H, VVD. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J1, J2 - DOUBLE PRECISION H1, H2 - - CALL sla_PDA2H ( -0.51D0, -1.31D0, 3.1D0, H1, J1, H2, J2 ) - CALL VVD ( H1, -0.1161784556585304927D0, 1D-14, 'sla_PDA2H', - : 'H1', STATUS ) - CALL VIV ( J1, 0, 'sla_PDA2H', 'J1', STATUS ) - CALL VVD ( H2, -2.984787179226459D0, 1D-13, 'sla_PDA2H', - : 'H2', STATUS ) - CALL VIV ( J2, 0, 'sla_PDA2H', 'J2', STATUS ) - - END - - SUBROUTINE T_PDQ2H ( STATUS ) -*+ -* - - - - - - - - -* T _ P D Q 2 H -* - - - - - - - - -* -* Test sla_PDQ2H routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PDQ2H, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J1, J2 - DOUBLE PRECISION H1, H2 - - CALL sla_PDQ2H ( 0.9D0, 0.2D0, 0.1D0, H1, J1, H2, J2 ) - CALL VVD ( H1, 0.1042809894435257D0, 1D-14, 'sla_PDQ2H', - : 'H1', STATUS ) - CALL VIV ( J1, 0, 'sla_PDQ2H', 'J1', STATUS ) - CALL VVD ( H2, 2.997450098818439D0, 1D-13, 'sla_PDQ2H', - : 'H2', STATUS ) - CALL VIV ( J2, 0, 'sla_PDQ2H', 'J2', STATUS ) - - END - - SUBROUTINE T_PERCOM ( STATUS ) -*+ -* - - - - - - - - - -* T _ P E R C O M -* - - - - - - - - - -* -* Test sla_COMBN, sla_PERMUT routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_COMBN, VIV, sla_PERMUT. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER LIST(3), I, J, ISTATE(4), IORDER(4) - - LIST(1) = 0 - - DO I = 1, 11 - CALL sla_COMBN ( 3, 5, LIST, J ) - END DO - - CALL VIV ( J, 1, 'sla_COMBN', 'J', STATUS ) - CALL VIV ( LIST(1), 1, 'sla_COMBN', 'LIST(1)', STATUS ) - CALL VIV ( LIST(2), 2, 'sla_COMBN', 'LIST(2)', STATUS ) - CALL VIV ( LIST(3), 3, 'sla_COMBN', 'LIST(3)', STATUS ) - - ISTATE(1) = -1 - - DO I = 1, 25 - CALL sla_PERMUT ( 4, ISTATE, IORDER, J ) - END DO - - CALL VIV ( J, 1, 'sla_PERMUT', 'J', STATUS ) - CALL VIV ( IORDER(1), 4, 'sla_PERMUT', 'IORDER(1)', STATUS ) - CALL VIV ( IORDER(2), 3, 'sla_PERMUT', 'IORDER(2)', STATUS ) - CALL VIV ( IORDER(3), 2, 'sla_PERMUT', 'IORDER(3)', STATUS ) - CALL VIV ( IORDER(4), 1, 'sla_PERMUT', 'IORDER(4)', STATUS ) - - END - - SUBROUTINE T_PLANET ( STATUS ) -*+ -* - - - - - - - - - -* T _ P L A N E T -* - - - - - - - - - -* -* Test sla_EL2UE, sla_PERTEL, sla_PERTUE, sla_PLANEL, sla_PLANET, -* sla_PLANTE, sla_PLANTU, sla_PV2EL, sla_PV2UE, sla_RDPLAN, sla_UE2EL -* and sla_UE2PV routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_EL2UE, sla_PERTEL, sla_PERTUE, sla_PLANEL, sla_PLANET, -* sla_PLANTE, sla_PLANTU, sla_PV2EL, sla_PV2UE, sla_RDPLAN, -* sla_UE2EL, sla_UE2PV, VIV, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J, JFORM - DOUBLE PRECISION U(13), PV(6), RA, DEC, R, DIAM, EPOCH, ORBINC, - : ANODE, PERIH, AORQ, E, AORL, DM - - - CALL sla_EL2UE ( 50000D0, 1, 49000D0, 0.1D0, 2D0, 0.2D0, - : 3D0, 0.05D0, 3D0, 0.003312D0, U, J ) - CALL VVD ( U(1), 1.000878908362435284D0, 1D-12, 'sla_EL2UE', - : 'U(1)', STATUS ) - CALL VVD ( U(2), -0.3336263027874777288D0, 1D-12, 'sla_EL2UE', - : 'U(2)', STATUS ) - CALL VVD ( U(3), 50000D0, 1D-12, 'sla_EL2UE', - : 'U(3)', STATUS ) - CALL VVD ( U(4), 2.840425801310305210D0, 1D-12, 'sla_EL2UE', - : 'U(4)', STATUS ) - CALL VVD ( U(5), 0.1264380368035014224D0, 1D-12, 'sla_EL2UE', - : 'U(5)', STATUS ) - CALL VVD ( U(6), -0.2287711835229143197D0, 1D-12, 'sla_EL2UE', - : 'U(6)', STATUS ) - CALL VVD ( U(7), -0.01301062595106185195D0, 1D-12, 'sla_EL2UE', - : 'U(7)', STATUS ) - CALL VVD ( U(8), 0.5657102158104651697D0, 1D-12, 'sla_EL2UE', - : 'U(8)', STATUS ) - CALL VVD ( U(9), 0.2189745287281794885D0, 1D-12, 'sla_EL2UE', - : 'U(9)', STATUS ) - CALL VVD ( U(10), 2.852427310959998500D0, 1D-12, 'sla_EL2UE', - : 'U(10)', STATUS ) - CALL VVD ( U(11), -0.01552349065435120900D0, 1D-12, 'sla_EL2UE', - : 'U(11)', STATUS ) - CALL VVD ( U(12), 50000D0, 1D-12, 'sla_EL2UE', - : 'U(12)', STATUS ) - CALL VVD ( U(13), 0D0, 1D-12, 'sla_EL2UE', - : 'U(13)', STATUS ) - CALL VIV ( J, 0, 'sla_EL2UE', 'J', STATUS ) - - CALL sla_PERTEL ( 2, 43000D0, 43200D0, 43000D0, - : 0.2D0, 3D0, 4D0, 5D0, 0.02D0, 6D0, - : EPOCH, ORBINC, ANODE, PERIH, AORQ, E, AORL, J ) - CALL VVD ( EPOCH, 43200D0, 1D-10, 'sla_PERTEL', - : 'EPOCH', STATUS ) - CALL VVD ( ORBINC, 0.1995661466545422381D0, 1D-7, 'sla_PERTEL', - : 'ORBINC', STATUS ) - CALL VVD ( ANODE, 2.998052737821591215D0, 1D-7, 'sla_PERTEL', - : 'ANODE', STATUS ) - CALL VVD ( PERIH, 4.009516448441143636D0, 1D-6, 'sla_PERTEL', - : 'PERIH', STATUS ) - CALL VVD ( AORQ, 5.014216294790922323D0, 1D-7, 'sla_PERTEL', - : 'AORQ', STATUS ) - CALL VVD ( E, 0.02281386258309823607D0, 1D-7, 'sla_PERTEL', - : 'E', STATUS ) - CALL VVD ( AORL, 0.01735248648779583748D0, 1D-6, 'sla_PERTEL', - : 'AORL', STATUS ) - CALL VIV ( J, 0, 'sla_PERTEL', 'J', STATUS ) - - CALL sla_PERTUE ( 50100D0, U, J ) - CALL VVD ( U(1), 1.000000000000000D0, 1D-12, 'sla_PERTUE', - : 'U(1)', STATUS ) - CALL VVD ( U(2), -0.3329769417028020949D0, 1D-11, 'sla_PERTUE', - : 'U(2)', STATUS ) - CALL VVD ( U(3), 50100D0, 1D-12, 'sla_PERTUE', - : 'U(3)', STATUS ) - CALL VVD ( U(4), 2.638884303608524597D0, 1D-11, 'sla_PERTUE', - : 'U(4)', STATUS ) - CALL VVD ( U(5), 1.070994304747824305D0, 1D-11, 'sla_PERTUE', - : 'U(5)', STATUS ) - CALL VVD ( U(6), 0.1544112080167568589D0, 1D-11, 'sla_PERTUE', - : 'U(6)', STATUS ) - CALL VVD ( U(7), -0.2188240619161439344D0, 1D-11, 'sla_PERTUE', - : 'U(7)', STATUS ) - CALL VVD ( U(8), 0.5207557453451906385D0, 1D-11, 'sla_PERTUE', - : 'U(8)', STATUS ) - CALL VVD ( U(9), 0.2217782439275216936D0, 1D-11, 'sla_PERTUE', - : 'U(9)', STATUS ) - CALL VVD ( U(10), 2.852118859689216658D0, 1D-11, 'sla_PERTUE', - : 'U(10)', STATUS ) - CALL VVD ( U(11), 0.01452010174371893229D0, 1D-11, 'sla_PERTUE', - : 'U(11)', STATUS ) - CALL VVD ( U(12), 50100D0, 1D-12, 'sla_PERTUE', - : 'U(12)', STATUS ) - CALL VVD ( U(13), 0D0, 1D-12, 'sla_PERTUE', - : 'U(13)', STATUS ) - CALL VIV ( J, 0, 'sla_PERTUE', 'J', STATUS ) - - CALL sla_PLANEL ( 50600D0, 2, 50500D0, 0.1D0, 3D0, 5D0, - : 2D0, 0.3D0, 4D0, 0D0, PV, J ) - CALL VVD ( PV(1), 1.947628959288897677D0, 1D-12, 'sla_PLANEL', - : 'PV(1)', STATUS ) - CALL VVD ( PV(2), -1.013736058752235271D0, 1D-12, 'sla_PLANEL', - : 'PV(2)', STATUS ) - CALL VVD ( PV(3), -0.3536409947732733647D0, 1D-12, 'sla_PLANEL', - : 'PV(3)', STATUS ) - CALL VVD ( PV(4), 2.742247411571786194D-8, 1D-19, 'sla_PLANEL', - : 'PV(4)', STATUS ) - CALL VVD ( PV(5), 1.170467244079075911D-7, 1D-19, 'sla_PLANEL', - : 'PV(5)', STATUS ) - CALL VVD ( PV(6), 3.709878268217564005D-8, 1D-19, 'sla_PLANEL', - : 'PV(6)', STATUS ) - CALL VIV ( J, 0, 'sla_PLANEL', 'J', STATUS ) - - CALL sla_PLANET ( 1D6, 0, PV, J ) - CALL VVD ( PV(1), 0D0, 0D0, 'sla_PLANET', - : 'PV(1) 1', STATUS ) - CALL VVD ( PV(2), 0D0, 0D0, 'sla_PLANET', - : 'PV(2) 1', STATUS ) - CALL VVD ( PV(3), 0D0, 0D0, 'sla_PLANET', - : 'PV(3) 1', STATUS ) - CALL VVD ( PV(4), 0D0, 0D0, 'sla_PLANET', - : 'PV(4) 1', STATUS ) - CALL VVD ( PV(5), 0D0, 0D0, 'sla_PLANET', - : 'PV(5) 1', STATUS ) - CALL VVD ( PV(6), 0D0, 0D0, 'sla_PLANET', - : 'PV(6) 1', STATUS ) - CALL VIV ( J, -1, 'sla_PLANET', 'J 1', STATUS ) - - CALL sla_PLANET ( 1D6, 10, PV, J ) - CALL VIV ( J, -1, 'sla_PLANET', 'J 2', STATUS ) - - CALL sla_PLANET ( -320000D0, 3, PV, J ) - CALL VVD ( PV(1), 0.9308038666827242603D0, 1D-11, 'sla_PLANET', - : 'PV(1) 3', STATUS ) - CALL VVD ( PV(2), 0.3258319040252137618D0, 1D-11, 'sla_PLANET', - : 'PV(2) 3', STATUS ) - CALL VVD ( PV(3), 0.1422794544477122021D0, 1D-11, 'sla_PLANET', - : 'PV(3) 3', STATUS ) - CALL VVD ( PV(4), -7.441503423889371696D-8, 1D-17, 'sla_PLANET', - : 'PV(4) 3', STATUS ) - CALL VVD ( PV(5), 1.699734557528650689D-7, 1D-17, 'sla_PLANET', - : 'PV(5) 3', STATUS ) - CALL VVD ( PV(6), 7.415505123001430864D-8, 1D-17, 'sla_PLANET', - : 'PV(6) 3', STATUS ) - CALL VIV ( J, 1, 'sla_PLANET', 'J 3', STATUS ) - - CALL sla_PLANET ( 43999.9D0, 1, PV, J ) - CALL VVD ( PV(1), 0.2945293959257422246D0, 1D-11, 'sla_PLANET', - : 'PV(1) 4', STATUS ) - CALL VVD ( PV(2), -0.2452204176601052181D0, 1D-11, 'sla_PLANET', - : 'PV(2) 4', STATUS ) - CALL VVD ( PV(3), -0.1615427700571978643D0, 1D-11, 'sla_PLANET', - : 'PV(3) 4', STATUS ) - CALL VVD ( PV(4), 1.636421147459047057D-7, 1D-18, 'sla_PLANET', - : 'PV(4) 4', STATUS ) - CALL VVD ( PV(5), 2.252949422574889753D-7, 1D-18, 'sla_PLANET', - : 'PV(5) 4', STATUS ) - CALL VVD ( PV(6), 1.033542799062371839D-7, 1D-18, 'sla_PLANET', - : 'PV(6) 4', STATUS ) - CALL VIV ( J, 0, 'sla_PLANET', 'J 4', STATUS ) - - CALL sla_PLANTE ( 50600D0, -1.23D0, 0.456D0, 2, 50500D0, - : 0.1D0, 3D0, 5D0, 2D0, 0.3D0, 4D0, - : 0D0, RA, DEC, R, J ) - CALL VVD ( RA, 6.222958101333794007D0, 1D-10, 'sla_PLANTE', - : 'RA', STATUS ) - CALL VVD ( DEC, 0.01142220305739771601D0, 1D-10, 'sla_PLANTE', - : 'DEC', STATUS ) - CALL VVD ( R, 2.288902494080167624D0, 1D-8, 'sla_PLANTE', - : 'R', STATUS ) - CALL VIV ( J, 0, 'sla_PLANTE', 'J', STATUS ) - - U(1) = 1.0005D0 - U(2) = -0.3D0 - U(3) = 55000D0 - U(4) = 2.8D0 - U(5) = 0.1D0 - U(6) = -0.2D0 - U(7) = -0.01D0 - U(8) = 0.5D0 - U(9) = 0.22D0 - U(10) = 2.8D0 - U(11) = -0.015D0 - U(12) = 55001D0 - U(13) = 0D0 - - CALL sla_PLANTU ( 55001D0, -1.23D0, 0.456D0, U, RA, DEC, R, J ) - CALL VVD ( RA, 0.3531814831241686647D0, 1D-9, 'sla_PLANTU', - : 'RA', STATUS ) - CALL VVD ( DEC, 0.06940344580567131328D0, 1D-9, 'sla_PLANTU', - : 'DEC', STATUS ) - CALL VVD ( R, 3.031687170873274464D0, 1D-8, 'sla_PLANTU', - : 'R', STATUS ) - CALL VIV ( J, 0, 'sla_PLANTU', 'J', STATUS ) - - PV(1) = 0.3D0 - PV(2) = -0.2D0 - PV(3) = 0.1D0 - PV(4) = -0.9D-7 - PV(5) = 0.8D-7 - PV(6) = -0.7D-7 - CALL sla_PV2EL ( PV, 50000D0, 0.00006D0, 1, - : JFORM, EPOCH, ORBINC, ANODE, PERIH, - : AORQ, E, AORL, DM, J ) - CALL VIV ( JFORM, 1, 'sla_PV2EL', 'JFORM', STATUS ) - CALL VVD ( EPOCH, 50000D0, 1D-10, 'sla_PV2EL', - : 'EPOCH', STATUS ) - CALL VVD ( ORBINC, 1.52099895268912D0, 1D-12, 'sla_PV2EL', - : 'ORBINC', STATUS ) - CALL VVD ( ANODE, 2.720503180538650D0, 1D-12, 'sla_PV2EL', - : 'ANODE', STATUS ) - CALL VVD ( PERIH, 2.194081512031836D0, 1D-12, 'sla_PV2EL', - : 'PERIH', STATUS ) - CALL VVD ( AORQ, 0.2059371035373771D0, 1D-12, 'sla_PV2EL', - : 'AORQ', STATUS ) - CALL VVD ( E, 0.9866822985810528D0, 1D-12, 'sla_PV2EL', - : 'E', STATUS ) - CALL VVD ( AORL, 0.2012758344836794D0, 1D-12, 'sla_PV2EL', - : 'AORL', STATUS ) - CALL VVD ( DM, 0.1840740507951820D0, 1D-12, 'sla_PV2EL', - : 'DM', STATUS ) - CALL VIV ( J, 0, 'sla_PV2EL', 'J', STATUS ) - - CALL sla_PV2UE ( PV, 50000D0, 0.00006D0, U, J ) - CALL VVD ( U(1), 1.00006D0, 1D-12, 'sla_PV2UE', - : 'U(1)', STATUS ) - CALL VVD ( U(2), -4.856142884511782D0, 1D-12, 'sla_PV2UE', - : 'U(2)', STATUS ) - CALL VVD ( U(3), 50000D0, 1D-12, 'sla_PV2UE', - : 'U(3)', STATUS ) - CALL VVD ( U(4), 0.3D0, 1D-12, 'sla_PV2UE', - : 'U(4)', STATUS ) - CALL VVD ( U(5), -0.2D0, 1D-12, 'sla_PV2UE', - : 'U(5)', STATUS ) - CALL VVD ( U(6), 0.1D0, 1D-12, 'sla_PV2UE', - : 'U(6)', STATUS ) - CALL VVD ( U(7), -0.4520378601821727D0, 1D-12, 'sla_PV2UE', - : 'U(7)', STATUS ) - CALL VVD ( U(8), 0.4018114312730424D0, 1D-12, 'sla_PV2UE', - : 'U(8)', STATUS ) - CALL VVD ( U(9), -.3515850023639121D0, 1D-12, 'sla_PV2UE', - : 'U(9)', STATUS ) - CALL VVD ( U(10), 0.3741657386773941D0, 1D-12, 'sla_PV2UE', - : 'U(10)', STATUS ) - CALL VVD ( U(11), -0.2511321445456515D0, 1D-12, 'sla_PV2UE', - : 'U(11)', STATUS ) - CALL VVD ( U(12), 50000D0, 1D-12, 'sla_PV2UE', - : 'U(12)', STATUS ) - CALL VVD ( U(13), 0D0, 1D-12, 'sla_PV2UE', - : 'U(13)', STATUS ) - CALL VIV ( J, 0, 'sla_PV2UE', 'J', STATUS ) - - CALL sla_RDPLAN ( 40999.9D0, 0, 0.1D0, -0.9D0, RA, DEC, DIAM ) - CALL VVD ( RA, 5.772270359389275837D0, 1D-7, 'sla_RDPLAN', - : 'RA 0', STATUS ) - CALL VVD ( DEC, -0.2089207338795416192D0, 1D-7, 'sla_RDPLAN', - : 'DEC 0', STATUS ) - CALL VVD ( DIAM, 9.415338935229717875D-3, 1D-14, 'sla_RDPLAN', - : 'DIAM 0', STATUS ) - CALL sla_RDPLAN ( 41999.9D0, 1, 1.1D0, -0.9D0, RA, DEC, DIAM ) - CALL VVD ( RA, 3.866363420052936653D0, 1D-7, 'sla_RDPLAN', - : 'RA 1', STATUS ) - CALL VVD ( DEC, -0.2594430577550113130D0, 1D-7, 'sla_RDPLAN', - : 'DEC 1', STATUS ) - CALL VVD ( DIAM, 4.638468996795023071D-5, 1D-14, 'sla_RDPLAN', - : 'DIAM 1', STATUS ) - CALL sla_RDPLAN ( 42999.9D0, 2, 2.1D0, 0.9D0, RA, DEC, DIAM ) - CALL VVD ( RA, 2.695383203184077378D0, 1D-7, 'sla_RDPLAN', - : 'RA 2', STATUS ) - CALL VVD ( DEC, 0.2124044506294805126D0, 1D-7, 'sla_RDPLAN', - : 'DEC 2', STATUS ) - CALL VVD ( DIAM, 4.892222838681000389D-5, 1D-14, 'sla_RDPLAN', - : 'DIAM 2', STATUS ) - CALL sla_RDPLAN ( 43999.9D0, 3, 3.1D0, 0.9D0, RA, DEC, DIAM ) - CALL VVD ( RA, 2.908326678461540165D0, 1D-7, 'sla_RDPLAN', - : 'RA 3', STATUS ) - CALL VVD ( DEC, 0.08729783126905579385D0, 1D-7, 'sla_RDPLAN', - : 'DEC 3', STATUS ) - CALL VVD ( DIAM, 8.581305866034962476D-3, 1D-14, 'sla_RDPLAN', - : 'DIAM 3', STATUS ) - CALL sla_RDPLAN ( 44999.9D0, 4, -0.1D0, 1.1D0, RA, DEC, DIAM ) - CALL VVD ( RA, 3.429840787472851721D0, 1D-7, 'sla_RDPLAN', - : 'RA 4', STATUS ) - CALL VVD ( DEC, -0.06979851055261161013D0, 1D-7, 'sla_RDPLAN', - : 'DEC 4', STATUS ) - CALL VVD ( DIAM, 4.540536678439300199D-5, 1D-14, 'sla_RDPLAN', - : 'DIAM 4', STATUS ) - CALL sla_RDPLAN ( 45999.9D0, 5, -1.1D0, 0.1D0, RA, DEC, DIAM ) - CALL VVD ( RA, 4.864669466449422548D0, 1D-7, 'sla_RDPLAN', - : 'RA 5', STATUS ) - CALL VVD ( DEC, -0.4077714497908953354D0, 1D-7, 'sla_RDPLAN', - : 'DEC 5', STATUS ) - CALL VVD ( DIAM, 1.727945579027815576D-4, 1D-14, 'sla_RDPLAN', - : 'DIAM 5', STATUS ) - CALL sla_RDPLAN ( 46999.9D0, 6, -2.1D0, -0.1D0, RA, DEC, DIAM ) - CALL VVD ( RA, 4.432929829176388766D0, 1D-7, 'sla_RDPLAN', - : 'RA 6', STATUS ) - CALL VVD ( DEC, -0.3682820877854730530D0, 1D-7, 'sla_RDPLAN', - : 'DEC 6', STATUS ) - CALL VVD ( DIAM, 8.670829016099083311D-5, 1D-14, 'sla_RDPLAN', - : 'DIAM 6', STATUS ) - CALL sla_RDPLAN ( 47999.9D0, 7, -3.1D0, -1.1D0, RA, DEC, DIAM ) - CALL VVD ( RA, 4.894972492286818487D0, 1D-7, 'sla_RDPLAN', - : 'RA 7', STATUS ) - CALL VVD ( DEC, -0.4084068901053653125D0, 1D-7, 'sla_RDPLAN', - : 'DEC 7', STATUS ) - CALL VVD ( DIAM, 1.793916783975974163D-5, 1D-14, 'sla_RDPLAN', - : 'DIAM 7', STATUS ) - CALL sla_RDPLAN ( 48999.9D0, 8, 0D0, 0D0, RA, DEC, DIAM ) - CALL VVD ( RA, 5.066050284760144000D0, 1D-7, 'sla_RDPLAN', - : 'RA 8', STATUS ) - CALL VVD ( DEC, -0.3744690779683850609D0, 1D-7, 'sla_RDPLAN', - : 'DEC 8', STATUS ) - CALL VVD ( DIAM, 1.062210086082700563D-5, 1D-14, 'sla_RDPLAN', - : 'DIAM 8', STATUS ) - CALL sla_RDPLAN ( 49999.9D0, 9, 0D0, 0D0, RA, DEC, DIAM ) - CALL VVD ( RA, 4.179543143097200945D0, 1D-7, 'sla_RDPLAN', - : 'RA 9', STATUS ) - CALL VVD ( DEC, -0.1258021632894033300D0, 1D-7, 'sla_RDPLAN', - : 'DEC 9', STATUS ) - CALL VVD ( DIAM, 5.034057475664904352D-7, 1D-14, 'sla_RDPLAN', - : 'DIAM 9', STATUS ) - - CALL sla_UE2EL ( U, 1, JFORM, EPOCH, ORBINC, ANODE, PERIH, - : AORQ, E, AORL, DM, J ) - CALL VIV ( JFORM, 1, 'sla_UE2EL', 'JFORM', STATUS ) - CALL VVD ( EPOCH, 50000.00000000000D0, 1D-10, 'sla_PV2EL', - : 'EPOCH', STATUS ) - CALL VVD ( ORBINC, 1.520998952689120D0, 1D-12, 'sla_UE2EL', - : 'ORBINC', STATUS ) - CALL VVD ( ANODE, 2.720503180538650D0, 1D-12, 'sla_UE2EL', - : 'ANODE', STATUS ) - CALL VVD ( PERIH, 2.194081512031836D0, 1D-12, 'sla_UE2EL', - : 'PERIH', STATUS ) - CALL VVD ( AORQ, 0.2059371035373771D0, 1D-12, 'sla_UE2EL', - : 'AORQ', STATUS ) - CALL VVD ( E, 0.9866822985810528D0, 1D-12, 'sla_UE2EL', - : 'E', STATUS ) - CALL VVD ( AORL, 0.2012758344836794D0, 1D-12, 'sla_UE2EL', - : 'AORL', STATUS ) - CALL VIV ( J, 0, 'sla_UE2EL', 'J', STATUS ) - - CALL sla_UE2PV ( 50010D0, U, PV, J ) - CALL VVD ( U(1), 1.00006D0, 1D-12, 'sla_UE2PV', - : 'U(1)', STATUS ) - CALL VVD ( U(2), -4.856142884511782111D0, 1D-12, 'sla_UE2PV', - : 'U(2)', STATUS ) - CALL VVD ( U(3), 50000D0, 1D-12, 'sla_UE2PV', - : 'U(3)', STATUS ) - CALL VVD ( U(4), 0.3D0, 1D-12, 'sla_UE2PV', - : 'U(4)', STATUS ) - CALL VVD ( U(5), -0.2D0, 1D-12, 'sla_UE2PV', - : 'U(5)', STATUS ) - CALL VVD ( U(6), 0.1D0, 1D-12, 'sla_UE2PV', - : 'U(6)', STATUS ) - CALL VVD ( U(7), -0.4520378601821727110D0, 1D-12, 'sla_UE2PV', - : 'U(7)', STATUS ) - CALL VVD ( U(8), 0.4018114312730424097D0, 1D-12, 'sla_UE2PV', - : 'U(8)', STATUS ) - CALL VVD ( U(9), -0.3515850023639121085D0, 1D-12, 'sla_UE2PV', - : 'U(9)', STATUS ) - CALL VVD ( U(10), 0.3741657386773941386D0, 1D-12, 'sla_UE2PV', - : 'U(10)', STATUS ) - CALL VVD ( U(11), -0.2511321445456515061D0, 1D-12, 'sla_UE2PV', - : 'U(11)', STATUS ) - CALL VVD ( U(12), 50010.00000000000D0, 1D-12, 'sla_UE2PV', - : 'U(12)', STATUS ) - CALL VVD ( U(13), 0.7194308220038886856D0, 1D-12, 'sla_UE2PV', - : 'U(13)', STATUS ) - CALL VVD ( PV(1), 0.07944764084631667011D0, 1D-12, 'sla_UE2PV', - : 'PV(1)', STATUS ) - CALL VVD ( PV(2), -0.04118141077419014775D0, 1D-12, 'sla_UE2PV', - : 'PV(2)', STATUS ) - CALL VVD ( PV(3), 0.002915180702063625400D0, 1D-12, 'sla_UE2PV', - : 'PV(3)', STATUS ) - CALL VVD ( PV(4), -0.6890132370721108608D-6, 1D-18,'sla_UE2PV', - : 'PV(4)', STATUS ) - CALL VVD ( PV(5), 0.4326690733487621457D-6, 1D-18, 'sla_UE2PV', - : 'PV(5)', STATUS ) - CALL VVD ( PV(6), -0.1763249096254134306D-6, 1D-18, 'sla_UE2PV', - : 'PV(6)', STATUS ) - CALL VIV ( J, 0, 'sla_UE2PV', 'J', STATUS ) - - END - - SUBROUTINE T_PM ( STATUS ) -*+ -* - - - - - -* T _ P M -* - - - - - -* -* Test sla_PM routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PM, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION R1, D1 - - CALL sla_PM ( 5.43D0, -0.87D0, -0.33D-5, 0.77D-5, 0.7D0, - : 50.3D0*365.2422D0/365.25D0, 1899D0, 1943D0, - : R1, D1 ) - CALL VVD ( R1, 5.429855087793875D0, 1D-12, 'sla_PM', - : 'R', STATUS ) - CALL VVD ( D1, -0.8696617307805072D0, 1D-12, 'sla_PM', - : 'D', STATUS ) - - END - - SUBROUTINE T_POLMO ( STATUS ) -*+ -* - - - - - - - - -* T _ P O L M O -* - - - - - - - - -* -* Test sla_POLMO routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_POLMO, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION ELONG, PHI, DAZ - - CALL sla_POLMO ( 0.7D0, -0.5D0, 1D-6, -2D-6, ELONG, PHI, DAZ ) - - CALL VVD ( ELONG, 0.7000004837322044D0, 1D-12, 'sla_POLMO', - : 'ELONG', STATUS ) - CALL VVD ( PHI, -0.4999979467222241D0, 1D-12, 'sla_POLMO', - : 'PHI', STATUS ) - CALL VVD ( DAZ, 1.008982781275728D-6, 1D-12, 'sla_POLMO', - : 'DAZ', STATUS ) - - END - - SUBROUTINE T_PREBN ( STATUS ) -*+ -* - - - - - - - - -* T _ P R E B N -* - - - - - - - - -* -* Test sla_PREBN routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PREBN, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RMATP(3,3) - - CALL sla_PREBN ( 1925D0, 1975D0, RMATP ) - - CALL VVD ( RMATP(1,1), 9.999257613786738D-1, 1D-12, - : 'sla_PREBN', '(1,1)', STATUS ) - CALL VVD ( RMATP(1,2), -1.117444640880939D-2, 1D-12, - : 'sla_PREBN', '(1,2)', STATUS ) - CALL VVD ( RMATP(1,3), -4.858341150654265D-3, 1D-12, - : 'sla_PREBN', '(1,3)', STATUS ) - CALL VVD ( RMATP(2,1), 1.117444639746558D-2, 1D-12, - : 'sla_PREBN', '(2,1)', STATUS ) - CALL VVD ( RMATP(2,2), 9.999375635561940D-1, 1D-12, - : 'sla_PREBN', '(2,2)', STATUS ) - CALL VVD ( RMATP(2,3), -2.714797892626396D-5, 1D-12, - : 'sla_PREBN', '(2,3)', STATUS ) - CALL VVD ( RMATP(3,1), 4.858341176745641D-3, 1D-12, - : 'sla_PREBN', '(3,1)', STATUS ) - CALL VVD ( RMATP(3,2), -2.714330927085065D-5, 1D-12, - : 'sla_PREBN', '(3,2)', STATUS ) - CALL VVD ( RMATP(3,3), 9.999881978224798D-1, 1D-12, - : 'sla_PREBN', '(3,3)', STATUS ) - - END - - SUBROUTINE T_PREC ( STATUS ) -*+ -* - - - - - - - -* T _ P R E C -* - - - - - - - -* -* Test sla_PREC and sla_PRECL routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PREC, sla_PRECL, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RMATP(3,3) - - CALL sla_PREC ( 1925D0, 1975D0, RMATP ) - - CALL VVD ( RMATP(1,1), 9.999257249850045D-1, 1D-12, - : 'sla_PREC', '(1,1)', STATUS ) - CALL VVD ( RMATP(1,2), -1.117719859160180D-2, 1D-12, - : 'sla_PREC', '(1,2)', STATUS ) - CALL VVD ( RMATP(1,3), -4.859500474027002D-3, 1D-12, - : 'sla_PREC', '(1,3)', STATUS ) - CALL VVD ( RMATP(2,1), 1.117719858025860D-2, 1D-12, - : 'sla_PREC', '(2,1)', STATUS ) - CALL VVD ( RMATP(2,2), 9.999375327960091D-1, 1D-12, - : 'sla_PREC', '(2,2)', STATUS ) - CALL VVD ( RMATP(2,3), -2.716114374174549D-5, 1D-12, - : 'sla_PREC', '(2,3)', STATUS ) - CALL VVD ( RMATP(3,1), 4.859500500117173D-3, 1D-12, - : 'sla_PREC', '(3,1)', STATUS ) - CALL VVD ( RMATP(3,2), -2.715647545167383D-5, 1D-12, - : 'sla_PREC', '(3,2)', STATUS ) - CALL VVD ( RMATP(3,3), 9.999881921889954D-1, 1D-12, - : 'sla_PREC', '(3,3)', STATUS ) - - CALL sla_PRECL ( 1925D0, 1975D0, RMATP ) - - CALL VVD ( RMATP(1,1), 9.999257331781050D-1, 1D-12, - : 'sla_PREC', '(1,1)', STATUS ) - CALL VVD ( RMATP(1,2), -1.117658038434041D-2, 1D-12, - : 'sla_PREC', '(1,2)', STATUS ) - CALL VVD ( RMATP(1,3), -4.859236477249598D-3, 1D-12, - : 'sla_PREC', '(1,3)', STATUS ) - CALL VVD ( RMATP(2,1), 1.117658037299592D-2, 1D-12, - : 'sla_PREC', '(2,1)', STATUS ) - CALL VVD ( RMATP(2,2), 9.999375397061558D-1, 1D-12, - : 'sla_PREC', '(2,2)', STATUS ) - CALL VVD ( RMATP(2,3), -2.715816653174189D-5, 1D-12, - : 'sla_PREC', '(2,3)', STATUS ) - CALL VVD ( RMATP(3,1), 4.859236503342703D-3, 1D-12, - : 'sla_PREC', '(3,1)', STATUS ) - CALL VVD ( RMATP(3,2), -2.715349745834860D-5, 1D-12, - : 'sla_PREC', '(3,2)', STATUS ) - CALL VVD ( RMATP(3,3), 9.999881934719490D-1, 1D-12, - : 'sla_PREC', '(3,3)', STATUS ) - - END - - SUBROUTINE T_PRECES ( STATUS ) -*+ -* - - - - - - - - - -* T _ P R E C E S -* - - - - - - - - - -* -* Test sla_PRECES routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PRECES, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RA, DC - - RA = 6.28D0 - DC = -1.123D0 - CALL sla_PRECES ( 'FK4', 1925D0, 1950D0, RA, DC ) - CALL VVD ( RA, 0.002403604864728447D0, 1D-12, 'sla_PRECES', - : 'R', STATUS ) - CALL VVD ( DC, -1.120570643322045D0, 1D-12, 'sla_PRECES', - : 'D', STATUS ) - - RA = 0.0123D0 - DC = 1.0987D0 - CALL sla_PRECES ( 'FK5', 2050D0, 1990D0, RA, DC ) - CALL VVD ( RA, 6.282003602708382D0, 1D-12, 'sla_PRECES', - : 'R', STATUS ) - CALL VVD ( DC, 1.092870326188383D0, 1D-12, 'sla_PRECES', - : 'D', STATUS ) - - END - - SUBROUTINE T_PRENUT ( STATUS ) -*+ -* - - - - - - - - - -* P R E N U T -* - - - - - - - - - -* -* Test sla_PRENUT routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PRENUT, VVD. -* -* Last revision: 16 November 2001 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION RMATPN(3,3) - - CALL sla_PRENUT ( 1985D0, 50123.4567D0, RMATPN ) - - CALL VVD ( RMATPN(1,1), 9.999962358680738D-1, 1D-12, - : 'sla_PRENUT', '(1,1)', STATUS ) - CALL VVD ( RMATPN(1,2), -2.516417057665452D-3, 1D-12, - : 'sla_PRENUT', '(1,2)', STATUS ) - CALL VVD ( RMATPN(1,3), -1.093569785342370D-3, 1D-12, - : 'sla_PRENUT', '(1,3)', STATUS ) - CALL VVD ( RMATPN(2,1), 2.516462370370876D-3, 1D-12, - : 'sla_PRENUT', '(2,1)', STATUS ) - CALL VVD ( RMATPN(2,2), 9.999968329010883D-1, 1D-12, - : 'sla_PRENUT', '(2,2)', STATUS ) - CALL VVD ( RMATPN(2,3), 4.006159587358310D-5, 1D-12, - : 'sla_PRENUT', '(2,3)', STATUS ) - CALL VVD ( RMATPN(3,1), 1.093465510215479D-3, 1D-12, - : 'sla_PRENUT', '(3,1)', STATUS ) - CALL VVD ( RMATPN(3,2), -4.281337229063151D-5, 1D-12, - : 'sla_PRENUT', '(3,2)', STATUS ) - CALL VVD ( RMATPN(3,3), 9.999994012499173D-1, 1D-12, - : 'sla_PRENUT', '(3,3)', STATUS ) - - END - - SUBROUTINE T_PVOBS ( STATUS ) -*+ -* - - - - - - - - -* T _ P V O B S -* - - - - - - - - -* -* Test sla_PVOBS routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_PVOBS, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION PV(6) - - CALL sla_PVOBS ( 0.5123D0, 3001D0, -0.567D0, PV ) - - CALL VVD ( PV(1), 0.3138647803054939D-4, 1D-16, 'sla_PVOBS', - : '(1)', STATUS ) - CALL VVD ( PV(2),-0.1998515596527082D-4, 1D-16, 'sla_PVOBS', - : '(2)', STATUS ) - CALL VVD ( PV(3), 0.2078572043443275D-4, 1D-16, 'sla_PVOBS', - : '(3)', STATUS ) - CALL VVD ( PV(4), 0.1457340726851264D-8, 1D-20, 'sla_PVOBS', - : '(4)', STATUS ) - CALL VVD ( PV(5), 0.2288738340888011D-8, 1D-20, 'sla_PVOBS', - : '(5)', STATUS ) - CALL VVD ( PV(6), 0D0, 0D0, 'sla_PVOBS', - : '(6)', STATUS ) - - END - - SUBROUTINE T_RANGE ( STATUS ) -*+ -* - - - - - - - - -* T _ R A N G E -* - - - - - - - - -* -* Test sla_RANGE, sla_DRANGE routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_RANGE, VVD, sla_DRANGE. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL sla_RANGE - DOUBLE PRECISION sla_DRANGE - - - CALL VVD ( DBLE( sla_RANGE ( -4.0 ) ), 2.283185307179586D0, - : 1D-6, 'sla_RANGE', ' ', STATUS ) - CALL VVD ( sla_DRANGE ( -4D0 ), 2.283185307179586D0, - : 1D-12, 'sla_DRANGE', ' ', STATUS ) - - END - - SUBROUTINE T_RANORM ( STATUS ) -*+ -* - - - - - - - - - -* T _ R A N O R M -* - - - - - - - - - -* -* Test sla_RANORM, sla_DRANRM routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_RANORM, VVD, sla_DRANRM. -* -* Last revision: 22 October 2006 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL sla_RANORM - DOUBLE PRECISION sla_DRANRM - - - CALL VVD ( DBLE( sla_RANORM ( -0.1E0 ) ), 6.183185307179587D0, - : 1D-5, 'sla_RANORM', '1', STATUS ) - CALL VVD ( sla_DRANRM ( -0.1D0 ), 6.183185307179587D0, - : 1D-12, 'sla_DRANRM', '2', STATUS ) - - END - - SUBROUTINE T_RCC ( STATUS ) -*+ -* - - - - - - -* T _ R C C -* - - - - - - -* -* Test sla_RCC routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_RCC, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_RCC - - - CALL VVD ( sla_RCC ( 48939.123D0, 0.76543D0, 5.0123D0, - : 5525.242D0, 3190D0 ), - : -1.280131613589158D-3, 1D-15, 'sla_RCC', ' ', STATUS ) - - END - - SUBROUTINE T_REF ( STATUS ) -*+ -* - - - - - - -* T _ R E F -* - - - - - - -* -* Test sla_REFRO, sla_REFCO, sla_ATMDSP, sla_REFV, sla_REFZ routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_REFRO, VVD, sla_REFCO, sla_REFCOQ, sla_ATMDSP, -* sla_DCS2C, sla_REFV, sla_REFZ. -* -* Last revision: 17 January 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION REF, REFA, REFB, REFA2, REFB2, VU(3), VR(3), ZR - - CALL sla_REFRO ( 1.4D0, 3456.7D0, 280D0, 678.9D0, 0.9D0, 0.55D0, - : -0.3D0, 0.006D0, 1D-9, REF ) - CALL VVD ( REF, 0.00106715763018568D0, 1D-12, 'sla_REFRO', - : 'O', STATUS ) - - CALL sla_REFRO ( 1.4D0, 3456.7D0, 280D0, 678.9D0, 0.9D0, 1000D0, - : -0.3D0, 0.006D0, 1D-9, REF ) - CALL VVD ( REF, 0.001296416185295403D0, 1D-12, 'sla_REFRO', - : 'R', STATUS ) - - CALL sla_REFCOQ ( 275.9D0, 709.3D0, 0.9D0, 101D0, REFA, REFB ) - CALL VVD ( REFA, 2.324736903790639D-4, 1D-12, 'sla_REFCOQ', - : 'A/R', STATUS ) - CALL VVD ( REFB, -2.442884551059D-7, 1D-15, 'sla_REFCOQ', - : 'B/R', STATUS ) - - CALL sla_REFCO ( 2111.1D0, 275.9D0, 709.3D0, 0.9D0, 101D0, - : -1.03D0, 0.0067D0, 1D-12, REFA, REFB ) - CALL VVD ( REFA, 2.324673985217244D-4, 1D-12, 'sla_REFCO', - : 'A/R', STATUS ) - CALL VVD ( REFB, -2.265040682496D-7, 1D-15, 'sla_REFCO', - : 'B/R', STATUS ) - - CALL sla_REFCOQ ( 275.9D0, 709.3D0, 0.9D0, 0.77D0, REFA, REFB ) - CALL VVD ( REFA, 2.007406521596588D-4, 1D-12, 'sla_REFCOQ', - : 'A', STATUS ) - CALL VVD ( REFB, -2.264210092590D-7, 1D-15, 'sla_REFCOQ', - : 'B', STATUS ) - - CALL sla_REFCO ( 2111.1D0, 275.9D0, 709.3D0, 0.9D0, 0.77D0, - : -1.03D0, 0.0067D0, 1D-12, REFA, REFB ) - CALL VVD ( REFA, 2.007202720084551D-4, 1D-12, 'sla_REFCO', - : 'A', STATUS ) - CALL VVD ( REFB, -2.223037748876D-7, 1D-15, 'sla_REFCO', - : 'B', STATUS ) - - CALL sla_ATMDSP ( 275.9D0, 709.3D0, 0.9D0, 0.77D0, - : REFA, REFB, 0.5D0, REFA2, REFB2 ) - CALL VVD ( REFA2, 2.034523658888048D-4, 1D-12, 'sla_ATMDSP', - : 'A', STATUS ) - CALL VVD ( REFB2, -2.250855362179D-7, 1D-15, 'sla_ATMDSP', - : 'B', STATUS ) - - CALL sla_DCS2C ( 0.345D0, 0.456D0, VU ) - CALL sla_REFV ( VU, REFA, REFB, VR ) - CALL VVD ( VR(1), 0.8447487047790478D0, 1D-12, 'sla_REFV', - : 'X1', STATUS ) - CALL VVD ( VR(2), 0.3035794890562339D0, 1D-12, 'sla_REFV', - : 'Y1', STATUS ) - CALL VVD ( VR(3), 0.4407256738589851D0, 1D-12, 'sla_REFV', - : 'Z1', STATUS ) - - CALL sla_DCS2C ( 3.7D0, 0.03D0, VU ) - CALL sla_REFV ( VU, REFA, REFB, VR ) - CALL VVD ( VR(1), -0.8476187691681673D0, 1D-12, 'sla_REFV', - : 'X2', STATUS ) - CALL VVD ( VR(2), -0.5295354802804889D0, 1D-12, 'sla_REFV', - : 'Y2', STATUS ) - CALL VVD ( VR(3), 0.0322914582168426D0, 1D-12, 'sla_REFV', - : 'Z2', STATUS ) - - CALL sla_REFZ ( 0.567D0, REFA, REFB, ZR ) - CALL VVD ( ZR, 0.566872285910534D0, 1D-12, 'sla_REFZ', - : 'hi el', STATUS ) - - CALL sla_REFZ ( 1.55D0, REFA, REFB, ZR ) - CALL VVD ( ZR, 1.545697350690958D0, 1D-12, 'sla_REFZ', - : 'lo el', STATUS ) - - END - - SUBROUTINE T_RV ( STATUS ) -*+ -* - - - - - -* T _ R V -* - - - - - -* -* Test sla_RVEROT, sla_RVGALC, sla_RVLG, sla_RVLSRD, sla_RVLSRK routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: VVD, sla_RVEROT, sla_RVGALC, sla_RVLG, sla_RVLSRD, sla_RVLSRK. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - REAL sla_RVEROT, sla_RVGALC, sla_RVLG, sla_RVLSRD, sla_RVLSRK - - - CALL VVD ( DBLE( sla_RVEROT ( -0.777E0, 5.67E0, -0.3E0, - : 3.19E0 ) ), -0.1948098355075913D0, 1D-6, - : 'sla_RVEROT', ' ', STATUS ) - CALL VVD ( DBLE( sla_RVGALC ( 1.11E0, -0.99E0 ) ), - : 158.9630759840254D0, 1D-3, 'sla_RVGALC', ' ', STATUS ) - CALL VVD ( DBLE( sla_RVLG ( 3.97E0, 1.09E0 ) ), - : -197.818762175363D0, 1D-3, 'sla_RVLG', ' ', STATUS ) - CALL VVD ( DBLE( sla_RVLSRD ( 6.01E0, 0.1E0 ) ), - : -4.082811335150567D0, 1D-4, 'sla_RVLSRD', ' ', STATUS ) - CALL VVD ( DBLE( sla_RVLSRK ( 6.01E0, 0.1E0 ) ), - : -5.925180579830265D0, 1D-4, 'sla_RVLSRK', ' ', STATUS ) - - END - - SUBROUTINE T_SEP ( STATUS ) -*+ -* - - - - - - - -* T _ S E P -* - - - - - - - -* -* Test sla_DSEP, sla_DSEPV, sla_SEP, sla_SEPV routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_DSEP, sla_SEP, VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I - REAL sla_SEP, sla_SEPV - REAL R1(3), R2(3), AR1, BR1, AR2, BR2 - DOUBLE PRECISION sla_DSEP, sla_DSEPV - DOUBLE PRECISION D1(3), D2(3), AD1, BD1, AD2, BD2 - - - R1(1) = 1.0 - R1(2) = 0.1 - R1(3) = 0.2 - R2(1) = -3.0 - R2(2) = 1E-3 - R2(3) = 0.2 - - DO I = 1, 3 - D1(I) = DBLE( R1(I) ) - D2(I) = DBLE( R2(I) ) - END DO - - CALL sla_DCC2S ( D1, AD1, BD1 ) - CALL sla_DCC2S ( D2, AD2, BD2 ) - - AR1 = SNGL( AD1 ) - BR1 = SNGL( BD1 ) - AR2 = SNGL( AD2 ) - BR2 = SNGL( BD2 ) - - CALL VVD ( sla_DSEP ( AD1, BD1, AD2, BD2 ), - : 2.8603919190246608D0, 1D-7, 'sla_DSEP', ' ', STATUS ) - CALL VVD ( DBLE( sla_SEP ( AR1, BR1, AR2, BR2 ) ), - : 2.8603919190246608D0, 1D-4, 'sla_SEP', ' ', STATUS ) - CALL VVD ( sla_DSEPV ( D1, D2 ), - : 2.8603919190246608D0, 1D-7, 'sla_DSEPV', ' ', STATUS ) - CALL VVD ( DBLE( sla_SEPV ( R1, R2 ) ), - : 2.8603919190246608D0, 1D-4, 'sla_SEPV', ' ', STATUS ) - - END - - SUBROUTINE T_SMAT ( STATUS ) -*+ -* - - - - - - - -* T _ S M A T -* - - - - - - - -* -* Test sla_SMAT routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_SMAT, VVD, VIV. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J, IW(3) - REAL A(3,3) - REAL V(3) - REAL D - - DATA A/2.22E0, 1.6578E0, 1.380522E0, - : 1.6578E0, 1.380522E0, 1.22548578E0, - : 1.380522E0, 1.22548578E0, 1.1356276122E0/ - DATA V/2.28625E0, 1.7128825E0, 1.429432225E0/ - - - CALL sla_SMAT ( 3, A, V, D, J, IW ) - - CALL VVD ( DBLE( A(1,1) ), 18.02550629769198D0, - : 1D-2, 'sla_SMAT', 'A(0,0)', STATUS ) - CALL VVD ( DBLE( A(1,2) ), -52.16386644917481D0, - : 1D-2, 'sla_SMAT', 'A(0,1)', STATUS ) - CALL VVD ( DBLE( A(1,3) ), 34.37875949717994D0, - : 1D-2, 'sla_SMAT', 'A(0,2)', STATUS ) - CALL VVD ( DBLE( A(2,1) ), -52.16386644917477D0, - : 1D-2, 'sla_SMAT', 'A(1,0)', STATUS ) - CALL VVD ( DBLE( A(2,2) ), 168.1778099099869D0, - : 1D-1, 'sla_SMAT', 'A(1,1)', STATUS ) - CALL VVD ( DBLE( A(2,3) ), -118.0722869694278D0, - : 1D-2, 'sla_SMAT', 'A(1,2)', STATUS ) - CALL VVD ( DBLE( A(3,1) ), 34.37875949717988D0, - : 1D-2, 'sla_SMAT', 'A(2,0)', STATUS ) - CALL VVD ( DBLE( A(3,2) ), -118.07228696942770D0, - : 1D-2, 'sla_SMAT', 'A(2,1)', STATUS ) - CALL VVD ( DBLE( A(3,3) ), 86.50307003740468D0, - : 1D-2, 'sla_SMAT', 'A(2,2)', STATUS ) - CALL VVD ( DBLE( V(1) ), 1.002346480763383D0, - : 1D-4, 'sla_SMAT', 'V(1)', STATUS ) - CALL VVD ( DBLE( V(2) ), 0.0328559401697292D0, - : 1D-4, 'sla_SMAT', 'V(2)', STATUS ) - CALL VVD ( DBLE( V(3) ), 0.004760688414898454D0, - : 1D-4, 'sla_SMAT', 'V(3)', STATUS ) - CALL VVD ( DBLE( D ), 0.003658344147359863D0, - : 1D-4, 'sla_SMAT', 'D', STATUS ) - CALL VIV ( J, 0, 'sla_SMAT', 'J', STATUS ) - - END - - SUBROUTINE T_SUPGAL ( STATUS ) -*+ -* - - - - - - - - - -* T _ S U P G A L -* - - - - - - - - - -* -* Test sla_SUPGAL routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_SUPGAL, VVD. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION DL, DB - - CALL sla_SUPGAL ( 6.1D0, -1.4D0, Dl, DB ) - - CALL VVD ( DL, 3.798775860769474D0, 1D-12, 'sla_SUPGAL', - : 'DL', STATUS ) - CALL VVD ( DB, -0.1397070490669407D0, 1D-12, 'sla_SUPGAL', - : 'DB', STATUS ) - - END - - SUBROUTINE T_SVD ( STATUS ) -*+ -* - - - - - - -* T _ S V D -* - - - - - - -* -* Test sla_SVD, sla_SVDSOL, sla_SVDCOV routines. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: sla_SVD, VVD, sla_SVDSOL, sla_SVDCOV. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER M, N - INTEGER I, J - INTEGER MP, NP, NC - - PARAMETER (MP = 10) - PARAMETER (NP = 6) - PARAMETER (NC = 7) - - DOUBLE PRECISION A(MP,NP), W(NP), V(NP,NP), WORK(NP), - : B(MP), X(NP), C(NC,NC) - DOUBLE PRECISION VAL - - M = 5 - N = 4 - - DO I = 1, M - VAL = DFLOAT( ( I ) ) / 2D0 - B(I) = 23D0 - 3D0 * VAL - 11D0 * DSIN ( VAL ) + - : 13D0 * DCOS ( VAL ) - A(I,1) = 1D0 - A(I,2) = VAL - A(I,3) = DSIN ( VAL ) - A(I,4) = DCOS ( VAL ) - END DO - - CALL sla_SVD ( M, N, MP, NP, A, W, V, WORK, J ) - -* Allow U and V to have reversed signs. - IF (A(1,1) .GT. 0D0) THEN - DO I = 1, M - DO J = 1, N - A(I,J) = - A(I,J) - V(I,J) = - V(I,J) - END DO - END DO - END IF - - CALL VVD ( A(1,1), -0.21532492989299D0, 1D-12, 'sla_SVD', - : 'A(1,1)', STATUS ) - CALL VVD ( A(1,2), 0.67675050651267D0, 1D-12, 'sla_SVD', - : 'A(1,2)', STATUS ) - CALL VVD ( A(1,3), -0.37267876361644D0, 1D-12, 'sla_SVD', - : 'A(1,3)', STATUS ) - CALL VVD ( A(1,4), 0.58330405917160D0, 1D-12, 'sla_SVD', - : 'A(1,4)', STATUS ) - CALL VVD ( A(2,1), -0.33693420368121D0, 1D-12, 'sla_SVD', - : 'A(2,1)', STATUS ) - CALL VVD ( A(2,2), 0.48011695963936D0, 1D-12, 'sla_SVD', - : 'A(2,2)', STATUS ) - CALL VVD ( A(2,3), 0.62656568539705D0, 1D-12, 'sla_SVD', - : 'A(2,3)', STATUS ) - CALL VVD ( A(2,4), -0.17479918328198D0, 1D-12, 'sla_SVD', - : 'A(2,4)', STATUS ) - CALL VVD ( A(3,1), -0.44396825906047D0, 1D-12, 'sla_SVD', - : 'A(3,1)', STATUS ) - CALL VVD ( A(3,2), 0.18255923809825D0, 1D-12, 'sla_SVD', - : 'A(3,2)', STATUS ) - CALL VVD ( A(3,3), 0.02228154115994D0, 1D-12, 'sla_SVD', - : 'A(3,3)', STATUS ) - CALL VVD ( A(3,4), -0.51743308030238D0, 1D-12, 'sla_SVD', - : 'A(3,4)', STATUS ) - CALL VVD ( A(4,1), -0.53172583816951D0, 1D-12, 'sla_SVD', - : 'A(4,1)', STATUS ) - CALL VVD ( A(4,2), -0.16537863535943D0, 1D-12, 'sla_SVD', - : 'A(4,2)', STATUS ) - CALL VVD ( A(4,3), -0.61134201569990D0, 1D-12, 'sla_SVD', - : 'A(4,3)', STATUS ) - CALL VVD ( A(4,4), -0.28871221824912D0, 1D-12, 'sla_SVD', - : 'A(4,4)', STATUS ) - CALL VVD ( A(5,1), -0.60022523682867D0, 1D-12, 'sla_SVD', - : 'A(5,1)', STATUS ) - CALL VVD ( A(5,2), -0.50081781972404D0, 1D-12, 'sla_SVD', - : 'A(5,2)', STATUS ) - CALL VVD ( A(5,3), 0.30706750690326D0, 1D-12, 'sla_SVD', - : 'A(5,3)', STATUS ) - CALL VVD ( A(5,4), 0.52736124480318D0, 1D-12, 'sla_SVD', - : 'A(5,4)', STATUS ) - - CALL VVD ( W(1), 4.57362714220621D0, 1D-12, 'sla_SVD', - : 'W(1)', STATUS ) - CALL VVD ( W(2), 1.64056393111226D0, 1D-12, 'sla_SVD', - : 'W(2)', STATUS ) - CALL VVD ( W(3), 0.03999179717447D0, 1D-12, 'sla_SVD', - : 'W(3)', STATUS ) - CALL VVD ( W(4), 0.37267332634218D0, 1D-12, 'sla_SVD', - : 'W(4)', STATUS ) - - CALL VVD ( V(1,1), -0.46531525230679D0, 1D-12, 'sla_SVD', - : 'V(1,1)', STATUS ) - CALL VVD ( V(1,2), 0.41036514115630D0, 1D-12, 'sla_SVD', - : 'V(1,2)', STATUS ) - CALL VVD ( V(1,3), -0.70279526907678D0, 1D-12, 'sla_SVD', - : 'V(1,3)', STATUS ) - CALL VVD ( V(1,4), 0.34808185338758D0, 1D-12, 'sla_SVD', - : 'V(1,4)', STATUS ) - CALL VVD ( V(2,1), -0.80342444002914D0, 1D-12, 'sla_SVD', - : 'V(2,1)', STATUS ) - CALL VVD ( V(2,2), -0.29896472833787D0, 1D-12, 'sla_SVD', - : 'V(2,2)', STATUS ) - CALL VVD ( V(2,3), 0.46592932810178D0, 1D-12, 'sla_SVD', - : 'V(2,3)', STATUS ) - CALL VVD ( V(2,4), 0.21917828721921D0, 1D-12, 'sla_SVD', - : 'V(2,4)', STATUS ) - CALL VVD ( V(3,1), -0.36564497020801D0, 1D-12, 'sla_SVD', - : 'V(3,1)', STATUS ) - CALL VVD ( V(3,2), 0.28066812941896D0, 1D-12, 'sla_SVD', - : 'V(3,2)', STATUS ) - CALL VVD ( V(3,3), -0.03324480702665D0, 1D-12, 'sla_SVD', - : 'V(3,3)', STATUS ) - CALL VVD ( V(3,4), -0.88680546891402D0, 1D-12, 'sla_SVD', - : 'V(3,4)', STATUS ) - CALL VVD ( V(4,1), 0.06553350971918D0, 1D-12, 'sla_SVD', - : 'V(4,1)', STATUS ) - CALL VVD ( V(4,2), 0.81452191085452D0, 1D-12, 'sla_SVD', - : 'V(4,2)', STATUS ) - CALL VVD ( V(4,3), 0.53654771808636D0, 1D-12, 'sla_SVD', - : 'V(4,3)', STATUS ) - CALL VVD ( V(4,4), 0.21065602782287D0, 1D-12, 'sla_SVD', - : 'V(4,4)', STATUS ) - - CALL sla_SVDSOL ( M, N, MP, NP, B, A, W, V, WORK, X ) - - CALL VVD ( X(1), 23D0, 1D-12, 'sla_SVDSOL', 'X(1)', STATUS ) - CALL VVD ( X(2), -3D0, 1D-12, 'sla_SVDSOL', 'X(2)', STATUS ) - CALL VVD ( X(3), -11D0, 1D-12, 'sla_SVDSOL', 'X(3)', STATUS ) - CALL VVD ( X(4), 13D0, 1D-12, 'sla_SVDSOL', 'X(4)', STATUS ) - - CALL sla_SVDCOV ( N, NP, NC, W, V, WORK, C ) - - CALL VVD ( C(1,1), 309.77269378273270D0, 1D-10, - : 'sla_SVDCOV', 'C(1,1)', STATUS ) - CALL VVD ( C(1,2), -204.22043941662150D0, 1D-10, - : 'sla_SVDCOV', 'C(1,2)', STATUS ) - CALL VVD ( C(1,3), 12.43704316907477D0, 1D-10, - : 'sla_SVDCOV', 'C(1,3)', STATUS ) - CALL VVD ( C(1,4), -235.12299986206710D0, 1D-10, - : 'sla_SVDCOV', 'C(1,4)', STATUS ) - CALL VVD ( C(2,1), -204.22043941662150D0, 1D-10, - : 'sla_SVDCOV', 'C(2,1)', STATUS ) - CALL VVD ( C(2,2), 136.14695961108110D0, 1D-10, - : 'sla_SVDCOV', 'C(2,2)', STATUS ) - CALL VVD ( C(2,3), -11.10167446246327D0, 1D-10, - : 'sla_SVDCOV', 'C(2,3)', STATUS ) - CALL VVD ( C(2,4), 156.54937371198730D0, 1D-10, - : 'sla_SVDCOV', 'C(2,4)', STATUS ) - CALL VVD ( C(3,1), 12.43704316907477D0, 1D-10, - : 'sla_SVDCOV', 'C(3,1)', STATUS ) - CALL VVD ( C(3,2), -11.10167446246327D0, 1D-10, - : 'sla_SVDCOV', 'C(3,2)', STATUS ) - CALL VVD ( C(3,3), 6.38909830090602D0, 1D-10, - : 'sla_SVDCOV', 'C(3,3)', STATUS ) - CALL VVD ( C(3,4), -12.41424302586736D0, 1D-10, - : 'sla_SVDCOV', 'C(3,4)', STATUS ) - CALL VVD ( C(4,1), -235.12299986206710D0, 1D-10, - : 'sla_SVDCOV', 'C(4,1)', STATUS ) - CALL VVD ( C(4,2), 156.54937371198730D0, 1D-10, - : 'sla_SVDCOV', 'C(4,2)', STATUS ) - CALL VVD ( C(4,3), -12.41424302586736D0, 1D-10, - : 'sla_SVDCOV', 'C(4,3)', STATUS ) - CALL VVD ( C(4,4), 180.56719842359560D0, 1D-10, - : 'sla_SVDCOV', 'C(4,4)', STATUS ) - - END - - SUBROUTINE T_TP ( STATUS ) -*+ -* - - - - - - -* T _ T P -* - - - - - - -* -* Test spherical tangent-planD-projection routines: -* -* sla_S2TP sla_DS2TP sla_DTPS2C -* sla_TP2S sla_DTP2S sla_TPS2C -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: all the above, plus VVD and VIV. -* -* Last revision: 10 July 2000 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - REAL R0, D0, R1, D1, X, Y, R2, D2, R01, D01, R02, D02 - DOUBLE PRECISION DR0, DD0, DR1, DD1, DX, DY, DR2, DD2, DR01, - : DD01, DR02, DD02 - - R0 = 3.1E0 - D0 = -0.9E0 - R1 = R0 + 0.2E0 - D1 = D0 - 0.1E0 - CALL sla_S2TP ( R1, D1, R0, D0, X, Y, J ) - CALL VVD ( DBLE( X ), 0.1086112301590404D0, 1D-6, 'sla_S2TP', - : 'X', STATUS ) - CALL VVD ( DBLE( Y ), -0.1095506200711452D0, 1D-6, 'sla_S2TP', - : 'Y', STATUS ) - CALL VIV ( J, 0, 'sla_S2TP', 'J', STATUS ) - CALL sla_TP2S ( X, Y, R0, D0, R2, D2 ) - CALL VVD ( DBLE( ( R2 - R1 ) ), 0D0, 1D-6, 'sla_TP2S', - : 'R', STATUS ) - CALL VVD ( DBLE( ( D2 - D1 ) ), 0D0, 1D-6, 'sla_TP2S', - : 'D', STATUS ) - CALL sla_TPS2C ( X, Y, R2, D2, R01, D01, R02, D02, J ) - CALL VVD ( DBLE( R01 ), 3.1D0, 1D-6, 'sla_TPS2C', - : 'R1', STATUS ) - CALL VVD ( DBLE( D01 ), -0.9D0, 1D-6, 'sla_TPS2C', - : 'D1', STATUS ) - CALL VVD ( DBLE( R02 ), 0.3584073464102072D0, 1D-6, 'sla_TPS2C', - : 'R2', STATUS ) - CALL VVD ( DBLE( D02 ), -2.023361658234722D0, 1D-6, 'sla_TPS2C', - : 'D2', STATUS ) - CALL VIV ( J, 1, 'sla_TPS2C', 'N', STATUS ) - - DR0 = 3.1D0 - DD0 = -0.9D0 - DR1 = DR0 + 0.2D0 - DD1 = DD0 - 0.1D0 - CALL sla_DS2TP ( DR1, DD1, DR0, DD0, DX, DY, J ) - CALL VVD ( DX, 0.1086112301590404D0, 1D-12, 'sla_DS2TP', - : 'X', STATUS ) - CALL VVD ( DY, -0.1095506200711452D0, 1D-12, 'sla_DS2TP', - : 'Y', STATUS ) - CALL VIV ( J, 0, 'sla_DS2TP', 'J', STATUS ) - CALL sla_DTP2S ( DX, DY, DR0, DD0, DR2, DD2 ) - CALL VVD ( DR2 - DR1, 0D0, 1D-12, 'sla_DTP2S', 'R', STATUS ) - CALL VVD ( DD2 - DD1, 0D0, 1D-12, 'sla_DTP2S', 'D', STATUS ) - CALL sla_DTPS2C ( DX, DY, DR2, DD2, DR01, DD01, DR02, DD02, J ) - CALL VVD ( DR01, 3.1D0, 1D-12, 'sla_DTPS2C', 'R1', STATUS ) - CALL VVD ( DD01, -0.9D0, 1D-12, 'sla_DTPS2C', 'D1', STATUS ) - CALL VVD ( DR02, 0.3584073464102072D0, 1D-12, 'sla_DTPS2C', - : 'R2', STATUS ) - CALL VVD ( DD02, -2.023361658234722D0, 1D-12, 'sla_DTPS2C', - : 'D2', STATUS ) - CALL VIV ( J, 1, 'sla_DTPS2C', 'N', STATUS ) - - END - - SUBROUTINE T_TPV ( STATUS ) -*+ -* - - - - - - -* T _ T P V -* - - - - - - -* -* Test Cartesian tangent-planD-projection routines: -* -* sla_TP2V sla_V2TP sla_TPV2C -* sla_DTP2V sla_DV2TP sla_DTPV2C -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: all the above, plus VVD and VIV. -* -* Last revision: 21 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER J - REAL RXI, RETA, RV(3), RV0(3), RTXI, RTETA, RTV(3), - : RTV01(3), RTV02(3) - DOUBLE PRECISION XI, ETA, X, Y, Z, V(3), V0(3), TXI, TETA, - : TV(3), TV01(3), TV02(3) - - XI = -0.1D0 - ETA = 0.055D0 - RXI = SNGL( XI ) - RETA = SNGL( ETA ) - - X = -0.7D0 - Y = -0.13D0 - Z = DSQRT ( 1D0 - X * X - Y * Y ) - RV(1) = SNGL( X ) - RV(2) = SNGL( Y ) - RV(3) = SNGL( Z ) - V(1) = X - V(2) = Y - V(3) = Z - - X = -0.72D0 - Y = -0.16D0 - Z = DSQRT ( 1D0 - X * X - Y * Y ) - RV0(1) = SNGL( X ) - RV0(2) = SNGL( Y ) - RV0(3) = SNGL( Z ) - V0(1) = X - V0(2) = Y - V0(3) = Z - - CALL sla_TP2V ( RXI, RETA, RV0, RTV ) - CALL VVD ( DBLE( RTV(1) ), -0.700887428128D0, 1D-6, 'sla_TP2V', - : 'V(1)', STATUS ) - CALL VVD ( DBLE( RTV(2) ), -0.05397407D0, 1D-6, 'sla_TP2V', - : 'V(2)', STATUS ) - CALL VVD ( DBLE( RTV(3) ), 0.711226836562D0, 1D-6, 'sla_TP2V', - : 'V(3)', STATUS ) - - CALL sla_DTP2V ( XI, ETA, V0, TV ) - CALL VVD ( TV(1), -0.7008874281280771D0, 1D-13, 'sla_DTP2V', - : 'V(1)', STATUS ) - CALL VVD ( TV(2), -0.05397406827952735D0, 1D-13, 'sla_DTP2V', - : 'V(2)', STATUS ) - CALL VVD ( TV(3), 0.7112268365615617D0, 1D-13, 'sla_DTP2V', - : 'V(3)', STATUS ) - - CALL sla_V2TP ( RV, RV0, RTXI, RTETA, J) - CALL VVD ( DBLE( RTXI ), -0.02497229197D0, 1D-6, 'sla_V2TP', - : 'XI', STATUS ) - CALL VVD ( DBLE( RTETA ), 0.03748140764D0, 1D-6, 'sla_V2TP', - : 'ETA', STATUS ) - CALL VIV ( J, 0, 'sla_V2TP', 'J', STATUS ) - - CALL sla_DV2TP ( V, V0, TXI, TETA, J ) - CALL VVD ( TXI, -0.02497229197023852D0, 1D-13, 'sla_DV2TP', - : 'XI', STATUS ) - CALL VVD ( TETA, 0.03748140764224765D0, 1D-13, 'sla_DV2TP', - : 'ETA', STATUS ) - CALL VIV ( J, 0, 'sla_DV2TP', 'J', STATUS ) - - CALL sla_TPV2C ( RXI, RETA, RV, RTV01, RTV02, J ) - CALL VVD ( DBLE( RTV01(1) ), -0.7074573732537283D0, 1D-6, - : 'sla_TPV2C', 'V01(1)', STATUS ) - CALL VVD ( DBLE( RTV01(2) ), -0.2372965765309941D0, 1D-6, - : 'sla_TPV2C', 'V01(2)', STATUS ) - CALL VVD ( DBLE( RTV01(3) ), 0.6657284730245545D0, 1D-6, - : 'sla_TPV2C', 'V01(3)', STATUS ) - CALL VVD ( DBLE( RTV02(1) ), -0.6680480104758149D0, 1D-6, - : 'sla_TPV2C', 'V02(1)', STATUS ) - CALL VVD ( DBLE( RTV02(2) ), -0.02915588494045333D0, 1D-6, - : 'sla_TPV2C', 'V02(2)', STATUS ) - CALL VVD ( DBLE( RTV02(3) ), 0.7435467638774610D0, 1D-6, - : 'sla_TPV2C', 'V02(3)', STATUS ) - CALL VIV ( J, 1, 'sla_TPV2C', 'N', STATUS ) - - CALL sla_DTPV2C ( XI, ETA, V, TV01, TV02, J ) - CALL VVD ( TV01(1), -0.7074573732537283D0, 1D-13, 'sla_DTPV2C', - : 'V01(1)', STATUS ) - CALL VVD ( TV01(2), -0.2372965765309941D0, 1D-13, 'sla_DTPV2C', - : 'V01(2)', STATUS ) - CALL VVD ( TV01(3), 0.6657284730245545D0, 1D-13, 'sla_DTPV2C', - : 'V01(3)', STATUS ) - CALL VVD ( TV02(1), -0.6680480104758149D0, 1D-13, 'sla_DTPV2C', - : 'V02(1)', STATUS ) - CALL VVD ( TV02(2), -0.02915588494045333D0, 1D-13, 'sla_DTPV2C', - : 'V02(2)', STATUS ) - CALL VVD ( TV02(3), 0.7435467638774610D0, 1D-13, 'sla_DTPV2C', - : 'V02(3)', STATUS ) - CALL VIV ( J, 1, 'sla_DTPV2C', 'N', STATUS ) - - END - - SUBROUTINE T_VECMAT ( STATUS ) -*+ -* - - - - - - - - - -* T _ V E C M A T -* - - - - - - - - - -* -* Test all the 3-vector and 3x3 matrix routines: -* -* sla_AV2M sla_DAV2M -* sla_CC2S sla_DCC2S -* sla_CS2C sla_DCS2C -* sla_EULER sla_DEULER -* sla_IMXV sla_DIMXV -* sla_M2AV sla_DM2AV -* sla_MXM sla_DMXM -* sla_MXV sla_DMXV -* sla_VDV sla_DVDV -* sla_VN sla_DVN -* sla_VXV sla_DVXV -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: all the above, plus VVD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - INTEGER I - REAL sla_VDV - REAL AV(3), RM1(3,3), RM2(3,3), RM(3,3), V1(3), V2(3), - : V3(3), V4(3), V5(3), VM, V6(3), V7(3) - DOUBLE PRECISION sla_DVDV - DOUBLE PRECISION DAV(3), DRM1(3,3), DRM2(3,3), DRM(3,3), - : DV1(3), DV2(3), DV3(3), DV4(3), DV5(3), - : DVM, DV6(3), DV7(3) - - -* Make a rotation matrix. - AV(1) = -0.123E0 - AV(2) = 0.0987E0 - AV(3) = 0.0654E0 - CALL sla_AV2M ( AV, RM1 ) - CALL VVD ( DBLE( RM1(1,1) ), 0.9930075842721269D0, - : 1D-6, 'sla_AV2M', '11', STATUS ) - CALL VVD ( DBLE( RM1(1,2) ), 0.05902743090199868D0, - : 1D-6, 'sla_AV2M', '12', STATUS ) - CALL VVD ( DBLE( RM1(1,3) ), -0.1022335560329612D0, - : 1D-6, 'sla_AV2M', '13', STATUS ) - CALL VVD ( DBLE( RM1(2,1) ), -0.07113807138648245D0, - : 1D-6, 'sla_AV2M', '21', STATUS ) - CALL VVD ( DBLE( RM1(2,2) ), 0.9903204657727545D0, - : 1D-6, 'sla_AV2M', '22', STATUS ) - CALL VVD ( DBLE( RM1(2,3) ), -0.1191836812279541D0, - : 1D-6, 'sla_AV2M', '23', STATUS ) - CALL VVD ( DBLE( RM1(3,1) ), 0.09420887631983825D0, - : 1D-6, 'sla_AV2M', '31', STATUS ) - CALL VVD ( DBLE( RM1(3,2) ), 0.1256229973879967D0, - : 1D-6, 'sla_AV2M', '32', STATUS ) - CALL VVD ( DBLE( RM1(3,3) ), 0.9875948309655174D0, - : 1D-6, 'sla_AV2M', '33', STATUS ) - -* Make another. - CALL sla_EULER ( 'YZY', 2.345E0, -0.333E0, 2.222E0, RM2 ) - CALL VVD ( DBLE( RM2(1,1) ), -0.1681574770810878D0, - : 1D-6, 'sla_EULER', '11', STATUS ) - CALL VVD ( DBLE( RM2(1,2) ), 0.1981362273264315D0, - : 1D-6, 'sla_EULER', '12', STATUS ) - CALL VVD ( DBLE( RM2(1,3) ), 0.9656423242187410D0, - : 1D-6, 'sla_EULER', '13', STATUS ) - CALL VVD ( DBLE( RM2(2,1) ), -0.2285369373983370D0, - : 1D-6, 'sla_EULER', '21', STATUS ) - CALL VVD ( DBLE( RM2(2,2) ), 0.9450659587140423D0, - : 1D-6, 'sla_EULER', '22', STATUS ) - CALL VVD ( DBLE( RM2(2,3) ), -0.2337117924378156D0, - : 1D-6, 'sla_EULER', '23', STATUS ) - CALL VVD ( DBLE( RM2(3,1) ), -0.9589024617479674D0, - : 1D-6, 'sla_EULER', '31', STATUS ) - CALL VVD ( DBLE( RM2(3,2) ), -0.2599853247796050D0, - : 1D-6, 'sla_EULER', '32', STATUS ) - CALL VVD ( DBLE( RM2(3,3) ), -0.1136384607117296D0, - : 1D-6, 'sla_EULER', '33', STATUS ) - -* Combine them. - CALL sla_MXM ( RM2, RM1, RM ) - CALL VVD ( DBLE( RM(1,1) ), -0.09010460088585805D0, - : 1D-6, 'sla_MXM', '11', STATUS ) - CALL VVD ( DBLE( RM(1,2) ), 0.3075993402463796D0, - : 1D-6, 'sla_MXM', '12', STATUS ) - CALL VVD ( DBLE( RM(1,3) ), 0.9472400998581048D0, - : 1D-6, 'sla_MXM', '13', STATUS ) - CALL VVD ( DBLE( RM(2,1) ), -0.3161868071070688D0, - : 1D-6, 'sla_MXM', '21', STATUS ) - CALL VVD ( DBLE( RM(2,2) ), 0.8930686362478707D0, - : 1D-6, 'sla_MXM', '22', STATUS ) - CALL VVD ( DBLE( RM(2,3) ),-0.3200848543149236D0, - : 1D-6, 'sla_MXM', '23', STATUS ) - CALL VVD ( DBLE( RM(3,1) ),-0.9444083141897035D0, - : 1D-6, 'sla_MXM', '31', STATUS ) - CALL VVD ( DBLE( RM(3,2) ),-0.3283459407855694D0, - : 1D-6, 'sla_MXM', '32', STATUS ) - CALL VVD ( DBLE( RM(3,3) ), 0.01678926022795169D0, - : 1D-6, 'sla_MXM', '33', STATUS ) - -* Create a vector. - CALL sla_CS2C ( 3.0123E0, -0.999E0, V1 ) - CALL VVD ( DBLE( V1(1) ), -0.5366267667260525D0, - : 1D-6, 'sla_CS2C', 'X', STATUS ) - CALL VVD ( DBLE( V1(2) ), 0.06977111097651444D0, - : 1D-6, 'sla_CS2C', 'Y', STATUS ) - CALL VVD ( DBLE( V1(3) ), -0.8409302618566215D0, - : 1D-6, 'sla_CS2C', 'Z', STATUS ) - -* Rotate it using the two matrices sequentially. - CALL sla_MXV ( RM1, V1, V2 ) - CALL sla_MXV ( RM2, V2, V3 ) - CALL VVD ( DBLE( V3(1) ), -0.7267487768696160D0, - : 1D-6, 'sla_MXV', 'X', STATUS ) - CALL VVD ( DBLE( V3(2) ), 0.5011537352639822D0, - : 1D-6, 'sla_MXV', 'Y', STATUS ) - CALL VVD ( DBLE( V3(3) ), 0.4697671220397141D0, - : 1D-6, 'sla_MXV', 'Z', STATUS ) - -* Derotate it using the combined matrix. - CALL sla_IMXV ( RM, V3, V4 ) - CALL VVD ( DBLE( V4(1) ), -0.5366267667260526D0, - : 1D-6, 'sla_IMXV', 'X', STATUS ) - CALL VVD ( DBLE( V4(2) ), 0.06977111097651445D0, - : 1D-6, 'sla_IMXV', 'Y', STATUS ) - CALL VVD ( DBLE( V4(3) ), -0.8409302618566215D0, - : 1D-6, 'sla_IMXV', 'Z', STATUS ) - -* Convert the combined matrix into an axial vector. - CALL sla_M2AV ( RM, V5 ) - CALL VVD ( DBLE( V5(1) ), 0.006889040510209034D0, - : 1D-6, 'sla_M2AV', 'X', STATUS ) - CALL VVD ( DBLE( V5(2) ), -1.577473205461961D0, - : 1D-6, 'sla_M2AV', 'Y', STATUS ) - CALL VVD ( DBLE( V5(3) ), 0.5201843672856759D0, - : 1D-6, 'sla_M2AV', 'Z', STATUS ) - -* Multiply it by a scalar and then normalize. - DO I = 1, 3 - V5(I) = V5(I) * 1000.0 - END DO - - CALL sla_VN ( V5, V6, VM ) - CALL VVD ( DBLE( V6(1) ), 0.004147420704640065D0, - : 1D-6, 'sla_VN', 'X', STATUS ) - CALL VVD ( DBLE( V6(2) ), -0.9496888606842218D0, - : 1D-6, 'sla_VN', 'Y', STATUS ) - CALL VVD ( DBLE( V6(3) ), 0.3131674740355448D0, - : 1D-6, 'sla_VN', 'Z', STATUS ) - CALL VVD ( DBLE( VM ), 1661.042127339937D0, - : 1D-3, 'sla_VN', 'M', STATUS ) - -* Dot product with the original vector. - CALL VVD ( DBLE( sla_VDV ( V6, V1 ) ), - : -0.3318384698006295D0, 1D-6, 'sla_VN', ' ', STATUS ) - -* Cross product with the original vector. - CALL sla_VXV (V6, V1, V7 ) - CALL VVD ( DBLE( V7(1) ), 0.7767720597123304D0, - : 1D-6, 'sla_VXV', 'X', STATUS ) - CALL VVD ( DBLE( V7(2) ), -0.1645663574562769D0, - : 1D-6, 'sla_VXV', 'Y', STATUS ) - CALL VVD ( DBLE( V7(3) ), -0.5093390925544726D0, - : 1D-6, 'sla_VXV', 'Z', STATUS ) - -* Same in double precision. - - DAV(1) = -0.123D0 - DAV(2) = 0.0987D0 - DAV(3) = 0.0654D0 - CALL sla_DAV2M ( DAV, DRM1 ) - CALL VVD ( DRM1(1,1), 0.9930075842721269D0, 1D-12, - : 'sla_DAV2M', '11', STATUS ) - CALL VVD ( DRM1(1,2), 0.05902743090199868D0, 1D-12, - : 'sla_DAV2M', '12', STATUS ) - CALL VVD ( DRM1(1,3), -0.1022335560329612D0, 1D-12, - : 'sla_DAV2M', '13', STATUS ) - CALL VVD ( DRM1(2,1), -0.07113807138648245D0, 1D-12, - : 'sla_DAV2M', '21', STATUS ) - CALL VVD ( DRM1(2,2), 0.9903204657727545D0, 1D-12, - : 'sla_DAV2M', '22', STATUS ) - CALL VVD ( DRM1(2,3), -0.1191836812279541D0, 1D-12, - : 'sla_DAV2M', '23', STATUS ) - CALL VVD ( DRM1(3,1), 0.09420887631983825D0, 1D-12, - : 'sla_DAV2M', '31', STATUS ) - CALL VVD ( DRM1(3,2), 0.1256229973879967D0, 1D-12, - : 'sla_DAV2M', '32', STATUS ) - CALL VVD ( DRM1(3,3), 0.9875948309655174D0, 1D-12, - : 'sla_DAV2M', '33', STATUS ) - - CALL sla_DEULER ( 'YZY', 2.345D0, -0.333D0, 2.222D0, DRM2 ) - CALL VVD ( DRM2(1,1), -0.1681574770810878D0, 1D-12, - : 'sla_DEULER', '11', STATUS ) - CALL VVD ( DRM2(1,2), 0.1981362273264315D0, 1D-12, - : 'sla_DEULER', '12', STATUS ) - CALL VVD ( DRM2(1,3), 0.9656423242187410D0, 1D-12, - : 'sla_DEULER', '13', STATUS ) - CALL VVD ( DRM2(2,1), -0.2285369373983370D0, 1D-12, - : 'sla_DEULER', '21', STATUS ) - CALL VVD ( DRM2(2,2), 0.9450659587140423D0, 1D-12, - : 'sla_DEULER', '22', STATUS ) - CALL VVD ( DRM2(2,3), -0.2337117924378156D0, 1D-12, - : 'sla_DEULER', '23', STATUS ) - CALL VVD ( DRM2(3,1), -0.9589024617479674D0, 1D-12, - : 'sla_DEULER', '31', STATUS ) - CALL VVD ( DRM2(3,2), -0.2599853247796050D0, 1D-12, - : 'sla_DEULER', '32', STATUS ) - CALL VVD ( DRM2(3,3), -0.1136384607117296D0, 1D-12, - : 'sla_DEULER', '33', STATUS ) - - CALL sla_DMXM ( DRM2, DRM1, DRM ) - CALL VVD ( DRM(1,1), -0.09010460088585805D0, 1D-12, - : 'sla_DMXM', '11', STATUS ) - CALL VVD ( DRM(1,2), 0.3075993402463796D0, 1D-12, - : 'sla_DMXM', '12', STATUS ) - CALL VVD ( DRM(1,3), 0.9472400998581048D0, 1D-12, - : 'sla_DMXM', '13', STATUS ) - CALL VVD ( DRM(2,1), -0.3161868071070688D0, 1D-12, - : 'sla_DMXM', '21', STATUS ) - CALL VVD ( DRM(2,2), 0.8930686362478707D0, 1D-12, - : 'sla_DMXM', '22', STATUS ) - CALL VVD ( DRM(2,3), -0.3200848543149236D0, 1D-12, - : 'sla_DMXM', '23', STATUS ) - CALL VVD ( DRM(3,1), -0.9444083141897035D0, 1D-12, - : 'sla_DMXM', '31', STATUS ) - CALL VVD ( DRM(3,2), -0.3283459407855694D0, 1D-12, - : 'sla_DMXM', '32', STATUS ) - CALL VVD ( DRM(3,3), 0.01678926022795169D0, 1D-12, - : 'sla_DMXM', '33', STATUS ) - - CALL sla_DCS2C ( 3.0123D0, -0.999D0, DV1 ) - CALL VVD ( DV1(1), -0.5366267667260525D0, 1D-12, - : 'sla_DCS2C', 'X', STATUS ) - CALL VVD ( DV1(2), 0.06977111097651444D0, 1D-12, - : 'sla_DCS2C', 'Y', STATUS ) - CALL VVD ( DV1(3), -0.8409302618566215D0, 1D-12, - : 'sla_DCS2C', 'Z', STATUS ) - - CALL sla_DMXV ( DRM1, DV1, DV2 ) - CALL sla_DMXV ( DRM2, DV2, DV3 ) - CALL VVD ( DV3(1), -0.7267487768696160D0, 1D-12, - : 'sla_DMXV', 'X', STATUS ) - CALL VVD ( DV3(2), 0.5011537352639822D0, 1D-12, - : 'sla_DMXV', 'Y', STATUS ) - CALL VVD ( DV3(3), 0.4697671220397141D0, 1D-12, - : 'sla_DMXV', 'Z', STATUS ) - - CALL sla_DIMXV ( DRM, DV3, DV4 ) - CALL VVD ( DV4(1), -0.5366267667260526D0, 1D-12, - : 'sla_DIMXV', 'X', STATUS ) - CALL VVD ( DV4(2), 0.06977111097651445D0, 1D-12, - : 'sla_DIMXV', 'Y', STATUS ) - CALL VVD ( DV4(3), -0.8409302618566215D0, 1D-12, - : 'sla_DIMXV', 'Z', STATUS ) - - CALL sla_DM2AV ( DRM, DV5 ) - CALL VVD ( DV5(1), 0.006889040510209034D0, 1D-12, - : 'sla_DM2AV', 'X', STATUS ) - CALL VVD ( DV5(2), -1.577473205461961D0, 1D-12, - : 'sla_DM2AV', 'Y', STATUS ) - CALL VVD ( DV5(3), 0.5201843672856759D0, 1D-12, - : 'sla_DM2AV', 'Z', STATUS ) - - DO I = 1, 3 - DV5(I) = DV5(I) * 1000D0 - END DO - - CALL sla_DVN ( DV5, DV6, DVM ) - CALL VVD ( DV6(1), 0.004147420704640065D0, 1D-12, - : 'sla_DVN', 'X', STATUS ) - CALL VVD ( DV6(2), -0.9496888606842218D0, 1D-12, - : 'sla_DVN', 'Y', STATUS ) - CALL VVD ( DV6(3), 0.3131674740355448D0, 1D-12, - : 'sla_DVN', 'Z', STATUS ) - CALL VVD ( DVM, 1661.042127339937D0, 1D-9, 'sla_DVN', - : 'M', STATUS ) - - CALL VVD ( sla_DVDV ( DV6, DV1 ), -0.3318384698006295D0, - : 1D-12, 'sla_DVN', ' ', STATUS ) - - CALL sla_DVXV (DV6, DV1, DV7 ) - CALL VVD ( DV7(1), 0.7767720597123304D0, 1D-12, - : 'sla_DVXV', 'X', STATUS ) - CALL VVD ( DV7(2), -0.1645663574562769D0, 1D-12, - : 'sla_DVXV', 'Y', STATUS ) - CALL VVD ( DV7(3), -0.5093390925544726D0, 1D-12, - : 'sla_DVXV', 'Z', STATUS ) - - END - - SUBROUTINE T_ZD ( STATUS ) -*+ -* - - - - - -* T _ Z D -* - - - - - -* -* Test sla_ZD routine. -* -* Returned: -* STATUS LOGICAL .TRUE. = success, .FALSE. = fail -* -* Called: VVD, sla_ZD. -* -* Last revision: 22 October 2005 -* -* Copyright CLRC/Starlink. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - LOGICAL STATUS - - DOUBLE PRECISION sla_ZD - - - CALL VVD ( sla_ZD ( -1.023D0, -0.876D0, -0.432D0 ), - : 0.8963914139430839D0, 1D-12, 'sla_ZD', ' ', STATUS ) - - END diff --git a/src/slalib/smat.f b/src/slalib/smat.f deleted file mode 100644 index 3966a7462..000000000 --- a/src/slalib/smat.f +++ /dev/null @@ -1,158 +0,0 @@ - SUBROUTINE sla_SMAT (N, A, Y, D, JF, IW) -*+ -* - - - - - -* S M A T -* - - - - - -* -* Matrix inversion & solution of simultaneous equations -* (single precision) -* -* For the set of n simultaneous equations in n unknowns: -* A.Y = X -* -* where: -* A is a non-singular N x N matrix -* Y is the vector of N unknowns -* X is the known vector -* -* SMATRX computes: -* the inverse of matrix A -* the determinant of matrix A -* the vector of N unknowns -* -* Arguments: -* -* symbol type dimension before after -* -* N int no. of unknowns unchanged -* A real (N,N) matrix inverse -* Y real (N) vector solution -* D real - determinant -* * JF int - singularity flag -* IW int (N) - workspace -* -* * JF is the singularity flag. If the matrix is non-singular, -* JF=0 is returned. If the matrix is singular, JF=-1 & D=0.0 are -* returned. In the latter case, the contents of array A on return -* are undefined. -* -* Algorithm: -* Gaussian elimination with partial pivoting. -* -* Speed: -* Very fast. -* -* Accuracy: -* Fairly accurate - errors 1 to 4 times those of routines optimised -* for accuracy. -* -* Note: replaces the obsolete sla_SMATRX routine. -* -* P.T.Wallace Starlink 10 September 1990 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER N - REAL A(N,N),Y(N),D - INTEGER JF - INTEGER IW(N) - - REAL SFA - PARAMETER (SFA=1E-20) - - INTEGER K,IMX,I,J,NP1MK,KI - REAL AMX,T,AKK,YK,AIK - - - JF=0 - D=1.0 - DO K=1,N - AMX=ABS(A(K,K)) - IMX=K - IF (K.NE.N) THEN - DO I=K+1,N - T=ABS(A(I,K)) - IF (T.GT.AMX) THEN - AMX=T - IMX=I - END IF - END DO - END IF - IF (AMX.LT.SFA) THEN - JF=-1 - ELSE - IF (IMX.NE.K) THEN - DO J=1,N - T=A(K,J) - A(K,J)=A(IMX,J) - A(IMX,J)=T - END DO - T=Y(K) - Y(K)=Y(IMX) - Y(IMX)=T - D=-D - END IF - IW(K)=IMX - AKK=A(K,K) - D=D*AKK - IF (ABS(D).LT.SFA) THEN - JF=-1 - ELSE - AKK=1.0/AKK - A(K,K)=AKK - DO J=1,N - IF (J.NE.K) A(K,J)=A(K,J)*AKK - END DO - YK=Y(K)*AKK - Y(K)=YK - DO I=1,N - AIK=A(I,K) - IF (I.NE.K) THEN - DO J=1,N - IF (J.NE.K) A(I,J)=A(I,J)-AIK*A(K,J) - END DO - Y(I)=Y(I)-AIK*YK - END IF - END DO - DO I=1,N - IF (I.NE.K) A(I,K)=-A(I,K)*AKK - END DO - END IF - END IF - END DO - IF (JF.NE.0) THEN - D=0.0 - ELSE - DO K=1,N - NP1MK=N+1-K - KI=IW(NP1MK) - IF (NP1MK.NE.KI) THEN - DO I=1,N - T=A(I,NP1MK) - A(I,NP1MK)=A(I,KI) - A(I,KI)=T - END DO - END IF - END DO - END IF - END diff --git a/src/slalib/subet.f b/src/slalib/subet.f deleted file mode 100644 index 461a6bce8..000000000 --- a/src/slalib/subet.f +++ /dev/null @@ -1,83 +0,0 @@ - SUBROUTINE sla_SUBET (RC, DC, EQ, RM, DM) -*+ -* - - - - - - -* S U B E T -* - - - - - - -* -* Remove the E-terms (elliptic component of annual aberration) -* from a pre IAU 1976 catalogue RA,Dec to give a mean place -* (double precision) -* -* Given: -* RC,DC dp RA,Dec (radians) with E-terms included -* EQ dp Besselian epoch of mean equator and equinox -* -* Returned: -* RM,DM dp RA,Dec (radians) without E-terms -* -* Called: -* sla_ETRMS, sla_DCS2C, sla_,DVDV, sla_DCC2S, sla_DRANRM -* -* Explanation: -* Most star positions from pre-1984 optical catalogues (or -* derived from astrometry using such stars) embody the -* E-terms. This routine converts such a position to a -* formal mean place (allowing, for example, comparison with a -* pulsar timing position). -* -* Reference: -* Explanatory Supplement to the Astronomical Ephemeris, -* section 2D, page 48. -* -* P.T.Wallace Starlink 10 May 1990 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION RC,DC,EQ,RM,DM - - DOUBLE PRECISION sla_DRANRM,sla_DVDV - DOUBLE PRECISION A(3),V(3),F - - INTEGER I - - - -* E-terms - CALL sla_ETRMS(EQ,A) - -* Spherical to Cartesian - CALL sla_DCS2C(RC,DC,V) - -* Include the E-terms - F=1D0+sla_DVDV(V,A) - DO I=1,3 - V(I)=F*V(I)-A(I) - END DO - -* Cartesian to spherical - CALL sla_DCC2S(V,RM,DM) - -* Bring RA into conventional range - RM=sla_DRANRM(RM) - - END diff --git a/src/slalib/supgal.f b/src/slalib/supgal.f deleted file mode 100644 index a149e79c4..000000000 --- a/src/slalib/supgal.f +++ /dev/null @@ -1,96 +0,0 @@ - SUBROUTINE sla_SUPGAL (DSL, DSB, DL, DB) -*+ -* - - - - - - - -* S U P G A L -* - - - - - - - -* -* Transformation from de Vaucouleurs supergalactic coordinates -* to IAU 1958 galactic coordinates (double precision) -* -* Given: -* DSL,DSB dp supergalactic longitude and latitude -* -* Returned: -* DL,DB dp galactic longitude and latitude L2,B2 -* -* (all arguments are radians) -* -* Called: -* sla_DCS2C, sla_DIMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE -* -* References: -* -* de Vaucouleurs, de Vaucouleurs, & Corwin, Second Reference -* Catalogue of Bright Galaxies, U. Texas, page 8. -* -* Systems & Applied Sciences Corp., Documentation for the -* machine-readable version of the above catalogue, -* Contract NAS 5-26490. -* -* (These two references give different values for the galactic -* longitude of the supergalactic origin. Both are wrong; the -* correct value is L2=137.37.) -* -* P.T.Wallace Starlink March 1986 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DSL,DSB,DL,DB - - DOUBLE PRECISION sla_DRANRM,sla_DRANGE - - DOUBLE PRECISION V1(3),V2(3) - -* -* System of supergalactic coordinates: -* -* SGL SGB L2 B2 (deg) -* - +90 47.37 +6.32 -* 0 0 - 0 -* -* Galactic to supergalactic rotation matrix: -* - DOUBLE PRECISION RMAT(3,3) - DATA RMAT(1,1),RMAT(1,2),RMAT(1,3), - : RMAT(2,1),RMAT(2,2),RMAT(2,3), - : RMAT(3,1),RMAT(3,2),RMAT(3,3)/ - : -0.735742574804D0,+0.677261296414D0,+0.000000000000D0, - : -0.074553778365D0,-0.080991471307D0,+0.993922590400D0, - : +0.673145302109D0,+0.731271165817D0,+0.110081262225D0/ - - - -* Spherical to Cartesian - CALL sla_DCS2C(DSL,DSB,V1) - -* Supergalactic to galactic - CALL sla_DIMXV(RMAT,V1,V2) - -* Cartesian to spherical - CALL sla_DCC2S(V2,DL,DB) - -* Express in conventional ranges - DL=sla_DRANRM(DL) - DB=sla_DRANGE(DB) - - END diff --git a/src/slalib/svd.f b/src/slalib/svd.f deleted file mode 100644 index 543fb0eb7..000000000 --- a/src/slalib/svd.f +++ /dev/null @@ -1,400 +0,0 @@ - SUBROUTINE sla_SVD (M, N, MP, NP, A, W, V, WORK, JSTAT) -*+ -* - - - - -* S V D -* - - - - -* -* Singular value decomposition (double precision) -* -* This routine expresses a given matrix A as the product of -* three matrices U, W, V: -* -* A = U x W x VT -* -* Where: -* -* A is any M (rows) x N (columns) matrix, where M.GE.N -* U is an M x N column-orthogonal matrix -* W is an N x N diagonal matrix with W(I,I).GE.0 -* VT is the transpose of an N x N orthogonal matrix -* -* Note that M and N, above, are the LOGICAL dimensions of the -* matrices and vectors concerned, which can be located in -* arrays of larger PHYSICAL dimensions, given by MP and NP. -* -* Given: -* M,N i numbers of rows and columns in matrix A -* MP,NP i physical dimensions of array containing matrix A -* A d(MP,NP) array containing MxN matrix A -* -* Returned: -* A d(MP,NP) array containing MxN column-orthogonal matrix U -* W d(N) NxN diagonal matrix W (diagonal elements only) -* V d(NP,NP) array containing NxN orthogonal matrix V -* WORK d(N) workspace -* JSTAT i 0 = OK, -1 = A wrong shape, >0 = index of W -* for which convergence failed. See note 2, below. -* -* Notes: -* -* 1) V contains matrix V, not the transpose of matrix V. -* -* 2) If the status JSTAT is greater than zero, this need not -* necessarily be treated as a failure. It means that, due to -* chance properties of the matrix A, the QR transformation -* phase of the routine did not fully converge in a predefined -* number of iterations, something that very seldom occurs. -* When this condition does arise, it is possible that the -* elements of the diagonal matrix W have not been correctly -* found. However, in practice the results are likely to -* be trustworthy. Applications should report the condition -* as a warning, but then proceed normally. -* -* References: -* The algorithm is an adaptation of the routine SVD in the EISPACK -* library (Garbow et al 1977, EISPACK Guide Extension, Springer -* Verlag), which is a FORTRAN 66 implementation of the Algol -* routine SVD of Wilkinson & Reinsch 1971 (Handbook for Automatic -* Computation, vol 2, ed Bauer et al, Springer Verlag). These -* references give full details of the algorithm used here. A good -* account of the use of SVD in least squares problems is given in -* Numerical Recipes (Press et al 1986, Cambridge University Press), -* which includes another variant of the EISPACK code. -* -* Last revision: 8 September 2005 -* -* Copyright P.T.Wallace. All rights reserved. -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER M,N,MP,NP - DOUBLE PRECISION A(MP,NP),W(N),V(NP,NP),WORK(N) - INTEGER JSTAT - -* Maximum number of iterations in QR phase - INTEGER ITMAX - PARAMETER (ITMAX=30) - - INTEGER L,L1,I,K,J,K1,ITS,I1 - LOGICAL CANCEL - DOUBLE PRECISION G,SCALE,AN,S,X,F,H,C,Y,Z - - - -* Variable initializations to avoid compiler warnings. - L = 0 - L1 = 0 - -* Check that the matrix is the right shape - IF (M.LT.N) THEN - -* No: error status - JSTAT = -1 - - ELSE - -* Yes: preset the status to OK - JSTAT = 0 - -* -* Householder reduction to bidiagonal form -* ---------------------------------------- - - G = 0D0 - SCALE = 0D0 - AN = 0D0 - DO I=1,N - L = I+1 - WORK(I) = SCALE*G - G = 0D0 - S = 0D0 - SCALE = 0D0 - IF (I.LE.M) THEN - DO K=I,M - SCALE = SCALE+ABS(A(K,I)) - END DO - IF (SCALE.NE.0D0) THEN - DO K=I,M - X = A(K,I)/SCALE - A(K,I) = X - S = S+X*X - END DO - F = A(I,I) - G = -SIGN(SQRT(S),F) - H = F*G-S - A(I,I) = F-G - IF (I.NE.N) THEN - DO J=L,N - S = 0D0 - DO K=I,M - S = S+A(K,I)*A(K,J) - END DO - F = S/H - DO K=I,M - A(K,J) = A(K,J)+F*A(K,I) - END DO - END DO - END IF - DO K=I,M - A(K,I) = SCALE*A(K,I) - END DO - END IF - END IF - W(I) = SCALE*G - G = 0D0 - S = 0D0 - SCALE = 0D0 - IF (I.LE.M .AND. I.NE.N) THEN - DO K=L,N - SCALE = SCALE+ABS(A(I,K)) - END DO - IF (SCALE.NE.0D0) THEN - DO K=L,N - X = A(I,K)/SCALE - A(I,K) = X - S = S+X*X - END DO - F = A(I,L) - G = -SIGN(SQRT(S),F) - H = F*G-S - A(I,L) = F-G - DO K=L,N - WORK(K) = A(I,K)/H - END DO - IF (I.NE.M) THEN - DO J=L,M - S = 0D0 - DO K=L,N - S = S+A(J,K)*A(I,K) - END DO - DO K=L,N - A(J,K) = A(J,K)+S*WORK(K) - END DO - END DO - END IF - DO K=L,N - A(I,K) = SCALE*A(I,K) - END DO - END IF - END IF - -* Overestimate of largest column norm for convergence test - AN = MAX(AN,ABS(W(I))+ABS(WORK(I))) - - END DO - -* -* Accumulation of right-hand transformations -* ------------------------------------------ - - DO I=N,1,-1 - IF (I.NE.N) THEN - IF (G.NE.0D0) THEN - DO J=L,N - V(J,I) = (A(I,J)/A(I,L))/G - END DO - DO J=L,N - S = 0D0 - DO K=L,N - S = S+A(I,K)*V(K,J) - END DO - DO K=L,N - V(K,J) = V(K,J)+S*V(K,I) - END DO - END DO - END IF - DO J=L,N - V(I,J) = 0D0 - V(J,I) = 0D0 - END DO - END IF - V(I,I) = 1D0 - G = WORK(I) - L = I - END DO - -* -* Accumulation of left-hand transformations -* ----------------------------------------- - - DO I=N,1,-1 - L = I+1 - G = W(I) - IF (I.NE.N) THEN - DO J=L,N - A(I,J) = 0D0 - END DO - END IF - IF (G.NE.0D0) THEN - IF (I.NE.N) THEN - DO J=L,N - S = 0D0 - DO K=L,M - S = S+A(K,I)*A(K,J) - END DO - F = (S/A(I,I))/G - DO K=I,M - A(K,J) = A(K,J)+F*A(K,I) - END DO - END DO - END IF - DO J=I,M - A(J,I) = A(J,I)/G - END DO - ELSE - DO J=I,M - A(J,I) = 0D0 - END DO - END IF - A(I,I) = A(I,I)+1D0 - END DO - -* -* Diagonalisation of the bidiagonal form -* -------------------------------------- - - DO K=N,1,-1 - K1 = K-1 - -* Iterate until converged - ITS = 0 - DO WHILE (ITS.LT.ITMAX) - ITS = ITS+1 - -* Test for splitting into submatrices - CANCEL = .TRUE. - DO L=K,1,-1 - L1 = L-1 - IF (AN+ABS(WORK(L)).EQ.AN) THEN - CANCEL = .FALSE. - GO TO 10 - END IF -* (Following never attempted for L=1 because WORK(1) is zero) - IF (AN+ABS(W(L1)).EQ.AN) GO TO 10 - END DO - 10 CONTINUE - -* Cancellation of WORK(L) if L>1 - IF (CANCEL) THEN - C = 0D0 - S = 1D0 - DO I=L,K - F = S*WORK(I) - IF (AN+ABS(F).EQ.AN) GO TO 20 - G = W(I) - H = SQRT(F*F+G*G) - W(I) = H - C = G/H - S = -F/H - DO J=1,M - Y = A(J,L1) - Z = A(J,I) - A(J,L1) = Y*C+Z*S - A(J,I) = -Y*S+Z*C - END DO - END DO - 20 CONTINUE - END IF - -* Converged? - Z = W(K) - IF (L.EQ.K) THEN - -* Yes: stop iterating - ITS = ITMAX - -* Ensure singular values non-negative - IF (Z.LT.0D0) THEN - W(K) = -Z - DO J=1,N - V(J,K) = -V(J,K) - END DO - END IF - ELSE - -* Not converged yet: set status if iteration limit reached - IF (ITS.EQ.ITMAX) JSTAT = K - -* Shift from bottom 2x2 minor - X = W(L) - Y = W(K1) - G = WORK(K1) - H = WORK(K) - F = ((Y-Z)*(Y+Z)+(G-H)*(G+H))/(2D0*H*Y) - IF (ABS(F).LE.1D15) THEN - G = SQRT(F*F+1D0) - ELSE - G = ABS(F) - END IF - F = ((X-Z)*(X+Z)+H*(Y/(F+SIGN(G,F))-H))/X - -* Next QR transformation - C = 1D0 - S = 1D0 - DO I1=L,K1 - I = I1+1 - G = WORK(I) - Y = W(I) - H = S*G - G = C*G - Z = SQRT(F*F+H*H) - WORK(I1) = Z - IF (Z.NE.0D0) THEN - C = F/Z - S = H/Z - ELSE - C = 1D0 - S = 0D0 - END IF - F = X*C+G*S - G = -X*S+G*C - H = Y*S - Y = Y*C - DO J=1,N - X = V(J,I1) - Z = V(J,I) - V(J,I1) = X*C+Z*S - V(J,I) = -X*S+Z*C - END DO - Z = SQRT(F*F+H*H) - W(I1) = Z - IF (Z.NE.0D0) THEN - C = F/Z - S = H/Z - END IF - F = C*G+S*Y - X = -S*G+C*Y - DO J=1,M - Y = A(J,I1) - Z = A(J,I) - A(J,I1) = Y*C+Z*S - A(J,I) = -Y*S+Z*C - END DO - END DO - WORK(L) = 0D0 - WORK(K) = F - W(K) = X - END IF - END DO - END DO - END IF - - END diff --git a/src/slalib/svdcov.f b/src/slalib/svdcov.f deleted file mode 100644 index 863e7cc4b..000000000 --- a/src/slalib/svdcov.f +++ /dev/null @@ -1,77 +0,0 @@ - SUBROUTINE sla_SVDCOV (N, NP, NC, W, V, WORK, CVM) -*+ -* - - - - - - - -* S V D C O V -* - - - - - - - -* -* From the W and V matrices from the SVD factorisation of a matrix -* (as obtained from the sla_SVD routine), obtain the covariance matrix. -* -* (double precision) -* -* Given: -* N i number of rows and columns in matrices W and V -* NP i first dimension of array containing matrix V -* NC i first dimension of array to receive CVM -* W d(N) NxN diagonal matrix W (diagonal elements only) -* V d(NP,NP) array containing NxN orthogonal matrix V -* -* Returned: -* WORK d(N) workspace -* CVM d(NC,NC) array to receive covariance matrix -* -* Reference: -* Numerical Recipes, section 14.3. -* -* P.T.Wallace Starlink December 1988 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER N,NP,NC - DOUBLE PRECISION W(N),V(NP,NP),WORK(N),CVM(NC,NC) - - INTEGER I,J,K - DOUBLE PRECISION S - - - - DO I=1,N - S=W(I) - IF (S.NE.0D0) THEN - WORK(I)=1D0/(S*S) - ELSE - WORK(I)=0D0 - END IF - END DO - DO I=1,N - DO J=1,I - S=0D0 - DO K=1,N - S=S+V(I,K)*V(J,K)*WORK(K) - END DO - CVM(I,J)=S - CVM(J,I)=S - END DO - END DO - - END diff --git a/src/slalib/svdsol.f b/src/slalib/svdsol.f deleted file mode 100644 index b2f61782b..000000000 --- a/src/slalib/svdsol.f +++ /dev/null @@ -1,126 +0,0 @@ - SUBROUTINE sla_SVDSOL (M, N, MP, NP, B, U, W, V, WORK, X) -*+ -* - - - - - - - -* S V D S O L -* - - - - - - - -* -* From a given vector and the SVD of a matrix (as obtained from -* the SVD routine), obtain the solution vector (double precision) -* -* This routine solves the equation: -* -* A . x = b -* -* where: -* -* A is a given M (rows) x N (columns) matrix, where M.GE.N -* x is the N-vector we wish to find -* b is a given M-vector -* -* by means of the Singular Value Decomposition method (SVD). In -* this method, the matrix A is first factorised (for example by -* the routine sla_SVD) into the following components: -* -* A = U x W x VT -* -* where: -* -* A is the M (rows) x N (columns) matrix -* U is an M x N column-orthogonal matrix -* W is an N x N diagonal matrix with W(I,I).GE.0 -* VT is the transpose of an NxN orthogonal matrix -* -* Note that M and N, above, are the LOGICAL dimensions of the -* matrices and vectors concerned, which can be located in -* arrays of larger PHYSICAL dimensions MP and NP. -* -* The solution is found from the expression: -* -* x = V . [diag(1/Wj)] . (transpose(U) . b) -* -* Notes: -* -* 1) If matrix A is square, and if the diagonal matrix W is not -* adjusted, the method is equivalent to conventional solution -* of simultaneous equations. -* -* 2) If M>N, the result is a least-squares fit. -* -* 3) If the solution is poorly determined, this shows up in the -* SVD factorisation as very small or zero Wj values. Where -* a Wj value is small but non-zero it can be set to zero to -* avoid ill effects. The present routine detects such zero -* Wj values and produces a sensible solution, with highly -* correlated terms kept under control rather than being allowed -* to elope to infinity, and with meaningful values for the -* other terms. -* -* Given: -* M,N i numbers of rows and columns in matrix A -* MP,NP i physical dimensions of array containing matrix A -* B d(M) known vector b -* U d(MP,NP) array containing MxN matrix U -* W d(N) NxN diagonal matrix W (diagonal elements only) -* V d(NP,NP) array containing NxN orthogonal matrix V -* -* Returned: -* WORK d(N) workspace -* X d(N) unknown vector x -* -* Reference: -* Numerical Recipes, section 2.9. -* -* P.T.Wallace Starlink 29 October 1993 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - INTEGER M,N,MP,NP - DOUBLE PRECISION B(M),U(MP,NP),W(N),V(NP,NP),WORK(N),X(N) - - INTEGER J,I,JJ - DOUBLE PRECISION S - - - -* Calculate [diag(1/Wj)] . transpose(U) . b (or zero for zero Wj) - DO J=1,N - S=0D0 - IF (W(J).NE.0D0) THEN - DO I=1,M - S=S+U(I,J)*B(I) - END DO - S=S/W(J) - END IF - WORK(J)=S - END DO - -* Multiply by matrix V to get result - DO J=1,N - S=0D0 - DO JJ=1,N - S=S+V(J,JJ)*WORK(JJ) - END DO - X(J)=S - END DO - - END diff --git a/src/slalib/tp2s.f b/src/slalib/tp2s.f deleted file mode 100644 index 7bd65a112..000000000 --- a/src/slalib/tp2s.f +++ /dev/null @@ -1,59 +0,0 @@ - SUBROUTINE sla_TP2S (XI, ETA, RAZ, DECZ, RA, DEC) -*+ -* - - - - - -* T P 2 S -* - - - - - -* -* Transform tangent plane coordinates into spherical -* (single precision) -* -* Given: -* XI,ETA real tangent plane rectangular coordinates -* RAZ,DECZ real spherical coordinates of tangent point -* -* Returned: -* RA,DEC real spherical coordinates (0-2pi,+/-pi/2) -* -* Called: sla_RANORM -* -* P.T.Wallace Starlink 24 July 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL XI,ETA,RAZ,DECZ,RA,DEC - - REAL sla_RANORM - - REAL SDECZ,CDECZ,DENOM - - - - SDECZ=SIN(DECZ) - CDECZ=COS(DECZ) - - DENOM=CDECZ-ETA*SDECZ - - RA=sla_RANORM(ATAN2(XI,DENOM)+RAZ) - DEC=ATAN2(SDECZ+ETA*CDECZ,SQRT(XI*XI+DENOM*DENOM)) - - END diff --git a/src/slalib/tp2v.f b/src/slalib/tp2v.f deleted file mode 100644 index 32d4805b2..000000000 --- a/src/slalib/tp2v.f +++ /dev/null @@ -1,73 +0,0 @@ - SUBROUTINE sla_TP2V (XI, ETA, V0, V) -*+ -* - - - - - -* T P 2 V -* - - - - - -* -* Given the tangent-plane coordinates of a star and the direction -* cosines of the tangent point, determine the direction cosines -* of the star. -* -* (single precision) -* -* Given: -* XI,ETA r tangent plane coordinates of star -* V0 r(3) direction cosines of tangent point -* -* Returned: -* V r(3) direction cosines of star -* -* Notes: -* -* 1 If vector V0 is not of unit length, the returned vector V will -* be wrong. -* -* 2 If vector V0 points at a pole, the returned vector V will be -* based on the arbitrary assumption that the RA of the tangent -* point is zero. -* -* 3 This routine is the Cartesian equivalent of the routine sla_TP2S. -* -* P.T.Wallace Starlink 11 February 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL XI,ETA,V0(3),V(3) - - REAL X,Y,Z,F,R - - - X=V0(1) - Y=V0(2) - Z=V0(3) - F=SQRT(1.0+XI*XI+ETA*ETA) - R=SQRT(X*X+Y*Y) - IF (R.EQ.0.0) THEN - R=1E-20 - X=R - END IF - V(1)=(X-(XI*Y+ETA*X*Z)/R)/F - V(2)=(Y+(XI*X-ETA*Y*Z)/R)/F - V(3)=(Z+ETA*R)/F - - END diff --git a/src/slalib/tps2c.f b/src/slalib/tps2c.f deleted file mode 100644 index 1d5ee39ae..000000000 --- a/src/slalib/tps2c.f +++ /dev/null @@ -1,108 +0,0 @@ - SUBROUTINE sla_TPS2C (XI, ETA, RA, DEC, RAZ1, DECZ1, - : RAZ2, DECZ2, N) -*+ -* - - - - - - -* T P S 2 C -* - - - - - - -* -* From the tangent plane coordinates of a star of known RA,Dec, -* determine the RA,Dec of the tangent point. -* -* (single precision) -* -* Given: -* XI,ETA r tangent plane rectangular coordinates -* RA,DEC r spherical coordinates -* -* Returned: -* RAZ1,DECZ1 r spherical coordinates of tangent point, solution 1 -* RAZ2,DECZ2 r spherical coordinates of tangent point, solution 2 -* N i number of solutions: -* 0 = no solutions returned (note 2) -* 1 = only the first solution is useful (note 3) -* 2 = both solutions are useful (note 3) -* -* Notes: -* -* 1 The RAZ1 and RAZ2 values are returned in the range 0-2pi. -* -* 2 Cases where there is no solution can only arise near the poles. -* For example, it is clearly impossible for a star at the pole -* itself to have a non-zero XI value, and hence it is -* meaningless to ask where the tangent point would have to be -* to bring about this combination of XI and DEC. -* -* 3 Also near the poles, cases can arise where there are two useful -* solutions. The argument N indicates whether the second of the -* two solutions returned is useful. N=1 indicates only one useful -* solution, the usual case; under these circumstances, the second -* solution corresponds to the "over-the-pole" case, and this is -* reflected in the values of RAZ2 and DECZ2 which are returned. -* -* 4 The DECZ1 and DECZ2 values are returned in the range +/-pi, but -* in the usual, non-pole-crossing, case, the range is +/-pi/2. -* -* 5 This routine is the spherical equivalent of the routine sla_DTPV2C. -* -* Called: sla_RANORM -* -* P.T.Wallace Starlink 5 June 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL XI,ETA,RA,DEC,RAZ1,DECZ1,RAZ2,DECZ2 - INTEGER N - - REAL X2,Y2,SD,CD,SDF,R2,R,S,C - - REAL sla_RANORM - - - X2=XI*XI - Y2=ETA*ETA - SD=SIN(DEC) - CD=COS(DEC) - SDF=SD*SQRT(1.0+X2+Y2) - R2=CD*CD*(1.0+Y2)-SD*SD*X2 - IF (R2.GE.0.0) THEN - R=SQRT(R2) - S=SDF-ETA*R - C=SDF*ETA+R - IF (XI.EQ.0.0.AND.R.EQ.0.0) R=1.0 - RAZ1=sla_RANORM(RA-ATAN2(XI,R)) - DECZ1=ATAN2(S,C) - R=-R - S=SDF-ETA*R - C=SDF*ETA+R - RAZ2=sla_RANORM(RA-ATAN2(XI,R)) - DECZ2=ATAN2(S,C) - IF (ABS(SDF).LT.1.0) THEN - N=1 - ELSE - N=2 - END IF - ELSE - N=0 - END IF - - END diff --git a/src/slalib/tpv2c.f b/src/slalib/tpv2c.f deleted file mode 100644 index 2f4838c92..000000000 --- a/src/slalib/tpv2c.f +++ /dev/null @@ -1,100 +0,0 @@ - SUBROUTINE sla_TPV2C (XI, ETA, V, V01, V02, N) -*+ -* - - - - - - -* T P V 2 C -* - - - - - - -* -* Given the tangent-plane coordinates of a star and its direction -* cosines, determine the direction cosines of the tangent-point. -* -* (single precision) -* -* Given: -* XI,ETA r tangent plane coordinates of star -* V r(3) direction cosines of star -* -* Returned: -* V01 r(3) direction cosines of tangent point, solution 1 -* V02 r(3) direction cosines of tangent point, solution 2 -* N i number of solutions: -* 0 = no solutions returned (note 2) -* 1 = only the first solution is useful (note 3) -* 2 = both solutions are useful (note 3) -* -* Notes: -* -* 1 The vector V must be of unit length or the result will be wrong. -* -* 2 Cases where there is no solution can only arise near the poles. -* For example, it is clearly impossible for a star at the pole -* itself to have a non-zero XI value, and hence it is meaningless -* to ask where the tangent point would have to be. -* -* 3 Also near the poles, cases can arise where there are two useful -* solutions. The argument N indicates whether the second of the -* two solutions returned is useful. N=1 indicates only one useful -* solution, the usual case; under these circumstances, the second -* solution can be regarded as valid if the vector V02 is interpreted -* as the "over-the-pole" case. -* -* 4 This routine is the Cartesian equivalent of the routine sla_TPS2C. -* -* P.T.Wallace Starlink 5 June 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL XI,ETA,V(3),V01(3),V02(3) - INTEGER N - - REAL X,Y,Z,RXY2,XI2,ETA2P1,SDF,R2,R,C - - - X=V(1) - Y=V(2) - Z=V(3) - RXY2=X*X+Y*Y - XI2=XI*XI - ETA2P1=ETA*ETA+1.0 - SDF=Z*SQRT(XI2+ETA2P1) - R2=RXY2*ETA2P1-Z*Z*XI2 - IF (R2.GT.0.0) THEN - R=SQRT(R2) - C=(SDF*ETA+R)/(ETA2P1*SQRT(RXY2*(R2+XI2))) - V01(1)=C*(X*R+Y*XI) - V01(2)=C*(Y*R-X*XI) - V01(3)=(SDF-ETA*R)/ETA2P1 - R=-R - C=(SDF*ETA+R)/(ETA2P1*SQRT(RXY2*(R2+XI2))) - V02(1)=C*(X*R+Y*XI) - V02(2)=C*(Y*R-X*XI) - V02(3)=(SDF-ETA*R)/ETA2P1 - IF (ABS(SDF).LT.1.0) THEN - N=1 - ELSE - N=2 - END IF - ELSE - N=0 - END IF - - END diff --git a/src/slalib/ue2el.f b/src/slalib/ue2el.f deleted file mode 100644 index bccf8d469..000000000 --- a/src/slalib/ue2el.f +++ /dev/null @@ -1,211 +0,0 @@ - SUBROUTINE sla_UE2EL (U, JFORMR, - : JFORM, EPOCH, ORBINC, ANODE, PERIH, - : AORQ, E, AORL, DM, JSTAT) -*+ -* - - - - - - -* U E 2 E L -* - - - - - - -* -* Transform universal elements into conventional heliocentric -* osculating elements. -* -* Given: -* U d(13) universal orbital elements (Note 1) -* -* (1) combined mass (M+m) -* (2) total energy of the orbit (alpha) -* (3) reference (osculating) epoch (t0) -* (4-6) position at reference epoch (r0) -* (7-9) velocity at reference epoch (v0) -* (10) heliocentric distance at reference epoch -* (11) r0.v0 -* (12) date (t) -* (13) universal eccentric anomaly (psi) of date, approx -* -* JFORMR i requested element set (1-3; Note 3) -* -* Returned: -* JFORM d element set actually returned (1-3; Note 4) -* EPOCH d epoch of elements (TT MJD) -* ORBINC d inclination (radians) -* ANODE d longitude of the ascending node (radians) -* PERIH d longitude or argument of perihelion (radians) -* AORQ d mean distance or perihelion distance (AU) -* E d eccentricity -* AORL d mean anomaly or longitude (radians, JFORM=1,2 only) -* DM d daily motion (radians, JFORM=1 only) -* JSTAT i status: 0 = OK -* -1 = illegal combined mass -* -2 = illegal JFORMR -* -3 = position/velocity out of range -* -* Notes -* -* 1 The "universal" elements are those which define the orbit for the -* purposes of the method of universal variables (see reference 2). -* They consist of the combined mass of the two bodies, an epoch, -* and the position and velocity vectors (arbitrary reference frame) -* at that epoch. The parameter set used here includes also various -* quantities that can, in fact, be derived from the other -* information. This approach is taken to avoiding unnecessary -* computation and loss of accuracy. The supplementary quantities -* are (i) alpha, which is proportional to the total energy of the -* orbit, (ii) the heliocentric distance at epoch, (iii) the -* outwards component of the velocity at the given epoch, (iv) an -* estimate of psi, the "universal eccentric anomaly" at a given -* date and (v) that date. -* -* 2 The universal elements are with respect to the mean equator and -* equinox of epoch J2000. The orbital elements produced are with -* respect to the J2000 ecliptic and mean equinox. -* -* 3 Three different element-format options are supported: -* -* Option JFORM=1, suitable for the major planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = longitude of perihelion, curly pi (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e -* AORL = mean longitude L (radians) -* DM = daily motion (radians) -* -* Option JFORM=2, suitable for minor planets: -* -* EPOCH = epoch of elements (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = mean distance, a (AU) -* E = eccentricity, e -* AORL = mean anomaly M (radians) -* -* Option JFORM=3, suitable for comets: -* -* EPOCH = epoch of perihelion (TT MJD) -* ORBINC = inclination i (radians) -* ANODE = longitude of the ascending node, big omega (radians) -* PERIH = argument of perihelion, little omega (radians) -* AORQ = perihelion distance, q (AU) -* E = eccentricity, e -* -* 4 It may not be possible to generate elements in the form -* requested through JFORMR. The caller is notified of the form -* of elements actually returned by means of the JFORM argument: -* -* JFORMR JFORM meaning -* -* 1 1 OK - elements are in the requested format -* 1 2 never happens -* 1 3 orbit not elliptical -* -* 2 1 never happens -* 2 2 OK - elements are in the requested format -* 2 3 orbit not elliptical -* -* 3 1 never happens -* 3 2 never happens -* 3 3 OK - elements are in the requested format -* -* 5 The arguments returned for each value of JFORM (cf Note 6: JFORM -* may not be the same as JFORMR) are as follows: -* -* JFORM 1 2 3 -* EPOCH t0 t0 T -* ORBINC i i i -* ANODE Omega Omega Omega -* PERIH curly pi omega omega -* AORQ a a q -* E e e e -* AORL L M - -* DM n - - -* -* where: -* -* t0 is the epoch of the elements (MJD, TT) -* T " epoch of perihelion (MJD, TT) -* i " inclination (radians) -* Omega " longitude of the ascending node (radians) -* curly pi " longitude of perihelion (radians) -* omega " argument of perihelion (radians) -* a " mean distance (AU) -* q " perihelion distance (AU) -* e " eccentricity -* L " longitude (radians, 0-2pi) -* M " mean anomaly (radians, 0-2pi) -* n " daily motion (radians) -* - means no value is set -* -* 6 At very small inclinations, the longitude of the ascending node -* ANODE becomes indeterminate and under some circumstances may be -* set arbitrarily to zero. Similarly, if the orbit is close to -* circular, the true anomaly becomes indeterminate and under some -* circumstances may be set arbitrarily to zero. In such cases, -* the other elements are automatically adjusted to compensate, -* and so the elements remain a valid description of the orbit. -* -* References: -* -* 1 Sterne, Theodore E., "An Introduction to Celestial Mechanics", -* Interscience Publishers Inc., 1960. Section 6.7, p199. -* -* 2 Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983. -* -* Called: sla_PV2EL -* -* P.T.Wallace Starlink 18 March 1999 -* -* Copyright (C) 1999 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION U(13) - INTEGER JFORMR,JFORM - DOUBLE PRECISION EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM - INTEGER JSTAT - -* Gaussian gravitational constant (exact) - DOUBLE PRECISION GCON - PARAMETER (GCON=0.01720209895D0) - -* Canonical days to seconds - DOUBLE PRECISION CD2S - PARAMETER (CD2S=GCON/86400D0) - - INTEGER I - DOUBLE PRECISION PMASS,DATE,PV(6) - - -* Unpack the universal elements. - PMASS = U(1)-1D0 - DATE = U(3) - DO I=1,3 - PV(I) = U(I+3) - PV(I+3) = U(I+6)*CD2S - END DO - -* Convert the position and velocity etc into conventional elements. - CALL sla_PV2EL(PV,DATE,PMASS,JFORMR,JFORM,EPOCH,ORBINC,ANODE, - : PERIH,AORQ,E,AORL,DM,JSTAT) - - END diff --git a/src/slalib/ue2pv.f b/src/slalib/ue2pv.f deleted file mode 100644 index ea7bb2b7d..000000000 --- a/src/slalib/ue2pv.f +++ /dev/null @@ -1,252 +0,0 @@ - SUBROUTINE sla_UE2PV ( DATE, U, PV, JSTAT ) -*+ -* - - - - - - -* U E 2 P V -* - - - - - - -* -* Heliocentric position and velocity of a planet, asteroid or comet, -* starting from orbital elements in the "universal variables" form. -* -* Given: -* DATE d date, Modified Julian Date (JD-2400000.5) -* -* Given and returned: -* U d(13) universal orbital elements (updated; Note 1) -* -* given (1) combined mass (M+m) -* " (2) total energy of the orbit (alpha) -* " (3) reference (osculating) epoch (t0) -* " (4-6) position at reference epoch (r0) -* " (7-9) velocity at reference epoch (v0) -* " (10) heliocentric distance at reference epoch -* " (11) r0.v0 -* returned (12) date (t) -* " (13) universal eccentric anomaly (psi) of date -* -* Returned: -* PV d(6) position (AU) and velocity (AU/s) -* JSTAT i status: 0 = OK -* -1 = radius vector zero -* -2 = failed to converge -* -* Notes -* -* 1 The "universal" elements are those which define the orbit for the -* purposes of the method of universal variables (see reference). -* They consist of the combined mass of the two bodies, an epoch, -* and the position and velocity vectors (arbitrary reference frame) -* at that epoch. The parameter set used here includes also various -* quantities that can, in fact, be derived from the other -* information. This approach is taken to avoiding unnecessary -* computation and loss of accuracy. The supplementary quantities -* are (i) alpha, which is proportional to the total energy of the -* orbit, (ii) the heliocentric distance at epoch, (iii) the -* outwards component of the velocity at the given epoch, (iv) an -* estimate of psi, the "universal eccentric anomaly" at a given -* date and (v) that date. -* -* 2 The companion routine is sla_EL2UE. This takes the conventional -* orbital elements and transforms them into the set of numbers -* needed by the present routine. A single prediction requires one -* one call to sla_EL2UE followed by one call to the present routine; -* for convenience, the two calls are packaged as the routine -* sla_PLANEL. Multiple predictions may be made by again -* calling sla_EL2UE once, but then calling the present routine -* multiple times, which is faster than multiple calls to sla_PLANEL. -* -* It is not obligatory to use sla_EL2UE to obtain the parameters. -* However, it should be noted that because sla_EL2UE performs its -* own validation, no checks on the contents of the array U are made -* by the present routine. -* -* 3 DATE is the instant for which the prediction is required. It is -* in the TT timescale (formerly Ephemeris Time, ET) and is a -* Modified Julian Date (JD-2400000.5). -* -* 4 The universal elements supplied in the array U are in canonical -* units (solar masses, AU and canonical days). The position and -* velocity are not sensitive to the choice of reference frame. The -* sla_EL2UE routine in fact produces coordinates with respect to the -* J2000 equator and equinox. -* -* 5 The algorithm was originally adapted from the EPHSLA program of -* D.H.P.Jones (private communication, 1996). The method is based -* on Stumpff's Universal Variables. -* -* Reference: Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983. -* -* P.T.Wallace Starlink 22 October 2005 -* -* Copyright (C) 2005 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DATE,U(13),PV(6) - INTEGER JSTAT - -* Gaussian gravitational constant (exact) - DOUBLE PRECISION GCON - PARAMETER (GCON=0.01720209895D0) - -* Canonical days to seconds - DOUBLE PRECISION CD2S - PARAMETER (CD2S=GCON/86400D0) - -* Test value for solution and maximum number of iterations - DOUBLE PRECISION TEST - INTEGER NITMAX - PARAMETER (TEST=1D-13,NITMAX=25) - - INTEGER I,NIT,N - - DOUBLE PRECISION CM,ALPHA,T0,P0(3),V0(3),R0,SIGMA0,T,PSI,DT,W, - : TOL,PSJ,PSJ2,BETA,S0,S1,S2,S3, - : FF,R,FLAST,PLAST,F,G,FD,GD - - - -* Unpack the parameters. - CM = U(1) - ALPHA = U(2) - T0 = U(3) - DO I=1,3 - P0(I) = U(I+3) - V0(I) = U(I+6) - END DO - R0 = U(10) - SIGMA0 = U(11) - T = U(12) - PSI = U(13) - -* Approximately update the universal eccentric anomaly. - PSI = PSI+(DATE-T)*GCON/R0 - -* Time from reference epoch to date (in Canonical Days: a canonical -* day is 58.1324409... days, defined as 1/GCON). - DT = (DATE-T0)*GCON - -* Refine the universal eccentric anomaly, psi. - NIT = 1 - W = 1D0 - TOL = 0D0 - DO WHILE (ABS(W).GE.TOL) - -* Form half angles until BETA small enough. - N = 0 - PSJ = PSI - PSJ2 = PSJ*PSJ - BETA = ALPHA*PSJ2 - DO WHILE (ABS(BETA).GT.0.7D0) - N = N+1 - BETA = BETA/4D0 - PSJ = PSJ/2D0 - PSJ2 = PSJ2/4D0 - END DO - -* Calculate Universal Variables S0,S1,S2,S3 by nested series. - S3 = PSJ*PSJ2*((((((BETA/210D0+1D0) - : *BETA/156D0+1D0) - : *BETA/110D0+1D0) - : *BETA/72D0+1D0) - : *BETA/42D0+1D0) - : *BETA/20D0+1D0)/6D0 - S2 = PSJ2*((((((BETA/182D0+1D0) - : *BETA/132D0+1D0) - : *BETA/90D0+1D0) - : *BETA/56D0+1D0) - : *BETA/30D0+1D0) - : *BETA/12D0+1D0)/2D0 - S1 = PSJ+ALPHA*S3 - S0 = 1D0+ALPHA*S2 - -* Undo the angle-halving. - TOL = TEST - DO WHILE (N.GT.0) - S3 = 2D0*(S0*S3+PSJ*S2) - S2 = 2D0*S1*S1 - S1 = 2D0*S0*S1 - S0 = 2D0*S0*S0-1D0 - PSJ = PSJ+PSJ - TOL = TOL+TOL - N = N-1 - END DO - -* Values of F and F' corresponding to the current value of psi. - FF = R0*S1+SIGMA0*S2+CM*S3-DT - R = R0*S0+SIGMA0*S1+CM*S2 - -* If first iteration, create dummy "last F". - IF ( NIT.EQ.1) FLAST = FF - -* Check for sign change. - IF ( FF*FLAST.LT.0D0 ) THEN - -* Sign change: get psi adjustment using secant method. - W = FF*(PLAST-PSI)/(FLAST-FF) - ELSE - -* No sign change: use Newton-Raphson method instead. - IF (R.EQ.0D0) GO TO 9010 - W = FF/R - END IF - -* Save the last psi and F values. - PLAST = PSI - FLAST = FF - -* Apply the Newton-Raphson or secant adjustment to psi. - PSI = PSI-W - -* Next iteration, unless too many already. - IF (NIT.GT.NITMAX) GO TO 9020 - NIT = NIT+1 - END DO - -* Project the position and velocity vectors (scaling velocity to AU/s). - W = CM*S2 - F = 1D0-W/R0 - G = DT-CM*S3 - FD = -CM*S1/(R0*R) - GD = 1D0-W/R - DO I=1,3 - PV(I) = P0(I)*F+V0(I)*G - PV(I+3) = CD2S*(P0(I)*FD+V0(I)*GD) - END DO - -* Update the parameters to allow speedy prediction of PSI next time. - U(12) = DATE - U(13) = PSI - -* OK exit. - JSTAT = 0 - GO TO 9999 - -* Null radius vector. - 9010 CONTINUE - JSTAT = -1 - GO TO 9999 - -* Failed to converge. - 9020 CONTINUE - JSTAT = -2 - - 9999 CONTINUE - END diff --git a/src/slalib/unpcd.f b/src/slalib/unpcd.f deleted file mode 100644 index 21bc5a21a..000000000 --- a/src/slalib/unpcd.f +++ /dev/null @@ -1,144 +0,0 @@ - SUBROUTINE sla_UNPCD ( DISCO, X, Y ) -*+ -* - - - - - - -* U N P C D -* - - - - - - -* -* Remove pincushion/barrel distortion from a distorted [x,y] to give -* tangent-plane [x,y]. -* -* Given: -* DISCO d pincushion/barrel distortion coefficient -* X,Y d distorted coordinates -* -* Returned: -* X,Y d tangent-plane coordinates -* -* Notes: -* -* 1) The distortion is of the form RP = R*(1+C*R^2), where R is -* the radial distance from the tangent point, C is the DISCO -* argument, and RP is the radial distance in the presence of -* the distortion. -* -* 2) For pincushion distortion, C is +ve; for barrel distortion, -* C is -ve. -* -* 3) For X,Y in "radians" - units of one projection radius, -* which in the case of a photograph is the focal length of -* the camera - the following DISCO values apply: -* -* Geometry DISCO -* -* astrograph 0.0 -* Schmidt -0.3333 -* AAT PF doublet +147.069 -* AAT PF triplet +178.585 -* AAT f/8 +21.20 -* JKT f/8 +13.32 -* -* 4) The present routine is a rigorous inverse of the companion -* routine sla_PCD. The expression for RP in Note 1 is rewritten -* in the form x^3+a*x+b=0 and solved by standard techniques. -* -* 5) Cases where the cubic has multiple real roots can sometimes -* occur, corresponding to extreme instances of barrel distortion -* where up to three different undistorted [X,Y]s all produce the -* same distorted [X,Y]. However, only one solution is returned, -* the one that produces the smallest change in [X,Y]. -* -* P.T.Wallace Starlink 3 September 2000 -* -* Copyright (C) 2000 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION DISCO,X,Y - - DOUBLE PRECISION THIRD - PARAMETER (THIRD=1D0/3D0) - DOUBLE PRECISION D2PI - PARAMETER (D2PI=6.283185307179586476925286766559D0) - - DOUBLE PRECISION RP,Q,R,D,W,S,T,F,C,T3,F1,F2,F3,W1,W2,W3 - - - -* Distance of the point from the origin. - RP = SQRT(X*X+Y*Y) - -* If zero, or if no distortion, no action is necessary. - IF (RP.NE.0D0.AND.DISCO.NE.0D0) THEN - -* Begin algebraic solution. - Q = 1D0/(3D0*DISCO) - R = RP/(2D0*DISCO) - W = Q*Q*Q+R*R - -* Continue if one real root, or three of which only one is positive. - IF (W.GE.0D0) THEN - D = SQRT(W) - W = R+D - S = SIGN(ABS(W)**THIRD,W) - W = R-D - T = SIGN((ABS(W))**THIRD,W) - F = S+T - ELSE - -* Three different real roots: use geometrical method instead. - W = 2D0/SQRT(-3D0*DISCO) - C = 4D0*RP/(DISCO*W*W*W) - S = SQRT(1D0-MIN(C*C,1D0)) - T3 = ATAN2(S,C) - -* The three solutions. - F1 = W*COS((D2PI-T3)/3D0) - F2 = W*COS((T3)/3D0) - F3 = W*COS((D2PI+T3)/3D0) - -* Pick the one that moves [X,Y] least. - W1 = ABS(F1-RP) - W2 = ABS(F2-RP) - W3 = ABS(F3-RP) - IF (W1.LT.W2) THEN - IF (W1.LT.W3) THEN - F = F1 - ELSE - F = F3 - END IF - ELSE - IF (W2.LT.W3) THEN - F = F2 - ELSE - F = F3 - END IF - END IF - - END IF - -* Remove the distortion. - F = F/RP - X = F*X - Y = F*Y - - END IF - - END diff --git a/src/slalib/v2tp.f b/src/slalib/v2tp.f deleted file mode 100644 index 6640f2e9b..000000000 --- a/src/slalib/v2tp.f +++ /dev/null @@ -1,95 +0,0 @@ - SUBROUTINE sla_V2TP (V, V0, XI, ETA, J) -*+ -* - - - - - -* V 2 T P -* - - - - - -* -* Given the direction cosines of a star and of the tangent point, -* determine the star's tangent-plane coordinates. -* -* (single precision) -* -* Given: -* V r(3) direction cosines of star -* V0 r(3) direction cosines of tangent point -* -* Returned: -* XI,ETA r tangent plane coordinates of star -* J i status: 0 = OK -* 1 = error, star too far from axis -* 2 = error, antistar on tangent plane -* 3 = error, antistar too far from axis -* -* Notes: -* -* 1 If vector V0 is not of unit length, or if vector V is of zero -* length, the results will be wrong. -* -* 2 If V0 points at a pole, the returned XI,ETA will be based on the -* arbitrary assumption that the RA of the tangent point is zero. -* -* 3 This routine is the Cartesian equivalent of the routine sla_S2TP. -* -* P.T.Wallace Starlink 27 November 1996 -* -* Copyright (C) 1996 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL V(3),V0(3),XI,ETA - INTEGER J - - REAL X,Y,Z,X0,Y0,Z0,R2,R,W,D - - REAL TINY - PARAMETER (TINY=1E-6) - - - X=V(1) - Y=V(2) - Z=V(3) - X0=V0(1) - Y0=V0(2) - Z0=V0(3) - R2=X0*X0+Y0*Y0 - R=SQRT(R2) - IF (R.EQ.0.0) THEN - R=1E-20 - X0=R - END IF - W=X*X0+Y*Y0 - D=W+Z*Z0 - IF (D.GT.TINY) THEN - J=0 - ELSE IF (D.GE.0.0) THEN - J=1 - D=TINY - ELSE IF (D.GT.-TINY) THEN - J=2 - D=-TINY - ELSE - J=3 - END IF - D=D*R - XI=(Y*X0-X*Y0)/D - ETA=(Z*R2-Z0*W)/D - - END diff --git a/src/slalib/vdv.f b/src/slalib/vdv.f deleted file mode 100644 index 86b0adc26..000000000 --- a/src/slalib/vdv.f +++ /dev/null @@ -1,44 +0,0 @@ - REAL FUNCTION sla_VDV (VA, VB) -*+ -* - - - - -* V D V -* - - - - -* -* Scalar product of two 3-vectors (single precision) -* -* Given: -* VA real(3) first vector -* VB real(3) second vector -* -* The result is the scalar product VA.VB (single precision) -* -* P.T.Wallace Starlink November 1984 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL VA(3),VB(3) - - - sla_VDV=VA(1)*VB(1)+VA(2)*VB(2)+VA(3)*VB(3) - - END diff --git a/src/slalib/veri.f b/src/slalib/veri.f deleted file mode 100644 index c54f48054..000000000 --- a/src/slalib/veri.f +++ /dev/null @@ -1,52 +0,0 @@ - INTEGER FUNCTION sla_VERI () -*+ -* - - - - - -* V E R I -* - - - - - -* -* Report the SLALIB version number as an integer. -* -* Given: -* None -* -* The result is the SLALIB version number as an integer m*1e6+n*1e3+r, -* where m is the major version, n the minor version and r the release -* number. -* -* Notes: -* -* To obtain the version number in a printable form, see -* subroutine sla_vers(version). -* -* The sla_veri subroutine was introduced in SLALIB version 2.5-1, so -* if this function is absent, one can only tell that the release -* predates that one. -* -* Norman Gray Starlink 8 April 2005 -* -* Copyright (C) 2005 Council for the Central Laboratory of the -* Research Councils -* -* Licence: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - sla_VERI=2005004 - - END diff --git a/src/slalib/vers.f b/src/slalib/vers.f deleted file mode 100644 index 5a5174191..000000000 --- a/src/slalib/vers.f +++ /dev/null @@ -1,58 +0,0 @@ - SUBROUTINE sla_VERS (VERSION) -*+ -* - - - - - -* V E R S -* - - - - - -* -* Report the SLALIB version number. -* -* Given: -* None -* -* Returned: -* VERSION c*(*) Version number, in the form 'm.n-r'. -* The major version is m, the minor version n, and -* release r. The string passed in should be at least -* 8 characters in length, to account for the (remote) -* possibility that these numbers will ever go to -* two digits. -* -* Notes: -* -* To obtain the version number in a more easily processed form, see -* function sla_veri(). -* -* The sla_vers subroutine was introduced in SLALIB version 2.5-1, so -* if this function is absent, one can only tell that the release -* predates that one. -* -* Norman Gray Starlink 8 April 2005 -* -* Copyright (C) 2005 Council for the Central Laboratory of the -* Research Councils -* -* Licence: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - CHARACTER VERSION*(*) - - VERSION='2.5-4' - - END diff --git a/src/slalib/vn.f b/src/slalib/vn.f deleted file mode 100644 index 6ba68d100..000000000 --- a/src/slalib/vn.f +++ /dev/null @@ -1,63 +0,0 @@ - SUBROUTINE sla_VN (V, UV, VM) -*+ -* - - - -* V N -* - - - -* -* Normalizes a 3-vector also giving the modulus (single precision) -* -* Given: -* V real(3) vector -* -* Returned: -* UV real(3) unit vector in direction of V -* VM real modulus of V -* -* If the modulus of V is zero, UV is set to zero as well -* -* P.T.Wallace Starlink 23 November 1995 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL V(3),UV(3),VM - - INTEGER I - REAL W1,W2 - - -* Modulus - W1=0.0 - DO I=1,3 - W2=V(I) - W1=W1+W2*W2 - END DO - W1=SQRT(W1) - VM=W1 - -* Normalize the vector - IF (W1.LE.0.0) W1=1.0 - DO I=1,3 - UV(I)=V(I)/W1 - END DO - - END diff --git a/src/slalib/vxv.f b/src/slalib/vxv.f deleted file mode 100644 index f39efd02e..000000000 --- a/src/slalib/vxv.f +++ /dev/null @@ -1,56 +0,0 @@ - SUBROUTINE sla_VXV (VA, VB, VC) -*+ -* - - - - -* V X V -* - - - - -* -* Vector product of two 3-vectors (single precision) -* -* Given: -* VA real(3) first vector -* VB real(3) second vector -* -* Returned: -* VC real(3) vector result -* -* P.T.Wallace Starlink March 1986 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL VA(3),VB(3),VC(3) - - REAL VW(3) - INTEGER I - - -* Form the vector product VA cross VB - VW(1)=VA(2)*VB(3)-VA(3)*VB(2) - VW(2)=VA(3)*VB(1)-VA(1)*VB(3) - VW(3)=VA(1)*VB(2)-VA(2)*VB(1) - -* Return the result - DO I=1,3 - VC(I)=VW(I) - END DO - - END diff --git a/src/slalib/wait.f b/src/slalib/wait.f deleted file mode 100644 index 94ed70fd8..000000000 --- a/src/slalib/wait.f +++ /dev/null @@ -1,49 +0,0 @@ - SUBROUTINE sla_WAIT (DELAY) -*+ -* - - - - - -* W A I T -* - - - - - -* -* Interval wait -* -* !!! Version for: SPARC/SunOS4, -* SPARC/Solaris2, -* DEC Mips/Ultrix -* DEC AXP/Digital Unix -* Intel/Linux -* Convex -* -* Given: -* DELAY real delay in seconds -* -* Called: SLEEP (a Fortran Intrinsic on all obove platforms) -* -* P.T.Wallace Starlink 22 January 1998 -* -* Copyright (C) 1998 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - REAL DELAY - - CALL SLEEP(NINT(DELAY)) - - END diff --git a/src/slalib/xy2xy.f b/src/slalib/xy2xy.f deleted file mode 100644 index cb76cce30..000000000 --- a/src/slalib/xy2xy.f +++ /dev/null @@ -1,66 +0,0 @@ - SUBROUTINE sla_XY2XY (X1,Y1,COEFFS,X2,Y2) -*+ -* - - - - - - -* X Y 2 X Y -* - - - - - - -* -* Transform one [X,Y] into another using a linear model of the type -* produced by the sla_FITXY routine. -* -* Given: -* X1 d x-coordinate -* Y1 d y-coordinate -* COEFFS d(6) transformation coefficients (see note) -* -* Returned: -* X2 d x-coordinate -* Y2 d y-coordinate -* -* The model relates two sets of [X,Y] coordinates as follows. -* Naming the elements of COEFFS: -* -* COEFFS(1) = A -* COEFFS(2) = B -* COEFFS(3) = C -* COEFFS(4) = D -* COEFFS(5) = E -* COEFFS(6) = F -* -* the present routine performs the transformation: -* -* X2 = A + B*X1 + C*Y1 -* Y2 = D + E*X1 + F*Y1 -* -* See also sla_FITXY, sla_PXY, sla_INVF, sla_DCMPF -* -* P.T.Wallace Starlink 5 December 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION X1,Y1,COEFFS(6),X2,Y2 - - - X2=COEFFS(1)+COEFFS(2)*X1+COEFFS(3)*Y1 - Y2=COEFFS(4)+COEFFS(5)*X1+COEFFS(6)*Y1 - - END diff --git a/src/slalib/zd.f b/src/slalib/zd.f deleted file mode 100644 index 041a0ec78..000000000 --- a/src/slalib/zd.f +++ /dev/null @@ -1,79 +0,0 @@ - DOUBLE PRECISION FUNCTION sla_ZD (HA, DEC, PHI) -*+ -* - - - -* Z D -* - - - -* -* HA, Dec to Zenith Distance (double precision) -* -* Given: -* HA d Hour Angle in radians -* DEC d declination in radians -* PHI d observatory latitude in radians -* -* The result is in the range 0 to pi. -* -* Notes: -* -* 1) The latitude must be geodetic. In critical applications, -* corrections for polar motion should be applied. -* -* 2) In some applications it will be important to specify the -* correct type of hour angle and declination in order to -* produce the required type of zenith distance. In particular, -* it may be important to distinguish between the zenith distance -* as affected by refraction, which would require the "observed" -* HA,Dec, and the zenith distance in vacuo, which would require -* the "topocentric" HA,Dec. If the effects of diurnal aberration -* can be neglected, the "apparent" HA,Dec may be used instead of -* the topocentric HA,Dec. -* -* 3) No range checking of arguments is done. -* -* 4) In applications which involve many zenith distance calculations, -* rather than calling the present routine it will be more efficient -* to use inline code, having previously computed fixed terms such -* as sine and cosine of latitude, and perhaps sine and cosine of -* declination. -* -* P.T.Wallace Starlink 3 April 1994 -* -* Copyright (C) 1995 Rutherford Appleton Laboratory -* -* License: -* This program is free software; you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation; either version 2 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program (see SLA_CONDITIONS); if not, write to the -* Free Software Foundation, Inc., 59 Temple Place, Suite 330, -* Boston, MA 02111-1307 USA -* -*- - - IMPLICIT NONE - - DOUBLE PRECISION HA,DEC,PHI - - DOUBLE PRECISION SH,CH,SD,CD,SP,CP,X,Y,Z - - - SH=SIN(HA) - CH=COS(HA) - SD=SIN(DEC) - CD=COS(DEC) - SP=SIN(PHI) - CP=COS(PHI) - X=CH*CD*SP-SD*CP - Y=SH*CD - Z=CH*CD*CP+SD*SP - sla_ZD=ATAN2(SQRT(X*X+Y*Y),Z) - - END diff --git a/src/spigot2filterbank.c b/src/spigot2filterbank.c deleted file mode 100644 index 3e3166c60..000000000 --- a/src/spigot2filterbank.c +++ /dev/null @@ -1,389 +0,0 @@ -#include "presto.h" -#include "mask.h" -#include "spigot.h" -#include "sigproc_fb.h" -#include "fitsfile.h" -#include "fitshead.h" -#include "spigot2filterbank_cmd.h" -#include "slalib.h" - -extern void get_calibrated_lags(void *rawlags, float *calibrated_lags); - -/* extern void sla_obs_(int *N, char *scope, char *name, */ -/* double *lon, double *lat, double *hgt); */ -/* extern void sla_oap_(char *type, double *azimuth, double *zendist, */ -/* double *MJD, double *dut, double *lon, double *lat, */ -/* double *hgt, double *xp, double *yp, double *temp, */ -/* double *atm, double *humid, double *microns, */ -/* double *tlr, double *rap, double *dap); */ -/* extern void sla_amp_(double *rap, double *dap, double *MJD, */ -/* double *equinox, double *ramean, double *decmean); */ - -void spigot2sigprocfb(SPIGOT_INFO * spigot, sigprocfb * fb, char *filenmbase, - int lokill, int hikill, int downsamp, - int update_posn, double time_offset) -{ - int h_or_d, m; - double s, dt; - - /* Set the time offset for the posn calc */ - if (update_posn) { - dt = time_offset; - } else { - dt = 0.0; - } - strncpy(fb->inpfile, filenmbase, 40); - strncpy(fb->source_name, spigot->object, 80); - fb->nifs = 1; - if (spigot->num_samplers == 1) - strncpy(fb->ifstream, "YXXX", 8); - else if (spigot->num_samplers == 2) - strncpy(fb->ifstream, "YYXX", 8); - fb->tstart = spigot->MJD_obs + spigot->elapsed_time / SECPERDAY; - fb->tsamp = spigot->dt_us / 1e6 * downsamp; - hours2hms(spigot->ra / 15.0, &h_or_d, &m, &s); - fb->src_raj = h_or_d * 10000.0 + m * 100.0 + s; - deg2dms(spigot->dec, &h_or_d, &m, &s); - fb->src_dej = abs(h_or_d) * 10000.0 + abs(m) * 100.0 + fabs(s); - if (spigot->dec < 0) - fb->src_dej = -fb->src_dej; - fb->az_start = spigot->az; - fb->za_start = 90.0 - spigot->el; - fb->nchans = spigot->lags_per_sample; - fb->foff = spigot->bandwidth / fb->nchans; - fb->fch1 = spigot->freq_ctr + (fb->nchans / 2 - 0.5) * fb->foff; - fb->fch1 -= fb->foff * hikill; - fb->nchans -= (hikill + lokill); - fb->foff = -fb->foff; - fb->machine_id = 7; - fb->telescope_id = 6; - fb->nbits = 8; - fb->sumifs = spigot->summed_pols; - if (fb->sumifs) - fb->nifs = 1; - else { - if (spigot->num_samplers == 2) - fb->nifs = 2; - else - fb->nifs = 1; - } - /* The following are not necessary for writing filterbank files */ - fb->headerlen = 0; - fb->N = spigot->samples_per_file; - - /* Update the position if the GBT was not tracking */ - /* (i.e. for the driftscan surveys) */ - if (update_posn && !spigot->tracking) { - int N = 0; - char scope[10] = { "GBT" }, type[] = { - "A"}; - char name[40]; - double MJD, lon, lat, hgt, microns, az, zd, rap, dap, rmn, dmn; - double dtmp = 0.0, atm = 1010.0, temp = 283.0; - double humid = 0.5, tlr = 0.0065, eq = 2000.0; - - /* Compute the RA/DEC using SLALIB from the Az/El */ - - slaObs(N, scope, name, &lon, &lat, &hgt); - if (fabs(hgt - 880.0) > 0.01) { - printf("Warning!: SLALIB is not correctly identifying the GBT!\n\n"); - } - //printf("slalib: %d '%s' '%s' %f %f %f\n", - // N, scope, name, lon, lat, hgt); - lon = -lon; - az = fb->az_start * DEGTORAD; - zd = fb->za_start * DEGTORAD; - microns = 3e8 / (spigot->freq_ctr * 1e6) * 1e6; - MJD = fb->tstart + dt / 86400.0; - slaOap(type, az, zd, MJD, dtmp, lon, lat, hgt, - dtmp, dtmp, temp, atm, humid, microns, tlr, &rap, &dap); - //printf("slalib: %.15f %.15f\n", rap, dap); - slaAmp(rap, dap, MJD, eq, &rmn, &dmn); - //printf("slalib: %.15f %.15f\n", rmn, dmn); - - /* Now update the positions */ - hours2hms(rmn * RADTODEG / 15.0, &h_or_d, &m, &s); - fb->src_raj = h_or_d * 10000.0 + m * 100.0 + s; - deg2dms(dmn * RADTODEG, &h_or_d, &m, &s); - fb->src_dej = abs(h_or_d) * 10000.0 + abs(m) * 100.0 + fabs(s); - if (dmn < 0) - fb->src_dej = -fb->src_dej; - } -} - - -int main(int argc, char *argv[]) -{ - FILE **infiles, *outfile = NULL, *scalingfile, *zerolagfile = NULL; - int filenum, ptsperblock, numlags, numfiles, outnumlags; - int bytes_per_read, scaling = 0, numscalings, firstfile, firstspec; - int write_data = 1, update_posn = 0; - long long N, numconverted = 0, numwritten = 0; - char *path, *filenm, rawlags[4096]; - char outfilenm[200], filenmbase[200], zerolagnm[200], scalingnm[200]; - unsigned char output_samples[2048]; - float *scalings = NULL, lags[2048], tmp_floats[2048]; - double dt, T, time_offset; - SPIGOT_INFO *spigots; - sigprocfb fb; - infodata idata; - Cmdline *cmd; - - /* Call usage() if we have no command line arguments */ - if (argc == 1) { - Program = argv[0]; - usage(); - exit(0); - } - - /* Parse the command line using the excellent program Clig */ - cmd = parseCmdline(argc, argv); - // showOptionValues(); - numfiles = cmd->argc; - - /* If requesting that we skip values or only write */ - /* a specific number of values, require an output file name */ - if ((cmd->skip > 0) || cmd->numoutP) { - if (!cmd->outfileP && !cmd->stdoutP) { - fprintf(stderr, - "\nspigot2filterbank ERROR: You need to specify an output\n" - " filename (or -stdout) when using the -skip and/or \n" - " -numout options!\n\n"); - exit(1); - } - } - - /* Give an error if specifying stdout and an output file */ - if (cmd->stdoutP && cmd->outfileP) { - fprintf(stderr, - "\nspigot2filterbank ERROR: You cannot specify both an output\n" - " file and that the data should go to STDOUT!\n\n"); - exit(1); - } - - if (!cmd->stdoutP) - printf - ("\nConverting SPIGOT FITs lags into SIGPROC filterbank format...\n\n"); - - /* Determine the filename base from the first spigot file */ - split_path_file(cmd->argv[0], &path, &filenm); - strncpy(filenmbase, filenm, strlen(filenm) - 5); - filenmbase[strlen(filenm) - 5] = '\0'; - free(path); - free(filenm); - - /* Open a file to store the zerolags */ - if (cmd->zerolagsP) { - if (cmd->outfileP) { - sprintf(zerolagnm, "%s.zerolags", cmd->outfile); - } else { - sprintf(zerolagnm, "%s.zerolags", filenmbase); - } - zerolagfile = chkfopen(zerolagnm, "wb"); - } - - /* Attempt to read a file with lag scalings in it */ - sprintf(scalingnm, "%s.scaling", filenmbase); - if ((scalingfile = fopen(scalingnm, "rb"))) { - /* Determine the length of the file */ - numscalings = (int) chkfilelen(scalingfile, sizeof(float)); - /* Create the array and read 'em */ - scalings = gen_fvect(numscalings); - chkfread(scalings, sizeof(float), numscalings, scalingfile); - scaling = 1; - /* close the scaling file */ - fclose(scalingfile); - if (!cmd->stdoutP) - printf("Scaling the lags with the %d values found in '%s'\n\n", - numscalings, scalingnm); - } - - /* Read and convert the basic SPIGOT file information */ - if (!cmd->stdoutP) - printf("Spigot card input file information:\n"); - spigots = (SPIGOT_INFO *) malloc(sizeof(SPIGOT_INFO) * numfiles); - infiles = (FILE **) malloc(sizeof(FILE *) * numfiles); - for (filenum = 0; filenum < numfiles; filenum++) { - if (!cmd->stdoutP) - printf(" '%s'\n", cmd->argv[filenum]); - infiles[filenum] = chkfopen(cmd->argv[filenum], "rb"); - read_SPIGOT_header(cmd->argv[filenum], spigots + filenum); - rewind(infiles[filenum]); - } - if (!cmd->stdoutP) - printf("\n"); - - /* The following is necessary in order to initialize all the */ - /* static variables in spigot.c */ - get_SPIGOT_file_info(infiles, spigots, numfiles, 0, 0, &N, - &ptsperblock, &numlags, &dt, &T, &idata, !cmd->stdoutP); - - /* Compute the first file required */ - firstfile = cmd->skip / spigots[0].samples_per_file; - firstspec = cmd->skip % spigots[0].samples_per_file; - if (!cmd->numoutP) { - cmd->numout = (N - cmd->skip) / cmd->downsamp; - } - bytes_per_read = numlags * spigots[0].bits_per_lag / 8; - outnumlags = numlags - cmd->lokill - cmd->hikill; - - /* Step through the SPIGOT files */ - filenum = firstfile; - while (numwritten < cmd->numout) { - split_path_file(cmd->argv[filenum], &path, &filenm); - strncpy(filenmbase, filenm, strlen(filenm) - 5); - filenmbase[strlen(filenm) - 5] = '\0'; - if (cmd->outfileP) { - if (filenum == firstfile) { - sprintf(outfilenm, "%s", cmd->outfile); - outfile = chkfopen(outfilenm, "wb"); - } - } else { - sprintf(outfilenm, "%s.fil", filenmbase); - if (cmd->stdoutP) { - outfile = stdout; - } else { - outfile = chkfopen(outfilenm, "wb"); - } - } - if (!cmd->stdoutP) { - if (filenum == firstfile) - printf("Reading Spigot lags from '%s' (starting at sample %d)\n", - cmd->argv[filenum], firstspec); - else - printf("Reading Spigot lags from '%s'\n", cmd->argv[filenum]); - printf("Writing filterbank spectra to '%s'\n\n", outfilenm); - } - - /* Update the filterbank header information for each file */ - if (!spigots[filenum].tracking) { - if (cmd->outfileP || cmd->stdoutP) { - time_offset = 0.5 * cmd->numout * - spigots[filenum].dt_us * 1e-6 * cmd->downsamp; - } else { // Just normal files - time_offset = 0.5 * spigots[filenum].file_duration; - } - update_posn = 1; - } else { - update_posn = 0; - time_offset = 0.0; - } - /* Adjust the Spigot start time for the skip */ - spigots[filenum].elapsed_time += cmd->skip * spigots[filenum].dt_us * 1e-6; - /* Determine the SIGPROC header */ - spigot2sigprocfb(&(spigots[filenum]), &fb, filenmbase, - cmd->lokill, cmd->hikill, cmd->downsamp, - update_posn, time_offset); - /* Correct the structure if we are using floats */ - if (cmd->floatsP) - fb.nbits = 32; - - /* Write a filterbank header if we have not been told not to. */ - /* Don't write it, though, if using stdio or a specified output */ - /* file and the input file is not the first. */ - if (!cmd->nohdrP) { - if ((!cmd->stdoutP && !cmd->outfileP) || - ((cmd->stdoutP || cmd->outfileP) && filenum == firstfile)) { - write_filterbank_header(&fb, outfile); - } - } - - /* Go to the correct autocorrelation in the correct first FITs file */ - chkfseek(infiles[filenum], - spigots[filenum].header_len + bytes_per_read * firstspec, SEEK_SET); - - /* Loop over the samples in the file */ - while ((numwritten < cmd->numout) && - (chkfread(rawlags, bytes_per_read, 1, infiles[filenum]))) { - if (cmd->zerolagsP) { - /* Correct the lags so we can write the zerolag */ - get_calibrated_lags(rawlags, lags); - chkfwrite(lags, sizeof(float), 1, zerolagfile); - } - if (scaling) { - convert_SPIGOT_point(rawlags, output_samples, SUMIFS, - scalings[cmd->skip + numconverted]); - } else { - convert_SPIGOT_point(rawlags, output_samples, SUMIFS, 1.0); - } - /* If downsampling, average the current spectra */ - if (cmd->downsamp > 1) { - int ii; - if (numconverted % cmd->downsamp == 0) { - write_data = 0; - /* Zero the array used for averaging */ - for (ii = 0; ii < outnumlags; ii++) - tmp_floats[ii] = 0.0; - } else { - /* Add the current data to the array used for averaging */ - for (ii = 0; ii < outnumlags; ii++) - tmp_floats[ii] += (float) output_samples[ii + cmd->lokill]; - /* If that was the last sample to be added, average them */ - /* and put them back into output_samples */ - if (numconverted % cmd->downsamp == (cmd->downsamp - 1)) { - write_data = 1; - for (ii = 0; ii < outnumlags; ii++) { - tmp_floats[ii] /= (float) cmd->downsamp; - output_samples[ii + cmd->lokill] = - (unsigned char) (tmp_floats[ii] + 0.5); - } - } - } - } - numconverted++; - - if (write_data) { - int ii; - - /* Invert the band so that the high freqs are first */ - /* This is how SIGPROC stores its data. */ - if (cmd->floatsP) { - float tempzz = 0.0, *loptr, *hiptr; - loptr = tmp_floats; // killed channels are already gone - hiptr = tmp_floats + outnumlags - 1; - for (ii = 0; ii < outnumlags / 2; ii++, loptr++, hiptr--) { - SWAP(*loptr, *hiptr); - } - } else { - unsigned char tempzz = 0.0, *loptr, *hiptr; - loptr = output_samples + cmd->lokill; - hiptr = output_samples + cmd->lokill + outnumlags - 1; - for (ii = 0; ii < outnumlags / 2; ii++, loptr++, hiptr--) { - SWAP(*loptr, *hiptr); - } - } - - /* Now actually write the data */ - if (cmd->floatsP) { - /* Copy the bytes to floats */ - for (ii = 0; ii < outnumlags; ii++) - tmp_floats[ii] = (float) output_samples[ii + cmd->lokill]; - chkfwrite(tmp_floats, sizeof(float), fb.nchans, outfile); - } else { - chkfwrite(output_samples + cmd->lokill, - sizeof(unsigned char), fb.nchans, outfile); - } - numwritten++; - } - } - if ((!cmd->stdoutP) && (!cmd->outfileP)) - fclose(outfile); - fclose(infiles[filenum]); - firstspec = 0; - filenum++; - free(path); - free(filenm); - } - if ((!cmd->stdoutP) && (cmd->outfileP)) - fclose(outfile); - if (cmd->zerolagsP) - fclose(zerolagfile); - if (!cmd->stdoutP) - fprintf(stderr, "Converted %lld samples and wrote %lld.\n\n", - numconverted, numwritten); - if (scaling) - vect_free(scalings); - free(spigots); - free(infiles); - return 0; -} diff --git a/src/spigot2filterbank_cmd.c b/src/spigot2filterbank_cmd.c deleted file mode 100644 index 78cbdf897..000000000 --- a/src/spigot2filterbank_cmd.c +++ /dev/null @@ -1,1051 +0,0 @@ -/***** - command line parser -- generated by clig - (http://wsd.iitb.fhg.de/~kir/clighome/) - - The command line parser `clig': - (C) 1995-2004 Harald Kirsch (clig@geggus.net) -*****/ - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "spigot2filterbank_cmd.h" - -char *Program; - -/*@-null*/ - -static Cmdline cmd = { - /***** -o: Output file name (optional; for a single output file) */ - /* outfileP = */ 0, - /* outfile = */ (char *) 0, - /* outfileC = */ 0, - /***** -nohdr: Output just raw data. No headers are output */ - /* nohdrP = */ 0, - /***** -stdout: Send the data to STDOUT instead of files */ - /* stdoutP = */ 0, - /***** -floats: Output data as 32-bit floats instead of 8-bit unsigned chars */ - /* floatsP = */ 0, - /***** -zerolags: Dump the raw spigot zerolags in 32-bit floats format to a file */ - /* zerolagsP = */ 0, - /***** -skip: Number of spectra to skip from the initial value */ - /* skipP = */ 1, - /* skip = */ 0, - /* skipC = */ 1, - /***** -numout: Number of spectra to output (default is all) */ - /* numoutP = */ 0, - /* numout = */ (int) 0, - /* numoutC = */ 0, - /***** -downsamp: Number of spectra to average on output */ - /* downsampP = */ 1, - /* downsamp = */ 1, - /* downsampC = */ 1, - /***** -lokill: Number of low-freq channels to ignore */ - /* lokillP = */ 1, - /* lokill = */ 0, - /* lokillC = */ 1, - /***** -hikill: Number of high-freq channels to ignore */ - /* hikillP = */ 1, - /* hikill = */ 0, - /* hikillC = */ 1, - /***** uninterpreted rest of command line */ - /* argc = */ 0, - /* argv = */ (char **) 0, - /***** the original command line concatenated */ - /* full_cmd_line = */ NULL -}; - -/*@=null*/ - -/***** let LCLint run more smoothly */ -/*@-predboolothers*/ -/*@-boolops*/ - - -/******************************************************************/ -/***** - This is a bit tricky. We want to make a difference between overflow - and underflow and we want to allow v==Inf or v==-Inf but not - v>FLT_MAX. - - We don't use fabs to avoid linkage with -lm. -*****/ -static void checkFloatConversion(double v, char *option, char *arg) -{ - char *err = NULL; - - if ((errno == ERANGE && v != 0.0) /* even double overflowed */ - ||(v < HUGE_VAL && v > -HUGE_VAL && (v < 0.0 ? -v : v) > (double) FLT_MAX)) { - err = "large"; - } else if ((errno == ERANGE && v == 0.0) - || (v != 0.0 && (v < 0.0 ? -v : v) < (double) FLT_MIN)) { - err = "small"; - } - if (err) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to %s to represent\n", - Program, arg, option, err); - exit(EXIT_FAILURE); - } -} - -int getIntOpt(int argc, char **argv, int i, int *value, int force) -{ - char *end; - long v; - - if (++i >= argc) - goto nothingFound; - - errno = 0; - v = strtol(argv[i], &end, 0); - - /***** check for conversion error */ - if (end == argv[i]) - goto nothingFound; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - goto nothingFound; - - /***** check if it fits into an int */ - if (errno == ERANGE || v > (long) INT_MAX || v < (long) INT_MIN) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to large to represent\n", - Program, argv[i], argv[i - 1]); - exit(EXIT_FAILURE); - } - *value = (int) v; - - return i; - - nothingFound: - if (!force) - return i - 1; - - fprintf(stderr, - "%s: missing or malformed integer value after option `%s'\n", - Program, argv[i - 1]); - exit(EXIT_FAILURE); -} - -/**********************************************************************/ - -int getIntOpts(int argc, char **argv, int i, int **values, int cmin, int cmax) -/***** - We want to find at least cmin values and at most cmax values. - cmax==-1 then means infinitely many are allowed. -*****/ -{ - int alloced, used; - char *end; - long v; - if (i + cmin >= argc) { - fprintf(stderr, - "%s: option `%s' wants at least %d parameters\n", - Program, argv[i], cmin); - exit(EXIT_FAILURE); - } - - /***** - alloc a bit more than cmin values. It does not hurt to have room - for a bit more values than cmax. - *****/ - alloced = cmin + 4; - *values = (int *) calloc((size_t) alloced, sizeof(int)); - if (!*values) { - outMem: - fprintf(stderr, - "%s: out of memory while parsing option `%s'\n", Program, argv[i]); - exit(EXIT_FAILURE); - } - - for (used = 0; (cmax == -1 || used < cmax) && used + i + 1 < argc; used++) { - if (used == alloced) { - alloced += 8; - *values = (int *) realloc(*values, alloced * sizeof(int)); - if (!*values) - goto outMem; - } - - errno = 0; - v = strtol(argv[used + i + 1], &end, 0); - - /***** check for conversion error */ - if (end == argv[used + i + 1]) - break; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - break; - - /***** check for overflow */ - if (errno == ERANGE || v > (long) INT_MAX || v < (long) INT_MIN) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to large to represent\n", - Program, argv[i + used + 1], argv[i]); - exit(EXIT_FAILURE); - } - - (*values)[used] = (int) v; - - } - - if (used < cmin) { - fprintf(stderr, - "%s: parameter `%s' of `%s' should be an " - "integer value\n", Program, argv[i + used + 1], argv[i]); - exit(EXIT_FAILURE); - } - - return i + used; -} - -/**********************************************************************/ - -int getLongOpt(int argc, char **argv, int i, long *value, int force) -{ - char *end; - - if (++i >= argc) - goto nothingFound; - - errno = 0; - *value = strtol(argv[i], &end, 0); - - /***** check for conversion error */ - if (end == argv[i]) - goto nothingFound; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - goto nothingFound; - - /***** check for overflow */ - if (errno == ERANGE) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to large to represent\n", - Program, argv[i], argv[i - 1]); - exit(EXIT_FAILURE); - } - return i; - - nothingFound: - /***** !force means: this parameter may be missing.*/ - if (!force) - return i - 1; - - fprintf(stderr, - "%s: missing or malformed value after option `%s'\n", - Program, argv[i - 1]); - exit(EXIT_FAILURE); -} - -/**********************************************************************/ - -int getLongOpts(int argc, char **argv, int i, long **values, int cmin, int cmax) -/***** - We want to find at least cmin values and at most cmax values. - cmax==-1 then means infinitely many are allowed. -*****/ -{ - int alloced, used; - char *end; - - if (i + cmin >= argc) { - fprintf(stderr, - "%s: option `%s' wants at least %d parameters\n", - Program, argv[i], cmin); - exit(EXIT_FAILURE); - } - - /***** - alloc a bit more than cmin values. It does not hurt to have room - for a bit more values than cmax. - *****/ - alloced = cmin + 4; - *values = (long int *) calloc((size_t) alloced, sizeof(long)); - if (!*values) { - outMem: - fprintf(stderr, - "%s: out of memory while parsing option `%s'\n", Program, argv[i]); - exit(EXIT_FAILURE); - } - - for (used = 0; (cmax == -1 || used < cmax) && used + i + 1 < argc; used++) { - if (used == alloced) { - alloced += 8; - *values = (long int *) realloc(*values, alloced * sizeof(long)); - if (!*values) - goto outMem; - } - - errno = 0; - (*values)[used] = strtol(argv[used + i + 1], &end, 0); - - /***** check for conversion error */ - if (end == argv[used + i + 1]) - break; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - break; - - /***** check for overflow */ - if (errno == ERANGE) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to large to represent\n", - Program, argv[i + used + 1], argv[i]); - exit(EXIT_FAILURE); - } - - } - - if (used < cmin) { - fprintf(stderr, - "%s: parameter `%s' of `%s' should be an " - "integer value\n", Program, argv[i + used + 1], argv[i]); - exit(EXIT_FAILURE); - } - - return i + used; -} - -/**********************************************************************/ - -int getFloatOpt(int argc, char **argv, int i, float *value, int force) -{ - char *end; - double v; - - if (++i >= argc) - goto nothingFound; - - errno = 0; - v = strtod(argv[i], &end); - - /***** check for conversion error */ - if (end == argv[i]) - goto nothingFound; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - goto nothingFound; - - /***** check for overflow */ - checkFloatConversion(v, argv[i - 1], argv[i]); - - *value = (float) v; - - return i; - - nothingFound: - if (!force) - return i - 1; - - fprintf(stderr, - "%s: missing or malformed float value after option `%s'\n", - Program, argv[i - 1]); - exit(EXIT_FAILURE); - -} - -/**********************************************************************/ - -int getFloatOpts(int argc, char **argv, int i, float **values, int cmin, int cmax) -/***** - We want to find at least cmin values and at most cmax values. - cmax==-1 then means infinitely many are allowed. -*****/ -{ - int alloced, used; - char *end; - double v; - - if (i + cmin >= argc) { - fprintf(stderr, - "%s: option `%s' wants at least %d parameters\n", - Program, argv[i], cmin); - exit(EXIT_FAILURE); - } - - /***** - alloc a bit more than cmin values. - *****/ - alloced = cmin + 4; - *values = (float *) calloc((size_t) alloced, sizeof(float)); - if (!*values) { - outMem: - fprintf(stderr, - "%s: out of memory while parsing option `%s'\n", Program, argv[i]); - exit(EXIT_FAILURE); - } - - for (used = 0; (cmax == -1 || used < cmax) && used + i + 1 < argc; used++) { - if (used == alloced) { - alloced += 8; - *values = (float *) realloc(*values, alloced * sizeof(float)); - if (!*values) - goto outMem; - } - - errno = 0; - v = strtod(argv[used + i + 1], &end); - - /***** check for conversion error */ - if (end == argv[used + i + 1]) - break; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - break; - - /***** check for overflow */ - checkFloatConversion(v, argv[i], argv[i + used + 1]); - - (*values)[used] = (float) v; - } - - if (used < cmin) { - fprintf(stderr, - "%s: parameter `%s' of `%s' should be a " - "floating-point value\n", Program, argv[i + used + 1], argv[i]); - exit(EXIT_FAILURE); - } - - return i + used; -} - -/**********************************************************************/ - -int getDoubleOpt(int argc, char **argv, int i, double *value, int force) -{ - char *end; - - if (++i >= argc) - goto nothingFound; - - errno = 0; - *value = strtod(argv[i], &end); - - /***** check for conversion error */ - if (end == argv[i]) - goto nothingFound; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - goto nothingFound; - - /***** check for overflow */ - if (errno == ERANGE) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to %s to represent\n", - Program, argv[i], argv[i - 1], (*value == 0.0 ? "small" : "large")); - exit(EXIT_FAILURE); - } - - return i; - - nothingFound: - if (!force) - return i - 1; - - fprintf(stderr, - "%s: missing or malformed value after option `%s'\n", - Program, argv[i - 1]); - exit(EXIT_FAILURE); - -} - -/**********************************************************************/ - -int getDoubleOpts(int argc, char **argv, int i, double **values, int cmin, int cmax) -/***** - We want to find at least cmin values and at most cmax values. - cmax==-1 then means infinitely many are allowed. -*****/ -{ - int alloced, used; - char *end; - - if (i + cmin >= argc) { - fprintf(stderr, - "%s: option `%s' wants at least %d parameters\n", - Program, argv[i], cmin); - exit(EXIT_FAILURE); - } - - /***** - alloc a bit more than cmin values. - *****/ - alloced = cmin + 4; - *values = (double *) calloc((size_t) alloced, sizeof(double)); - if (!*values) { - outMem: - fprintf(stderr, - "%s: out of memory while parsing option `%s'\n", Program, argv[i]); - exit(EXIT_FAILURE); - } - - for (used = 0; (cmax == -1 || used < cmax) && used + i + 1 < argc; used++) { - if (used == alloced) { - alloced += 8; - *values = (double *) realloc(*values, alloced * sizeof(double)); - if (!*values) - goto outMem; - } - - errno = 0; - (*values)[used] = strtod(argv[used + i + 1], &end); - - /***** check for conversion error */ - if (end == argv[used + i + 1]) - break; - - /***** check for surplus non-whitespace */ - while (isspace((int) *end)) - end += 1; - if (*end) - break; - - /***** check for overflow */ - if (errno == ERANGE) { - fprintf(stderr, - "%s: parameter `%s' of option `%s' to %s to represent\n", - Program, argv[i + used + 1], argv[i], - ((*values)[used] == 0.0 ? "small" : "large")); - exit(EXIT_FAILURE); - } - - } - - if (used < cmin) { - fprintf(stderr, - "%s: parameter `%s' of `%s' should be a " - "double value\n", Program, argv[i + used + 1], argv[i]); - exit(EXIT_FAILURE); - } - - return i + used; -} - -/**********************************************************************/ - -/** - force will be set if we need at least one argument for the option. -*****/ -int getStringOpt(int argc, char **argv, int i, char **value, int force) -{ - i += 1; - if (i >= argc) { - if (force) { - fprintf(stderr, "%s: missing string after option `%s'\n", - Program, argv[i - 1]); - exit(EXIT_FAILURE); - } - return i - 1; - } - - if (!force && argv[i][0] == '-') - return i - 1; - *value = argv[i]; - return i; -} - -/**********************************************************************/ - -int getStringOpts(int argc, char **argv, int i, char * **values, int cmin, int cmax) -/***** - We want to find at least cmin values and at most cmax values. - cmax==-1 then means infinitely many are allowed. -*****/ -{ - int alloced, used; - - if (i + cmin >= argc) { - fprintf(stderr, - "%s: option `%s' wants at least %d parameters\n", - Program, argv[i], cmin); - exit(EXIT_FAILURE); - } - - alloced = cmin + 4; - - *values = (char **) calloc((size_t) alloced, sizeof(char *)); - if (!*values) { - outMem: - fprintf(stderr, - "%s: out of memory during parsing of option `%s'\n", - Program, argv[i]); - exit(EXIT_FAILURE); - } - - for (used = 0; (cmax == -1 || used < cmax) && used + i + 1 < argc; used++) { - if (used == alloced) { - alloced += 8; - *values = (char **) realloc(*values, alloced * sizeof(char *)); - if (!*values) - goto outMem; - } - - if (used >= cmin && argv[used + i + 1][0] == '-') - break; - (*values)[used] = argv[used + i + 1]; - } - - if (used < cmin) { - fprintf(stderr, - "%s: less than %d parameters for option `%s', only %d found\n", - Program, cmin, argv[i], used); - exit(EXIT_FAILURE); - } - - return i + used; -} - -/**********************************************************************/ - -void checkIntLower(char *opt, int *values, int count, int max) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] <= max) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' greater than max=%d\n", - Program, i + 1, opt, max); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkIntHigher(char *opt, int *values, int count, int min) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] >= min) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' smaller than min=%d\n", - Program, i + 1, opt, min); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkLongLower(char *opt, long *values, int count, long max) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] <= max) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' greater than max=%ld\n", - Program, i + 1, opt, max); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkLongHigher(char *opt, long *values, int count, long min) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] >= min) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' smaller than min=%ld\n", - Program, i + 1, opt, min); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkFloatLower(char *opt, float *values, int count, float max) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] <= max) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' greater than max=%f\n", - Program, i + 1, opt, max); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkFloatHigher(char *opt, float *values, int count, float min) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] >= min) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' smaller than min=%f\n", - Program, i + 1, opt, min); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkDoubleLower(char *opt, double *values, int count, double max) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] <= max) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' greater than max=%f\n", - Program, i + 1, opt, max); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -void checkDoubleHigher(char *opt, double *values, int count, double min) -{ - int i; - - for (i = 0; i < count; i++) { - if (values[i] >= min) - continue; - fprintf(stderr, - "%s: parameter %d of option `%s' smaller than min=%f\n", - Program, i + 1, opt, min); - exit(EXIT_FAILURE); - } -} - -/**********************************************************************/ - -static char *catArgv(int argc, char **argv) -{ - int i; - size_t l; - char *s, *t; - - for (i = 0, l = 0; i < argc; i++) - l += (1 + strlen(argv[i])); - s = (char *) malloc(l); - if (!s) { - fprintf(stderr, "%s: out of memory\n", Program); - exit(EXIT_FAILURE); - } - strcpy(s, argv[0]); - t = s; - for (i = 1; i < argc; i++) { - t = t + strlen(t); - *t++ = ' '; - strcpy(t, argv[i]); - } - return s; -} - -/**********************************************************************/ - -void showOptionValues(void) -{ - int i; - - printf("Full command line is:\n`%s'\n", cmd.full_cmd_line); - - /***** -o: Output file name (optional; for a single output file) */ - if (!cmd.outfileP) { - printf("-o not found.\n"); - } else { - printf("-o found:\n"); - if (!cmd.outfileC) { - printf(" no values\n"); - } else { - printf(" value = `%s'\n", cmd.outfile); - } - } - - /***** -nohdr: Output just raw data. No headers are output */ - if (!cmd.nohdrP) { - printf("-nohdr not found.\n"); - } else { - printf("-nohdr found:\n"); - } - - /***** -stdout: Send the data to STDOUT instead of files */ - if (!cmd.stdoutP) { - printf("-stdout not found.\n"); - } else { - printf("-stdout found:\n"); - } - - /***** -floats: Output data as 32-bit floats instead of 8-bit unsigned chars */ - if (!cmd.floatsP) { - printf("-floats not found.\n"); - } else { - printf("-floats found:\n"); - } - - /***** -zerolags: Dump the raw spigot zerolags in 32-bit floats format to a file */ - if (!cmd.zerolagsP) { - printf("-zerolags not found.\n"); - } else { - printf("-zerolags found:\n"); - } - - /***** -skip: Number of spectra to skip from the initial value */ - if (!cmd.skipP) { - printf("-skip not found.\n"); - } else { - printf("-skip found:\n"); - if (!cmd.skipC) { - printf(" no values\n"); - } else { - printf(" value = `%d'\n", cmd.skip); - } - } - - /***** -numout: Number of spectra to output (default is all) */ - if (!cmd.numoutP) { - printf("-numout not found.\n"); - } else { - printf("-numout found:\n"); - if (!cmd.numoutC) { - printf(" no values\n"); - } else { - printf(" value = `%d'\n", cmd.numout); - } - } - - /***** -downsamp: Number of spectra to average on output */ - if (!cmd.downsampP) { - printf("-downsamp not found.\n"); - } else { - printf("-downsamp found:\n"); - if (!cmd.downsampC) { - printf(" no values\n"); - } else { - printf(" value = `%d'\n", cmd.downsamp); - } - } - - /***** -lokill: Number of low-freq channels to ignore */ - if (!cmd.lokillP) { - printf("-lokill not found.\n"); - } else { - printf("-lokill found:\n"); - if (!cmd.lokillC) { - printf(" no values\n"); - } else { - printf(" value = `%d'\n", cmd.lokill); - } - } - - /***** -hikill: Number of high-freq channels to ignore */ - if (!cmd.hikillP) { - printf("-hikill not found.\n"); - } else { - printf("-hikill found:\n"); - if (!cmd.hikillC) { - printf(" no values\n"); - } else { - printf(" value = `%d'\n", cmd.hikill); - } - } - if (!cmd.argc) { - printf("no remaining parameters in argv\n"); - } else { - printf("argv ="); - for (i = 0; i < cmd.argc; i++) { - printf(" `%s'", cmd.argv[i]); - } - printf("\n"); - } -} - -/**********************************************************************/ - -void usage(void) -{ - fprintf(stderr, "%s", - " [-o outfile] [-nohdr] [-stdout] [-floats] [-zerolags] [-skip skip] [-numout numout] [-downsamp downsamp] [-lokill lokill] [-hikill hikill] [--] fitsfiles ...\n"); - fprintf(stderr, "%s", - " Converts raw GBT Spigot FITs files (lag data) into SIGPROC-style filterbank format.\n"); - fprintf(stderr, "%s", - " -o: Output file name (optional; for a single output file)\n"); - fprintf(stderr, "%s", " 1 char* value\n"); - fprintf(stderr, "%s", - " -nohdr: Output just raw data. No headers are output\n"); - fprintf(stderr, "%s", - " -stdout: Send the data to STDOUT instead of files\n"); - fprintf(stderr, "%s", - " -floats: Output data as 32-bit floats instead of 8-bit unsigned chars\n"); - fprintf(stderr, "%s", - " -zerolags: Dump the raw spigot zerolags in 32-bit floats format to a file\n"); - fprintf(stderr, "%s", - " -skip: Number of spectra to skip from the initial value\n"); - fprintf(stderr, "%s", " 1 int value between 0 and oo\n"); - fprintf(stderr, "%s", " default: `0'\n"); - fprintf(stderr, "%s", - " -numout: Number of spectra to output (default is all)\n"); - fprintf(stderr, "%s", " 1 int value between 0 and oo\n"); - fprintf(stderr, "%s", " -downsamp: Number of spectra to average on output\n"); - fprintf(stderr, "%s", " 1 int value between 0 and oo\n"); - fprintf(stderr, "%s", " default: `1'\n"); - fprintf(stderr, "%s", " -lokill: Number of low-freq channels to ignore\n"); - fprintf(stderr, "%s", " 1 int value between 0 and oo\n"); - fprintf(stderr, "%s", " default: `0'\n"); - fprintf(stderr, "%s", " -hikill: Number of high-freq channels to ignore\n"); - fprintf(stderr, "%s", " 1 int value between 0 and oo\n"); - fprintf(stderr, "%s", " default: `0'\n"); - fprintf(stderr, "%s", " fitsfiles: Input Spigot FITs files.\n"); - fprintf(stderr, "%s", " 1...1024 values\n"); - fprintf(stderr, "%s", " version: 12Mar10\n"); - fprintf(stderr, "%s", " "); - exit(EXIT_FAILURE); -} - -/**********************************************************************/ -Cmdline *parseCmdline(int argc, char **argv) -{ - int i; - - Program = argv[0]; - cmd.full_cmd_line = catArgv(argc, argv); - for (i = 1, cmd.argc = 1; i < argc; i++) { - if (0 == strcmp("--", argv[i])) { - while (++i < argc) - argv[cmd.argc++] = argv[i]; - continue; - } - - if (0 == strcmp("-o", argv[i])) { - int keep = i; - cmd.outfileP = 1; - i = getStringOpt(argc, argv, i, &cmd.outfile, 1); - cmd.outfileC = i - keep; - continue; - } - - if (0 == strcmp("-nohdr", argv[i])) { - cmd.nohdrP = 1; - continue; - } - - if (0 == strcmp("-stdout", argv[i])) { - cmd.stdoutP = 1; - continue; - } - - if (0 == strcmp("-floats", argv[i])) { - cmd.floatsP = 1; - continue; - } - - if (0 == strcmp("-zerolags", argv[i])) { - cmd.zerolagsP = 1; - continue; - } - - if (0 == strcmp("-skip", argv[i])) { - int keep = i; - cmd.skipP = 1; - i = getIntOpt(argc, argv, i, &cmd.skip, 1); - cmd.skipC = i - keep; - checkIntHigher("-skip", &cmd.skip, cmd.skipC, 0); - continue; - } - - if (0 == strcmp("-numout", argv[i])) { - int keep = i; - cmd.numoutP = 1; - i = getIntOpt(argc, argv, i, &cmd.numout, 1); - cmd.numoutC = i - keep; - checkIntHigher("-numout", &cmd.numout, cmd.numoutC, 0); - continue; - } - - if (0 == strcmp("-downsamp", argv[i])) { - int keep = i; - cmd.downsampP = 1; - i = getIntOpt(argc, argv, i, &cmd.downsamp, 1); - cmd.downsampC = i - keep; - checkIntHigher("-downsamp", &cmd.downsamp, cmd.downsampC, 0); - continue; - } - - if (0 == strcmp("-lokill", argv[i])) { - int keep = i; - cmd.lokillP = 1; - i = getIntOpt(argc, argv, i, &cmd.lokill, 1); - cmd.lokillC = i - keep; - checkIntHigher("-lokill", &cmd.lokill, cmd.lokillC, 0); - continue; - } - - if (0 == strcmp("-hikill", argv[i])) { - int keep = i; - cmd.hikillP = 1; - i = getIntOpt(argc, argv, i, &cmd.hikill, 1); - cmd.hikillC = i - keep; - checkIntHigher("-hikill", &cmd.hikill, cmd.hikillC, 0); - continue; - } - - if (argv[i][0] == '-') { - fprintf(stderr, "\n%s: unknown option `%s'\n\n", Program, argv[i]); - usage(); - } - argv[cmd.argc++] = argv[i]; - } /* for i */ - - - /*@-mustfree */ - cmd.argv = argv + 1; - /*@=mustfree */ - cmd.argc -= 1; - - if (1 > cmd.argc) { - fprintf(stderr, "%s: there should be at least 1 non-option argument(s)\n", - Program); - exit(EXIT_FAILURE); - } - if (1024 < cmd.argc) { - fprintf(stderr, "%s: there should be at most 1024 non-option argument(s)\n", - Program); - exit(EXIT_FAILURE); - } - /*@-compmempass */ - return &cmd; -} diff --git a/src/spigotSband2filterbank.c b/src/spigotSband2filterbank.c deleted file mode 100644 index 730e81b32..000000000 --- a/src/spigotSband2filterbank.c +++ /dev/null @@ -1,179 +0,0 @@ -#include "presto.h" -#include "mask.h" -#include "spigot.h" -#include "sigproc_fb.h" -#include "fitsfile.h" -#include "fitshead.h" - -void spigot2sigprocfb(SPIGOT_INFO * spigot, sigprocfb * fb, char *filenmbase) -{ - int h_or_d, m; - double s; - - strncpy(fb->inpfile, filenmbase, 40); - strncpy(fb->source_name, spigot->object, 80); - fb->nifs = 1; - if (spigot->num_samplers == 1) - strncpy(fb->ifstream, "YXXX", 8); - else if (spigot->num_samplers == 2) - strncpy(fb->ifstream, "YYXX", 8); - fb->tstart = spigot->MJD_obs + spigot->elapsed_time / SECPERDAY; - fb->tsamp = spigot->dt_us / 1e6; - hours2hms(spigot->ra / 15.0, &h_or_d, &m, &s); - fb->src_raj = h_or_d * 10000.0 + m * 100.0 + s; - deg2dms(spigot->dec, &h_or_d, &m, &s); - fb->src_dej = abs(h_or_d) * 10000.0 + abs(m) * 100.0 + fabs(s); - if (spigot->dec < 0) - fb->src_dej = -fb->src_dej; - fb->az_start = spigot->az; - fb->za_start = 90.0 - spigot->el; - fb->nchans = spigot->lags_per_sample; - fb->foff = spigot->bandwidth / fb->nchans; - fb->fch1 = spigot->freq_ctr + (fb->nchans / 2 - 0.5) * fb->foff; - fb->foff = -fb->foff; - // Here is where we chop the bottom 1/4 (200MHz) of the band - fb->nchans = fb->nchans - fb->nchans / 4; - fb->machine_id = 7; - fb->telescope_id = 6; - fb->nbits = 8; - fb->sumifs = spigot->summed_pols; - if (fb->sumifs) - fb->nifs = 1; - else { - if (spigot->num_samplers == 2) - fb->nifs = 2; - else - fb->nifs = 1; - } - /* The following are not necessary for writing filterbank files */ - fb->headerlen = 0; - fb->N = spigot->samples_per_file; -} - - -int main(int argc, char *argv[]) -{ - FILE **infiles, *outfile = NULL, *scalingfile; - int filenum, argnum = 1, ii = 0, ptsperblock, numlags, numfiles; - int bytes_per_read, scaling = 0, numscalings, output = 1; - long long N; - char *path, *filenm; - char outfilenm[200], filenmbase[200], scalingnm[200], rawlags[4096]; - unsigned char output_samples[2048]; - float *scalings = NULL; - double dt, T; - SPIGOT_INFO *spigots; - sigprocfb fb; - infodata idata; - - if (argc == 1) { - fprintf(stderr, "Usage: spigotSband2filterbank [-stdout] SPIGOT_files\n"); - exit(0); - } - - if (!strcmp(argv[argnum], "-stdout")) { /* Use STDOUT */ - argnum++; - output = 0; - outfile = stdout; - } else { - printf - ("\nConverting raw SPIGOT S-band FITs data into SIGPROC\n" - "filterbank format and throwing out the bottom 200MHz...\n\n"); - } - - /* Attempt to read a file with lag scalings in it */ - sprintf(scalingnm, "%s.scaling", filenmbase); - if ((scalingfile = fopen(scalingnm, "rb"))) { - /* Determine the length of the file */ - numscalings = (int) chkfilelen(scalingfile, sizeof(float)); - /* Create the array and read 'em */ - scalings = gen_fvect(numscalings); - chkfread(scalings, sizeof(float), numscalings, scalingfile); - scaling = 1; - /* close the scaling file */ - fclose(scalingfile); - if (outfile != stdout) - printf("Scaling the lags with the %d values found in '%s'\n\n", - numscalings, scalingnm); - } - - /* Read and convert the basic SPIGOT file information */ - - numfiles = argc - 1; - if (outfile == stdout) - numfiles--; - else - printf("Spigot card input file information:\n"); - spigots = (SPIGOT_INFO *) malloc(sizeof(SPIGOT_INFO) * numfiles); - infiles = (FILE **) malloc(sizeof(FILE *) * numfiles); - for (filenum = 0; filenum < numfiles; filenum++, argnum++) { - if (outfile != stdout) - printf(" '%s'\n", argv[argnum]); - infiles[filenum] = chkfopen(argv[argnum], "rb"); - read_SPIGOT_header(argv[argnum], spigots + filenum); - rewind(infiles[filenum]); - } - if (outfile != stdout) - printf("\n"); - - /* The following is necessary in order to initialize all the */ - /* static variables in spigot.c */ - get_SPIGOT_file_info(infiles, spigots, numfiles, 0, 0, &N, - &ptsperblock, &numlags, &dt, &T, &idata, output); - - /* Step through the SPIGOT files */ - ii = 0; - if (outfile == stdout) - argnum = 2; - else - argnum = 1; - for (filenum = 0; filenum < numfiles; filenum++, argnum++) { - split_path_file(argv[argnum], &path, &filenm); - strncpy(filenmbase, filenm, strlen(filenm) - 5); - filenmbase[strlen(filenm) - 5] = '\0'; - sprintf(outfilenm, "%s.fil", filenmbase); - if (outfile != stdout) { - printf("Reading S-band Spigot lags from '%s'\n", argv[argnum]); - printf("Writing filterbank spectra to '%s'\n\n", outfilenm); - outfile = chkfopen(outfilenm, "wb"); - } - // Update the filterbank header information for each file - spigot2sigprocfb(&(spigots[filenum]), &fb, filenmbase); - write_filterbank_header(&fb, outfile); - chkfseek(infiles[filenum], spigots[filenum].header_len, SEEK_SET); - bytes_per_read = numlags * spigots[filenum].bits_per_lag / 8; - - /* Loop over the samples in the file */ - while (chkfread(rawlags, bytes_per_read, 1, infiles[filenum])) { - if (scaling) - convert_SPIGOT_point(rawlags, output_samples, SUMIFS, scalings[ii]); - else - convert_SPIGOT_point(rawlags, output_samples, SUMIFS, 1.0); - ii++; - /* Invert the band so that the high freqs are first */ - /* This is how SIGPROC stores its data. */ - { - int jj; - unsigned char tempzz = 0.0, *loptr, *hiptr; - loptr = output_samples + 0; - hiptr = output_samples + numlags - 1; - for (jj = 0; jj < numlags / 2; jj++, loptr++, hiptr--) { - SWAP(*loptr, *hiptr); - } - } - chkfwrite(output_samples, sizeof(unsigned char), fb.nchans, outfile); - } - fclose(infiles[filenum]); - if (outfile != stdout) - fclose(outfile); - } - if (outfile != stdout) - fprintf(stderr, "Converted and wrote %d samples.\n\n", ii); - if (scaling) - vect_free(scalings); - free(spigots); - free(path); - free(filenm); - free(infiles); - return 0; -}