CzeV343: discovery of a double eclipsing binary with periods near a 3:2 ratio P. Cagas1 & O. Pejcha2 1 BSO, Zlin, Czech Republic 2 Department of Astronomy, The Ohio State University Emails: pavel_[dot]_cagas_[at]_bsobservatory_[dot]_org, pejcha_[at]_astronomy_[dot]_ohio-state_[dot]_edu Link to our paper

In our paper, we suggest that CzeV343 is a quadruple system composed of two eclipsing binaries. If the two binaries are indeed physically connected, the parameters of the mutual orbit can be obtained by precision timing of minima over time through light travel time effect, apsidal motion or orbital precession. However, such goal requires joint analysis of data from different sources obtained through various techniques and with insufficiently quantified uncertainties. In particular, photometric uncertainties are often underestimated, which yields too small uncertainties in minima timings if determined through analysis of a χ² surface. The task is even more difficult for double eclipsing binaries, especially those with periods close to a resonance such as CzeV344, where minima get often blended with each other.

In addition to CzeV343, two double eclipsing binaries are known: V994 Her and KIC 4247791 and more will likely be discovered in the near future. In order to aid the analysis of systems such as CzeV343, we make publicly available our code that solves the double binary parameters simultaneously and then uses these parameters to determine minima timings (or more specifically O-C values) for individual datasets. In both cases, the uncertainties (or more precisely confidence intervals) are determined through bootstrap resampling of the original data. This procedure to a large extent alleviates the common problem with underestimated photometric uncertainties and provides a check on possible degeneracies in the parameters and the stability of the results. While there are shortcomings to this method as well when compared to Markov Chain Monte Carlo methods, the ease of the implementation of bootstrapping is a significant advantage.

Code description

• hierarchy - finds the best solution to the measurements by starting the minimization from many random initial parameter values and picking the one with lowest χ². The best solution is then used to generate light curve and separate the fluxes of the two systems. Can be also used to vary the scale factor in a systematic way.
• bootstrap - performs bootstrap resampling with repeats of the original dataset. For each realization, the minimization is started at a number of random positions and the best solution is determined. Thee best-fitting parameter values for each bootstrapping can be then analyzed by an external program to determine confidence intervals. Additionally, can be used to diagnose "wrong" data by analyzing the frequency of individual data points as a function of the fitted parameters.
• oc - takes the best-fit parameters from hierarchy and fits the datasets individually for a shift in magnitude and time zero point. This yields an equivalent of minima timings. Each dataset is bootstrap resampled and results reported to be analyzed with an external program.

Additionally, the code has a number of functions to read data and pass parameters between the minimizing routine and the binary light curve code. In fact, these routines are the only original part of the code: we use the great minimization routine cmpfit and the excellent binary light curve code JKTEBOP by John Southworth.

Installation

The code is designed to work under linux because of the easiness to combine C and Fortran. But it runs exactly the same under Windows in Cygwin. The code has a capability of multithreading through OpenMP. To make use of this capability, you need a recent compiler. The code works without modification with no multithreading support, but (especially) the bootstrapping gets very slow.

This code is based on external minimization routine and eclipsing binary light curve code. You need to get them separately.

cmpfit installation

Go to http://www.physics.wisc.edu/~craigm/idl/cmpfit.html and download cmpfit-1.2. Unzip the file in the directory with our code - this should do the trick. Just check the main Makefile that the paths are correct.

JKTEBOP installation

This is a bit more difficult as it requires editing the JKTEBOP source code to link it with the rest of the C code.

• Go to http://www.astro.keele.ac.uk/jkt/codes/jktebop.html and download the tar file. This was tested with version 28, but should work with other versions as well.
• Copy jktebop.f to the main code directory and open it with a text editor.
• Comment everything between lines 136 and 279. You do this by putting "!" in front of every line. This is done so that the compiler is not confused about what is the main program when everything is linked together.
• Now we need to tell JKTEBOP to report flux instead of magnitudes. Find line 4026, which should say
  
  FMAG = -2.5d0 * log10(FLITE) + SFACT
  
  Comment this line and put in a new line
  
  FMAG = FLITE
  
  Don't forget to align the new line with the other ones (Fortran is an old language)!

Compile everything

Usage

When you successfuly compile the code, then it should be set up so that you get results just by running ./hierarchy.exe followed by ./bootstrap.exe output.dat or ./oc.exe. There are some comments in the source files - if you want to do something with the code then you'd have to go through the sources anyway so it's better to start early.

The output of hierarchy and bootstrap is essentially Table 2 of our paper, while oc gives you Table 1.

Notes

• We do not assume any responsibility over the code nor its fitness for any purpose. If you can't get it working, we can offer limited help but do not expect much. There aren't many double eclipsing binaries and so you'll have to invest some time in understanding how things work.
• Set the number of threads in fitujeme.cpp on the line starting with #pragma omp.... The optimal number of threads is not necessarily the highest possible. For example, this code was run on a machine with two 6-core CPUs with hyperthreading, which yields 24 logical threads. Yet, the code actually slows down if you select more than 12 threads, probably due to copying stuff back and forth.
• Don't be worried if most of the time the result of the fit some huge χ². Unless there is some bug in the code (memory leak), then the code should find the best solution from 50 random initial conditions.