def search_sbdb(name): """Searchs JPL Small-Body DataBase to search for object information. As the name implies, it looks only for Small Bodies. Planets and satellites information are not retrieved by this function. Parameters: name (str): The name of the object for the search. It can be the used spkid or designation number. The name is case insensitive. Return: sbdb (dict): An OrderedDict with the object information Important note: The query is not an autocomplete search, so name='Charikl' will not find Chariklo. If more than 1 object is found, the user is asked to select the correct one (e.g: name='neowise') """ print('Obtaining data for {} from SBDB'.format(name)) sbdb = SBDB.query(name, full_precision=True, solution_epoch=True, validity=True, phys=True, discovery=True) if 'message' in sbdb: if sbdb['message'] == values.not_found_message: raise ValueError(values.not_found_message + " on SBDB") elif sbdb['message'] == values.many_objects_message: sbdb = select_body(sbdb) return sbdb
def queryJPL(designation): """Query JPL Horizons for information about object 'designation'. Parameters ---------- designation: str A name for the object that JPL Horizons will understand. Returns ------- pd.Series Series containing orbit and select physical information. """ sbdb = SBDB.query(designation, phys=True, full_precision=True) if 'orbit' not in sbdb: raise ValueError( 'Problem identifying orbit in returned information: %s', sbdb) orbval = sbdb['orbit']['elements'] phys = sbdb['phys_par'] if 'diameter' in phys: diam = phys['diameter'].to('km') else: diam = np.NaN if 'albedo' in phys: albedo = float(phys['albedo']) else: albedo = np.NaN if 'H' in phys: H = phys['H'] else: H = 999. if 'rot_per' in phys: rot = phys['rot_per'].to('hr') else: rot = np.NaN if 'fullname' in sbdb['object']: fullname = sbdb['object']['fullname'] else: fullname = sbdb['object']['des'] orbit = pd.Series( data={ 'des': sbdb['object']['des'], 'fullname': fullname, 'FORMAT': 'KEP', 'a': orbval['a'].to('AU'), 'q': orbval['q'].to('AU'), 'e': float(orbval['e']), 'inc': orbval['i'].to('deg'), 'Omega': orbval['om'].to('deg'), 'argPeri': orbval['w'].to('deg'), 'tPeri': orbval['tp'].to('d') - 2400000.5, # to MJD 'meanAnomaly': orbval['ma'].to('deg'), 'epoch': sbdb['orbit']['epoch'].to('d') - 2400000.5, # to MJD 'H': H, 'g': 0.15, 'diam': diam, 'albedo': albedo, 'rot': rot }) return orbit
def from_sbdb(cls, name, **kargs): """Return osculating `Orbit` by using `SBDB` from Astroquery. Parameters ---------- body_name: string Name of the body to make the request. Returns ------- ss: poliastro.twobody.orbit.Orbit Orbit corresponding to body_name Examples -------- >>> from poliastro.twobody.orbit import Orbit >>> apophis_orbit = Orbit.from_sbdb('apophis') """ obj = SBDB.query(name, full_precision=True, **kargs) if "count" in obj: # no error till now ---> more than one object has been found # contains all the name of the objects objects_name = obj["list"]["name"] objects_name_in_str = ( "" ) # used to store them in string form each in new line for i in objects_name: objects_name_in_str += i + "\n" raise ValueError( str(obj["count"]) + " different objects found: \n" + objects_name_in_str ) a = obj["orbit"]["elements"]["a"].to(u.AU) * u.AU ecc = float(obj["orbit"]["elements"]["e"]) * u.one inc = obj["orbit"]["elements"]["i"].to(u.deg) * u.deg raan = obj["orbit"]["elements"]["om"].to(u.deg) * u.deg argp = obj["orbit"]["elements"]["w"].to(u.deg) * u.deg # Since JPL provides Mean Anomaly (M) we need to make # the conversion to the true anomaly (\nu) nu = M_to_nu(obj["orbit"]["elements"]["ma"].to(u.deg) * u.deg, ecc) epoch = time.Time(obj["orbit"]["epoch"].to(u.d), format="jd") ss = cls.from_classical( Sun, a, ecc, inc, raan, argp, nu, epoch=epoch.tdb, plane=Planes.EARTH_ECLIPTIC, ) return ss
def from_sbdb(cls, name, **kargs): """Return osculating `Orbit` by using `SBDB` from Astroquery. Parameters ---------- body_name: string Name of the body to make the request. Returns ------- ss: poliastro.twobody.orbit.Orbit Orbit corresponding to body_name Examples -------- >>> from poliastro.twobody.orbit import Orbit >>> apophis_orbit = Orbit.from_sbdb('apophis') """ obj = SBDB.query(name, full_precision=True, **kargs) if "count" in obj: # no error till now ---> more than one object has been found # contains all the name of the objects objects_name = obj["list"]["name"] objects_name_in_str = ( "" ) # used to store them in string form each in new line for i in objects_name: objects_name_in_str += i + "\n" raise ValueError( str(obj["count"]) + " different objects found: \n" + objects_name_in_str ) a = obj["orbit"]["elements"]["a"].to(u.AU) * u.AU ecc = float(obj["orbit"]["elements"]["e"]) * u.one inc = obj["orbit"]["elements"]["i"].to(u.deg) * u.deg raan = obj["orbit"]["elements"]["om"].to(u.deg) * u.deg argp = obj["orbit"]["elements"]["w"].to(u.deg) * u.deg # Since JPL provides Mean Anomaly (M) we need to make # the conversion to the true anomaly (\nu) nu = M_to_nu(obj["orbit"]["elements"]["ma"].to(u.deg) * u.deg, ecc) epoch = time.Time(obj["orbit"]["epoch"].to(u.d), format="jd") ss = cls.from_classical( Sun, a, ecc, inc, raan, argp, nu, epoch=epoch.tdb, plane=Planes.EARTH_ECLIPTIC, ) return ss
def getSBDBClass(obj_ids): data = {"targetname": [], "orbit_class": []} for obj_id in obj_ids: results = SBDB.query(obj_id) targetname = results["object"]["fullname"] orbit_class = results["object"]["orbit_class"]["name"] data["targetname"].append(targetname) data["orbit_class"].append(orbit_class) return pd.DataFrame(data)
def orbit_from_sbdb(name, **kwargs): obj = SBDB.query(name, full_precision=True, **kwargs) if "count" in obj: # No error till now ---> more than one object has been found # Contains all the name of the objects objects_name = obj["list"]["name"] objects_name_in_str = "" # Used to store them in string form each in new line for i in objects_name: objects_name_in_str += i + "\n" raise ValueError( str(obj["count"]) + " different objects found: \n" + objects_name_in_str) if "object" not in obj.keys(): raise ValueError(f"Object {name} not found") a = obj["orbit"]["elements"]["a"] ecc = float(obj["orbit"]["elements"]["e"]) * u.one inc = obj["orbit"]["elements"]["i"] raan = obj["orbit"]["elements"]["om"] argp = obj["orbit"]["elements"]["w"] # Since JPL provides Mean Anomaly (M) we need to make # the conversion to the true anomaly (nu) M = obj["orbit"]["elements"]["ma"].to(u.rad) # NOTE: It is unclear how this conversion should happen, # see https://ssd-api.jpl.nasa.gov/doc/sbdb.html if ecc < 1: M = (M + np.pi * u.rad) % (2 * np.pi * u.rad) - np.pi * u.rad nu = E_to_nu(M_to_E(M, ecc), ecc) elif ecc == 1: nu = D_to_nu(M_to_D(M)) else: nu = F_to_nu(M_to_F(M, ecc), ecc) epoch = Time(obj["orbit"]["epoch"].to(u.d), format="jd") return Orbit.from_classical( attractor=Sun, a=a, ecc=ecc, inc=inc, raan=raan, argp=argp, nu=nu, epoch=epoch.tdb, plane=Planes.EARTH_ECLIPTIC, )
def database_lookup(object_name): neo = SBDB.query(object_name) elements = neo['orbit']['elements'] #vecto = [elements['e'], # elements['a'], # elements['q'], # elements['i'], # elements['om'], # elements['w'], # elements['ma'], # elements['tp'], #elements['per'], # elements['n'], # elements['ad']] return (elements)
def from_sbdb(cls, name, **kargs): """Return osculating `Orbit` by using `SBDB` from Astroquery. Parameters ---------- body_name: string Name of the body to make the request. Returns ------- ss: poliastro.twobody.orbit.Orbit Orbit corresponding to body_name Examples -------- >>> from poliastro.twobody.orbit import Orbit >>> apophis_orbit = Orbit.from_sbdb('apophis') """ obj = SBDB.query(name, full_precision=True, **kargs) a = obj["orbit"]["elements"]["a"].to(u.AU) * u.AU ecc = float(obj["orbit"]["elements"]["e"]) * u.one inc = obj["orbit"]["elements"]["i"].to(u.deg) * u.deg raan = obj["orbit"]["elements"]["om"].to(u.deg) * u.deg argp = obj["orbit"]["elements"]["w"].to(u.deg) * u.deg # Since JPL provides Mean Anomaly (M) we need to make # the conversion to the true anomaly (\nu) nu = M_to_nu(obj["orbit"]["elements"]["ma"].to(u.deg) * u.deg, ecc) epoch = time.Time(obj["orbit"]["epoch"].to(u.d), format="jd") ss = cls.from_classical( Sun, a, ecc, inc, raan, argp, nu, epoch=epoch.tdb, plane=Planes.EARTH_ECLIPTIC, ) return ss
def sdss_colors(orbits, sdss_moc_filename='ADR4.dat'): sdss = read_sdss_moc(sdss_moc_filename) sdss = sdss.query('Name != "-"') jpl_des = np.zeros(len(sdss), dtype=object) for c, name in enumerate(sdss.Name.values): sbdb = SBDB.query(name.replace('_', ' ')) if 'object' in sbdb: jpl_des[c] = sbdb['object']['des'] sdss = sdss.assign(jpl_des=jpl_des) sdsscolors = {} bands = ('u', 'g', 'r', 'i', 'z', 'sdssa') errs = ('uerr', 'gerr', 'rerr', 'ierr', 'zerr', 'aerr') for band in bands: sdsscolors[band] = np.zeros(len(data)) - 999 for err in errs: sdsscolors[err] = np.zeros(len(data)) - 999 for c, des in enumerate(orbits.jpl_des.values): tmp = sdss.query('jpl_des == @des') if len(tmp) > 0: for band, err in zip(bands, errs): mags = sdss[des][band].values errors = sdss[des][err].values good = np.where((mags < 40) & (errors < 2)) if len(good[0]) > 0: mag = np.mean(mags[good]) errval = np.sqrt(np.sum(errors[good]**2)) sdsscolors[band][c] = mag sdsscolors[err][c] = errval colors = pd.DataFrame({ 'jpl_des': orbits.jpl_des.values, 'sdssa': sdsscolors['sdssa'], 'aerr': sdsscolors['aerr'], 'u': sdsscolors['u'], 'uerr': sdsscolors['uerr'], 'g': sdsscolors['g'], 'gerr': sdsscolors['gerr'], 'i': sdsscolors['i'], 'ierr': sdsscolors['ierr'], 'z': sdsscolors['z'], 'zerr': sdsscolors['zerr'] }) return colors
def from_sbdb(cls, targetids, references=False, notes=False): """Load physical properties from `JPL Small-Body Database (SBDB) <https://ssd.jpl.nasa.gov/sbdb.cgi>`_ using `~astroquery.jplsbdb` for one or more targets. Builds a `~Phys` object from the output of `'phys_par'` from SBDB. Units are applied, where available. Missing data are filled up as nan values. Note that SBDB only serves physical properties data for a limited number of objects. Parameters ---------- targetids : str, int or iterable thereof Target identifier(s) to be queried; use object numbers, names, or designations as unambiguous as possible. Returns ------- `~Phys` object Examples -------- >>> from sbpy.data import Phys >>> phys = Phys.from_sbdb(['Ceres', '12893', '3552']) # doctest: +REMOTE_DATA >>> print(phys['targetname', 'H', 'diameter']) # doctest: +SKIP targetname H diameter mag km -------------------------- ------------------ -------- 1 Ceres 3.34 939.4 12893 Mommert (1998 QS55) 13.9 5.214 3552 Don Quixote (1983 SA) 12.800000000000002 19.0 """ if not isinstance(targetids, (list, ndarray, tuple)): targetids = [targetids] alldata = [] columnnames = ['targetname'] columnunits = OrderedDict([('targetname', set())]) for targetid in targetids: sbdb = SBDB.query(str(targetid), phys=True) # assemble data from sbdb output data = OrderedDict([('targetname', sbdb['object']['fullname'])]) for key, val in sbdb['phys_par'].items(): if val is None or val == 'None': val = nan if '_note' in key: if notes: data[key] = val elif '_ref' in key: if references: data[key] = val else: try: if isnan(val): val = nan except TypeError: pass data[key] = val # add to columnnames if not yet there if key not in columnnames: columnnames.append(key) columnunits[key] = set() # identify units if isinstance(val, u.Quantity): columnunits[key].add(val.unit) elif isinstance(val, u.CompositeUnit): for unit in val.bases: columnunits[key].add(unit) alldata.append(data) # re-assemble data on a per-column basis coldata = [] for col in columnnames: data = [] for obj in alldata: try: data.append(obj[col]) except KeyError: data.append(nan) # identify common unit (or at least any unit) try: unit = list(columnunits[col])[0] # transform data to this unit newdata = [] for dat in data: if isinstance(dat, (u.Quantity, u.CompositeUnit)): try: newdata.append(dat.to(unit)) except u.UnitConversionError: # keep data untouched if conversion fails unit = 1 newdata = data break else: newdata.append(dat) except IndexError: # data has no unit assigned unit = 1 newdata = data # convert lists of strings to floats, where possible try: data = array(newdata).astype(float) except (ValueError, TypeError): data = newdata # apply unit, if available if unit != 1: coldata.append(data * unit) else: coldata.append(data) # assemble data as Phys object return cls.from_columns(coldata, names=columnnames)
def get_dict(name_list): """ # Return information for each bodies in name_list from JPL Small Body Database in form of dictionair # INPUT # name_list list [name1, name2, ..., nameN] # OUTPUT # dict_bodies dict with the following structure # str(name): "fullname" # "our_id" is the id inside the new dict, from 0 to N-1 where N is the name_list length # "neo_flag" # "orbit_class" # "pha_flag" # "object_kind" # "moid" # "orbita_elements" # "condition_code" # "rms" # "orbit_comment" # "magn_radius_flag" is "H" if the next parameter is the magnitude, is "D" if the next parameter is the diameter # "H" or "D" # "spectral_category_flag" T, S or 0 # "spectral_category" # "N_obs" Number of observations # "obs_span" Time between first and last observation # "impacts": str(impact id): 'width' # 'energy' # 'stretch' # 'ip' # 'dt' # 'date' # 'sigma_lov' # 'h' # 'mass' # 'v_inf' # 'sigma_imp' # 'method' # 'ts' # 'diam' # 'dist' # 'v_imp' # 'ps' """ our_id = 0 dict_bodies = {} for name in name_list: sbdb = SBDB.query(name, neo_only=True, full_precision=True, phys=True, virtual_impactor=True) if sbdb["object"]["kind"] != 'cn' or sbdb["object"]["kind"] != 'cu': asteroid = { "fullname": sbdb["object"]["fullname"], # TODO vogliamo fare un check? "our_id": our_id, "neo_flag": sbdb["object"]["neo"], "orbit_class": sbdb["object"]["orbit_class"]["code"], "pha_flag": sbdb["object"]["pha"], "object_kind": sbdb["object"] ["kind"], #an asteroid numbered au unbered asteroid (cn, cu for comet) "moid": sbdb["orbit"]["moid"], "orbital_elements": sbdb["orbit"]['elements'], "condition_code": sbdb["orbit"]["condition_code"], #OCC "rms": sbdb["orbit"]["rms"], "orbit_comment": sbdb["orbit"]["comment"], } try: asteroid["magn_radius_flag"] = 'H' asteroid["H"] = sbdb['phys_par']['H'] except: asteroid["magn_radius_flag"] = 'D' asteroid["D"] = sbdb['phys_par']['diameter'] asteroid["N_obs"] = sbdb['orbit']['n_obs_used'] asteroid["obs_span"] = sbdb['orbit']['data_arc'] asteroid["impacts"] = {} flag_bool = 1 if 'phys_par' in sbdb.keys(): spect_flag = 0 if 'spec_T' in sbdb['phys_par'].keys(): asteroid["spectral_category_flag"] = 'T' asteroid["spectral_category"] = sbdb['phys_par']['spec_T'] spect_flag = 1 if 'spec_B' in sbdb['phys_par'].keys(): asteroid["spectral_category_flag"] = 'B' asteroid["spectral_category"] = sbdb['phys_par']['spec_B'] spect_flag = 1 if spect_flag == 0: asteroid["spectral_category_flag"] = '0' else: asteroid["spectral_category"] = '0' if 'ip' in sbdb["vi_data"]: n_imp = len(sbdb["vi_data"]['ip']) for key in sbdb["vi_data"].keys(): if flag_bool == 1: for i in range(0, n_imp): asteroid["impacts"][str(i)] = {} flag_bool = 0 for i in range(0, n_imp): try: if isinstance(sbdb["vi_data"][key], str): asteroid["impacts"][str( i)][key] = sbdb["vi_data"][key] else: asteroid["impacts"][str( i)][key] = sbdb["vi_data"][key][i] except: print( name + " could raise error in importing virtual impact data" ) #this exception is raised if only one impact is present dict_bodies[name] = asteroid our_id = our_id + 1 flag_bool = 1 del asteroid return dict_bodies
def from_sbdb(cls, name, **kwargs): """Return osculating `Orbit` by using `SBDB` from Astroquery. Parameters ---------- name: str Name of the body to make the request. Returns ------- ss: poliastro.twobody.orbit.Orbit Orbit corresponding to body_name Examples -------- >>> from poliastro.twobody.orbit import Orbit >>> apophis_orbit = Orbit.from_sbdb('apophis') # doctest: +REMOTE_DATA """ from poliastro.bodies import Sun obj = SBDB.query(name, full_precision=True, **kwargs) if "count" in obj: # No error till now ---> more than one object has been found # Contains all the name of the objects objects_name = obj["list"]["name"] objects_name_in_str = ( "" # Used to store them in string form each in new line ) for i in objects_name: objects_name_in_str += i + "\n" raise ValueError( str(obj["count"]) + " different objects found: \n" + objects_name_in_str ) if "object" not in obj.keys(): raise ValueError(f"Object {name} not found") a = obj["orbit"]["elements"]["a"] ecc = float(obj["orbit"]["elements"]["e"]) * u.one inc = obj["orbit"]["elements"]["i"] raan = obj["orbit"]["elements"]["om"] argp = obj["orbit"]["elements"]["w"] # Since JPL provides Mean Anomaly (M) we need to make # the conversion to the true anomaly (nu) M = obj["orbit"]["elements"]["ma"].to(u.rad) # NOTE: It is unclear how this conversion should happen, # see https://ssd-api.jpl.nasa.gov/doc/sbdb.html if ecc < 1: M = (M + np.pi * u.rad) % (2 * np.pi * u.rad) - np.pi * u.rad nu = E_to_nu(M_to_E(M, ecc), ecc) elif ecc == 1: nu = D_to_nu(M_to_D(M)) else: nu = F_to_nu(M_to_F(M, ecc), ecc) epoch = time.Time(obj["orbit"]["epoch"].to(u.d), format="jd") ss = cls.from_classical( Sun, a, ecc, inc, raan, argp, nu, epoch=epoch.tdb, plane=Planes.EARTH_ECLIPTIC, ) return ss