def test_one2oneflux(self): dataset = tkp.db.DataSet(database=self.database, data={'description': 'flux test set: 1-1'}) n_images = 3 im_params = db_subs.generate_timespaced_dbimages_data(n_images) src_list = [] src = db_subs.example_extractedsource_tuple() src0 = src._replace(flux=2.0) src_list.append(src0) src1 = src._replace(flux=2.5) src_list.append(src1) src2 = src._replace(flux=2.4) src_list.append(src2) for idx, im in enumerate(im_params): image = tkp.db.Image(database=self.database, dataset=dataset, data=im) image.insert_extracted_sources([src_list[idx]]) associate_extracted_sources(image.id, deRuiter_r=3.717) query = """\ SELECT rf.avg_f_int FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat """ self.database.cursor.execute(query, {'dataset': dataset.id}) result = zip(*self.database.cursor.fetchall()) avg_f_int = result[0] self.assertEqual(len(avg_f_int), 1) py_metrics = db_subs.lightcurve_metrics(src_list) self.assertAlmostEqual(avg_f_int[0], py_metrics[-1]['avg_f_int']) runcat_id = columns_from_table('runningcatalog', where={'dataset': dataset.id}) self.assertEqual(len(runcat_id), 1) runcat_id = runcat_id[0]['id'] # Check evolution of variability indices db_metrics = db_queries.get_assoc_entries(self.database, runcat_id) self.assertEqual(len(db_metrics), n_images) # Compare the python- and db-calculated values for i in range(len(db_metrics)): for key in ('v_int', 'eta_int'): self.assertAlmostEqual(db_metrics[i][key], py_metrics[i][key])
def test_one2oneflux(self): dataset = tkp.db.DataSet(database=self.database, data={'description': 'flux test set: 1-1'}) n_images = 3 im_params = db_subs.generate_timespaced_dbimages_data(n_images) src_list = [] src = db_subs.example_extractedsource_tuple() src0 = src._replace(flux=2.0) src_list.append(src0) src1 = src._replace(flux=2.5) src_list.append(src1) src2 = src._replace(flux=2.4) src_list.append(src2) for idx, im in enumerate(im_params): image = tkp.db.Image(database=self.database, dataset=dataset, data=im) image.insert_extracted_sources([src_list[idx]]) associate_extracted_sources(image.id, deRuiter_r=3.717) query = """\ SELECT rf.avg_f_int FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat """ self.database.cursor.execute(query, {'dataset': dataset.id}) result = zip(*self.database.cursor.fetchall()) avg_f_int = result[0] self.assertEqual(len(avg_f_int), 1) py_metrics = db_subs.lightcurve_metrics(src_list) self.assertAlmostEqual(avg_f_int[0], py_metrics[-1]['avg_f_int']) runcat_id = columns_from_table('runningcatalog', where={'dataset':dataset.id}) self.assertEqual(len(runcat_id),1) runcat_id = runcat_id[0]['id'] # Check evolution of variability indices db_metrics = db_queries.get_assoc_entries(self.database, runcat_id) self.assertEqual(len(db_metrics), n_images) # Compare the python- and db-calculated values for i in range(len(db_metrics)): for key in ('v_int','eta_int'): self.assertAlmostEqual(db_metrics[i][key], py_metrics[i][key])
def test_lightcurve(self): # make 4 images with different date images = [] image_datasets = db_subs.generate_timespaced_dbimages_data(n_images=4, taustart_ts= datetime.datetime(2010, 3, 3) ) for dset in image_datasets: image = Image(dataset=self.dataset, data=dset) images.append(image) # 3 sources per image, with different coordinates & flux data_list = [] for i in range(1, 4): data_list.append({ 'ra': 111.11 + i, 'decl': 11.11 + i, 'i_peak': 10. * i , 'i_peak_err': 0.1, }) # Insert the 3 sources in each image, while further varying the flux lightcurves_sorted_by_ra = [[],[],[]] for im_idx, image in enumerate(images): # Create the "source finding results" # Note that we reuse 'i_peak' as both peak & integrated flux. img_sources = [] for src_idx, data in enumerate(data_list): src = db_subs.example_extractedsource_tuple( ra = data['ra'],dec=data['decl'], peak=data['i_peak']* (1 + im_idx), flux = data['i_peak']* (1 + im_idx) ) lightcurves_sorted_by_ra[src_idx].append(src) img_sources.append(src) insert_extracted_sources(image._id, img_sources) associate_extracted_sources(image._id, deRuiter_r=3.7, new_source_sigma_margin=3) # updates the dataset and its set of images self.dataset.update() self.dataset.update_images() # update the images and their sets of sources for image in self.dataset.images: image.update() image.update_sources() # Now pick last image, select the first source (smallest RA) # and extract its light curve sources = self.dataset.images[-1].sources sources = sorted(sources, key=attrgetter('ra')) lightcurve = ligtcurve_func(sources[0]._id) # check if the sources are associated in all images self.assertEqual(len(images), len(lightcurve)) self.assertEqual(lightcurve[0][0], datetime.datetime(2010, 3, 3, 0, 0)) self.assertEqual(lightcurve[1][0], datetime.datetime(2010, 3, 4, 0, 0)) self.assertEqual(lightcurve[2][0], datetime.datetime(2010, 3, 5, 0, 0)) self.assertEqual(lightcurve[3][0], datetime.datetime(2010, 3, 6, 0, 0)) self.assertAlmostEqual(lightcurve[0][2], 10.) self.assertAlmostEqual(lightcurve[1][2], 20.) self.assertAlmostEqual(lightcurve[2][2], 30.) self.assertAlmostEqual(lightcurve[3][2], 40.) #Check the summary statistics (avg flux, etc) query = """\ SELECT rf.avg_f_int ,rf.avg_f_int_sq ,avg_weighted_f_int ,avg_f_int_weight FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat ORDER BY r.wm_ra """ self.database.cursor.execute(query, {'dataset': self.dataset.id}) runcat_flux_entries = get_db_rows_as_dicts(self.database.cursor) self.assertEqual(len(runcat_flux_entries), len(lightcurves_sorted_by_ra)) for idx, flux_summary in enumerate(runcat_flux_entries): py_results = db_subs.lightcurve_metrics(lightcurves_sorted_by_ra[idx]) for key in flux_summary.keys(): self.assertAlmostEqual(flux_summary[key], py_results[-1][key]) #Now check the per-timestep statistics (variability indices) sorted_runcat_ids = columns_from_table('runningcatalog', where={'dataset':self.dataset.id}, order='wm_ra') sorted_runcat_ids = [entry['id'] for entry in sorted_runcat_ids] for idx, rcid in enumerate(sorted_runcat_ids): db_indices = db_queries.get_assoc_entries(self.database, rcid) py_indices = db_subs.lightcurve_metrics(lightcurves_sorted_by_ra[idx]) self.assertEqual(len(db_indices), len(py_indices)) for nstep in range(len(db_indices)): for key in ('v_int', 'eta_int', 'f_datapoints'): self.assertAlmostEqual(db_indices[nstep][key], py_indices[nstep][key], places=5)
def test_one2manyflux(self): dataset = tkp.db.DataSet(database=self.database, data={'description': 'flux test set: 1-n'}) n_images = 2 im_params = db_subs.generate_timespaced_dbimages_data(n_images) central_ra, central_dec = 123.1235, 10.55, position_offset_deg = 100. / 3600 #100 arcsec = 0.03 deg approx # image 1 image = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[0]) imageid1 = image.id img1_srclist = [] # 1 source img1_srclist.append( db_subs.example_extractedsource_tuple( central_ra, central_dec, peak=1.5, peak_err=5e-1, flux=3.0, flux_err=5e-1, )) dbgen.insert_extracted_sources(imageid1, img1_srclist, 'blind') associate_extracted_sources(imageid1, deRuiter_r=3.717) # image 2 image = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[1]) imageid2 = image.id img2_srclist = [] # 2 sources (both close to source 1, catching the 1-to-many case) img2_srclist.append( db_subs.example_extractedsource_tuple( central_ra, central_dec, peak=1.6, peak_err=5e-1, flux=3.2, flux_err=5e-1, )) img2_srclist.append( db_subs.example_extractedsource_tuple( central_ra + position_offset_deg, central_dec, peak=1.9, peak_err=5e-1, flux=3.4, flux_err=5e-1, )) dbgen.insert_extracted_sources(imageid2, img2_srclist, 'blind') associate_extracted_sources(imageid2, deRuiter_r=3.717) # Manually compose the lists of sources we expect to see associated # into runningcatalog entries: # NB img2_srclist[1] has larger RA value. lightcurves_sorted_by_ra = [] lightcurves_sorted_by_ra.append([img1_srclist[0], img2_srclist[0]]) lightcurves_sorted_by_ra.append([img1_srclist[0], img2_srclist[1]]) #Check the summary statistics (avg flux, etc) query = """\ SELECT rf.avg_f_int ,rf.avg_f_int_sq ,avg_weighted_f_int ,avg_f_int_weight FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat ORDER BY r.wm_ra """ self.database.cursor.execute(query, {'dataset': dataset.id}) runcat_flux_entries = get_db_rows_as_dicts(self.database.cursor) self.assertEqual(len(runcat_flux_entries), 2) for idx, flux_summary in enumerate(runcat_flux_entries): py_results = db_subs.lightcurve_metrics( lightcurves_sorted_by_ra[idx]) for key in flux_summary.keys(): self.assertAlmostEqual(flux_summary[key], py_results[-1][key]) #Now check the per-timestep statistics (variability indices) sorted_runcat_ids = columns_from_table('runningcatalog', where={'dataset': dataset.id}, order='wm_ra') sorted_runcat_ids = [entry['id'] for entry in sorted_runcat_ids] for idx, rcid in enumerate(sorted_runcat_ids): db_indices = db_queries.get_assoc_entries(self.database, rcid) py_indices = db_subs.lightcurve_metrics( lightcurves_sorted_by_ra[idx]) self.assertEqual(len(db_indices), len(py_indices)) for nstep in range(len(db_indices)): for key in ('v_int', 'eta_int', 'f_datapoints'): self.assertAlmostEqual(db_indices[nstep][key], py_indices[nstep][key])
def test_many2manyflux_reduced_to_two_1to1(self): """ (See also assoc. test test_many2many_reduced_to_two_1to1 ) In this test-case we cross-associate between a rhombus of sources spread about a central position, east-west in the first image, north-south in the second. The latter, north-south pair are slightly offset towards positive RA and negative RA respectively. The result is that the candidate associations are pruned down to two one-to-one pairings.. """ dataset = tkp.db.DataSet(database=self.database, data={ 'description': 'flux test set: n-m, ' + self._testMethodName }) n_images = 2 im_params = db_subs.generate_timespaced_dbimages_data(n_images) centre_ra, centre_dec = 123., 10.5, offset_deg = 20 / 3600. #20 arcsec tiny_offset_deg = 1 / 3600. #1 arcsec eastern_src = db_subs.example_extractedsource_tuple( ra=centre_ra + offset_deg, dec=centre_dec, peak=1.5, peak_err=1e-1, flux=3.0, flux_err=1e-1, ) western_src = db_subs.example_extractedsource_tuple( ra=centre_ra - offset_deg, dec=centre_dec, peak=1.7, peak_err=1e-1, flux=3.2, flux_err=1e-1, ) northern_source = db_subs.example_extractedsource_tuple( ra=centre_ra + tiny_offset_deg, dec=centre_dec + offset_deg, peak=1.8, peak_err=1e-1, flux=3.3, flux_err=1e-1, ) southern_source = db_subs.example_extractedsource_tuple( ra=centre_ra - tiny_offset_deg, dec=centre_dec - offset_deg, peak=1.4, peak_err=1e-1, flux=2.9, flux_err=1e-1, ) # image 1 image1 = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[0]) dbgen.insert_extracted_sources(image1.id, [eastern_src, western_src], 'blind') associate_extracted_sources(image1.id, deRuiter_r=3.717) # image 2 image2 = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[1]) dbgen.insert_extracted_sources(image2.id, [northern_source, southern_source], 'blind') associate_extracted_sources(image2.id, deRuiter_r=3.717) # Manually compose the lists of sources we expect to see associated # into runningcatalog entries: # NB img1_srclist[1] has larger RA value. lightcurves_sorted_by_ra = [] lightcurves_sorted_by_ra.append([western_src, southern_source]) lightcurves_sorted_by_ra.append([eastern_src, northern_source]) #Check the summary statistics (avg flux, etc) query = """\ SELECT rf.avg_f_int ,rf.avg_f_int_sq ,avg_weighted_f_int ,avg_f_int_weight FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat ORDER BY r.wm_ra, r.wm_decl """ self.database.cursor.execute(query, {'dataset': dataset.id}) runcat_flux_entries = get_db_rows_as_dicts(self.database.cursor) self.assertEqual(len(runcat_flux_entries), len(lightcurves_sorted_by_ra)) for idx, flux_summary in enumerate(runcat_flux_entries): py_results = db_subs.lightcurve_metrics( lightcurves_sorted_by_ra[idx]) for key in flux_summary.keys(): self.assertAlmostEqual(flux_summary[key], py_results[-1][key]) #Now check the per-timestep statistics (variability indices) sorted_runcat_ids = columns_from_table('runningcatalog', where={'dataset': dataset.id}, order='wm_ra,wm_decl') sorted_runcat_ids = [entry['id'] for entry in sorted_runcat_ids] for idx, rcid in enumerate(sorted_runcat_ids): db_indices = db_queries.get_assoc_entries(self.database, rcid) py_indices = db_subs.lightcurve_metrics( lightcurves_sorted_by_ra[idx]) self.assertEqual(len(db_indices), len(py_indices)) for nstep in range(len(db_indices)): for key in ('v_int', 'eta_int', 'f_datapoints'): self.assertAlmostEqual(db_indices[nstep][key], py_indices[nstep][key])
def test_one2manyflux(self): dataset = tkp.db.DataSet(database=self.database, data={'description': 'flux test set: 1-n'}) n_images = 2 im_params = db_subs.generate_timespaced_dbimages_data(n_images) central_ra, central_dec = 123.1235, 10.55, position_offset_deg = 100./3600 #100 arcsec = 0.03 deg approx # image 1 image = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[0]) imageid1 = image.id img1_srclist = [] # 1 source img1_srclist.append(db_subs.example_extractedsource_tuple(central_ra, central_dec, peak = 1.5, peak_err = 5e-1, flux = 3.0, flux_err = 5e-1, )) dbgen.insert_extracted_sources(imageid1, img1_srclist, 'blind') associate_extracted_sources(imageid1, deRuiter_r=3.717) # image 2 image = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[1]) imageid2 = image.id img2_srclist = [] # 2 sources (both close to source 1, catching the 1-to-many case) img2_srclist.append(db_subs.example_extractedsource_tuple( central_ra, central_dec, peak = 1.6, peak_err = 5e-1, flux = 3.2, flux_err = 5e-1, )) img2_srclist.append(db_subs.example_extractedsource_tuple( central_ra + position_offset_deg, central_dec, peak = 1.9, peak_err = 5e-1, flux = 3.4, flux_err = 5e-1, )) dbgen.insert_extracted_sources(imageid2, img2_srclist, 'blind') associate_extracted_sources(imageid2, deRuiter_r=3.717) # Manually compose the lists of sources we expect to see associated # into runningcatalog entries: # NB img2_srclist[1] has larger RA value. lightcurves_sorted_by_ra =[] lightcurves_sorted_by_ra.append( [img1_srclist[0], img2_srclist[0]]) lightcurves_sorted_by_ra.append( [img1_srclist[0], img2_srclist[1]]) #Check the summary statistics (avg flux, etc) query = """\ SELECT rf.avg_f_int ,rf.avg_f_int_sq ,avg_weighted_f_int ,avg_f_int_weight FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat ORDER BY r.wm_ra """ self.database.cursor.execute(query, {'dataset': dataset.id}) runcat_flux_entries = get_db_rows_as_dicts(self.database.cursor) self.assertEqual(len(runcat_flux_entries), 2) for idx, flux_summary in enumerate(runcat_flux_entries): py_results = db_subs.lightcurve_metrics(lightcurves_sorted_by_ra[idx]) for key in flux_summary.keys(): self.assertAlmostEqual(flux_summary[key], py_results[-1][key]) #Now check the per-timestep statistics (variability indices) sorted_runcat_ids = columns_from_table('runningcatalog', where={'dataset':dataset.id}, order='wm_ra') sorted_runcat_ids = [entry['id'] for entry in sorted_runcat_ids] for idx, rcid in enumerate(sorted_runcat_ids): db_indices = db_queries.get_assoc_entries(self.database, rcid) py_indices = db_subs.lightcurve_metrics(lightcurves_sorted_by_ra[idx]) self.assertEqual(len(db_indices), len(py_indices)) for nstep in range(len(db_indices)): for key in ('v_int', 'eta_int', 'f_datapoints'): self.assertAlmostEqual(db_indices[nstep][key], py_indices[nstep][key])
def test_many2manyflux_reduced_to_two_1to1(self): """ (See also assoc. test test_many2many_reduced_to_two_1to1 ) In this test-case we cross-associate between a rhombus of sources spread about a central position, east-west in the first image, north-south in the second. The latter, north-south pair are slightly offset towards positive RA and negative RA respectively. The result is that the candidate associations are pruned down to two one-to-one pairings.. """ dataset = tkp.db.DataSet(database=self.database, data={'description': 'flux test set: n-m, ' + self._testMethodName}) n_images = 2 im_params = db_subs.generate_timespaced_dbimages_data(n_images) centre_ra, centre_dec = 123., 10.5, offset_deg = 20 / 3600. #20 arcsec tiny_offset_deg = 1 / 3600. #1 arcsec eastern_src = db_subs.example_extractedsource_tuple( ra=centre_ra + offset_deg, dec=centre_dec, peak = 1.5, peak_err = 1e-1, flux = 3.0, flux_err = 1e-1,) western_src = db_subs.example_extractedsource_tuple( ra=centre_ra - offset_deg, dec=centre_dec, peak = 1.7, peak_err = 1e-1, flux = 3.2, flux_err = 1e-1,) northern_source = db_subs.example_extractedsource_tuple( ra=centre_ra + tiny_offset_deg, dec=centre_dec + offset_deg, peak = 1.8, peak_err = 1e-1, flux = 3.3, flux_err = 1e-1, ) southern_source = db_subs.example_extractedsource_tuple( ra=centre_ra - tiny_offset_deg, dec=centre_dec - offset_deg, peak = 1.4, peak_err = 1e-1, flux = 2.9, flux_err = 1e-1,) # image 1 image1 = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[0]) dbgen.insert_extracted_sources( image1.id, [eastern_src,western_src], 'blind') associate_extracted_sources(image1.id, deRuiter_r = 3.717) # image 2 image2 = tkp.db.Image(database=self.database, dataset=dataset, data=im_params[1]) dbgen.insert_extracted_sources( image2.id, [northern_source, southern_source], 'blind') associate_extracted_sources(image2.id, deRuiter_r = 3.717) # Manually compose the lists of sources we expect to see associated # into runningcatalog entries: # NB img1_srclist[1] has larger RA value. lightcurves_sorted_by_ra =[] lightcurves_sorted_by_ra.append( [western_src, southern_source]) lightcurves_sorted_by_ra.append( [eastern_src, northern_source]) #Check the summary statistics (avg flux, etc) query = """\ SELECT rf.avg_f_int ,rf.avg_f_int_sq ,avg_weighted_f_int ,avg_f_int_weight FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset)s AND r.id = rf.runcat ORDER BY r.wm_ra, r.wm_decl """ self.database.cursor.execute(query, {'dataset': dataset.id}) runcat_flux_entries = get_db_rows_as_dicts(self.database.cursor) self.assertEqual(len(runcat_flux_entries), len(lightcurves_sorted_by_ra)) for idx, flux_summary in enumerate(runcat_flux_entries): py_results = db_subs.lightcurve_metrics(lightcurves_sorted_by_ra[idx]) for key in flux_summary.keys(): self.assertAlmostEqual(flux_summary[key], py_results[-1][key]) #Now check the per-timestep statistics (variability indices) sorted_runcat_ids = columns_from_table('runningcatalog', where={'dataset':dataset.id}, order='wm_ra,wm_decl') sorted_runcat_ids = [entry['id'] for entry in sorted_runcat_ids] for idx, rcid in enumerate(sorted_runcat_ids): db_indices = db_queries.get_assoc_entries(self.database, rcid) py_indices = db_subs.lightcurve_metrics(lightcurves_sorted_by_ra[idx]) self.assertEqual(len(db_indices), len(py_indices)) for nstep in range(len(db_indices)): for key in ('v_int', 'eta_int', 'f_datapoints'): self.assertAlmostEqual(db_indices[nstep][key], py_indices[nstep][key])
def test_multi_epoch_source_flare_and_fade(self): """ A steady source (i.e. detected in first image) flares up, then fades and finally disappears. """ im_params = self.im_params transient_src = db_subs.MockSource( template_extractedsource=db_subs.example_extractedsource_tuple( ra=im_params[0]['centre_ra'], dec=im_params[0]['centre_decl'], ), lightcurve={ im_params[0]['taustart_ts']: self.barely_detectable_flux, im_params[1]['taustart_ts']: 2 * self.barely_detectable_flux, im_params[2]['taustart_ts']: self.barely_detectable_flux, }) inserted_sources = [] for img_pars in im_params[:2]: image, blind_xtr, forced_fits = insert_image_and_simulated_sources( self.dataset, img_pars, [transient_src], self.new_source_sigma_margin) self.assertEqual(len(forced_fits), 0) inserted_sources.extend(blind_xtr) #This should always be 0: newsources = get_newsources_for_dataset(self.dataset.id) self.assertEqual(len(newsources), 0) transients = get_sources_filtered_by_final_variability( dataset_id=self.dataset.id, **self.search_params) #We've seen a flare: self.assertEqual(len(transients), 1) transient_properties = transients[0] # Check that the bands for the images are the same as the transient's band freq_bands = frequency_bands(self.dataset._id) self.assertEqual(len(freq_bands), 1) self.assertEqual(freq_bands[0], transient_properties['band']) #Sanity check that the runcat is correctly matched runcats = runcat_entries(self.dataset._id) self.assertEqual(len(runcats), 1) self.assertEqual(runcats[0]['runcat'], transient_properties['runcat_id']) #Check we have sensible variability indices # print "\n",transient_properties metrics = db_subs.lightcurve_metrics(inserted_sources) # print "\nAfter two images:" for metric_name in 'v_int', 'eta_int': # print metric_name, transient_properties[metric_name] self.assertAlmostEqual(transient_properties[metric_name], metrics[-1][metric_name]) #Add 3rd image (another blind detection), check everything is sane image, blind_xtr, forced_fits = insert_image_and_simulated_sources( self.dataset, im_params[2], [transient_src], self.new_source_sigma_margin) self.assertEqual(len(forced_fits), 0) inserted_sources.extend(blind_xtr) self.assertEqual(len(get_newsources_for_dataset(self.dataset.id)), 0) # Ok, now add the last image and check that we get a correct forced-fit # request: image, blind_xtr, forced_fits = insert_image_and_simulated_sources( self.dataset, im_params[3], [transient_src], self.new_source_sigma_margin) self.assertEqual(len(blind_xtr), 0) self.assertEqual(len(forced_fits), 1) inserted_sources.extend(forced_fits) self.assertEqual(len(get_newsources_for_dataset(self.dataset.id)), 0) transients = get_sources_filtered_by_final_variability( dataset_id=self.dataset.id, **self.search_params) # Variability indices should take non-detections into account self.assertEqual(len(transients), 1) transient_properties = transients[0] metrics = db_subs.lightcurve_metrics(inserted_sources) # print "\nAfter four images:" for metric_name in 'v_int', 'eta_int': # print metric_name, transient_properties[metric_name] self.assertAlmostEqual(transient_properties[metric_name], metrics[-1][metric_name])
def test_multi_epoch_source_flare_and_fade(self): """ A steady source (i.e. detected in first image) flares up, then fades and finally disappears. """ im_params = self.im_params transient_src = db_subs.MockSource( template_extractedsource=db_subs.example_extractedsource_tuple( ra=im_params[0]['centre_ra'], dec=im_params[0]['centre_decl'], ), lightcurve={ im_params[0]['taustart_ts'] : self.barely_detectable_flux, im_params[1]['taustart_ts'] : 2*self.barely_detectable_flux, im_params[2]['taustart_ts'] : self.barely_detectable_flux, } ) inserted_sources = [] for img_pars in im_params[:2]: image, blind_xtr,forced_fits = insert_image_and_simulated_sources( self.dataset,img_pars,[transient_src], self.new_source_sigma_margin) self.assertEqual(len(forced_fits), 0) inserted_sources.extend(blind_xtr) #This should always be 0: newsources = get_newsources_for_dataset(self.dataset.id) self.assertEqual(len(newsources), 0) transients = get_sources_filtered_by_final_variability(dataset_id=self.dataset.id, **self.search_params) #We've seen a flare: self.assertEqual(len(transients), 1) transient_properties = transients[0] # Check that the bands for the images are the same as the transient's band freq_bands = frequency_bands(self.dataset._id) self.assertEqual(len(freq_bands), 1) self.assertEqual(freq_bands[0], transient_properties['band']) #Sanity check that the runcat is correctly matched runcats = runcat_entries(self.dataset._id) self.assertEqual(len(runcats), 1) self.assertEqual(runcats[0]['runcat'], transient_properties['runcat_id']) #Check we have sensible variability indices # print "\n",transient_properties metrics = db_subs.lightcurve_metrics(inserted_sources) # print "\nAfter two images:" for metric_name in 'v_int', 'eta_int': # print metric_name, transient_properties[metric_name] self.assertAlmostEqual(transient_properties[metric_name], metrics[-1][metric_name]) #Add 3rd image (another blind detection), check everything is sane image, blind_xtr,forced_fits = insert_image_and_simulated_sources( self.dataset,im_params[2],[transient_src], self.new_source_sigma_margin) self.assertEqual(len(forced_fits), 0) inserted_sources.extend(blind_xtr) self.assertEqual(len(get_newsources_for_dataset(self.dataset.id)),0) # Ok, now add the last image and check that we get a correct forced-fit # request: image, blind_xtr,forced_fits = insert_image_and_simulated_sources( self.dataset,im_params[3],[transient_src], self.new_source_sigma_margin) self.assertEqual(len(blind_xtr),0) self.assertEqual(len(forced_fits),1) inserted_sources.extend(forced_fits) self.assertEqual(len(get_newsources_for_dataset(self.dataset.id)),0) transients = get_sources_filtered_by_final_variability(dataset_id=self.dataset.id, **self.search_params) # Variability indices should take non-detections into account self.assertEqual(len(transients), 1) transient_properties = transients[0] metrics = db_subs.lightcurve_metrics(inserted_sources) # print "\nAfter four images:" for metric_name in 'v_int', 'eta_int': # print metric_name, transient_properties[metric_name] self.assertAlmostEqual(transient_properties[metric_name], metrics[-1][metric_name])