def find_direction_flux(orbit, orbit_id, find='max', file_flux='flux_', folder='flux'): '''Find out the direction in which the flux is the maximum or minimum for a given orbit''' import numpy as np import TimeStepping as ts import parameters as param # Prepare the grid just like for the observability maps. resx = param.resx resy = param.resy ra_i = 0 ra_f = 2.*np.pi dec_i = -np.pi/2. dec_f = np.pi/2. ra_step = (ra_f-ra_i)/resx dec_step = (dec_f-dec_i)/resy iterable = (ra_i + ra_step/2 + i*ra_step for i in range(resx)) ras = np.fromiter(iterable, np.float) iterable = (dec_i + dec_step/2 + i*dec_step for i in range(resy)) decs = np.fromiter(iterable, np.float) t_ini, t_end, a_ini, a_end = ts.orbit2times(orbit,orbit_id) t_ini = np.ceil(t_ini) # not sure it's useful. minute = t_ini if find == 'max' : sl = 0 else: sl = 1e9 dd = np.nan ########################################################################### # Iterate on every time. while (minute <= t_end): # initialise the array for the current minute (ie. make sure nothing is left in the table from last time step. # value = np.zeros(resx*resy) try: # Try to load the fluxes for a given minute (minute goes from 0 to period whereas a_ini is the absolute time from 0:0:0.0 1/1/2018 in min ra, dec, S_sl = load_flux_file(int(minute+a_ini), file_flux, folder=folder) except IOError: # If not found it means that the satellite is over the SAA. Skip this step. minute +=1 continue # Maps the data to the full grid. # for i, target in enumerate(S_sl): # id_ra = find_nearest(ras,ra[i]) # id_dec = find_nearest(decs,dec[i]) # value[id_ra, id_dec] = S_sl[i] if find == 'max' and np.amax(S_sl) > sl: sl = np.amax(S_sl) id_max = find_nearest(S_sl,sl) ra_f = ra[id_max] dec_f= dec[id_max] dd= minute+a_ini elif find == 'min' and np.amin(S_sl[np.where(S_sl>0)]) < sl: sl = np.amin(S_sl[np.where(S_sl>0)]) id_max = find_nearest(S_sl,sl) ra_f = ra[id_max] dec_f = dec[id_max] dd = minute+a_ini minute += 1 return dd, ra_f, dec_f, sl
def find_direction_flux(orbit, orbit_id, find='max', file_flux='flux_', folder='flux'): '''Find out the direction in which the flux is the maximum or minimum for a given orbit''' import numpy as np import TimeStepping as ts import parameters as param # Prepare the grid just like for the observability maps. resx = param.resx resy = param.resy ra_i = 0 ra_f = 2. * np.pi dec_i = -np.pi / 2. dec_f = np.pi / 2. ra_step = (ra_f - ra_i) / resx dec_step = (dec_f - dec_i) / resy iterable = (ra_i + ra_step / 2 + i * ra_step for i in range(resx)) ras = np.fromiter(iterable, np.float) iterable = (dec_i + dec_step / 2 + i * dec_step for i in range(resy)) decs = np.fromiter(iterable, np.float) t_ini, t_end, a_ini, a_end = ts.orbit2times(orbit, orbit_id) t_ini = np.ceil(t_ini) # not sure it's useful. minute = t_ini if find == 'max': sl = 0 else: sl = 1e9 dd = np.nan ########################################################################### # Iterate on every time. while (minute <= t_end): # initialise the array for the current minute (ie. make sure nothing is left in the table from last time step. # value = np.zeros(resx*resy) try: # Try to load the fluxes for a given minute (minute goes from 0 to period whereas a_ini is the absolute time from 0:0:0.0 1/1/2018 in min ra, dec, S_sl = load_flux_file(int(minute + a_ini), file_flux, folder=folder) except IOError: # If not found it means that the satellite is over the SAA. Skip this step. minute += 1 continue # Maps the data to the full grid. # for i, target in enumerate(S_sl): # id_ra = find_nearest(ras,ra[i]) # id_dec = find_nearest(decs,dec[i]) # value[id_ra, id_dec] = S_sl[i] if find == 'max' and np.amax(S_sl) > sl: sl = np.amax(S_sl) id_max = find_nearest(S_sl, sl) ra_f = ra[id_max] dec_f = dec[id_max] dd = minute + a_ini elif find == 'min' and np.amin(S_sl[np.where(S_sl > 0)]) < sl: sl = np.amin(S_sl[np.where(S_sl > 0)]) id_max = find_nearest(S_sl, sl) ra_f = ra[id_max] dec_f = dec[id_max] dd = minute + a_ini minute += 1 return dd, ra_f, dec_f, sl
def compare_two_orbits(orbit_ref, orbit_val, orbit_id, p=0.05, file_flux='flux_', folder='flux',shift=0, return_max=False, return_direction=False): '''compare_two_orbits returns the maximum difference between them in relative terms. Unit : - (ie. 0.05 means 5%)''' import numpy as np import TimeStepping as ts import parameters as param # Prepare the grid just like for the observability maps. resx = param.resx resy = param.resy ra_i = 0 ra_f = 2.*np.pi dec_i = -np.pi/2. dec_f = np.pi/2. ra_step = (ra_f-ra_i)/resx dec_step = (dec_f-dec_i)/resy iterable = (ra_i + ra_step/2 + i*ra_step for i in range(resx)) ras = np.fromiter(iterable, np.float) iterable = (dec_i + dec_step/2 + i*dec_step for i in range(resy)) decs = np.fromiter(iterable, np.float) t_ini2, t_end2, a_ini2, a_end2 = ts.orbit2times(orbit_ref,orbit_id) references=ts.LoadReferences(a_ini2, a_end2,ras,decs,file_flux=file_flux,folder=folder) if t_end2 == 99: shift+=1 t_ini, t_end, a_ini, a_end = ts.orbit2times(orbit_val,orbit_id) error_max = 0 second_chance= False count_error = True t_ini = np.ceil(t_ini) # not sure it's useful. minute = t_ini sl_max = 0 ########################################################################### # Iterate on every time. while (minute <= t_end): # initialise the array for the current minute (ie. make sure nothing is left in the table from last time step. value = np.zeros([resx,resy]) try: ref = references[minute,:,:] except IndexError: minute = t_end+1 continue try: # Try to load the fluxes for a given minute (minute goes from 0 to period whereas a_ini is the absolute time from 0:0:0.0 1/1/2018 in min ra, dec, S_sl = load_flux_file(int(minute+a_ini+shift), file_flux, folder=folder) except IOError: # If not found it means that the satellite is (propably) over the SAA. Skip this step. minute +=1 continue # Maps the data to the full grid. for i, target in enumerate(S_sl): id_ra = find_nearest(ras,ra[i]) id_dec = find_nearest(decs,dec[i]) value[id_ra, id_dec] = S_sl[i] if np.amax(value) > sl_max: sl_max = np.amax(value) # Mask all targets that are not in each array. value[np.where(value-ref==value)] = 0 ref[np.where(value==0)] = 0 # Proceed with computation of mag, then their relative difference diff = ts.DeltaMagnitude(value,ref) # Select all points that are on both arrays and if we output the flags, do it ;) tostats = diff[np.where(diff>0)] err = np.amax(diff) # Verify that no more than number_illegal points are different than p % of the reference if (diff[np.where(diff>p)]).shape[0] > 0: # Well, that's illegal. Is it a problem of indicies ? # We give a second chance to the code : if not (second_chance): second_chance = True minute -= 1 shift += 1 else: second_chance = False count_error = False # print the flag i for illegal as we already had a second chance. shift -= 1 else: # Do not take into account if there are values > p and their # is less then the number_illegal. diff[np.where(diff>p)]=0 second_chance = False # Record the maximum error, but if there is another run, dismiss. if error_max < np.amax(diff) and count_error : error_max = err del value if not count_error : count_error = True minute += 1 ########################################################################### # Treats the whole orbit if return_max: return error_max, sl_max else: return error_max
def compare_two_orbits(orbit_ref, orbit_val, orbit_id, p=0.05, file_flux='flux_', folder='flux', shift=0, return_max=False, return_direction=False): '''compare_two_orbits returns the maximum difference between them in relative terms. Unit : - (ie. 0.05 means 5%)''' import numpy as np import TimeStepping as ts import parameters as param # Prepare the grid just like for the observability maps. resx = param.resx resy = param.resy ra_i = 0 ra_f = 2. * np.pi dec_i = -np.pi / 2. dec_f = np.pi / 2. ra_step = (ra_f - ra_i) / resx dec_step = (dec_f - dec_i) / resy iterable = (ra_i + ra_step / 2 + i * ra_step for i in range(resx)) ras = np.fromiter(iterable, np.float) iterable = (dec_i + dec_step / 2 + i * dec_step for i in range(resy)) decs = np.fromiter(iterable, np.float) t_ini2, t_end2, a_ini2, a_end2 = ts.orbit2times(orbit_ref, orbit_id) references = ts.LoadReferences(a_ini2, a_end2, ras, decs, file_flux=file_flux, folder=folder) if t_end2 == 99: shift += 1 t_ini, t_end, a_ini, a_end = ts.orbit2times(orbit_val, orbit_id) error_max = 0 second_chance = False count_error = True t_ini = np.ceil(t_ini) # not sure it's useful. minute = t_ini sl_max = 0 ########################################################################### # Iterate on every time. while (minute <= t_end): # initialise the array for the current minute (ie. make sure nothing is left in the table from last time step. value = np.zeros([resx, resy]) try: ref = references[minute, :, :] except IndexError: minute = t_end + 1 continue try: # Try to load the fluxes for a given minute (minute goes from 0 to period whereas a_ini is the absolute time from 0:0:0.0 1/1/2018 in min ra, dec, S_sl = load_flux_file(int(minute + a_ini + shift), file_flux, folder=folder) except IOError: # If not found it means that the satellite is (propably) over the SAA. Skip this step. minute += 1 continue # Maps the data to the full grid. for i, target in enumerate(S_sl): id_ra = find_nearest(ras, ra[i]) id_dec = find_nearest(decs, dec[i]) value[id_ra, id_dec] = S_sl[i] if np.amax(value) > sl_max: sl_max = np.amax(value) # Mask all targets that are not in each array. value[np.where(value - ref == value)] = 0 ref[np.where(value == 0)] = 0 # Proceed with computation of mag, then their relative difference diff = ts.DeltaMagnitude(value, ref) # Select all points that are on both arrays and if we output the flags, do it ;) tostats = diff[np.where(diff > 0)] err = np.amax(diff) # Verify that no more than number_illegal points are different than p % of the reference if (diff[np.where(diff > p)]).shape[0] > 0: # Well, that's illegal. Is it a problem of indicies ? # We give a second chance to the code : if not (second_chance): second_chance = True minute -= 1 shift += 1 else: second_chance = False count_error = False # print the flag i for illegal as we already had a second chance. shift -= 1 else: # Do not take into account if there are values > p and their # is less then the number_illegal. diff[np.where(diff > p)] = 0 second_chance = False # Record the maximum error, but if there is another run, dismiss. if error_max < np.amax(diff) and count_error: error_max = err del value if not count_error: count_error = True minute += 1 ########################################################################### # Treats the whole orbit if return_max: return error_max, sl_max else: return error_max