def main(): # Number of trials. n = 10 # Other parameters. baseline = 90. # days minutes_per_day = 24. * 60. signal_to_noise = 10000. nsamples = np.ceil(baseline * minutes_per_day) segsize, mindur, maxdur, nbins = (2., 0.01, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) period = np.random.uniform(segsize, 30.) # days duration = np.random.uniform(1. / 24., 5. / 24.) # days depth = np.random.uniform(-0.01, -0.5) phase = 0.5 # Create logarithmically spaced numbers of lightcurves. num_lightcurves = np.logspace(0., 3., n).astype('int64') # Allocate memory to store results. cython_times = np.zeros((n, ), dtype='float64') for i in xrange(n): # Print a status update message. print 'BENCHMARK: # lightcurves =', num_lightcurves[ i], '/', i + 1, 'of', n, '...' for j in xrange(num_lightcurves[i]): # Simulate the lightcurve. time, flux, fluxerr, _, _, _ = simulate_box_lightcurve( period, duration, depth, phase, signal_to_noise, nsamples, baseline) cython_start = clock() out_cython = bls_pulse_cython(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) cython_end = clock() cython_times[i] += cython_end - cython_start np.savez('unittests/benchmark2.npz', num_lightcurves=num_lightcurves, cython_times=cython_times) __generate_figure()
def main(): # Number of trials. n = 10 # Other parameters. baseline = 90. # days minutes_per_day = 24. * 60. signal_to_noise = 10000. nsamples = np.ceil(baseline * minutes_per_day) segsize, mindur, maxdur, nbins = (2., 0.01, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) period = np.random.uniform(segsize, 30.) # days duration = np.random.uniform(1. / 24., 5. / 24.) # days depth = np.random.uniform(-0.01, -0.5) phase = 0.5 # Create logarithmically spaced numbers of lightcurves. num_lightcurves = np.logspace(0., 3., n).astype('int64') # Allocate memory to store results. cython_times = np.zeros((n,), dtype='float64') for i in xrange(n): # Print a status update message. print 'BENCHMARK: # lightcurves =', num_lightcurves[i], '/', i + 1, 'of', n, '...' for j in xrange(num_lightcurves[i]): # Simulate the lightcurve. time, flux, fluxerr, _, _, _ = simulate_box_lightcurve(period, duration, depth, phase, signal_to_noise, nsamples, baseline) cython_start = clock() out_cython = bls_pulse_cython(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) cython_end = clock() cython_times[i] += cython_end - cython_start np.savez('unittests/benchmark2.npz', num_lightcurves=num_lightcurves, cython_times=cython_times) __generate_figure()
def main(err_on_fail=True, allow_straddling=True, ofile=None): if ofile is not None: ofile.write('#\tMeas. mid.\tAct. mid.\tMeas. dpth.\tAct. dpth.\tMeas. ' 'dur.\tAct. dur\n') # Define absolute/relative tolerances. midtime_atol = 0.1 duration_rtol = 0.1 depth_rtol = 0.1 # Other parameters. minutes_per_day = 24. * 60. sigma, baseline = (1.e-5, 100.) nsamples = np.ceil(baseline * minutes_per_day) segsize, mindur, maxdur, nbins = (2., 0.05, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) # Simulate the lightcurve. time, flux, fluxerr, duration, depth, midtime = \ simulate_compound_signal(baseline, nsamples, sigma, segsize, mindur, maxdur) dtime, dflux, dfluxerr, dsamples, segstart, segend = \ bin_and_detrend(time, flux, fluxerr, nbins, segsize, detrend_order=0) out = bls_pulse_cython(dtime, dflux, dfluxerr, dsamples, nbins, segsize, mindur, maxdur, direction=2) bls_du_dip = out['duration_dip'] bls_dp_dip = out['depth_dip'] bls_mid_dip = out['midtime_dip'] bls_du_blip = out['duration_blip'] bls_dp_blip = out['depth_blip'] bls_mid_blip = out['midtime_blip'] bls_du = np.concatenate((bls_du_dip, bls_du_blip)) bls_dp = np.concatenate((bls_dp_dip, bls_dp_blip)) bls_mid = np.concatenate((bls_mid_dip, bls_mid_blip)) for j in xrange(len(midtime)): ndx = np.nanargmin(np.absolute(midtime[j] - bls_mid)) if ofile: ofile.write('%d\t%f\t%f\t%f\t%f\t%f\t%f\n' % (j, bls_mid[ndx], midtime[j], bls_dp[ndx], depth[j], bls_du[ndx], duration[j])) if is_straddling(midtime[j], duration[j], segsize, time): print 'Test segment %02d.....PASS (straddling)' % j continue try: diff_midtime = np.absolute(midtime[j] - bls_mid[ndx]) diff_depth = np.absolute(depth[j] - bls_dp[ndx]) diff_duration = np.absolute(duration[j] - bls_du[ndx]) errstring = 'Test segment %02d.....FAIL\n' % j if diff_midtime > midtime_atol: errstring += 'MIDTIME: Expected ' + str(midtime[j]) + \ ', measured ' + str(bls_mid[ndx]) + ', diff. ' + \ str(diff_midtime) + ', allowed diff. ' + str(midtime_atol) print errstring raise RuntimeError #elif abs(diff_depth / depth[j]) > depth_rtol: # errstring += 'DEPTH: Expected ' + str(depth[j]) + \ # ', measured ' + str(bls_dp[ndx]) + ', rel. diff. ' + \ # str(diff_depth / depth[j] * 100) + \ # '%, allowed rel. diff. ' + str(depth_rtol * 100) + '%' # print errstring # raise RuntimeError elif abs(diff_duration / duration[j]) > duration_rtol: errstring += 'DURATION: Expected ' + str(duration[j]) + \ ', measured ' + str(bls_du[ndx]) + ', rel. diff. ' + \ str(diff_duration / duration[j] * 100) + \ '%, allowed diff. ' + str(duration_rtol * 100) + '%' print errstring raise RuntimeError else: # All values within relative or absolute tolerances. print 'Test segment %02d.....PASS' % j except RuntimeError: if err_on_fail: sys.exit(1)
def main(): ''' Main function for this module. Parses all command line arguments, reads in data from stdin, and sends it to the proper BLS algorithm. ''' # This is a global list of default values that will be used by the argument parser # and the configuration parser. defaults = { 'min_duration': '0.0416667', 'max_duration': '0.5', 'n_bins': '100', 'direction': '0', 'mode': 'vec', 'print_format': 'encoded', 'verbose': '0', 'profiling': '0' } # Set up the parser for command line arguments and read them. parser = __init_parser(defaults) args = parser.parse_args() if not args.config: # No configuration file specified -- read in command line arguments. if not args.segment: parser.error( 'No trial segment specified and no configuration file given.') segment = args.segment mindur = args.mindur maxdur = args.maxdur nbins = args.nbins direction = args.direction mode = args.mode fmt = args.fmt verbose = args.verbose profile = args.profile else: # Configuration file was given; read in that instead. cp = SafeConfigParser(defaults) cp.read(args.config) segment = cp.getfloat('DEFAULT', 'segment') mindur = cp.getfloat('DEFAULT', 'min_duration') maxdur = cp.getfloat('DEFAULT', 'max_duration') nbins = cp.getint('DEFAULT', 'n_bins') direction = cp.getint('DEFAULT', 'direction') mode = cp.get('DEFAULT', 'mode') fmt = cp.get('DEFAULT', 'print_format') verbose = cp.getboolean('DEFAULT', 'verbose') profile = cp.getboolean('DEFAULT', 'profiling') # Perform any sanity-checking on the arguments. __check_args(segment, mindur, maxdur, nbins, direction) # Send the data to the algorithm. for k, q, time, flux, fluxerr in read_mapper_output(sys.stdin): # Extract the array columns. time = np.array(time, dtype='float64') flux = np.array(flux, dtype='float64') fluxerr = np.array(fluxerr, dtype='float64') if profile: # Turn on profiling. pr = cProfile.Profile() pr.enable() if mode == 'python': raise NotImplementedError out = bls_pulse_python(time, flux, fluxerr, nbins, segment, mindur, maxdur, direction=direction) elif mode == 'vec': raise NotImplementedError out = bls_pulse_vec(time, flux, fluxerr, nbins, segment, mindur, maxdur, direction=direction) elif mode == 'cython': out = bls_pulse_cython(time, flux, fluxerr, nbins, segment, mindur, maxdur, direction=direction) else: raise ValueError('Invalid mode: %s' % mode) if profile: # Turn off profiling. pr.disable() ps = pstats.Stats(pr, stream=sys.stderr).sort_stats('time') ps.print_stats() if direction == 2: srsq_dip = out['srsq_dip'] duration_dip = out['duration_dip'] depth_dip = out['depth_dip'] midtime_dip = out['midtime_dip'] srsq_blip = out['srsq_blip'] duration_blip = out['duration_blip'] depth_blip = out['depth_blip'] midtime_blip = out['midtime_blip'] segstart = out['segstart'] segend = out['segend'] # Print output. if fmt == 'encoded': print "\t".join([ k, q, encode_array(segstart), encode_array(segend), encode_array(srsq_dip), encode_array(duration_dip), encode_array(depth_dip), encode_array(midtime_dip), encode_array(srsq_blip), encode_array(duration_blip), encode_array(depth_blip), encode_array(midtime_blip) ]) elif fmt == 'normal': print "-" * 120 print "Kepler " + k print "Quarters: " + q print "-" * 120 print '{0: <7s} {1: <13s} {2: <13s} {3: <13s} {4: <13s} {5: <13s} {6: <13s} {7: <13s} ' \ '{8: <13s}'.format('Segment', 'Dip SR^2', 'Dip dur.', 'Dip depth', 'Dip mid.', 'Blip SR^2', 'Blip dur.', 'Blip depth', 'Blip mid.') for i in xrange(len(srsq_dip)): print '{0: <7d} {1: <13.6f} {2: <13.6f} {3: <13.6f} {4: <13.6f} ' \ '{5: <13.6f} {6: <13.6f} {7: <13.6f} {8: <13.6f}'.format(i, srsq_dip[i], duration_dip[i], depth_dip[i], midtime_dip[i], srsq_blip[i], duration_blip[i], depth_blip[i], midtime_blip[i]) print "-" * 120 print print else: srsq = out['srsq'] duration = out['duration'] depth = out['depth'] midtime = out['midtime'] segstart = out['segstart'] segend = out['segend'] # Print output. if fmt == 'encoded': print "\t".join([ k, q, encode_array(segstart), encode_array(segend), encode_array(srsq), encode_array(duration), encode_array(depth), encode_array(midtime) ]) elif fmt == 'normal': print "-" * 80 print "Kepler " + k print "Quarters: " + q print "-" * 80 print '{0: <7s} {1: <13s} {2: <10s} {3: <9s} {4: <13s}'.format( 'Segment', 'SR^2', 'Duration', 'Depth', 'Midtime') for i in xrange(len(srsq)): print '{0: <7d} {1: <13.6f} {2: <10.6f} {3: <9.6f} {4: <13.6f}'.format( i, srsq[i], duration[i], depth[i], midtime[i]) print "-" * 80 print print
def main(): ''' Main function for this module. Parses all command line arguments, reads in data from stdin, and sends it to the proper BLS algorithm. ''' # This is a global list of default values that will be used by the argument parser # and the configuration parser. defaults = {'min_duration':'0.0416667', 'max_duration':'0.5', 'n_bins':'100', 'direction':'0', 'mode':'vec', 'print_format':'encoded', 'verbose':'0', 'profiling':'0'} # Set up the parser for command line arguments and read them. parser = __init_parser(defaults) args = parser.parse_args() if not args.config: # No configuration file specified -- read in command line arguments. if not args.segment: parser.error('No trial segment specified and no configuration file given.') segment = args.segment mindur = args.mindur maxdur = args.maxdur nbins = args.nbins direction = args.direction mode = args.mode fmt = args.fmt verbose = args.verbose profile = args.profile else: # Configuration file was given; read in that instead. cp = SafeConfigParser(defaults) cp.read(args.config) segment = cp.getfloat('DEFAULT', 'segment') mindur = cp.getfloat('DEFAULT', 'min_duration') maxdur = cp.getfloat('DEFAULT', 'max_duration') nbins = cp.getint('DEFAULT', 'n_bins') direction = cp.getint('DEFAULT', 'direction') mode = cp.get('DEFAULT', 'mode') fmt = cp.get('DEFAULT', 'print_format') verbose = cp.getboolean('DEFAULT', 'verbose') profile = cp.getboolean('DEFAULT', 'profiling') # Perform any sanity-checking on the arguments. __check_args(segment, mindur, maxdur, nbins, direction) # Send the data to the algorithm. for k, q, time, flux, fluxerr in read_mapper_output(sys.stdin): # Extract the array columns. time = np.array(time, dtype='float64') flux = np.array(flux, dtype='float64') fluxerr = np.array(fluxerr, dtype='float64') if profile: # Turn on profiling. pr = cProfile.Profile() pr.enable() if mode == 'python': raise NotImplementedError out = bls_pulse_python(time, flux, fluxerr, nbins, segment, mindur, maxdur, direction=direction) elif mode == 'vec': raise NotImplementedError out = bls_pulse_vec(time, flux, fluxerr, nbins, segment, mindur, maxdur, direction=direction) elif mode == 'cython': out = bls_pulse_cython(time, flux, fluxerr, nbins, segment, mindur, maxdur, direction=direction) else: raise ValueError('Invalid mode: %s' % mode) if profile: # Turn off profiling. pr.disable() ps = pstats.Stats(pr, stream=sys.stderr).sort_stats('time') ps.print_stats() if direction == 2: srsq_dip = out['srsq_dip'] duration_dip = out['duration_dip'] depth_dip = out['depth_dip'] midtime_dip = out['midtime_dip'] srsq_blip = out['srsq_blip'] duration_blip = out['duration_blip'] depth_blip = out['depth_blip'] midtime_blip = out['midtime_blip'] segstart = out['segstart'] segend = out['segend'] # Print output. if fmt == 'encoded': print "\t".join([k, q, encode_array(segstart), encode_array(segend), encode_array(srsq_dip), encode_array(duration_dip), encode_array(depth_dip), encode_array(midtime_dip), encode_array(srsq_blip), encode_array(duration_blip), encode_array(depth_blip), encode_array(midtime_blip)]) elif fmt == 'normal': print "-" * 120 print "Kepler " + k print "Quarters: " + q print "-" * 120 print '{0: <7s} {1: <13s} {2: <13s} {3: <13s} {4: <13s} {5: <13s} {6: <13s} {7: <13s} ' \ '{8: <13s}'.format('Segment', 'Dip SR^2', 'Dip dur.', 'Dip depth', 'Dip mid.', 'Blip SR^2', 'Blip dur.', 'Blip depth', 'Blip mid.') for i in xrange(len(srsq_dip)): print '{0: <7d} {1: <13.6f} {2: <13.6f} {3: <13.6f} {4: <13.6f} ' \ '{5: <13.6f} {6: <13.6f} {7: <13.6f} {8: <13.6f}'.format(i, srsq_dip[i], duration_dip[i], depth_dip[i], midtime_dip[i], srsq_blip[i], duration_blip[i], depth_blip[i], midtime_blip[i]) print "-" * 120 print print else: srsq = out['srsq'] duration = out['duration'] depth = out['depth'] midtime = out['midtime'] segstart = out['segstart'] segend = out['segend'] # Print output. if fmt == 'encoded': print "\t".join([k, q, encode_array(segstart), encode_array(segend), encode_array(srsq), encode_array(duration), encode_array(depth), encode_array(midtime)]) elif fmt == 'normal': print "-" * 80 print "Kepler " + k print "Quarters: " + q print "-" * 80 print '{0: <7s} {1: <13s} {2: <10s} {3: <9s} {4: <13s}'.format('Segment', 'SR^2', 'Duration', 'Depth', 'Midtime') for i in xrange(len(srsq)): print '{0: <7d} {1: <13.6f} {2: <10.6f} {3: <9.6f} {4: <13.6f}'.format(i, srsq[i], duration[i], depth[i], midtime[i]) print "-" * 80 print print
def main(err_on_fail=True, allow_straddling=True, ofile=None, mode='python'): if ofile is not None: ofile.write('#\tMeas. mid.\tAct. mid.\tMeas. dpth.\tAct. dpth.\tMeas. ' 'dur.\tAct. dur\n') # Define absolute/relative tolerances. midtime_atol = 0.1 duration_rtol = 0.1 depth_rtol = 0.1 # How many lightcurves to simulate. n = 10 # Other parameters. minutes_per_day = 24. * 60. signal_to_noise, baseline = (1.e5, 90.) nsamples = np.ceil(baseline * minutes_per_day) segsize, mindur, maxdur, nbins = (2., 0.01, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) period_list = np.random.uniform(segsize, 30., size=n) # days duration_list = np.random.uniform(1. / 24., 5. / 24., size=n) # days depth_list = np.random.uniform(-0.01, -0.5, size=n) phase_list = np.random.uniform(0., 1., size=n) for i, p, du, dp, ph in zip(np.arange(n), period_list, duration_list, depth_list, phase_list): # Print a status update message. print 'TEST_BLS_PULSE: Test case', i + 1, 'of', n, '...' # Simulate the lightcurve. time, flux, fluxerr, duration, depth, midtime = \ simulate_box_lightcurve(p, du, dp, ph, signal_to_noise, nsamples, baseline) if mode == 'python': out = bls_pulse_python(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) elif mode == 'vec': out = bls_pulse_vec(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) elif mode == 'cython': dtime, dflux, dfluxerr, dsamples, segstart, segend = \ bin_and_detrend(time, flux, fluxerr, nbins, segsize, detrend_order=0) out = bls_pulse_cython(dtime, dflux, dfluxerr, dsamples, nbins, segsize, mindur, maxdur, direction=0) else: raise ValueError('Invalid test mode: %s' % mode) bls_du = out['duration'].ravel() bls_dp = out['depth'].ravel() bls_mid = out['midtime'].ravel() for j in xrange(len(midtime)): ndx = np.nanargmin(np.absolute(midtime[j] - bls_mid)) if ofile: ofile.write('%d\t%f\t%f\t%f\t%f\t%f\t%f\n' % (j, bls_mid[ndx], midtime[j], bls_dp[ndx], depth[j], bls_du[ndx], duration[j])) if is_straddling(midtime[j], duration[j], segsize, time): print ' Transit %02d.....PASS (straddling)' % j continue try: diff_midtime = np.absolute(midtime[j] - bls_mid[ndx]) diff_depth = np.absolute(depth[j] - bls_dp[ndx]) diff_duration = np.absolute(duration[j] - bls_du[ndx]) errstring = ' Transit %02d.....FAIL\n' % j if diff_midtime > midtime_atol: errstring += 'MIDTIME: Expected ' + str(midtime[j]) + \ ', measured ' + str(bls_mid[ndx]) + ', diff. ' + \ str(diff_midtime) + ', allowed diff. ' + \ str(midtime_atol) print errstring raise RuntimeError #elif abs(diff_depth / depth[j]) > depth_rtol: # errstring += 'DEPTH: Expected ' + str(depth[j]) + \ # ', measured ' + str(bls_dp[ndx]) + ', rel. diff. ' + \ # str(diff_depth / depth[j] * 100) + \ # '%, allowed rel. diff. ' + str(depth_rtol * 100) + '%' # print errstring # raise RuntimeError elif abs(diff_duration / duration[j]) > duration_rtol: errstring += 'DURATION: Expected ' + str(duration[j]) + \ ', measured ' + str(bls_du[ndx]) + ', rel. diff. ' + \ str(diff_duration / duration[j] * 100) + \ '%, allowed diff. ' + str(duration_rtol * 100) + '%' print errstring raise RuntimeError else: # All values within relative or absolute tolerances. print ' Transit %02d.....PASS' % j except RuntimeError: if err_on_fail: sys.exit(1)
def main(): # Number of baselines to try. n = 10 # Other parameters. minutes_per_day = 24. * 60. signal_to_noise = 10000. segsize, mindur, maxdur, nbins = (2., 0.01, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) duration = np.random.uniform(1. / 24., 5. / 24.) # days depth = np.random.uniform(-0.01, -0.5) phase = 0.5 # Create logarithmically spaced baselines. baselines = np.logspace(1., 3., n) # Allocate memory to store results. python_times = np.empty_like(baselines) vec_times = np.empty_like(baselines) cython_times = np.empty_like(baselines) for i in xrange(n): # Print a status update message. print 'BENCHMARK: Baseline =', baselines[i], '/', i + 1, 'of', n, '...' # Simulate the lightcurve. nsamples = np.ceil(baselines[i] * minutes_per_day) period = np.random.uniform(segsize, baselines[i]) # days time, flux, fluxerr, _, _, _ = simulate_box_lightcurve( period, duration, depth, phase, signal_to_noise, nsamples, baselines[i]) sys.stdout.write(' Running Python test...') sys.stdout.flush() python_start = clock() out_python = bls_pulse_python(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) python_end = clock() sys.stdout.write(' done.\n') sys.stdout.flush() sys.stdout.write(' Running vectorized test...') sys.stdout.flush() vec_start = clock() out_vec = bls_pulse_vec(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) vec_end = clock() sys.stdout.write(' done.\n') sys.stdout.flush() sys.stdout.write(' Running Cython test...') sys.stdout.flush() cython_start = clock() out_cython = bls_pulse_cython(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) cython_end = clock() sys.stdout.write(' done.\n') sys.stdout.flush() python_times[i] = python_end - python_start vec_times[i] = vec_end - vec_start cython_times[i] = cython_end - cython_start np.savez('unittests/benchmark.npz', baselines=baselines, python_times=python_times, vec_times=vec_times, cython_times=cython_times) __generate_figure()
def main(): # Number of baselines to try. n = 10 # Other parameters. minutes_per_day = 24. * 60. signal_to_noise = 10000. segsize, mindur, maxdur, nbins = (2., 0.01, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) duration = np.random.uniform(1. / 24., 5. / 24.) # days depth = np.random.uniform(-0.01, -0.5) phase = 0.5 # Create logarithmically spaced baselines. baselines = np.logspace(1., 3., n) # Allocate memory to store results. python_times = np.empty_like(baselines) vec_times = np.empty_like(baselines) cython_times = np.empty_like(baselines) for i in xrange(n): # Print a status update message. print 'BENCHMARK: Baseline =', baselines[i], '/', i + 1, 'of', n, '...' # Simulate the lightcurve. nsamples = np.ceil(baselines[i] * minutes_per_day) period = np.random.uniform(segsize, baselines[i]) # days time, flux, fluxerr, _, _, _ = simulate_box_lightcurve(period, duration, depth, phase, signal_to_noise, nsamples, baselines[i]) sys.stdout.write(' Running Python test...') sys.stdout.flush() python_start = clock() out_python = bls_pulse_python(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) python_end = clock() sys.stdout.write(' done.\n') sys.stdout.flush() sys.stdout.write(' Running vectorized test...') sys.stdout.flush() vec_start = clock() out_vec = bls_pulse_vec(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) vec_end = clock() sys.stdout.write(' done.\n') sys.stdout.flush() sys.stdout.write(' Running Cython test...') sys.stdout.flush() cython_start = clock() out_cython = bls_pulse_cython(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) cython_end = clock() sys.stdout.write(' done.\n') sys.stdout.flush() python_times[i] = python_end - python_start vec_times[i] = vec_end - vec_start cython_times[i] = cython_end - cython_start np.savez('unittests/benchmark.npz', baselines=baselines, python_times=python_times, vec_times=vec_times, cython_times=cython_times) __generate_figure()
def main(err_on_fail=True, allow_straddling=True, ofile=None, mode='python'): if ofile is not None: ofile.write( '#\tMeas. mid.\tAct. mid.\tMeas. dpth.\tAct. dpth.\tMeas. dur.\tAct. dur\n' ) # Define absolute/relative tolerances. midtime_atol = 0.1 duration_rtol = 0.1 depth_rtol = 0.1 # How many lightcurves to simulate. n = 10 # Other parameters. minutes_per_day = 24. * 60. signal_to_noise, baseline = (10000., 90.) nsamples = np.ceil(baseline * minutes_per_day) segsize, mindur, maxdur, nbins = (2., 0.01, 0.5, 1000) # To make it deterministic, seed the PRNG. np.random.seed(4) period_list = np.random.uniform(segsize, 30., size=n) # days duration_list = np.random.uniform(1. / 24., 5. / 24., size=n) # days depth_list = np.random.uniform(-0.01, -0.5, size=n) phase_list = np.random.uniform(0., 1., size=n) for i, p, du, dp, ph in zip(np.arange(n), period_list, duration_list, depth_list, phase_list): # Print a status update message. print 'TEST_BLS_PULSE: Test case', i + 1, 'of', n, '...' # Simulate the lightcurve. time, flux, fluxerr, duration, depth, midtime = simulate_box_lightcurve( p, du, dp, ph, signal_to_noise, nsamples, baseline) if mode == 'python': out = bls_pulse_python(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) elif mode == 'vec': out = bls_pulse_vec(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) elif mode == 'cython': out = bls_pulse_cython(time, flux, fluxerr, nbins, segsize, mindur, maxdur, detrend_order=0, direction=0) else: raise ValueError('Invalid test mode: %s' % mode) bls_du = out['duration'].ravel() bls_dp = out['depth'].ravel() bls_mid = out['midtime'].ravel() for j in xrange(len(midtime)): ndx = np.nanargmin(np.absolute(midtime[j] - bls_mid)) if ofile: ofile.write('%d\t%f\t%f\t%f\t%f\t%f\t%f\n' % (j, bls_mid[ndx], midtime[j], bls_dp[ndx], depth[j], bls_du[ndx], duration[j])) if is_straddling(midtime[j], duration[j], segsize, time): print ' Transit %02d.....PASS (straddling)' % j continue try: diff_midtime = np.absolute(midtime[j] - bls_mid[ndx]) diff_depth = np.absolute(depth[j] - bls_dp[ndx]) diff_duration = np.absolute(duration[j] - bls_du[ndx]) errstring = ' Transit %02d.....FAIL\n' % j if diff_midtime > midtime_atol: errstring += 'MIDTIME: Expected ' + str(midtime[j]) + ', measured ' + \ str(bls_mid[ndx]) + ', diff. ' + str(diff_midtime) + \ ', allowed diff. ' + str(midtime_atol) print errstring raise RuntimeError elif diff_depth / depth[j] > depth_rtol: errstring += 'DEPTH: Expected ' + str(depth[j]) + ', measured ' + \ str(bls_dp[ndx]) + ', rel. diff. ' + \ str(diff_depth / depth[j] * 100) + '%, allowed rel. diff. ' + \ str(depth_rtol * 100) + '%' print errstring raise RuntimeError elif diff_duration / duration[j] > duration_rtol: errstring += 'DURATION: Expected ' + str(duration[j]) + ', measured ' + \ str(bls_du[ndx]) + ', rel. diff. ' + \ str(diff_duration / duration[j] * 100) + '%, allowed diff. ' + \ str(duration_rtol * 100) + '%' print errstring raise RuntimeError else: # All values within relative or absolute tolerances. print ' Transit %02d.....PASS' % j except RuntimeError: if err_on_fail: sys.exit(1)