Metadata-Version: 2.0
Name: pyeebls
Version: 0.1.6
Summary: Python f2py extension wrapping eebls.f by Kovacs et al. 2002.
Home-page: https://github.com/waqasbhatti/pyeebls
Author: Waqas Bhatti
Author-email: wbhatti@astro.princeton.edu
License: MIT
Description-Content-Type: UNKNOWN
Keywords: astronomy
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: MIT License
Classifier: Intended Audience :: Science/Research
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Requires-Dist: numpy

This is a module that wraps Geza Kovacs' eebls.f. Taken from Daniel
Foreman-Mackey's python-bls_ module, and broken out for easier use by other
packages. This is used by the astrobase_ module.


eebls.f
=======

- Kovacs, Zucker & Mazeh 2002, A&A, Vol. 391, 369
- http://arxiv.org/abs/astro-ph/0206099
- http://www.konkoly.hu/staff/kovacs/eebls.f


python-bls
==========

- Foreman-Mackey, D., Angus, R., et al. 2012
- https://github.com/dfm/python-bls.git


pyeebls
=======

- Bhatti, W., et al. 2017
- https://github.com/waqasbhatti/pyeebls


Installation
------------

This package is available from PyPI: https://pypi.python.org/pypi/pyeebls. If
you're using Python 2.7, 3.4--3.6 on 64-bit Linux or Python 2.7/3.6 on 64-bit
Windows, you should be able to install the binary wheels from PyPI so no Fortran
compiler is needed: ::

  (venv)$ pip install pyeebls

If this is not the case (Mac OSX; wheels will be built as soon as I figure out
how), you'll need to have numpy installed, along with a Fortran compiler: ::

  (venv)$ pip install numpy # in a virtualenv
  # or use dnf/yum/apt install numpy to install systemwide

  ## you'll need a Fortran compiler to install pyeebls!         ##
  ## on Linux: dnf/yum/apt install gcc gcc-gfortran             ##
  ## on OSX (using homebrew): brew install gcc && brew link gcc ##

Then, install pyeebls using pip (preferably in a virtualenv or use the --user
flag): ::

  (venv)$ pip install pyeebls

Or download the tarball from PyPI, extract the files, and run setup.py: ::

  (venv)$ python setup.py install


Documentation
-------------

There's only one function to use in this module. ::

  def pyeebls.eebls(times, mags, workarr_u, workarr_v,
                    nfreq, freqmin, stepsize,
                    nbins, minduration, maxduration):

Calculates the BLS spectrum for the input times and mags arrays.

**Parameters**

``times`` : *ndarray*
        A numpy array containing the times of the measurements.

``mags`` : *ndarray*
        A numpy array containing the mags or fluxes to use as measurements.

``workarr_u``, ``workarr_v`` : *ndarray*
        Numpy arrays that must be the same size as times, used as temp
        workspaces by the Fortran function.

``nfreq`` : *int*
        The number of frequencies to search for the best period.

``freqmin`` : *float*
        The minimum frequency to use.

``stepsize`` : *float*
        The stepsize in frequency units to use while searching.

``nbins`` : *int*
        The number of bins to use when phasing up the light curve at a
        single test period.

``minduration`` : *float*
        The minimum transit duration in phase units to consider when testing for
        a transit.

``maxduration`` : *float*
        The minimum transit duration in phase units to consider when testing for
        a transit.


**Returns**

A sequence of results: ::

  (power, bestperiod, bestpower, transdepth,
   transduration, transingressbin, transegressbin)

``power`` : *ndarray*
        A numpy array containing the values of the BLS spectrum at each tested
        frequency.

``bestperiod`` : *float*
        The period at the highest peak in the frequency spectrum.

``bestpower`` : *float*
        The power at the highest peak in the frequency spectrum.

``transdepth`` : *float*
        The depth of the transit at the best period.

``transduration`` : *float*
        The length of the transit as a fraction of the phase. This is the
        so-called 'q' parameter.

``transingressbin`` : *int*
        The phase bin index for the start of the transit.

``transegressbin`` : *int*
        The phase bin index for the end of the transit.


See Also
--------

- the comments at the top of eebls.f in this package
- the kbls_ module in astrobase_ for a high-level serial and parallelized
  interface to this module


License
-------

The license for the Python files is the MIT License. eebls.f is provided by
G. Kovacs; it appears to be re-distributable, but please make sure to cite
Kovacs, et al. 2002 if you use this implementation.


.. _python-bls: https://github.com/dfm/python-bls.git
.. _astrobase: https://github.com/waqasbhatti/astrobase/tree/master/astrobase/periodbase
.. _kbls: https://github.com/waqasbhatti/astrobase/blob/master/astrobase/periodbase/kbls.py


