def finalanglecheck(bam, traj, D, angle): points = traj.trajInterp2(div=100) ref_pos = Position(bam.setup.lat_centre, bam.setup.lon_centre, 0) azimuths = [] for pt in points: S = Position(pt[0], pt[1], pt[2]) S.pos_loc(ref_pos) D.pos_loc(ref_pos) sounding, _ = bam.atmos.getSounding(lat=[S.lat, D.lat], lon=[S.lon, D.lon], heights=[S.elev, D.elev]) az = cyscan(S.xyz, D.xyz, sounding) azimuths.append(az % 180) best_az_indx = np.nanargmin(np.abs(azimuths - angle)) err = np.abs(azimuths[best_az_indx] - angle) return points[best_az_indx], err
def angle2Geo(loc_coord, ref_loc): point = Position(0, 0, 0) point.x, point.y, point.z = loc_coord[0], loc_coord[1], loc_coord[2] point.pos_geo(ref_loc) return point
def windC(source, stn, atmos, Cs, s): # %========================================================================== # % # % sample variables: ([40 80 50],[40,85,1],atmos,340,[0,0,0]); # % # % This function calculates the speed of sound after it encounters winds. # % Input variables: # % source: [lat, long, elevation(km)] # % stn: [lat, long, elevation(km)] # % atmos: atmospheric profile # % Cs: ambient speed of sound # % switch: s = 0/1 switch [a,b,c], where # % a = inhomogeneous (1), homogeneous (0) atmosphere # % b = meridional winds on (1) or off (0) # % c = zonal winds on (1) or off (0) # % # % atmos = height, temperature, meridional, zonal, pressure # % Last modified on: 03-February-2010 # % E. A. Silber (c) 2010 # %========================================================================== # % # % determine the unit vector of the wave along the propagation path (great # % circle) sP = Position(*source) stP = Position(*stn) waveP = stP - sP x, y, z = waveP.x, waveP.y, waveP.z h = atmos[:, 0] k = len(h) wy = atmos[:, 2] wx = atmos[:, 3] wy0 = wy[0] wx0 = wx[0] Cs0 = Cs # % # %========================================================================== # % EFFECTIVE SPEED OF SOUND IN THE COMPONENT FORM # % Calculate the effective speed of sound components in the meridional and # % zonal direction. The effective speed of sound is the ambient speed of # % sound with added wind component # % Ceff = effective Cs in component form # % wCs = effective speed of sound (magnitude) Ceff = [] wCs = [] for i in range(k): Cx, Cy, Cz = (Cs0[i] + wx[i]) * x, (Cs0[i] + wy[i]) * y, Cs0[i] * z Ceff.append([Cx, Cy, Cz]) wCs.append(np.sqrt(Cx**2 + Cy**2 + Cz**2)) return wCs, wx, wy, Ceff
def addSources(self): title = self.title_edits.text() color = self.annote_color notes = self.notes_box.toPlainText() source_type = self.source_type.currentText() if source_type == "Fragmentation": source = Supracenter(Position(float(self.lat_edit.text()),\ float(self.lon_edit.text()), \ float(self.elev_edit.text())), \ float(self.time_edit.text())) elif source_type == "Ballistic": try: initial_pos = Position(float(self.lat_i_edit.text()), float(self.lon_i_edit.text()), float(self.elev_i_edit.text())) except ValueError: initial_pos = Position(None, None, None) try: final_pos = Position(float(self.lat_f_edit.text()), float(self.lon_f_edit.text()), float(self.elev_f_edit.text())) except ValueError: final_pos = Position(None, None, None) t = float(self.time_edit.text()) v = float(self.velocity_edit.text()) try: az = Angle(float(self.azimuth_edit.text())) except ValueError: az = None try: ze = Angle(float(self.zenith_edit.text())) except ValueError: ze = None source = Trajectory(t, v, zenith=ze, azimuth=az, pos_i=initial_pos, pos_f=final_pos, v_f=None) print(source) else: print("Error - unknown source") S = Source(title, source_type, source, notes=notes, color=color) if not hasattr(self.bam, "source_list"): self.bam.source_list = [] self.bam.source_list.append(S) self.close()
def makeTraj(x, args): base_points = args traj = Trajectory(0, 20000, zenith=Angle(x[1]), azimuth=Angle(x[0]), pos_f=Position(x[2], x[3], 0)) P = traj.trajInterp(div=20, write=True) masses = [] for pt in base_points: masses.append(pt[1]) error_pts = [] for source_loc in P: error = 0 for ii, m in enumerate(masses): az = (180 + traj.azimuth.deg)%360 ze = traj.zenith.deg darkFlight(source_loc, m, az, ze) data = readDarkflight(output, m) lat = data[-1, 0] lon = data[-1, 1] alt = data[-1, 2] error += (np.sqrt((lat-base_point[ii][0].lat)**2 + \ (lon-base_point[ii][0].lon)**2 + \ (alt-base_point[ii][0].elev)**2)) error_pts.append(error) return np.nanmin(error_pts)
def propegateBack(bam, stn, azimuth, offset=0, frag_height=30000): ref_pos = Position(bam.setup.lat_centre, bam.setup.lon_centre, 0) S = stn.metadata.position S.pos_loc(ref_pos) sounding, perturbations = bam.atmos.getSounding( lat=[S.lat, S.lat], lon=[S.lon, S.lon], heights=[S.elev, frag_height]) D = [] # Use 25 angles between 90 and 180 deg ### To do this more right, calculate D with bad winds, and then use D to find new winds and then recalc D for zenith in np.linspace(1, 89, 25): # D = anglescanrev(S.xyz, self.azimuth + offset, zenith, sounding, wind=True) # D = anglescanrev(S.xyz, (self.azimuth + offset + 180)%360, zenith, sounding, wind=True) D.append( anglescanrev(S.xyz, azimuth + offset, zenith, sounding, wind=True)) D.append( anglescanrev(S.xyz, (azimuth + offset + 180) % 360, zenith, sounding, wind=True)) # pt, err = finalanglecheck(self.bam, self.bam.setup.trajectory, self.stn.metadata.position, self.azimuth) start_pt = makePropLine(ref_pos, np.array(D)) return start_pt
def findNearestStation(lat, lon, stations): dist = [] for stn in stations: dist.append(stn.position.ground_latlon_distance(Position(lat, lon, 0))) return stations[np.nanargmin(dist)]
def tryPosition(lat, lon, elev): try: result = Position(lat, lon, elev) except: result = None return result
def trajectorySearch(bam, prefs): stat_file = os.path.join(prefs.workdir, bam.setup.fireball_name, bam.setup.station_picks_file) try: station_list = getStationList(stat_file) except TypeError as e: errorMessage('Unexpected station list location!', 2, info="Can not find where 'station_picks_file' is!", detail='{:}'.format(e)) return None except FileNotFoundError as e: errorMessage('Station Picks File was not found', 2, info="A .csv station picks file is required!", detail='{:}'.format(e)) return None class StationPick: def __init__(self): pass station_obj_list = [] for i in range(len(station_list)): stnp = StationPick() stnp.group = int(station_list[i][0]) stnp.network = station_list[i][1] stnp.code = station_list[i][2] stnp.position = Position(np.degrees(float(station_list[i][3])), \ np.degrees(float(station_list[i][4])), \ float(station_list[i][5])) stnp.position.pos_loc( Position(bam.setup.lat_centre, bam.setup.lon_centre, 0)) stnp.time = float(station_list[i][7]) station_obj_list.append([stnp.group, stnp.network, stnp.code, \ stnp.position.x, stnp.position.y, stnp.position.z, \ stnp.time]) return psoTrajectory(station_obj_list, bam, prefs)
def makeStaff(self, stn, ts, time_err, doc): # Generate pointes along trajecotry traj = self.bam.setup.trajectory points = traj.trajInterp2(div=100) D = stn.metadata.position ref_pos = Position(self.bam.setup.lat_centre, self.bam.setup.lon_centre, 0) D.pos_loc(ref_pos) times = [] heights = [] for pt in points: S = Position(pt[0], pt[1], pt[2]) S.pos_loc(ref_pos) sounding, perts = self.bam.atmos.getSounding( lat=[S.lat, D.lat], lon=[S.lon, D.lon], heights=[S.elev, D.elev]) f_time, _, _, _ = cyscan(S.xyz, D.xyz, sounding, wind=self.prefs.wind_en, n_theta=self.prefs.pso_theta, n_phi=self.prefs.pso_phi, \ h_tol=self.prefs.pso_min_ang, v_tol=self.prefs.pso_min_dist) times.append(f_time + pt[3]) heights.append(pt[2] / 1000) plt.scatter(heights, times) X = np.linspace(17, 50) for tt in range(len(ts)): plt.fill_between(X, ts[tt] - time_err[tt][0], y2=ts[tt] + time_err[tt][1]) plt.annotate('F{:}'.format(tt + 1), (18, ts[tt])) plt.axhline(y=ts[tt], color="black", linestyle="--") pic_file = os.path.join(self.prefs.workdir, self.bam.setup.fireball_name, 'staff.png') plt.savefig(pic_file) doc.add_picture(pic_file) os.remove(pic_file) plt.clf()
def psoDark(): azim_min = 330 azim_max = 335 zenith_min = 40 zenith_max = 45 lat_min = 45 lat_max = 46 lon_min = 15 lon_max = 16 base_points = [[Position(45.867428, 15.075969, 0), 0.469], [Position(45.816811, 15.112467, 0), 0.204], [Position(45.811897, 15.131436, 0), 0.048]] bounds_min = [azim_min, zenith_min, lat_min, lon_min] bounds_max = [azim_max, zenith_max, lat_max, lon_max] x_opt_temp, f_opt = pso(makeTraj, bounds_min, bounds_max, args=base_points, processes=multiprocessing.cpu_count(), particle_output=False)
def intCalc(self): stn = self.stn_list[self.current_station] if tryFloat(self.height_edits.text()) != None: height = tryFloat(self.height_edits.text()) self.rfang = tryFloat(self.rfangle_edits.text()) trans, ints, ts, ps, rfs, path_length, pdr = self.integrate( height, D_ANGLE=self.rfang) f_val = np.nanmean(trans) g_val = np.nanmean(ints) t_val = np.nanmean(ts) r_val = np.nanmean(rfs) # h = np.linspace(20000, 34000, 56) # d_ang = np.array([1.5, 2.0]) # c = ['w', 'm', 'r', 'b', 'g'] # print('Code Started') # for ii, d in enumerate(d_ang): # my_data = [] # for height in h: # trans, ints, ts, ps, rfs = self.integrate(height, D_ANGLE=d) # f_val = np.nanmean(trans) # g_val = np.nanmean(ints) # t_val = np.nanmean(ts) # p_val = np.nanmean(ps) # r_val = np.nanmean(rfs) # my_data.append(r_val) # print('RF: {:} | ANGLE: {:} | HEIGHT: {:}'.format(r_val, d, height)) # plt.scatter(h, my_data, label='Angle: {:} deg'.format(d), c=c[ii]) # plt.legend() # plt.show() # print('RF - Not checking if consistant') self.fd_edits.setText('{:.4f}'.format(f_val)) self.afi_edits.setText('{:.4f}'.format(g_val)) # self.c_edits.setText('{:.4f}'.format(t_val)) self.pressure_edits.setText('{:.4f}'.format(ps[0])) self.p_a_edits.setText('{:.4f}'.format(ps[1])) self.path_length = path_length self.pdr = pdr try: frag_pos = self.setup.trajectory.findGeo(height) except AttributeError: print("STATUS: No trajectory given, assuming lat/lon center") frag_pos = Position(self.setup.lat_centre, self.setup.lon_centre, height) self.geo_edits.setText('{:.4f}'.format(r_val)) stn_pos = stn.metadata.position dist = stn_pos.pos_distance(frag_pos) self.range_edits.setText('{:.4f}'.format(dist))
def windC(source, stn, atmos, Cs): sP = Position(*source) stP = Position(*stn) waveP = stP - sP x, y, z = waveP.x, waveP.y, waveP.z h = np.array(atmos[:, 0]) wy = np.array(atmos[:, 2]) wx = np.array(atmos[:, 3]) Ceff = [] wCs = [] for i in range(len(h)): Cx, Cy, Cz = (Cs[i] + wx[i]) * x, (Cs[i] + wy[i]) * y, Cs[i] * z Ceff.append([Cx, Cy, Cz]) wCs.append(np.sqrt(Cx * Cx + Cy * Cy + Cz * Cz)) wCs = np.array(wCs) Ceff = np.array(wCs) return wCs, wx, wy, Ceff
def loadIntoStations(data_list): stn_list = [] for station in data_list: meta = Metadata(station[0], station[1], \ Position(float(station[2]), float(station[3]), float(station[4])), station[5], source=station[9]) st = obspy.read(station[8]) resp = obspy.read_inventory(station[10]) stn = Station(meta, st, response=resp) stn_list.append(stn) return stn_list
def theoSearch(bam, prefs): ref_pos = Position(bam.setup.lat_centre, bam.setup.lon_centre, 0) s_info, s_name, weights = getStationData(bam.setup.station_picks_file, ref_pos) n_stations = len(s_name) xstn = s_info[0:n_stations, 0:3] results = psoSearch(s_info, weights, s_name, bam, prefs, ref_pos, pert_num=0, theo=True)
def saveStations(obj): stn_list = [] for stn_ex in obj.stat_widget_lst: if stn_ex.toggle.getState(): pos = Position(float(stn_ex.position.lat.text()), float(stn_ex.position.lon.text()), \ float(stn_ex.position.elev.text())) meta = Metadata(stn_ex.network.text(), stn_ex.code.text(), pos, stn_ex.name.text()) meta.enabled = True stn = Station(meta, stn_ex.stream, response=stn_ex.response) stn_list.append(stn) obj.bam.stn_list = stn_list save(obj, True)
def trySupracenter(statement, *t): supra_list = [] if len(t) == 0: try: for event in statement: supra_list.append( Supracenter(Position(event[0], event[1], event[2]), event[3])) except: supra_list = [None] else: try: supra_list.append(Supracenter(statement, t[0])) except: supra_list = [None] return supra_list
def saveEvent(self): traj = self.setup.trajectory points = traj.trajInterp2(div=tryInt(self.divisions.text()),\ min_p=tryFloat(self.low_point.text()),\ max_p=tryFloat(self.high_point.text())) for pt in points: source = Supracenter(Position(pt[0], pt[1], pt[2]), pt[3]) S = Source('Traj point - {:.2f} km'.format(pt[2] / 1000), 'Fragmentation', source) self.bam.source_list.append(S) save(self.obj, True) loadSourcesIntoBam(self.obj.bam) self.close()
def makePropLine(ref_pos, D, alpha=255): lats = [] lons = [] for line in D: temp = Position(0, 0, 0) temp.x = line[0] temp.y = line[1] temp.z = line[2] temp.pos_geo(ref_pos) if not np.isnan(temp.lat) and not np.isnan(temp.lon): lats.append(temp.lat) lons.append(temp.lon) lats.sort() lons.sort() return lats, lons
def saveStn(self): position = Position(float(self.lat.text()), float(self.lon.text()), float(self.elev.text())) st = obspy.read(self.edit.text()) meta = Metadata(self.network.text(), self.code.text(), position, self.name.text()) try: response = obspy.read_inventory(self.mresp_browser_edits.text()) except FileNotFoundError: response = None stn = Station(meta, st, response=response) self.bam.stn_list.append(stn) self.close()
def parseStationList(): file_name = 'supra/Atmosphere/igra2-station-list.txt' radio_stations = [] now = datetime.datetime.now() with open(file_name, 'r') as f: for line in f: line = line.split() a = Station( line[0], line[0], Position(float(line[1]), float(line[2]), float(line[3])), 'RSNDE', line[4]) if float(line[-2]) >= now.year: radio_stations.append(a) return radio_stations
def makePropLine(self, D, alpha=255): ref_pos = Position(self.bam.setup.lat_centre, self.bam.setup.lon_centre, 0) lats = [] lons = [] for line in D: temp = Position(0, 0, 0) temp.x = line[0] temp.y = line[1] temp.z = line[2] temp.pos_geo(ref_pos) if not np.isnan(temp.lat) and not np.isnan(temp.lon): lats.append(temp.lat) lons.append(temp.lon) lats.sort() lons.sort() start_pt = pg.PlotCurveItem() start_pt.setData(x=lons, y=lats) start_pt.setPen((255, 85, 0, alpha)) return start_pt
def calcAllTimes(stn_list, setup, sounding): """ Method to calculate all arrival times and place them into an array, so that they are not recalculated every time a new waveform is opened Arguments: data_list: [ndarray] array containing all station names and locations setup: [object] ini file parameters sounding: [ndarray] atmospheric profile Returns: allTimes: [ndarray] a ndarray that stores the arrival times for all stations over every perturbation [perturbation, station, 0 - ballistic/ 1 - fragmentation, frag number (0 for ballistic)] """ zenith_list = [5, 45, 85] velocity_list = [11, 15, 19, 23, 27, 31] ze_array = [0] * len(zenith_list) ze_array_dist = [0] * len(zenith_list) v_array = [0] * len(velocity_list) v_array_dist = [0] * len(velocity_list) #All perturbation happens here allTimes = [0] * setup.perturb_times allDists = [0] * setup.perturb_times # Ballistic Prediction ref_pos = Position(setup.lat_centre, setup.lon_centre, 0) #lat0, lon0, elev0 = data_list[0][2], data_list[0][3], data_list[0][4] # if setup.fragmentation_point == '': # setup.fragmentation_point = [] no_of_frags = len(setup.fragmentation_point) # array of frags and ballistic arrivals have to be the same size. So, minimum can be 1 if no_of_frags == 0: no_of_frags = 1 # Initialize variables b_time = 0 b_dist = 0 consts = Constants() # convert angles to radians az = np.radians(setup.azim) ze = np.radians(setup.zangle) # vector of the trajectory of the fireball traj_vect = np.array( [np.cos(az) * np.sin(ze), np.sin(az) * np.cos(ze), -np.cos(ze)]) # For temporal perturbations, fetch the soudning data for the hour before and after the event if setup.perturb_method == 'temporal': # sounding data one hour later sounding_u = parseWeather(setup, consts, time=1) # sounding data one hour earlier sounding_l = parseWeather(setup, consts, time=-1) else: sounding_u = [] sounding_l = [] if setup.perturb_method == 'ensemble': ensemble_file = setup.perturbation_spread_file d_time = (setup.perturb_times * len(stn_list) * no_of_frags * len(zenith_list) * len(velocity_list)) count = 0 #number of perturbations for ptb_n in range(setup.perturb_times - 1): if ptb_n > 0: if setup.debug: print("STATUS: Perturbation {:}".format(ptb_n)) # generate a perturbed sounding profile sounding_p = perturb(setup, sounding, setup.perturb_method, \ sounding_u=sounding_u, sounding_l=sounding_l, \ spread_file=setup.perturbation_spread_file, lat=setup.lat_centre, lon=setup.lon_centre, ensemble_file=ensemble_file, ensemble_no=ptb_n) else: # if not using perturbations on this current step, then return the original sounding profile sounding_p = sounding # Initialize station times array stnTimes = [0] * len(stn_list) stnDists = [0] * len(stn_list) #number of stations for n, stn in enumerate(stn_list): for ze_idx, ZE in enumerate(zenith_list): for v_idx, V in enumerate(velocity_list): # For ballistic arrivals if setup.show_ballistic_waveform: bTimes = [0] * no_of_frags bDist = [0] * no_of_frags for i in range(no_of_frags): #need filler values to make this a numpy array with fragmentation if i == 0: setup.zangle = ZE setup.v = V A, B = trajCalc(setup) setup.traj_i = Position(A[0], A[1], A[2]) setup.traj_f = Position(B[0], B[1], B[2]) stn.position.pos_loc(ref_pos) setup.traj_f.pos_loc(ref_pos) # Station location in local coordinates # xx, yy, zz = geo2Loc(lat0, lon0, elev0, \ # stat_lat, stat_lon, stat_elev) #xx, yy, zz = rotateVector(np.array([xx, yy, zz]), np.array([0, 0, 1]), -np.pi/2) # Time to travel from trajectory to station b_time = timeOfArrival([stn.position.x, stn.position.y, stn.position.z], setup.traj_f.x, setup.traj_f.y, setup.t0, 1000*V, \ np.radians(setup.azim), np.radians(ZE), setup, sounding=sounding_p, travel=False, fast=True, ref_loc=[ref_pos.lat, ref_pos.lon, ref_pos.elev], theo=True)# + setup.t S = waveReleasePointWinds([stn.position.x, stn.position.y, stn.position.z], setup.traj_f.x, setup.traj_f.y, setup.t0, 1000*V, \ np.radians(setup.azim), np.radians(ZE), setup, sounding_p, [ref_pos.lat, ref_pos.lon, ref_pos.elev]) # S = waveReleasePoint([stn.position.x, stn.position.y, stn.position.z], setup.traj_f.x, setup.traj_f.y, setup.t0, 1000*V, \ # np.radians(setup.azim), np.radians(ZE), 310) # Distance from the source location to the station #b_dist = ((stn.position.x)**2 + (stn.position.y)**2)**0.5 #bDist[i] = ((S[0] - stn.position.x)**2 + (S[1] - stn.position.y)**2 + (S[2] - stn.position.z)**2)**0.5 bDist[i] = S[2] bTimes[i] = b_time else: bDist[i] = np.nan bTimes[i] = np.nan else: bTimes = [np.nan] * no_of_frags bDist = [np.nan] * no_of_frags v_array_dist[v_idx] = np.array(bDist) v_array[v_idx] = np.array(bTimes) ze_array_dist[ze_idx] = np.array(v_array_dist) ze_array[ze_idx] = np.array(v_array) stnDists[n] = ([np.array(ze_array_dist)]) stnTimes[n] = ([np.array(ze_array)]) allDists[ptb_n] = np.array(stnDists) allTimes[ptb_n] = np.array(stnTimes) allTimes = np.array(allTimes) allDists = np.array(allDists) # Save as .npy file to be reused in SeismicTrajectory and Supracenter np.save( os.path.join(setup.working_directory, setup.fireball_name, 'all_pick_times'), allTimes) np.save( os.path.join(setup.working_directory, setup.fireball_name, 'all_pick_dists'), allDists) print("All Times File saved as {:}".format( os.path.join(setup.working_directory, setup.fireball_name, 'all_pick_times.npy'))) print("All Dists File saved as {:}".format( os.path.join(setup.working_directory, setup.fireball_name, 'all_pick_dists.npy'))) return allTimes
########################################################################################################## if not os.path.exists(setup.working_directory): os.makedirs(setup.working_directory) picks_name = setup.station_picks_file stn_list = [] with open(picks_name) as f: for ii, line in enumerate(f): if ii > 0: line = line.split(',') stn = Station( line[1], line[2], Position(float(line[3]), float(line[4]), float(line[5])), '...', '...', '...') stn_list.append(stn) # Remove duplicate lines recieved from different sources # stn_list = set(tuple(element) for element in stn_list) # stn_list = [list(t) for t in set(tuple(element) for element in stn_list)] if setup.stations is not None: stn_list = stn_list + setup.stations # Init the constants consts = Constants() setup.search_area = [0, 0, 0, 0] setup.search_area[0] = setup.lat_centre - setup.deg_radius setup.search_area[1] = setup.lat_centre + setup.deg_radius
def calcAllTimes(bam, prefs): ''' Calculates all arrivals to all stations ''' velocities = [11] zes = [85] az = 354.67 t = 0 pos_i = Position(48.1724466606, 13.0926245672, 50000) for vvv in range(len(velocities)): for z in range(len(zes)): points = [] file_name = 'C:\\Users\\lmcfd\\Desktop\\Theoretical\\v{:}_ze{:}.csv'.format( str(velocities[vvv]), str(zes[z])) with open(file_name, 'w+') as f: new_traj = Trajectory(t, velocities[vvv] * 1000, zenith=Angle(zes[z]), azimuth=Angle(az), pos_i=pos_i) points = new_traj.trajInterp2(div=150,\ min_p=17000,\ max_p=50000) az_temp = np.radians(az) ze_temp = np.radians(zes[z]) u = np.array([ np.sin(az_temp) * np.sin(ze_temp), np.cos(az_temp) * np.sin(ze_temp), -np.cos(ze_temp) ]) print(u) # Generate points #################### # Times Calculation #################### ref_pos = new_traj.pos_f no_of_frags = len(points) f.write( 'Net, Code, Nom time, min time, max time, time range, mean, length, std, nom height, min height, max height, height range, mean, length, std\n' ) for ii, stn in enumerate(bam.stn_list): print("Station {:}/{:} ".format(ii + 1, len(bam.stn_list))) stn.times = Times() stn.times.ballistic = [] stn.times.fragmentation = [] stn.metadata.position.pos_loc(ref_pos) ################ # Fragmentation ################ if prefs.frag_en: for i, frag in enumerate(points): offset = frag[3] a = [] supra = Position(frag[0], frag[1], frag[2]) # convert to local coordinates based off of the ref_pos supra.pos_loc(ref_pos) lats = [supra.lat, stn.metadata.position.lat] lons = [supra.lon, stn.metadata.position.lon] heights = [supra.elev, stn.metadata.position.elev] sounding, perturbations = bam.atmos.getSounding( lats, lons, heights) # Travel time of the fragmentation wave f_time, frag_azimuth, frag_takeoff, frag_err = cyscan(np.array([supra.x, supra.y, supra.z]), np.array([stn.metadata.position.x, stn.metadata.position.y, stn.metadata.position.z]), sounding, \ wind=prefs.wind_en, n_theta=prefs.pso_theta, n_phi=prefs.pso_phi, h_tol=prefs.pso_min_ang, v_tol=prefs.pso_min_dist) results = [] for pert in perturbations: temp = cyscan(np.array([supra.x, supra.y, supra.z]), np.array([stn.metadata.position.x, stn.metadata.position.y, stn.metadata.position.z]), pert, \ wind=prefs.wind_en, n_theta=prefs.pso_theta, n_phi=prefs.pso_phi, h_tol=prefs.pso_min_ang, v_tol=prefs.pso_min_dist) results.append(temp) a.append( [f_time, frag_azimuth, frag_takeoff, frag_err]) a.append(results) stn.times.fragmentation.append(a) ############ # Ballistic ############ if prefs.ballistic_en: best_indx = 0 az = 0 tf = 0 v = [] h_es = [] t_es = [] angle_off = [] X = [] for i in range(len(points)): az = stn.times.fragmentation[i][0][1] tf = stn.times.fragmentation[i][0][2] az = np.radians(az) tf = np.radians(180 - tf) v = np.array([ np.sin(az) * np.sin(tf), np.cos(az) * np.sin(tf), -np.cos(tf) ]) angle_off.append( np.degrees( np.arccos( np.dot(u / np.sqrt(u.dot(u)), v / np.sqrt(v.dot(v)))))) X.append(points[i][2]) angle_off = np.array(angle_off) try: best_indx = np.nanargmin(abs(angle_off - 90)) if not abs(angle_off[best_indx] - 90) <= 25: best_indx = None raise ValueError except ValueError: best_indx = None if best_indx is not None: h_es.append(points[best_indx][2]) t_es.append( stn.times.fragmentation[best_indx][0][0]) for pp in range(len(perturbations)): X = [] angle_off = [] for i in range(len(points)): az = stn.times.fragmentation[i][1][pp][1] tf = stn.times.fragmentation[i][1][pp][2] az = np.radians(az) tf = np.radians(180 - tf) v = np.array([ np.sin(az) * np.sin(tf), np.cos(az) * np.sin(tf), -np.cos(tf) ]) angle_off.append( np.degrees( np.arccos( np.dot(u / np.sqrt(u.dot(u)), v / np.sqrt(v.dot(v)))))) X.append(points[i][2]) angle_off = np.array(angle_off) try: best_indx = np.nanargmin(abs(angle_off - 90)) if not abs(angle_off[best_indx] - 90) <= 25: best_indx = None raise ValueError except ValueError: best_indx = None if best_indx is not None: h_es.append(points[best_indx][2]) t_es.append(stn.times.fragmentation[best_indx] [1][pp][0]) # supra = Position(points[best_indx][0], points[best_indx][1], points[best_indx][2]) # supra.pos_loc(ref_pos) # # Travel time of the fragmentation wave # f_time, frag_azimuth, frag_takeoff, frag_err = cyscan(np.array([supra.x, supra.y, supra.z]), np.array([stn.metadata.position.x, stn.metadata.position.y, stn.metadata.position.z]), sounding, \ # wind=prefs.wind_en, n_theta=prefs.pso_theta, n_phi=prefs.pso_phi, # h_tol=prefs.pso_min_ang, v_tol=prefs.pso_min_dist) # speed = bam.setup.trajectory.v # distance = supra.pos_distance(bam.setup.trajectory.pos_f) # timing = distance/speed # results = [] # print('ballistic', f_time) # for pert in perturbations: # e, b, c, d = cyscan(np.array([supra.x, supra.y, supra.z]), np.array([stn.metadata.position.x, stn.metadata.position.y, stn.metadata.position.z]), pert, \ # wind=prefs.wind_en, n_theta=prefs.pso_theta, n_phi=prefs.pso_phi, # h_tol=prefs.pso_min_ang, v_tol=prefs.pso_min_dist) # e += timing # results.append(np.array([e, b, c, d])) # a.append([f_time + timing, frag_azimuth, frag_takeoff, frag_err]) # a.append(results) # stn.times.ballistic.append(a) # print csv if len(t_es) > 0 and len(h_es) > 0: f.write('{:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:},\n'.format(stn.metadata.network,\ stn.metadata.code, \ t_es[0], np.nanmin(t_es), np.nanmax(t_es), np.nanmax(t_es)-np.nanmin(t_es), np.nanmean(t_es), len(t_es), np.std(t_es),\ h_es[0], np.nanmin(h_es), np.nanmax(h_es), np.nanmax(h_es)-np.nanmin(h_es), np.nanmean(h_es), len(h_es), np.std(h_es))) else: f.write('{:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:}, {:},\n'.format(stn.metadata.network,\ stn.metadata.code, \ np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,\ np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan)) # import winsound # duration = 1000 # milliseconds # freq = 440 # Hz # winsound.Beep(freq, duration) # winsound.Beep(freq*2, duration) exit() return None
def countStation(obj): print("Station Count:\n") print("##########################") seis_count = 0 infra_count = 0 seis_dist = np.inf infra_dist = np.inf ctbto_dist = np.inf ctbto_stats = [] with open(os.path.join("supra", "Misc", "CTBTO_stats.csv"), "r+") as f: a = f.readlines() for stat in a: stat_dat = stat.strip().split(',') stat_name = stat_dat[0] stat_lat = float(stat_dat[1]) stat_lon = float(stat_dat[2]) ctbto_stats.append(Position(stat_lat, stat_lon, 0)) # Extract coordinates of the reference station rng = False ref_pos = Position(obj.bam.setup.lat_centre, obj.bam.setup.lon_centre, 0) if hasattr(obj.bam.setup, "fragmentation_point"): if obj.prefs.frag_en and len(obj.bam.setup.fragmentation_point) >= 1: rng = True ref_pos = obj.bam.setup.fragmentation_point[0].position else: rng = False ref_pos = Position(obj.bam.setup.lat_centre, obj.bam.setup.lon_centre, 0) for stn in obj.bam.stn_list: stream = stn.stream if rng: stn.stn_distance(ref_pos) else: stn.stn_ground_distance(ref_pos) if len(stn.stream.select(channel="*HZ")) > 0: seis_count += 1 if rng: seis_temp = stn.distance else: seis_temp = stn.ground_distance if seis_temp <= seis_dist: seis_dist = seis_temp if len(stn.stream.select(channel="*DF")) > 0: infra_count += 1 if rng: infra_temp = stn.distance else: infra_temp = stn.ground_distance if infra_temp <= infra_dist: infra_dist = infra_temp for pos in ctbto_stats: dist = pos.ground_distance(ref_pos) if dist <= ctbto_dist: ctbto_dist = dist print("Seismic Stations: {:}".format(seis_count)) print("Infrasound Stations: {:}".format(infra_count)) if rng: print("Closest Seismic Station (Range): {:.3f} km".format( seis_dist / 1000)) print("Closest Infrasound Station (Range): {:.3f} km".format( infra_dist / 1000)) print("Closest CTBTO Station (Range): {:.3f} km".format( ctbto_dist / 1000)) else: print("Closest Seismic Station (Ground Distance): {:.3f} km".format( seis_dist / 1000)) print("Closest Infrasound Station (Ground Distance): {:.3f} km".format( infra_dist / 1000)) print("Closest CTBTO Station (Ground Distance): {:.3f} km".format( ctbto_dist / 1000))
def psoSearch(stns, w, s_name, bam, prefs, ref_pos, manual=False, pert_num=0, override_supra=[], theo=False): """ Optimizes the paths between the detector stations and a supracenter to find the best fit for the position of the supracenter, within the given search area. The supracenter is found with an initial guess, in a given grid, and is moved closer to points of better fit through particle swarm optimization. Produces a graph with the stations and residual results, and prints out the optimal supracenter location """ print('Data converted. Searching...') setup = bam.setup atmos = bam.atmos search_min = Position(setup.lat_min, setup.lon_min, setup.elev_min) search_max = Position(setup.lat_max, setup.lon_max, setup.elev_max) if not manual: try: search_min.pos_loc(ref_pos) search_max.pos_loc(ref_pos) except (AttributeError, TypeError) as e: errorMessage('Search min and search max have not been defined! Aborting search!', 2, info='Please define a search area in the "Sources" tab on the left side of the screen!', detail='{:}'.format(e)) return None output_name = prefs.workdir if not isinstance(override_supra, list): single_point = override_supra else: single_point = setup.manual_fragmentation_search[0] if single_point.toList()[0] is None and manual: errorMessage('Manual Fragmentation Point undefined', 2, info='Unable to parse: Lat: {:} Lon: {:} Elev: {:} Time: {:}'.format(*single_point.toList())) return None ref_time = setup.fireball_datetime if setup.enable_restricted_time: kotc = setup.restricted_time else: kotc = None # check if user defined occurrence time is used if kotc != None: kotc = (kotc - ref_time).total_seconds() # number of stations total n_stations = len(stns) # Station Location xstn = stns[0:n_stations, 0:3] # Initialize arrays # Travel time to each station time3D = np.zeros(n_stations) # Initial azimuths angles of each station az = np.zeros(n_stations) # Initial takeoff angles of each station tf = np.zeros(n_stations) # difference in theoretical and simulated travel times sotc = np.zeros_like(n_stations) # Initialize variables # combined weights nwn = sum(w) if prefs.ballistic_en: try: v = -setup.trajectory.vector.xyz setup.ref_pos = setup.trajectory.pos_f if prefs.debug: print("Constraining Trajectory") except: v = [None] if prefs.debug: print("Free Search") else: v = [None] if prefs.debug: print("Free Search") # If automatic search if not manual: # Prevent search below stations if search_min.elev < max(xstn[:, 2]): # Must be just above the stations search_min.elev = max(xstn[:, 2]) + 0.0001 # Boundaries of search volume # [x, y, z] local coordinates # arguments to be passed to timeFunction() args = (stns, w, kotc, setup, ref_pos, atmos, prefs, v, pert_num, theo) # Particle Swarm Optimization # x_opt - optimal supracenter location # f_opt - optimal supracenter error # if setup.restrict_to_trajectory: # #cons = [lineConstraintx, lineConstrainty, lineConstraintz] # x_opt, f_opt = pso(timeFunction, lb, ub, f_ieqcons=lineConstraint, args=args, swarmsize=int(setup.swarmsize), maxiter=int(setup.maxiter), \ # phip=setup.phip, phig=setup.phig, debug=False, omega=setup.omega, minfunc=setup.minfunc, minstep=setup.minstep) # else: # # Restricted to trajectory # if v[0] != None: # x_opt_temp, f_opt, sup, errors = pso(timeFunction, search_min.xyz, search_max.xyz, \ # ieqcons=[trajConstraints, timeConstraints], args=args,\ # swarmsize=int(prefs.pso_swarm_size), maxiter=int(prefs.pso_max_iter), \ # phip=prefs.pso_phi_p, phig=prefs.pso_phi_g, debug=False, omega=prefs.pso_omega, \ # minfunc=prefs.pso_min_error, minstep=prefs.pso_min_step, processes=1, particle_output=True) x_opt_temp, f_opt, sup, errors = pso(timeFunction, search_min.xyz, search_max.xyz, \ args=args, swarmsize=int(prefs.pso_swarm_size), maxiter=int(prefs.pso_max_iter), \ phip=prefs.pso_phi_p, phig=prefs.pso_phi_g, debug=False, omega=prefs.pso_omega,\ minfunc=prefs.pso_min_error, minstep=prefs.pso_min_step, processes=1, particle_output=True) print('Done Searching') x_opt = Position(0, 0, 0) x_opt.x = x_opt_temp[0] x_opt.y = x_opt_temp[1] x_opt.z = x_opt_temp[2] x_opt.pos_geo(ref_pos) # If manual search else: single_point.position.pos_loc(ref_pos) x_opt = single_point.position sup = single_point.position.xyz errors=0 # Get results for current Supracenter time3D, az, tf, r, motc, sotc, trace = outputWeather(n_stations, x_opt, stns, setup, \ ref_pos, atmos, output_name, s_name, kotc, w, prefs, theo) for ii, element in enumerate(time3D): if np.isnan(element): w[ii] = 0 sotc[ii] = 0 # Find error for manual searches if manual: f_opt = np.dot(w, np.absolute(sotc - np.dot(w, sotc)/nwn))/nwn # x, y distance from Supracenter to each station horz_dist = np.zeros(n_stations) for i in range(n_stations): horz_dist[i] = np.sqrt((x_opt.x - xstn[i, 0])**2 + (x_opt.y - xstn[i, 1])**2)/1000 # Calculate and Set the Occurrence Time into HH:MM:SS time_diff = motc + ref_time.microsecond/1e6 + ref_time.second + ref_time.minute*60 + ref_time.hour*3600 try: otc = (datetime.datetime.min + datetime.timedelta(seconds=time_diff)).time() except (ValueError, OverflowError): print('STATUS: Unable to parse otc') otc = None try: #while max(errors) > setup.max_error/100: a = [] std_error = np.std(errors) lim = np.mean(errors) + 0*std_error for i in range(len(errors)): if errors[i] >= lim: a.append(i) errors = np.delete(errors, (a), axis=0) sup = np.delete(sup, (a), axis=0) except: print("WARNING: Unable to filter errors") class Results: def __init__(self): pass results = Results() results.r = r results.w = w results.x_opt = x_opt results.f_opt = f_opt results.sup = sup results.errors = errors results.horz_dist = horz_dist results.time3D = time3D results.az = az results.tf = tf results.motc = motc results.sotc = sotc results.kotc = kotc results.otc = otc results.trace = trace return results # # scatter plot(s) # min_search, max_search = scatterPlot(single_point, n_stations, xstn, s_name, r, x_opt, \ # reported_points, search, output_name, ref_pos, sup, errors, tweaks, dataset) # # residual plot # residPlot(x_opt, s_name, xstn, r, output_name, n_stations) # # output results # outputText(min_search, max_search, single_point, ref_time, otc, kotc, x_opt, f_opt, n_stations, tweaks, s_name, xstn, \ # r, w, az, tf, time3D, horz_dist, output_name, tstn)
def timeFunction(x, *args): ''' Helper function for PSO Takes in supracenter ranges, and calculates the travel time, which is used to find the error. Returns the residual error with each guess of a supracenter from pso() Arguments: x: [ndarray] position to search with args: list of passed arguments stns: [list] list of station positions and arrival times w: [list] list of station weights kotc: [float] user-defined occurence time tweaks: [Object] user-defined option ref_pos: [list] mean station location used for converting to/from local coordinates dataset: [ndarray] atmospheric profile for the entire search area pool: [multiprocessing pool] pool of workers for multiprocessing Returns: err: [float] error in the current position, x, searched ''' # Retrieve passed arguments stns, w, kotc, setup, ref_pos, atmos, prefs, v, pert_num, theo = args # number of stations total n_stations = len(stns) # Residuals to each station sotc = np.empty(n_stations) # Initialize variables # Weight of each station wn = w # total weight nwn = sum(w) # Mean occurrence time motc = 0 S = Position(0, 0, 0) S.x, S.y, S.z = x[0], x[1], x[2] S.pos_geo(ref_pos) # number of stations total n_stations = len(stns) # Station Times tobs = stns[0:n_stations, 4] # Station Location xstn = stns[0:n_stations, 0:3] # Initialize arrays # Simulated travel times to each station time3D = np.empty(n_stations) # Residuals to each station sotc = np.empty(n_stations) for j in range(n_stations): # if station has weight if w[j] > 0: D = Position(0, 0, 0) D.x, D.y, D.z = xstn[j, 0], xstn[j, 1], xstn[j, 2] D.pos_geo(ref_pos) if not theo: if pert_num == 0: # No perturbations used here sounding, _ = atmos.getSounding(lat=[S.lat, D.lat], lon=[S.lon, D.lon], heights=[S.elev, D.elev], ref_time=setup.fireball_datetime) else: # Sounding is a specfic perturbation number # TODO: Go back and fix how this is done, not all perts need to be generated, just one here nom, sounding = atmos.getSounding(lat=[S.lat, D.lat], lon=[S.lon, D.lon], heights=[S.elev, D.elev], ref_time=setup.fireball_datetime) # sounding is none when there is an error in getting sounding if sounding is not None: sounding = sounding[pert_num - 1] else: sounding = nom # Use distance and atmospheric data to find path time time3D[j], _, _, _ = cyscan(S.xyz, D.xyz, sounding, \ wind=prefs.wind_en, h_tol=prefs.pso_min_ang, v_tol=prefs.pso_min_dist, processes=1) # Residual time for each station else: distance = np.sqrt((S.x - D.x)**2 + (S.y - D.y)**2 + (S.z - D.z)**2) time3D[j] = distance/prefs.avg_sp_sound sotc[j] = tobs[j] - time3D[j] # If station has no weight else: sotc[j] = tobs[j] motc = np.nanmean(sotc) ########## N_s = np.count_nonzero(~np.isnan(sotc)) # User defined occurrence time if kotc != None: # make kOTC a list err = np.dot(wn, np.absolute(sotc - np.array([kotc]*n_stations)))/nwn # Unknown occurrence time else: #err = np.dot(wn, np.absolute(sotc - motc))/nwn N_s = 0 err = 0 for s in sotc: if np.isnan(s): continue else: err += (1 + (s - motc)**2)**0.5 - 1 N_s += 1 if N_s == 0: err = np.inf else: err = err/N_s # if setup.debug: # # print out current search location # print("Supracenter: {:10.2f} m x {:10.2f} m y {:10.2f} m z Time: {:8.2f} Error: {:25.2f}".format(x[0], x[1], x[2], motc, err)) # variable to be minimized by the particle swarm optimization perc_fail = 100 - (n_stations-N_s)/n_stations*100 # temporary adjustment to try and get the most stations if N_s >= 3: total_error = err# + 2*max(error_list)*(failed_stats) else: total_error = np.inf if np.isnan(total_error): total_error = np.inf if prefs.debug: print("Error {:10.4f} | Solution {:10.4f}N {:10.4f}E {:8.2f} km {:8.2f} s | Failed Stats {:3} {:}".format(total_error, S.lat, S.lon, S.elev/1000, motc, n_stations-N_s, printPercent(perc_fail, N_s))) # Quick adjustment to try and better include stations return total_error
def makeWaveform(self, stn, times, time_err, doc, typ='frag', divs=[]): if len(times) == 0: return None st = stn.stream chn_list = [] for i in range(len(st)): chn = st[i].stats.channel[:2] chn_list.append((chn + '*')) chn_list = list(set(chn_list)) doc.add_paragraph('Available Channels:') doc.add_paragraph(', '.join(chn_list)) if 'BD*' in chn_list: chn_selected = 'BDF' elif 'HH*' in chn_list: chn_selected = 'HHZ' elif 'BH*' in chn_list: chn_selected = 'BHZ' st = st.select(channel=chn_selected)[0] st.detrend() waveform_data = st.data time_data = np.arange(0, st.stats.npts / st.stats.sampling_rate, st.stats.delta) waveform_data = waveform_data[:len(time_data)] start_datetime = st.stats.starttime.datetime end_datetime = st.stats.endtime.datetime stn.offset = (start_datetime - self.bam.setup.fireball_datetime).total_seconds() time_data = time_data[:len(waveform_data)] + stn.offset # Init the butterworth bandpass filter butter_b, butter_a = butterworthBandpassFilter(2, 8, \ 1.0/st.stats.delta, order=6) # Filter the data waveform_data = scipy.signal.filtfilt(butter_b, butter_a, np.copy(waveform_data)) plt.plot(time_data, waveform_data) for tt in range(len(times)): x1, x2, y1, y2 = plt.axis() y_range = y2 - y1 y_pos = 0.1 * y_range * tt if typ == 'frag': title = 'Fragmentation Arrivals' plt.annotate('F{:}'.format(tt + 1), (times[tt], y_pos), zorder=4) plt.errorbar([times[tt]], [y_pos], xerr=time_err[tt], fmt='o', zorder=3) elif typ == 'ball': title = 'Ballistic Arrivals' plt.annotate('B ', (times[tt], y_pos), zorder=4) plt.errorbar([times[tt]], [y_pos], xerr=time_err[tt], fmt='o', zorder=3) elif typ == 'prec': title = 'Precursor Arrivals' plt.annotate('P{:}'.format(tt + 1), (times[tt], y_pos), zorder=4) plt.errorbar([times[tt]], [y_pos], xerr=time_err[tt], fmt='o', zorder=3) elif typ == 'preview': title = 'All Arrivals' if tt < divs[0]: plt.annotate('F{:}'.format(tt + 1), (times[tt], y_pos), zorder=4) elif tt < divs[1] + divs[0]: plt.annotate('B ', (times[tt], y_pos), zorder=4) elif tt < divs[2] + divs[1] + divs[0]: plt.annotate('P{:}'.format(tt + 1 - divs[1] - divs[0]), (times[tt], y_pos), zorder=4) else: plt.annotate('?', (times[tt], y_pos), zorder=4) plt.errorbar([times[tt]], [y_pos], xerr=time_err[tt], fmt='o', zorder=3) plt.xlabel('Time after {:} [s]'.format( self.bam.setup.fireball_datetime)) plt.ylabel('Response') t_avg = np.nanmean(times) t_spr = np.nanstd(times) # I just REALLY want these to be nice graphs if t_spr > 0: plt.xlim(t_avg - SPREAD * t_spr, t_avg + SPREAD * t_spr) elif not np.isnan(t_avg): plt.xlim(t_avg - 5, t_avg + 5) elif not np.isnan(times[0]): plt.xlim(times[0] - 5, times[0] + 5) else: ref_pos = Position(self.bam.setup.lat_centre, self.bam.setup.lon_centre, 0) D = stn.stn_distance(ref_pos) plt.xlim(D / 330 - 5, D / 330 + 5) plt.title('{:} | Channel: {:}'.format(title, chn_selected)) pic_file = os.path.join(self.prefs.workdir, self.bam.setup.fireball_name, 'temp_Waveform.png') plt.savefig(pic_file) doc.add_picture(pic_file) os.remove(pic_file) plt.clf()
def psoTrajectory(station_list, bam, prefs): point_on_traj = None ref_pos = Position(bam.setup.lat_centre, bam.setup.lon_centre, 0) # ref_pos = bam.setup.trajectory.pos_f if bam.setup.pos_min.isNone() or bam.setup.pos_max.isNone(): errorMessage( 'Search boundaries are not defined!', 2, info= 'Please define the minimum and maximum parameters in the "Sources" tab on the left side of the screen!' ) return None bam.setup.pos_min.pos_loc(ref_pos) bam.setup.pos_max.pos_loc(ref_pos) if point_on_traj is None: bounds = [ (bam.setup.pos_min.x, bam.setup.pos_max.x), # X0 (bam.setup.pos_min.y, bam.setup.pos_max.y), # Y0 (bam.setup.t_min, bam.setup.t_max), # t0 (bam.setup.v_min, bam.setup.v_max), # Velocity (m/s) (bam.setup.azimuth_min.deg, bam.setup.azimuth_max.deg), # Azimuth (bam.setup.zenith_min.deg, bam.setup.zenith_max.deg ) # Zenith angle ] else: bounds = [ (bam.setup.v_min, bam.setup.v_max), # Velocity (m/s) (bam.setup.azimuth_min.deg, bam.setup.azimuth_max.deg), # Azimuth (bam.setup.zenith_min.deg, bam.setup.zenith_max.deg ) # Zenith angle ] lower_bounds = [bound[0] for bound in bounds] upper_bounds = [bound[1] for bound in bounds] if prefs.debug: print('Free Search') import matplotlib.pyplot as plt plt.ion() fig, ax = plt.subplots(2, 3, sharey='row') ax[0, 0].set_ylabel("Total Error") ax[1, 0].set_ylabel("Total Error") ax[0, 0].set_xlabel("Latitude") ax[0, 1].set_xlabel("Longitude") ax[0, 2].set_xlabel("Time") ax[1, 0].set_xlabel("Velocity") ax[1, 1].set_xlabel("Azimuth") ax[1, 2].set_xlabel("Zenith") plot = [] for i in range(2): for j in range(3): plot.append(ax[i, j].scatter([], [])) x, fopt = pso(trajSearch, lower_bounds, upper_bounds, args=(station_list, ref_pos, bam, prefs, plot, ax, fig, point_on_traj), \ maxiter=prefs.pso_max_iter, swarmsize=prefs.pso_swarm_size, \ phip=prefs.pso_phi_p, phig=prefs.pso_phi_g, debug=False, omega=prefs.pso_omega, \ particle_output=False) # if point_on_traj is None: print('Results:') print('X: {:.4f}'.format(x[0])) print('Y: {:.4f}'.format(x[1])) print('Time: {:.4f}'.format(x[2])) print('Velocity: {:.4f}'.format(x[3])) print('Azimuth: {:.4f}'.format(x[4])) print('Zenith: {:.4f}'.format(x[5])) print('Adjusted Error: {:.4f}'.format(fopt)) # else: # print('Results:') # print('Velocity: {:.4f}'.format(x[0])) # print('Azimuth: {:.4f}'.format(x[1])) # print('Zenith: {:.4f}'.format(x[2])) # print('Adjusted Error: {:.4f}'.format(fopt)) # if point_on_traj is None: geo = Position(0, 0, 0) geo.x = x[0] geo.y = x[1] geo.z = 0 geo.pos_geo(ref_pos) print('Geometric Landing Point:') print(geo) stat_names = [] stat_pick = [] final_traj = Trajectory(x[2], x[3], zenith=Angle(x[5]), azimuth=Angle(x[4]), pos_f=geo) points = final_traj.findPoints(gridspace=100, min_p=17000, max_p=50000) for stn in station_list: stat_names.append("{:}-{:}".format(stn[1], stn[2])) t_nom, t_pert = timeOfArrival(np.array([stn[3], stn[4], stn[5]]), final_traj, bam, prefs, points, ref_loc=ref_pos) stat_pick.append(t_nom - stn[6]) return [x, fopt, geo, stat_names, stat_pick]