# Let's grab IRAC colors from Megeath. megeath2012_by_ukvar = index_secondary_by_primary(mated_ukvar, Megeath2012) megeath2012_full_by_ukvar = index_secondary_by_primary(mated_ukvar, Megeath_Full) megeath2012_all_by_ukvar = index_secondary_by_primary(mated_ukvar, Megeath_Allgoodsources) # XMM catalog gets matched too. XMM_north_by_ukvar = index_secondary_by_primary( tablemater(Rice_UKvars, [XMM_north]), XMM_north) # And let's make some color slope references that we like. jhk_slope_reference = filter_color_slopes(autovars_strict, 'jhk', slope_confidence=0.5) jh_slope_reference = filter_color_slopes(autovars_true, 'jh', slope_confidence=0.5) hk_slope_reference = filter_color_slopes(autovars_true, 'hk', slope_confidence=0.5) def clobber_table_write(table, filename, **kwargs): """ Writes a table, even if it has to clobber an older one. """ try: table.write(filename, **kwargs) except Exception, e: print e print "Overwriting file." os.remove(filename) table.write(filename, **kwargs)
def calculate_color_slope_ratios_versus_time_baseline(delta_t_list=None, date_offset=0, shuffle_dates=False): """ Calculates the color slope ratios for each possible time baseline. """ autovars_photometry = variables_photometry.where( np.in1d(variables_photometry.SOURCEID, autovars_true.SOURCEID) & (variables_photometry.MEANMJDOBS >= np.min(variables_photometry.MEANMJDOBS) + date_offset)) date_list = np.sort(list(set(np.floor(autovars_photometry.MEANMJDOBS)))) # I think this is the only place I need to shuffle? Maybe? if shuffle_dates: random.shuffle(autovars_photometry.MEANMJDOBS) n_positive_slope_list = [] n_negative_slope_list = [] n_undef_slope_list = [] n_variables_list = [] # calculate these properties: # most basic properties = [{'name':'time_baseline', 'function':get_timespan, 'target':'data', 'container':[]}, {'name':'n_obs', 'function':get_n_obs, 'target':'data', 'container':[]}] # how many variables, using different stetson cuts? properties.extend( [{'name':'n_variables_{0}'.format(x), 'function':partial(get_n_variables_stetson, stetson=x), 'target':'spreadsheet', 'container':[]} for x in (0.8, 1.0, 1.2) ] ) # basic properties -- j, h, k amplitudes / deviations properties.extend( [{'name':'median_{0}_{1}'.format(x,y1), 'function':partial(compute_function_on_column,y2,'{0}_ranger'.format(x)), 'target':'spreadsheet', 'container':[] } for x in ('j', 'h', 'k') for y1, y2 in zip(('amplitude', 'deviation'), (np.median, mad))] ) # now broken down into Class properties.extend( [{'name':'{2}_median_{0}_{1}'.format(x,y1, z1), 'function':partial(compute_function_on_column_selected,y2,'{0}_ranger'.format(x),z2), 'target':'spreadsheet', 'container':[] } for x in ('j', 'h', 'k') for y1, y2 in zip(('amplitude', 'deviation'), (np.median, mad)) for z1, z2 in zip(('protostar', 'disk', 'nondisk'), (protostar_IDs, disk_IDs, nondisk_IDs))] ) # For a bunch of different obs_initial's... # (note: when we test this, we may want to only go from the FIRST observation, and then add in the complexity of all the other ones later) # also note: we'll probably want to truncate the MJDs to the nearest integer to avoid any complications from the whole four-exposures-per-band-per-night thing. last_n_obs = 0 for obs_initial in date_list: print "Starting from: MJD %f" % obs_initial longest_time_separation = max(date_list) - obs_initial if delta_t_list == None: delta_t_list = range(int(np.ceil(longest_time_separation))) for delta_t in delta_t_list: relevant_data = autovars_photometry.where( (autovars_photometry.MEANMJDOBS >= obs_initial) & (autovars_photometry.MEANMJDOBS < obs_initial + delta_t) ) n_obs = len(list(set(np.floor(relevant_data.MEANMJDOBS)))) print "%d observations over %d (delta-t) days" % (n_obs, delta_t) if n_obs < 2: print "not enough observations for this to be called 'variability'. Continuing." continue elif n_obs == last_n_obs: print "No new observations have been added. Continuing." continue else: last_n_obs = n_obs # note: # if you don't add any new observations between this delta-t # and the last delta-t, DON'T COMPUTE A SPREADSHEET. just continue. # if timespan_of_relevant_data <= (delta_t - 1): # print timespan_of_relevant_data, delta_t, "timespan is too short to be considered in this delta_t bin. Continuing." # continue relevant_lookup = spread3.base_lookup(relevant_data, 0 ) relevant_spreadsheet = spread3.spreadsheet_write_efficient( 20, relevant_data, relevant_lookup, -1, None, flags=0, colorslope=True, rob=True) # then run color_slope_filtering on it... relevant_khk_spreadsheet = filter_color_slopes( relevant_spreadsheet, 'hk', lower_obs_limit=n_obs/3, upper_obs_limit=n_obs*1.5) relevant_khk_spreadsheet_no_slope_confidence = filter_color_slopes( relevant_spreadsheet, 'hk', slope_confidence=None, lower_obs_limit=n_obs/3, upper_obs_limit=n_obs*1.5) targets = {} targets['spreadsheet'] = relevant_spreadsheet targets['data'] = relevant_data # and extract which guys have colors in the relevant ranges! n_positive_slope = len(relevant_khk_spreadsheet[ (np.degrees(np.arctan(relevant_khk_spreadsheet.khk_slope)) > 25) ]) n_negative_slope = len(relevant_khk_spreadsheet[ (np.degrees(np.arctan(relevant_khk_spreadsheet.khk_slope)) < -25) ]) n_undef_slope = (len(relevant_khk_spreadsheet_no_slope_confidence) - (n_positive_slope + n_negative_slope) ) n_variables = len(relevant_spreadsheet[relevant_spreadsheet.Stetson >= 1.0]) for prop in properties: prop['container'].append(prop['function'](targets[prop['target']]) ) n_positive_slope_list.append( n_positive_slope ) n_negative_slope_list.append( n_negative_slope ) n_undef_slope_list.append( n_undef_slope ) n_variables_list.append( n_variables) break color_slope_ratios_table = atpy.Table() addc = color_slope_ratios_table.add_column addc("n_positive_slope", n_positive_slope_list) addc("n_negative_slope", n_negative_slope_list) addc("n_undef_slope", n_undef_slope_list) addc("n_variables", n_variables_list) for prop in properties: addc(prop['name'], prop['container']) return color_slope_ratios_table