def query_for_spectral_type(identifier, only_first_two_characters=True, default_sptype='G0'): """ Search SIMBAD for the spectral type of a star. If no spectral type is found, the default return value is ``"G0"``. Parameters ---------- identifier : str Name of target only_first_two_characters : bool Return only first two characters of spectral type? default_sptype : str Spectral type returned when none is found on SIMBAD Returns ------- sptype : str Spectral type of the star. """ customSimbad = Simbad() customSimbad.SIMBAD_URL = 'http://simbad.harvard.edu/simbad/sim-script' customSimbad.add_votable_fields('sptype') result = customSimbad.query_object(identifier) if len(result['SP_TYPE']) > 0: if only_first_two_characters: return result['SP_TYPE'][0][:2].strip().decode() else: return result['SP_TYPE'][0].decode() else: return default_sptype.decode()
def get_random_object(max_star_fraction=0.1): """ Choose random RA/DEC and select nearest SIMBAD source, biasing against boring-looking stars. Returns a human-readable txt string and object RA/DEC. """ customSimbad = Simbad() customSimbad.add_votable_fields('otype(V)','coo(d)') coo = coord.SkyCoord(random()*360,random()*180-90,unit='deg') results = customSimbad.query_region(coo,radius='1 deg') for res in results: obj_name = ' '.join(res['MAIN_ID'].split()) obj_type = res['OTYPE_V'] if 'star' in obj_type.lower() and random() > max_star_fraction: continue a_an = 'an' if obj_type[0].upper() in ('X','A','E','I','O','U') else 'a' obj_coo = coord.SkyCoord(res['RA_d'],res['DEC_d'],unit='deg') constellation = coord.get_constellation(obj_coo) greeting = greetings[randint(0,len(greetings)-1)] txt_str = greeting + " %s is %s %s in the constellation %s. More: %s%s" % \ (obj_name,a_an,obj_type,constellation,more_url,urlencode({'Ident':obj_name})) return obj_name,txt_str,res['RA_d'],res['DEC_d']
def get_data(self): result_table = Simbad() # Extended timeout to search for 1000 rows result_table.TIMEOUT = 120 result_table.ROW_LIMIT = 1000 result_table.add_votable_fields( "flux(V)", "mt", "otype", "ra", "dec", "dim", "flux(U)", "flux(B)", "flux(R)", "flux(I)", "flux(J)", "flux(H)", "flux(K)", "flux(u)", "flux(g)", "flux(r)", "flux(i)", "flux(z)", *self.args ) result_table = result_table.query_object(self.name, **self.kwargs) return result_table
def construct_standard_star_table(stars, write_to=results_dir): mwo_dict = dict() apo_dict = dict() for star in stars: mwo_dict[star.name.upper()] = [] apo_dict[star.name.upper()] = [] names = list(mwo_dict.keys()) for star_name in names: all_obs_this_star = [star for star in stars if star.name.upper() == star_name] mwo_dict[star_name] = combine_measurements([s.s_mwo for s in all_obs_this_star]) apo_dict[star_name] = combine_measurements([s.s_apo for s in all_obs_this_star]) sp_types = [] s_mwo = [] s_apo = [] n_obs = [] for star in names: s_mwo.append(mwo_dict[star].to_latex()) s_apo.append(apo_dict[star].to_latex()) n_obs.append(apo_dict[star].meta) customSimbad = Simbad() customSimbad.add_votable_fields('sptype') sp_type = customSimbad.query_object(star)['SP_TYPE'][0] sp_types.append(sp_type) print('N_stars = {0}'.format(len(names))) print('N_spectra = {0}'.format(sum(n_obs))) print('N_sptype=G = {0}'.format(len([spt for spt in sp_types if spt.startswith(b'G')]))) print('N_sptype=K = {0}'.format(len([spt for spt in sp_types if spt.startswith(b'K')]))) print('N_sptype=M = {0}'.format(len([spt for spt in sp_types if spt.startswith(b'M')]))) # for star in stars: # names.append(star.name.upper()) # customSimbad = Simbad() # customSimbad.add_votable_fields('sptype') # sp_type = customSimbad.query_object(star.name)['SP_TYPE'][0] # sp_types.append(sp_type) # # s_mwo.append(star.s_mwo.to_latex()) # s_apo.append(star.s_apo.to_latex()) standard_table = Table([names, sp_types, s_mwo, s_apo, n_obs], names=['Star', 'Sp.~Type', '$S_{MWO}$', '$S_{APO}$', '$N$']) standard_table.sort(keys='$S_{MWO}$') latexdict = dict(col_align='l l c c c', preamble=r'\begin{center}', tablefoot=r'\end{center}', caption=r'Stars observed to calibrate the $S$-index ' r'(see Section~\ref{sec:def_s_index}). \label{tab:cals}', data_start=r'\hline') # output_path, ascii.write(standard_table, format='latex', latexdict=latexdict, output='cal_stars.tex')
def classify_file(filename, astroquery=True): """ This function uses the fits header information and the Simbad database to classify the object :param filename: The filename of the observation to be classified :return: """ # Read in the header and get the object name header = fits.getheader(filename) object = header['object'] print object # Default values plx = 30.0 # Make a Simbad object if astroquery: sim = Simbad() sim.add_votable_fields('plx', 'sp') data = sim.query_object(object) plx = data['PLX_VALUE'].item() spt_full = data['SP_TYPE'].item() spt = spt_full[0] + re.search(r'\d*\.?\d*', spt_full[1:]).group() else: link = pySIMBAD.buildLink(object) data = pySIMBAD.simbad(link) plx = data.Parallax() spt_full = data.SpectralType().split()[0] spt = spt_full[0] + re.search(r'\d*\.?\d*', spt_full[1:]).group() d = {'Object': object, 'plx': plx, 'SpT': spt, 'exptime': header['exptime']} return d
def app_simbad(): app.vars['name'] = request.form['name'] # Get the relevant information from Simbad customSimbad = Simbad() customSimbad.remove_votable_fields('coordinates') customSimbad.add_votable_fields('ra(d)', 'dec(d)', 'pmra', 'pmdec', 'rv_value', 'plx') simbad_query = customSimbad.query_object(app.vars['name']) try: df = simbad_query.to_pandas() except AttributeError: # no result return render_template('error.html', headermessage='Error', errmess='<p>Error querying Simbad for: ' + app.vars['name'] + '</p>') # Clear and set values clear_values() app.vars['ra'] = df['RA_d'][0] app.vars['dec'] = df['DEC_d'][0] app.vars['pmra'] = df['PMRA'][0] app.vars['pmdec'] = df['PMDEC'][0] app.vars['rv'] = df['RV_VALUE'][0] app.vars['dist'] = 1000./df['PLX_VALUE'][0] return redirect('/query')
def run_starlight(object_id,object_name,ob_id): SLdir=os.getenv("HOME")+"/STARLIGHT" scifile=SLdir+"/spectra/"+object_id+"_"+str(ob_id)+".fits" outfile=SLdir+"/spectra/"+object_id+"_"+str(ob_id)+".txt" ## ## get redshift of object Simbad.add_votable_fields("rv_value") q=Simbad.query_object(object_name) rv=q['RV_VALUE'].quantity.data[0]*1000 ## rv in m/s z=rv/constants.c print("Redshift of {object_id} is {z:7.5f}".format(object_id=object_id, z=z)) ## ## get spectrum from FITS file, interpolate bad pixels, convolve to BC03 resolution for STARLIGHT write_spec_starlight(scifile,outfile,z,[6000,9500])
def get_stellar_params(star_name): """ Astro query search """ #return Magnitudes, parralax, Temp customSimbad = Simbad() # Can add more fluxes here if need to extend to more flux ranges. although K is the limit for simbad. # if want higher need to search for Wise band in VISIER probably. customSimbad.add_votable_fields('parallax', 'sp', 'fluxdata(B)', 'fluxdata(V)', 'fluxdata(J)', 'fluxdata(K)', 'fe_h') result_table = customSimbad.query_object(star_name) #print("Table colums", result_table.colnames) return result_table
def __init__(self, targ_name): """ Construct and execute a Simbad query object. :param targ_name: The SIMBADNAME value for the current exoplanet. :type targ_name: str """ # Initialize an astroquery Simbad class object. simbad_info = Simbad() # Set up the list of filters and errors to query. self.filters = ['B', 'V', 'J', 'H', 'K'] f = ['flux({0})'.format(x) for x in self.filters] fe = ['flux_error({0})'.format(y) for y in self.filters] fields = f + fe # Add the list of filters and errors to the fields queried. [simbad_info.add_votable_fields(f) for f in fields] # Execute the Simbad query. self.results is now an astropy Table # object if valid results were returned. self.results = simbad_info.query_object(targ_name) # Convert masked values to NaN (some flux values return '--'). for col in self.results.colnames: if self.results[col][0] is np.ma.masked: self.results[col][0] = np.nan # Add BMV info to the results Table. self._add_bmv_info() # Wait to avoid a Simbad IP blacklist (somewhere around 4-5 # queries/sec) time.sleep(0.4)
def classify_file(filename, astroquery=True): """ This function uses the fits header information and the Simbad database to classify the object :param filename: The filename of the observation to be classified :return: """ # Read in the header and get the object name header = fits.getheader(filename) object = header['object'] print object # Default values if I can't get it any other way plx = 30.0 MS = SpectralTypeRelations.MainSequence() # Make a Simbad object if astroquery: sim = Simbad() sim.add_votable_fields('plx', 'sp', 'flux(V)') data = sim.query_object(object) spt_full = data['SP_TYPE'].item() # spt = spt_full[0] + re.search(r'\d*\.?\d*', spt_full[1:]).group() spt = spt_full if data['PLX_VALUE'].mask: if not data['FLUX_V'].mask: # Fall back to photometric parallax Vmag_obs = data['FLUX_V'].item() Vmag_abs = MS.GetAbsoluteMagnitude(spt, color='V') plx = 10 ** (3.0 + (Vmag_abs - Vmag_obs - 5.0) / 5.0) else: plx = data['PLX_VALUE'].item() else: link = pySIMBAD.buildLink(object) data = pySIMBAD.simbad(link) plx = data.Parallax() spt_full = data.SpectralType().split()[0] spt = spt_full[0] + re.search(r'\d*\.?\d*', spt_full[1:]).group() if 'exptime' not in header.keys(): header['exptime'] = 30.0 d = {'Object': object, 'plx': plx, 'SpT': spt, 'exptime': header['exptime']} return d
def coord2objs(ra, dec, radius=2, extras = False): """Get objects within given radius of given ra/dec as decimal degrees. If object type given, restrict to that""" sk = coordinates.SkyCoord(ra=ra, dec=dec, unit=u.deg) rad = radius * u.arcmin sb = Simbad() sb.add_votable_fields('id', 'otype') sres = sb.query_region(sk, radius=rad) if sres is None: return [] ids = [id for id in sres['MAIN_ID']] if not extras: return ids otypes = [ot for ot in sres['OTYPE']] idas = [string.split(oid, ', ') for oid in sres['ID']] resids = [] for n in zip(ids, idas, otypes): resids.append(n) return resids
def search_objects(self, params): Simbad.reset_votable_fields() fields = self.config.find_by_path("configuration.providers.Simbad.search_fields") for field in fields: Simbad.add_votable_fields(field) cel_objects = [] wildcard = not params.exact try: if params.exact: result = Simbad.query_object(params.term, wildcard=wildcard) else: Simbad.ROW_LIMIT = 20 if params.coordinates: if params.epoch and params.equinox: result = Simbad.query_region(params.coordinates, radius=params.radius, epoch=params.epoch, equinox=params.equinox) else: result = Simbad.query_region(params.coordinates, radius=params.radius) else: result = Simbad.query_region(params.term, radius=params.radius) if result: for entry in result: identifiers = Simbad.query_objectids(entry["MAIN_ID"]) celestial_obj = CelestialObject(entry, identifiers) cel_objects.append(celestial_obj) else: self.logger.info("Nothing found for '{0}'".format(params)) obj_collection = CelestialObjectCollection(cel_objects) json_result = dumper(obj_collection, cls=CelestialObjectEncoder) self.logger.info("Result from Simbad for '{0}' \n {1}".format(params, json_result)) return json_result except: self.logger.error("Error in SimbadProvider", exc_info=True) raise ProviderException("error", "something")
def __init__(self, targ_name): simbad_info = Simbad() self.filters = ['B', 'V', 'J', 'H', 'K'] f = ['flux({0})'.format(x) for x in self.filters] fe = ['flux_error({0})'.format(y) for y in self.filters] fields = f + fe [simbad_info.add_votable_fields(f) for f in fields] self.results = simbad_info.query_object(targ_name) for col in self.results.colnames: if self.results[col][0] is np.ma.masked: self.results[col][0] = np.nan
def request_df(list_identifiers): #SIMBAD request customSimbad = Simbad() customSimbad.add_votable_fields('ids', 'plx', 'flux(B)', 'flux(V)', 'sptype', 'sp_qual') table = customSimbad.query_objects(list_identifiers) simbad_df = table.to_pandas() simbad_df = simbad_df.filter([ 'IDS', 'RA', 'DEC', 'PLX_VALUE', 'FLUX_B', 'FLUX_V', 'SP_TYPE', 'SP_QUAL', ]) #HR and HD numbers come in a string with other identifiers. We find HR and HD identifiers and append 2 new columns to simbad_df list_hr, list_hd = split_ids(simbad_df['IDS']) simbad_df.insert( 0, "HR", list_hr) # Appends a new column named 'HR' with a list of HR codes simbad_df.insert(1, "HD", list_hd) simbad_df = simbad_df.drop('IDS', 1) # deletes the column 'IDS' simbad_df = simbad_df.astype('str') # converting every entry into string simbad_df = simbad_df.applymap( lambda x: x.strip(" 'b")) # gets rid of garbage appended to data list_of_HD = simbad_df['HD'].tolist() #VIZIER request vizier_df = request_vizier(list_of_HD) #Joinning Vizier and Simbad information in one dataframe final_df = simbad_df.join(vizier_df) return final_df
def query_simbad_by_targname(targname): """Querys SIMBAD for `targname`, and constructs a `astropy.coordinates.SkyCoord` object containing the RA, Dec, proper motion, radial velocity, and distance to the object. Paramters --------- targname : str Target name. Simbad is queried by target name. Returns ------- c : `astropy.coordinates.SkyCoord` SkyCoord object with query results. """ from astroquery.simbad import Simbad customSimbad = Simbad() customSimbad.add_votable_fields('pmra', 'pmdec', 'distance', 'rv_value') result_table = customSimbad.query_object(targname) RA = str(result_table['RA'].item()) RA = RA[0:2]+'h'+RA[3:5]+'m'+RA[6:]+'s' DEC = str(result_table['DEC'].item()) DEC = DEC[0:3]+'d'+DEC[4:6]+'m'+DEC[7:]+'s' PM_RA = result_table['PMRA'].item()*u.mas/u.yr PM_DEC = result_table['PMDEC'].item()*u.mas/u.yr c = SkyCoord(RA, DEC, frame='icrs', obstime=Time('J2000'), distance=result_table['Distance_distance'].item()*u.pc, pm_ra_cosdec=PM_RA, pm_dec=PM_DEC) return(c)
def lookuptargettype(name): """ Looks up target otype from SIMBAD returns list of types, with main type first """ main_type = None extra_types = None filename = UserDataFileBase("astro-observability-planner", "targettypecache.txt").getFileName() mysimbad = Simbad() mysimbad.remove_votable_fields('coordinates') mysimbad.add_votable_fields("otype", "otypes") with open(filename, "a+") as typeCacheFile: typeCacheFile.seek(0) typeCacheReader = csv.reader(typeCacheFile, dialect='excel') for entry in typeCacheReader: if name.lower() == entry[0]: main_type = entry[1] extra_types = entry[2] if not main_type: try: lookupname = CALDWELL_MAP[name.lower()] except KeyError: lookupname = name finally: time.sleep(0.05) result_table = mysimbad.query_object(lookupname) main_type = result_table["OTYPE"][0].decode() extra_types = result_table["OTYPES"][0].decode() typeCacheWriter = csv.writer(typeCacheFile, dialect='excel') typeCacheWriter.writerow( [name.lower(), main_type, extra_types]) if lookupname != name: typeCacheWriter.writerow( [lookupname.lower(), main_type, extra_types]) result = [main_type] + extra_types.split("|") return result
def objcurrcoord(obj, twhen = None): """Get current coordinates of object of at time if given""" sb = Simbad() sb.add_votable_fields('pmra', 'pmdec', 'velocity', 'distance') qo = sb.query_object(obj) if qo is None: return None ra = coordinates.Angle(qo['RA'][0], unit=u.hour) dec = coordinates.Angle(qo['DEC'][0], unit=u.deg) distc = qo['distance_distance'][0] if type(distc) is np.float64: dist = u.Quantity(distc, unit=qo['distance_unit'][0]) else: dist = u.Quantity(10.0, unit=u.pc) pmra = qo['PMRA'][0] * u.mas / u.yr pmdec = qo['PMDEC'][0] * u.mas / u.yr rvelc = qo['RVZ_RADVEL'] radvel = u.Quantity(rvelc[0], unit=rvelc.unit) sk = coordinates.SkyCoord(ra=ra, dec=dec, pm_ra_cosdec=pmra, pm_dec=pmdec, obstime=Time('J2000.0'), distance=dist, radial_velocity=radvel) if twhen is None: t = Time(datetime.datetime.now()) else: t = Time(twhen) sk2 = sk.apply_space_motion(new_obstime = t) return (sk2.ra.deg, sk2.dec.deg)
def pm(self, pm): if isinstance(pm, str): if 'auto' in pm.lower(): Simbad.add_votable_fields('pmra', 'pmdec') pm = Simbad.query_object(self.sname)['PMRA', 'PMDEC'] pm = [ pm['PMRA'].to('mas/yr')[0].value, pm['PMDEC'].to('mas/yr')[0].value ] * u.mas / u.yr Simbad.reset_votable_fields() else: raise ValueError('Did not understand your input "{}" for pm. \ Set it to "auto" to query Simbad or e.g. "[1., 2.,] *u.mas"') else: # make sure it is a list if len(pm) != 2: raise ValueError( 'Dont understand pm format. Please give 2 values') try: pm.unit except: print('No unit specified. Assuming mas/yr') pm = pm * u.mas / u.yr self._pm = pm
class SimbadHarvester(AbstractHarvester): """ The ``SimbadHarvester`` is the interface to the SIMBAD catalog. At present, it is only queryable by identifier. For information regarding identifier format, please see http://simbad.u-strasbg.fr/simbad/sim-fid or https://astroquery.readthedocs.io/en/latest/simbad/simbad.html. """ name = 'Simbad' def __init__(self, *args, **kwargs): self.simbad = Simbad() self.simbad.add_votable_fields('pmra', 'pmdec', 'ra(d)', 'dec(d)', 'id', 'parallax', 'distance') def query(self, term): try: self.catalog_data = self.simbad.query_object(term) except TableParseError: # SIMBAD will raise a TableParseError if a result is not found self.catalog_data = None # The CatalogQueryView will display a proper error if catalog_data is None def to_target(self): target = super().to_target() votable_fields = ['RA_d', 'DEC_d', 'PMRA', 'PMDEC', 'ID', 'Distance_distance'] result = {} for key in votable_fields: if str(self.catalog_data[key][0]) not in ['--', '']: result[key] = self.catalog_data[key][0] target.type = 'SIDEREAL' target.ra = result.get('RA_d') target.dec = result.get('DEC_d') target.pm_ra = result.get('PMRA') target.pm_dec = result.get('PMDEC') target.distance = result.get('Distance_distance') result_id = result.get('ID', b'') if isinstance(result_id, bytes): # NOTE: SIMBAD used to return a bytestring, we leave this here in case result_id = result_id.decode('UTF-8') target.name = result_id.split(',')[0].replace(' ', '') return target
def fromSimbad(self, name, **attributes): '''search for a star name in Simbad, and pull down its data''' # add a few extra pieces of information to the search Simbad.reset_votable_fields() Simbad.add_votable_fields('pm') Simbad.add_votable_fields('sptype') Simbad.add_votable_fields('flux(V)') Simbad.add_votable_fields('flux(K)') # send the query to Simbad self.table = Simbad.query_object(name) # pull out the official Simbad name self.name = name self.simbadname = self.table['MAIN_ID'].data[0] if len(self.simbadname) < len(self.name): self.speak("renaming {1} to {0}".format(self.simbadname, self.name)) self.name = self.simbadname ra = self.table['RA'].data[0] dec = self.table['DEC'].data[0] obstime = astropy.time.Time(2000.0, format='decimalyear') self.icrs = astropy.coordinates.SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs', obstime=obstime) self.pmra = self.table['PMRA'].data[0] # in (projected) mas/yr self.pmdec = self.table['PMDEC'].data[0] # in mas/yr self.attributes = {} self.attributes['V'] = float(self.table['FLUX_V'].data[0]) self.attributes['comment'] = self.table['SP_TYPE'].data[0] for k, v in attributes.items(): self.attributes[k] = v self.speak('made {0} from SIMBAD'.format(self))
def fromSimbad(self, name, **attributes): '''search for a star name in Simbad, and pull down its data''' # add a few extra pieces of information to the search Simbad.reset_votable_fields() Simbad.add_votable_fields('pm') Simbad.add_votable_fields('sptype') Simbad.add_votable_fields('flux(V)') Simbad.add_votable_fields('flux(K)') # send the query to Simbad self.table = Simbad.query_object(name) # pull out the official Simbad name self.name = name self.simbadname = self.table['MAIN_ID'].data[0] if len(self.simbadname) < len(self.name): self.speak( "renaming {1} to {0}".format(self.simbadname, self.name)) self.name = self.simbadname ra = self.table['RA'].data[0] dec = self.table['DEC'].data[0] obstime = astropy.time.Time(2000.0, format='decimalyear') self.icrs = astropy.coordinates.SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs', obstime=obstime) self.pmra = self.table['PMRA'].data[0] # in (projected) mas/yr self.pmdec = self.table['PMDEC'].data[0] # in mas/yr self.attributes = {} self.attributes['V'] = float(self.table['FLUX_V'].data[0]) self.attributes['comment'] = self.table['SP_TYPE'].data[0] for k, v in attributes.items(): self.attributes[k] = v self.speak('made {0} from SIMBAD'.format(self))
def stars_from_name(*names: str, handler: Simbad = None) -> [Star]: """Yield Star instance for each given name. """ if not handler: handler = Simbad() # print('FIELDS:', handler.get_votable_fields()) # print('ADD FIELDS…') handler.remove_votable_fields('coordinates') handler.add_votable_fields('parallax') handler.add_votable_fields('ra(d;A;GAL;J2000;2000)') handler.add_votable_fields('dec(d;D;GAL;J2000;2000)') # print('FIELDS:', handler.get_votable_fields()) for name in names: result_table = handler.query_object(name) if not result_table: print(f'ERROR: query for {name} failed by returing {result_table}') if len(result_table) != 1: print( f'ERROR: id {name} is associated with {len(result_table)} objects in SIMBAD db.' ) return for entry in result_table: # print(entry) # for col in entry.colnames: # print('\t', col, entry[col]) # print(entry.colnames) # print(entry.columns) galactic = entry['RA_d_A_GAL_J2000_2000'], entry[ 'DEC_d_D_GAL_J2000_2000'], entry['PLX_VALUE'] yield Star( entry['MAIN_ID'], *galactic, carthesian=coords.coords_from_long_lat(*galactic), source=name, )
from astroquery.simbad import Simbad from astroquery.vizier import Vizier import time import os from .tools_files import open_dict from ._1databases import databases from .astro_angles_and_time import Hours, Degrees, Target vizier = Vizier(columns=["*", "+_r"], catalog="II/246") Simbad.add_votable_fields('ids', 'flux(V)', 'flux(R)', 'flux(I)', 'flux(J)', 'flux(H)', 'flux(K)', 'parallax', 'pmdec', 'pmra') ecc_planets = open_dict(os.path.join(databases.oec, 'planets_catalogue.pickle')) ecc_stars = open_dict(os.path.join(databases.oec, 'stars_catalogue.pickle')) def flat_name(name): flat_name_list = [ [' ', ''], ['-', ''], ['cancri', 'cnc'], ['hatp10', 'wasp11'], ['wasp40', 'hatp27'], ['wasp51', 'hatp30'], ['wasp86', 'kelt12'], ['kelt22', 'wasp173'], ] name = name.lower()
class Transformation(object): def __init__(self, lg=None,obs=None,refraction_method=None): # self.lg=lg self.name='SF SOFA' self.refraction_method=refraction_method self.obs_astropy=obs longitude,latitude,height=self.obs_astropy.to_geodetic() self.elong=longitude self.phi=latitude self.hm=float(str(height).replace('m','').replace('meter','')) self.smbd=Simbad() self.smbd.add_votable_fields('propermotions','rv_value','parallax','flux(V)') # flux UBVR.... #print(smbd.get_votable_fields()) def transform_to_radec(self,tf=None,sky=None,simbad=False): aa,hd,rd=self.sofa(tf=tf,sky=sky,simbad=simbad) return rd def transform_to_hadec(self,tf=None,sky=None,simbad=False): aa,hd,rd=self.sofa(tf=tf,sky=sky,simbad=simbad) return hd def transform_to_altaz(self,tf=None,sky=None,simbad=False): aa,hd,rd=self.sofa(tf=tf,sky=sky,simbad=simbad) return aa def sofa(self,tf=None,sky=None,simbad=False): tc=phpa=rh=0. if sky is not None: tc=sky.temperature phpa=sky.pressure rh=sky.humidity wl=0.55 utc1=c_double() utc2=c_double() dtt=tf.obstime.datetime.timetuple() if sf.iauDtf2d (b'UTC', dtt.tm_year, dtt.tm_mon, dtt.tm_mday, dtt.tm_hour, dtt.tm_min, dtt.tm_sec, byref(utc1), byref(utc2)): self.lg.error('sofa: iauDtf2d failed') return None,None,None tai1=c_double() tai2=c_double() if sf.iauUtctai(utc1,utc2,byref(tai1), byref(tai2)): self.lg.error('sofa: iauUtctai failed') return None,None,None tt1=c_double() tt2=c_double() if sf.iauTaitt(tai1,tai2,byref(tt1), byref(tt2)): self.lg.error('sofa: iauTaitt failed') return None,None,None #/* EOPs: polar motion in radians, UT1-UTC in seconds. */ #xp = 50.995e-3 * DAS2R #yp = 376.723e-3 * DAS2R #dut1 = 155.0675e-3 iers_b = iers.IERS_B.open() ###dt=dateutil.parser.parse('2013-04-04T23:15:43.55Z') dtt=Time(tf.obstime.datetime) xp=yp=xp_u=yp_u=0. try: dut1_u=dtt.delta_ut1_utc = iers_b.ut1_utc(dtt) (xp_u,yp_u)=iers_b.pm_xy(dtt) dut1=dut1_u.value xp=xp_u.value*DAS2R yp=yp_u.value*DAS2R except iers.IERSRangeError as e: self.lg.error('sofa: IERSRangeError setting dut1,xp,yp to zero') dut1=0. #/* Corrections to IAU 2000A CIP (radians). */ #dx = 0.269e-3 * DAS2R #dy = -0.274e-3 * DAS2R dx=dy=0. rc=tf.ra.radian dc=tf.dec.radian pr=pd=px=rv=0. # identify star on SIMBAD if simbad: rslt_tbl = self.smbd.query_region(tf,radius='0d1m0s') #print(rslt_tbl.info) #MAIN_ID RA DEC RA_PREC DEC_PREC PMRA PMDEC PMRA_PREC PMDEC_PREC RV_VALUE PM_QUAL # "h:m:s" "d:m:s" mas / yr mas / yr km / s #------------ ------------- ------------- ------- -------- --------- --------- --------- ---------- -------- ------- #CPD-80 1068 23 21 32.1685 -79 31 09.138 8 8 3.900 -2.400 2 2 0.341 B #print(rslt_tbl['MAIN_ID','RA','DEC','RA_PREC','DEC_PREC','PMRA','PMDEC','PMRA_PREC','PMDEC_PREC','RV_VALUE','PM_QUAL']) # if len(rslt_tbl['RA'])>1: rslt_tbl.sort('FLUX_V') self.lg.warn('transform_to_altaz: found mor than one entry in SIMBAD table, using brightest main_id:{}'.format(rslt_tbl['MAIN_ID'][0])) print(rslt_tbl) (h,m,s)=str(rslt_tbl['RA'][0]).split() rc=Longitude('{0} {1} {2} hours'.format(h,m,s)).radian # (d,m,s)=str(rslt_tbl['DEC'][0]).split() dc=Latitude('{0} {1} {2} degrees'.format(d,m,s)).radian #/* Proper motion: RA/Dec derivatives, epoch J2000.0. */ #/* pr = atan2 ( -354.45e-3 * DAS2R, cos(dc) ); */ #/* pd = 595.35e-3 * DAS2R; */ # pmra=float(rslt_tbl['PMRA'][0]) pmrd=float(rslt_tbl['PMDEC'][0]) pr=np.arctan2(pmra*DAS2R,np.cos(dc)) pd=pmrd * DAS2R #/* Parallax (arcsec) and recession speed (km/s). */ #/* px = 164.99e-3; */ #/* rv = 0.0; */ # it is a masked table px = float(rslt_tbl['PLX_VALUE'][0]) if np.isnan(px): px=0. if np.isnan(rv): rv = float(rslt_tbl['RV_VALUE'][0]) #/* ICRS to observed. */ aob=c_double() zob=c_double() hob=c_double() dob=c_double() rob=c_double() eo= c_double() phi=c_double(self.phi.radian) elong=c_double(self.elong.radian) hm=c_double(self.hm) if sf.iauAtco13(rc,dc,pr,pd,px,rv,utc1,utc2,dut1, elong,phi,hm,xp,yp,phpa,tc,rh,wl, byref(aob), byref(zob), byref(hob), byref(dob), byref(rob), byref(eo)): self.lg.error('sofa: iauAtco13 failed') return None,None,None aa=SkyCoord(az=aob.value,alt=(np.pi/2.-zob.value),unit=(u.radian,u.radian),frame='altaz',location=self.obs_astropy,obstime=dtt,obswl=wl*u.micron, pressure=phpa*u.hPa,temperature=tc*u.deg_C,relative_humidity=rh) # observed RA,Dec rob,dob # observed HA,Dec hob,dec hd=SkyCoord(ra=hob.value,dec=dob,unit=(u.radian,u.radian),frame='gcrs',location=self.obs_astropy,obstime=dtt,obswl=wl*u.micron, pressure=phpa*u.hPa,temperature=tc*u.deg_C,relative_humidity=rh) rd=SkyCoord(ra=rob.value,dec=dob,unit=(u.radian,u.radian),frame='gcrs',location=self.obs_astropy,obstime=dtt,obswl=wl*u.micron, pressure=phpa*u.hPa,temperature=tc*u.deg_C,relative_humidity=rh) if abs(eo.value)> 1.: self.lg.error('sofa: eo=ERA-GST: {}'.format(eo.value)) return aa,hd,rd
def print_results(tic=12350): print_str = "" try: tic = int(tic) except ValueError: return (None, "Not a valid TIC number") target = Target(tic) catalogData = target.query().to_pandas() catalogData['ra'] = catalogData['ra'].round(5) catalogData['dec'] = catalogData['dec'].round(5) catalogData['eclong'] = catalogData['eclong'].round(5) catalogData['eclat'] = catalogData['eclat'].round(5) catalogData['pmRA'] = catalogData['pmRA'].round(2) catalogData['pmDEC'] = catalogData['pmDEC'].round(2) catalogData['Tmag'] = catalogData['Tmag'].round(2) catalogData['Vmag'] = catalogData['Vmag'].round(2) catalogData['Kmag'] = catalogData['Kmag'].round(2) output_table = catalogData[[ 'ID', 'ra', 'dec', 'pmRA', 'pmDEC', 'eclong', 'eclat', 'Tmag', 'Vmag', 'Kmag', 'Teff', 'rad', 'mass', 'd', ]].iloc[0:1] skobj = SkyCoord(ra=catalogData['ra'] * u.degree, dec=catalogData['dec'] * u.degree, frame='icrs') with warnings.catch_warnings(): warnings.simplefilter('ignore') customSimbad = Simbad() customSimbad.add_votable_fields('ra(2;A;ICRS;J2000;2000)', 'dec(2;D;ICRS;J2000;2000)') customSimbad.remove_votable_fields('coordinates') # try different search radii, be fast if possible for i in [5, 10, 20]: result_table = customSimbad.query_region(skobj, radius=i * u.arcsec) if result_table is None: continue else: break if result_table is None: print_str += "\n\n" print_str += "No Simbad target resolved\n\n" else: # print_str += "Target name: {}\n\n".format( # result_table['MAIN_ID'][0]) # print_str += "Target name: <a href=\"{1}{2}\">{0}</a>\n\n".format( # result_table['MAIN_ID'][0], # "http://simbad.u-strasbg.fr/simbad/sim-id?", # urlencode({"Ident": result_table['MAIN_ID'][0]})) print_str += "Target name: [{0}]({1}{2})\n\n".format( result_table['MAIN_ID'][0], "http://simbad.u-strasbg.fr/simbad/sim-id?", urlencode({"Ident": result_table['MAIN_ID'][0]})) print_str += "The target is in constellation {}\n\n".format( get_constellation(skobj)[0]) obs_sectors = target.get_obs() obs2, obsffi, obs20 = obs_sectors print_str += 'FFI data at MAST for sectors: {}\n\n'.format( str(sorted(list(set(obsffi)))).replace("[", r"\[").replace("]", r"\]")) print_str += '2-min data at MAST for sectors: {}\n\n'.format( str(sorted(list(set(obs2)))).replace("[", r"\[").replace("]", r"\]")) print_str += '20-s data at MAST for sectors: {}\n\n'.format( str(sorted(list(set(obs20)))).replace("[", r"\[").replace("]", r"\]")) return output_table, print_str
def feed_results_into_table(d, ids, infolder, innames, inra, indec, database, verbose=None, preftypes=None, parallel=1): """ Take the results of the query routine in this package and compile them into a table. Parallelisation does not work here unfortunately. """ nids = len(ids) nfail = 0 n_found_by_name = 0 n_found_by_coord = 0 if database == "NED": typecol = 'Type' racol = 'RA(deg)' deccol = 'DEC(deg)' if preftypes is None: preftypes = ['G', 'QSO'] elif database == "SIMBAD": # --- add the redshift as an output column cSimbad = Simbad() cSimbad.add_votable_fields('otype(3)', 'z_value', 'ra(d)', 'dec(d)') racol = 'RA_d' deccol = 'DEC_d' typecol = 'OTYPE_3' if preftypes is None: preftypes = ['AGN', 'LIN', 'SyG', 'Sy1', 'Sy2', 'Bla', 'BLL', 'OVV', 'QSO', 'AG?', 'Q?', 'Bz?', 'BL?', 'EmG', 'SBG', 'bCG', 'G', 'GiC', 'BiC', 'GiG', 'GiP', 'rG', 'H2G', 'LSB', 'IG', 'PaG', 'G?'] elif database == "SDSS": racol = 'ra' deccol = 'dec' typecol = 'class' if preftypes is None: preftypes = ['GALAXY', 'QSO'] if verbose: print(" - database: ", database) print(" - racol: ", racol) print(" - deccol: ", deccol) tstart = time.time() print(timestamp(), " -- Start") infiles = np.zeros(nids, dtype=object) fail = np.zeros(nids, dtype=int) found_by_name = np.zeros(nids, dtype=int) found_by_coord = np.zeros(nids, dtype=int) for i in range(nids): # infiles[i] = (infolder + "/Qno" + str(i) + "_" # + innames[i].replace(" ","") + ".csv") infiles[i] = (infolder + "/" + '{:.6f}'.format(inra[i]) + "_"+ '{:.6f}'.format(indec[i]) + "_" + innames[i].replace(" ","") + ".csv") # --- loop over all the searched objects if parallel == 1: for i in tqdm(range(nids)): _ = read_res_file(d, database, ids, i, infiles[i], innames[i], inra[i], indec[i], fail, found_by_name=found_by_name, found_by_coord=found_by_coord, racol=racol, deccol=deccol, typecol=typecol, preftypes=preftypes) # ---- parallel does not work currently # else: # _ = Parallel(n_jobs=parallel)(delayed(read_res_file)(d, database, ids, # i, infiles[i], innames[i], # inra[i], indec[i], fail, # found_by_name=found_by_name, # found_by_coord=found_by_coord, # racol=racol, deccol=deccol, typecol=typecol, # preftypes=preftypes) for i in range(nids)) tend = time.time() print(timestamp(), " -- End; Duration: ", tend - tstart) n_found_by_name = np.sum(found_by_name) n_found_by_coord = np.sum(found_by_coord) nfail = np.sum(fail) print("Total number searched: ", nids) print(" - Found matches by name: ", n_found_by_name) print(" - Found matches by coord: ", n_found_by_coord) print(" - Objects not found or error: ", nfail) print(" - Check sum: ", n_found_by_name + n_found_by_coord + nfail) return(n_found_by_name, n_found_by_coord, nfail)
def convert_to_bjd_tdb(jd, name, lat, lon, height, ra=None, dec=None): # Get target proper motion, parallax, and radial velocity from exofop epoch = 2451545.0 pmra = pmdec = None if ra: ra *= 15 # First try ExoFOP for proper motions # if ('TOI' in name) or ('toi' in name): # toi_table = pd.read_csv('https://exofop.ipac.caltech.edu/tess/download_toi.php?sort=toi&output=pipe', delimiter='|') # toi = re.search('(?:TOI|toi)(?:_| |-|.)(\d+)(?:.|-| |_)(\d+)', name) # if toi: # toi = int(toi.group(1)) + int(toi.group(2))/100 # if int(toi) == toi: # toi += .01 # toi_info = toi_table.loc[toi_table['TOI'] == toi] # if toi_info.values.size: # pmra = toi_info['PM RA (mas/yr)'].values[0] # pmdec = toi_info['PM Dec (mas/yr)'].values[0] # Query SIMBAD for proper motion, parallax, and RV try: simbad = Simbad() simbad.add_votable_fields('ra(2;A;ICRS;J2000)', 'dec(2;D;ICRS;J2000)', 'pm', 'plx', 'parallax', 'rv_value') simbad.remove_votable_fields('coordinates') table = simbad.query_object(name) except (urllib3.exceptions.MaxRetryError, urllib3.exceptions.HTTPError, urllib3.exceptions.TimeoutError, urllib3.exceptions.InvalidHeader, requests.exceptions.ConnectionError, requests.exceptions.Timeout, requests.exceptions.HTTPError, TimeoutError): return None if not table: if not ra or not dec: return None table = simbad.query_region(SkyCoord(ra * u.degree, dec * u.degree, frame='icrs'), radius='5m') if table: if not ra: ra = decimal(table['RA_2_A_ICRS_J2000'][0]) * 15 if not dec: dec = decimal(table['DEC_2_D_ICRS_J2000'][0]) if not pmra: pmra = table['PMRA'][0] if not pmdec: pmdec = table['PMDEC'][0] parallax = table['PLX_VALUE'][0] radial_velocity = table['RV_VALUE'][0] * 1000 else: return None if (not radial_velocity) or (not pmra) or (not pmdec) or (not ra) or ( not dec) or (not parallax): return None return JDUTC_to_BJDTDB(JDUTC=jd, ra=ra, dec=dec, epoch=epoch, pmra=pmra, pmdec=pmdec, px=parallax, rv=radial_velocity, lat=lat, longi=lon, alt=height, leap_update=False)[0][0]
from astroquery.simbad import Simbad s = Simbad() # bibcodelist(date1-date2) lists the number of bibliography # items referring to each object over that date range s.add_votable_fields('bibcodelist(2003-2013)') r = s.query_object('m31') r.pprint() """ MAIN_ID RA DEC RA_PREC DEC_PREC COO_ERR_MAJA COO_ERR_MINA COO_ERR_ANGLE COO_QUAL COO_WAVELENGTH COO_BIBCODE BIBLIST_2003_2013 ------- ------------ ------------ ------- -------- ------------ ------------ ------------- -------- -------------- ------------------- ----------------- M 31 00 42 44.330 +41 16 07.50 7 7 nan nan 0 B I 2006AJ....131.1163S 3758 """
def populate_system(star, star_pk): ''' Analyse provided 'star' dictionary and create a Star object ''' if 'get_simbad' in star: if star['get_simbad']: check_vizier = True else: check_vizier = False else: check_vizier = False # Load system/star model sobj = Star.objects.get(pk=star_pk) # Set project project = sobj.project # Coordinates if check_vizier: customSimbad = Simbad() customSimbad.add_votable_fields('sptype') simbad_tbl = customSimbad.query_object(star["main_id"]) if simbad_tbl is None: return False, "System ({}) not known by Simbad".format( star["main_id"]) ra = Angle(simbad_tbl[0]['RA'].strip(), unit='hour').degree dec = Angle(simbad_tbl[0]['DEC'].strip(), unit='degree').degree else: ra = float(star['ra']) dec = float(star['dec']) # Set RA & DEC sobj.ra = ra sobj.dec = dec # Check for duplicates duplicates = Star.objects.filter(name=star["main_id"]) \ .filter(ra__range=[ra - 1 / 3600., ra + 1 / 3600.]) \ .filter(dec__range=[dec - 1 / 3600., dec + 1 / 3600.]) \ .filter(project__exact=project.pk) if len(duplicates) != 0: return False, "System exists already: {}".format(star["main_id"]) # Set spectral type if check_vizier: sobj.classification = simbad_tbl[0]['SP_TYPE'] if simbad_tbl[0]['SP_TYPE'] != '': sobj.classification_type = 'SP' else: sobj.classification = star['sp_type'] if 'classification_type' in star: sobj.classification_type = star['classification_type'] # Set identifier ident = sobj.identifier_set.all()[0] ident.href = "http://simbad.u-strasbg.fr/simbad/" \ + "sim-id?Ident=" + star['main_id'] \ .replace(" ", "").replace('+', "%2B") ident.save() # Add JNAME as identifier if provided if 'JNAME' in star: sobj.identifier_set.create(name=star['JNAME']) # Add default Simbad name if query occurred # and if it is different compared to the provided name if check_vizier: if star["main_id"].strip() != simbad_tbl[0]['MAIN_ID'].strip(): sobj.identifier_set.create( name = simbad_tbl[0]['MAIN_ID'], href = "http://simbad.u-strasbg.fr/simbad/" \ + "sim-id?Ident=" + simbad_tbl[0]['MAIN_ID'] \ .replace(" ", "").replace('+', "%2B"), ) # -- Add Tags if 'tags' in star: for tag in star["tags"]: sobj.tags.add(tag) #-- Add photometry # 'simbad_id': ID of the catalog # 'columns': filter definition used by the catalog # 'err_columns': filter errors used by the catalog # 'passbands': internal names for the filters # 'photnames': external names (e.g., in .csv files) for the filters # 'errs': external names (e.g., in .csv files) for the errors catalogs = { 'GAIA2': { 'simbad_id': 'I/345/gaia2', 'columns': ['Gmag', 'BPmag', 'RPmag'], 'err_columns': ['e_Gmag', 'e_BPmag', 'e_RPmag'], 'passbands': ['GAIA2.G', 'GAIA2.BP', 'GAIA2.RP'], 'photnames': [ 'phot_g_mean_mag', 'phot_bp_mean_mag', 'phot_rp_mean_mag', ], 'errs': [ 'phot_g_mean_magerr', 'phot_bp_mean_magerr', 'phot_rp_mean_magerr', ], }, '2MASS': { 'simbad_id': 'II/246/out', 'columns': ['Jmag', 'Hmag', 'Kmag'], 'err_columns': ['e_Jmag', 'e_Hmag', 'e_Kmag'], 'passbands': ['2MASS.J', '2MASS.H', '2MASS.K'], 'photnames': ['Jmag', 'Hmag', 'Kmag'], 'errs': ['Jmagerr', 'Hmagerr', 'Kmagerr'], }, 'WISE': { 'simbad_id': 'II/328/allwise', 'columns': ['W1mag', 'W2mag', 'W3mag', 'W4mag'], 'err_columns': ['e_W1mag', 'e_W2mag', 'e_W3mag', 'e_W4mag'], 'passbands': ['WISE.W1', 'WISE.W2', 'WISE.W3', 'WISE.W4'], 'photnames': ['W1mag', 'W2mag', 'W3mag', 'W4mag'], 'errs': ['W1magerr', 'W2magerr', 'W3magerr', 'W4magerr'], }, 'GALEX': { 'simbad_id': 'II/312/ais', 'columns': ['FUV', 'NUV'], 'err_columns': ['e_FUV', 'e_NUV'], 'passbands': ['GALEX.FUV', 'GALEX.NUV'], 'photnames': ['FUV', 'NUV'], 'errs': ['FUVerr', 'NUVerr'], }, 'SKYMAP': { 'simbad_id': 'V/145/sky2kv5', 'columns': ['Umag', 'Vmag'], 'err_columns': ['e_Umag', 'e_Vmag'], 'passbands': ['SKYMAP.U', 'SKYMAP.V'], 'photnames': ['Umag', 'Vmag'], 'errs': ['Umagerr', 'Vmagerr'], }, 'APASS': { 'simbad_id': 'II/336/apass9', 'columns': ["Bmag", "Vmag", "g'mag", "r'mag", "i'mag"], 'err_columns': ["e_Bmag", "e_Vmag", "e_g'mag", "e_r'mag", "e_i'mag"], 'passbands': ['APASS.B', 'APASS.V', 'APASS.G', 'APASS.R', 'APASS.I'], 'photnames': ['APBmag', 'APVmag', 'APGmag', 'APRmag', 'APImag'], 'errs': [ 'APBmagerr', 'APVmagerr', 'APGmagerr', 'APRmagerr', 'APImagerr', ], }, 'SDSS': { 'simbad_id': 'V/147/sdss12', 'columns': ['umag', 'gmag', 'rmag', 'imag', 'zmag'], 'err_columns': ['e_umag', 'e_gmag', 'e_rmag', 'e_imag', 'e_zmag'], 'passbands': ['SDSS.U', 'SDSS.G', 'SDSS.R', 'SDSS.I', 'SDSS.Z'], 'photnames': [ 'SDSSUmag', 'SDSSGmag', 'SDSSRmag', 'SDSSImag', 'SDSSZmag', ], 'errs': [ 'SDSSUmagerr', 'SDSSGmagerr', 'SDSSRmagerr', 'SDSSImagerr', 'SDSSZmagerr', ], }, 'PANSTAR': { 'simbad_id': 'II/349/ps1', 'columns': ['gmag', 'rmag', 'imag', 'zmag', 'ymag'], 'err_columns': ['e_gmag', 'e_rmag', 'e_imag', 'e_zmag', 'e_ymag'], 'passbands': [ 'PANSTAR.G', 'PANSTAR.R', 'PANSTAR.I', 'PANSTAR.Z', 'PANSTAR.Y', ], 'photnames': ['PANGmag', 'PANRmag', 'PANImag', 'PANZmag', 'PANYmag'], 'errs': [ 'PANGmagerr', 'PANRmagerr', 'PANImagerr', 'PANZmagerr', 'PANYmagerr', ], }, } # Loop over catalogs for name, content in catalogs.items(): # Check if photometry shall be loaded from Vizier if check_vizier: # Define catalog and columns v = Vizier( catalog=content['simbad_id'], columns=content['columns'] + content['err_columns'], ) # Get data, assume a radius of 1" photo = v.query_region( SkyCoord(ra=ra, dec=dec, unit=(u.deg, u.deg), frame='icrs'), radius=1 * u.arcsec, ) # Check if catalog contains data for this object if len(photo) != 0: # Loop over photometry bands for i, band in enumerate(content['columns']): # Sanitize band/filter names band = band.replace("'", '_') # Get magnitudes mag = photo[0][band][0] # Sanitize error names err_band = content['err_columns'][i].replace("'", '_') # Get errors err = photo[0][err_band][0] # Set error to zero, if it is undefined if str(err) == '--' or np.isnan(err): err = 0. # Check if magnitude value is valid if mag != '--' and ~np.isnan(mag): # Set magnitude value and error sobj.photometry_set.create( band=content['passbands'][i], measurement=mag, error=err, unit='mag', ) else: for i, phot in enumerate(content['photnames']): # Check if photometry was provided if phot in star: err_name = content['errs'][i] # Check if error was provided if err_name in star: # Check if photometry and error is not empty if (star[phot] != None and star[phot] != "" and star[err_name] != None and star[err_name] != ""): sobj.photometry_set.create( band=content['passbands'][i], measurement=star[phot], error=star[err_name], unit='mag', ) # If error is empty set it to zero elif star[phot] != None and star[phot] != "": sobj.photometry_set.create( band=content['passbands'][i], measurement=star[phot], error=0., unit='mag', ) else: # If error is not provided set it to zero if star[phot] != None and star[phot] != "": sobj.photometry_set.create( band=content['passbands'][i], measurement=star[phot], error=0., unit='mag', ) # -- Add parameters from gaia DR2 if check_vizier: # Download GAIA EDR3 data gaia_data = Vizier( catalog='I/350/gaiaedr3', columns=['Plx', 'e_Plx', 'pmRA', 'e_pmRA', 'pmDE', 'e_pmDE'], ).query_region(star["main_id"], radius=1 * u.arcsec) # Check if GAIA data is available for the source if len(gaia_data) != 0: # Set data source try: dsgaia = DataSource.objects.get( name__exact='Gaia EDR3', project=project, ) except DataSource.DoesNotExist: dsgaia = DataSource.objects.create( name='Gaia EDR3', note='Early 3nd Gaia data release', reference='https://doi.org/10.1051/0004-6361/202141135', project=project, ) # Set parallax if (str(gaia_data[0]['Plx']) != '--' and str(gaia_data[0]['e_Plx']) != '--'): sobj.parameter_set.create( data_source=dsgaia, name='parallax', component=0, value=gaia_data[0]['Plx'], error=gaia_data[0]['e_Plx'], unit='', ) # RA proper motion if (str(gaia_data[0]['pmRA']) != '--' and str(gaia_data[0]['e_pmRA']) != '--'): sobj.parameter_set.create( data_source=dsgaia, name='pmra', component=0, value=gaia_data[0]['pmRA'], error=gaia_data[0]['e_pmRA'], unit='mas', ) # DEC proper motion if (str(gaia_data[0]['pmDE']) != '--' and str(gaia_data[0]['e_pmDE']) != '--'): sobj.parameter_set.create( data_source=dsgaia, name='pmdec', component=0, value=gaia_data[0]['pmDE'], error=gaia_data[0]['e_pmDE'], unit='mas', ) else: if (star['parallax'] != None or star['pmra_x'] != None or star['pmdec_x'] != None): try: dsgaia = DataSource.objects.get( name__exact='Gaia DR2', project=project, ) except DataSource.DoesNotExist: dsgaia = DataSource.objects.create( name='Gaia DR2', note='2nd Gaia data release', reference='https://doi.org/10.1051/0004-6361/201833051', project=project, ) # Set parallax if star['parallax'] != None: sobj.parameter_set.create( data_source=dsgaia, name='parallax', component=0, value=star['parallax'], error=star['parallax_error'], unit='', ) # RA proper motion if star['pmra_x'] != None: sobj.parameter_set.create( data_source=dsgaia, name='pmra', component=0, value=star['pmra_x'], error=star['pmra_error'], unit='mas', ) # DEC proper motion if star['pmdec_x'] != None: sobj.parameter_set.create( data_source=dsgaia, name='pmdec', component=0, value=star['pmdec_x'], error=star['pmdec_error'], unit='mas', ) sobj.save() return True, "New system ({}) created".format(star["main_id"])
# Make simbad query, this is where we start from astroquery.simbad import Simbad # Import astroquerey Simbad module from pylab import * Vmag_limits = [4, 5, 6, 7, 8, 9, 10] # Set properties from Simbad to store Simbad.add_votable_fields("flux(V)") # Store V-mag Simbad.add_votable_fields("pmra") # Store proper motion in RA Simbad.add_votable_fields("pmdec") # Store proper motion in Dec. for Vmag_limit in Vmag_limits: # Loop to make seperate lists for a variety of # Query Simbad # Note we are including spectral types A0Va, A0Vb, and A0Vs objects = Simbad.query_criteria( "(maintype=* | maintype=dS* | maintype=*iA | maintype=*iC) & Vmag < " + str(Vmag_limit) + " & (sptype=A0Va | sptype=A0Vb | sptype=A0Vs | sptype=A0V) & dec > -30" ) objects["PMRA"][isnan(objects["PMRA"])] = 0.0 objects["PMDEC"][isnan(objects["PMDEC"])] = 0.0 objects = objects[objects.argsort(keys="RA")] # Sort by RA lines = [] # Set up list to store lines for later outputting to file for i, obj in enumerate(objects): lines.append( str(i) + ' "' + obj["MAIN_ID"] + ", V=%0.1f" % obj["FLUX_V"] + '" '
newitem['alias'] = [x['value'] for x in item['alias']] newitem['ra'] = item['ra'][0]['value'] newitem['dec'] = item['dec'][0]['value'] if 'redshift' in item: newitem['redshift'] = item['redshift'][0]['value'] # Temporary fix for David's typo if newitem['dec'].count('.') == 2: newitem['dec'] = newitem['dec'][:newitem['dec'].rfind('.')] newcatalog.append(newitem) coo = coord([x['ra'] for x in newcatalog], [x['dec'] for x in newcatalog], unit=(un.hourangle, un.deg)) for ci, co in enumerate(tqdm(coo)): customSimbad = Simbad() customSimbad.add_votable_fields('otype', 'z_value') regstr = 'region(ICRS, ' + co.to_string('hmsdms') + ', 1m)' print(regstr) result_table = customSimbad.query_criteria(regstr, otype='Galaxy') if result_table: print(newcatalog[ci]) if 'redshift' in newcatalog[ci]: print(newcatalog[ci]['redshift']) print(result_table) # Convert to array since that's what datatables expects dupes = list(dupes.values()) jsonstring = json.dumps(dupes, indent='\t', separators=(',', ':'),
from astroquery.simbad import Simbad from PyQt5.QtWidgets import QDialog, QDialogButtonBox, QMessageBox from pyui.object_properties_dialog import Ui_ObjectPropertiesDialog import re from PyQt5.QtCore import Qt, QObject, pyqtSignal, QDateTime from astropy.coordinates import SkyCoord from astropy import units as u from object_properties import ObjectProperties Simbad.add_votable_fields('otype(V)') Simbad.add_votable_fields('sptype') class ObjectPropertiesDialog(QDialog): def __init__(self, settings, object_properties): super(ObjectPropertiesDialog, self).__init__() self.ui = Ui_ObjectPropertiesDialog() self.ui.setupUi(self) self.settings = settings self.object_properties = object_properties enable_simbad_button = lambda: self.ui.simbad.setEnabled(len(self.ui.name.currentText())) self.ui.name.editTextChanged.connect(lambda txt: enable_simbad_button()) self.ui.name.lineEdit().returnPressed.connect(self.simbad_query) self.ui.simbad.clicked.connect(self.simbad_query) self.accepted.connect(self.save_properties) enable_simbad_button() self.ui.name.setFocus() self.ui.name.setEditText(object_properties.name) self.ui.names.setText(object_properties.names) self.ui.comment.setText(object_properties.comment) self.ui.ra.setText(object_properties.ra_str()) self.ui.dec.setText(object_properties.dec_str())
from astroquery.simbad import Simbad from astroquery.exceptions import RemoteServiceError # Simbad configurations Simbad.ROW_LIMIT = 30 Simbad.TIMEOUT = 20 # Add query items/fields: # otype: standard name of the object type # rv_value: Radial velocity value. Eventually translated from a redshift # z_value: Redshift value. Eventually translated from a radial velocity # rvz_qual: Quality code (A: best, .., E: worst) # rvz_type: stored type of velocity: 'v'=radial velocity, 'z'=redshift Simbad.reset_votable_fields() Simbad.add_votable_fields('otype', 'rv_value', 'z_value', 'rvz_qual', 'rvz_type') def query_name(name, verbose=False, print_header=False): """ Query SIMBAD by name. """ try: q = Simbad.query_object(name) main_id = str(q['MAIN_ID'][0], encoding='utf-8') otype = str(q['OTYPE'][0], encoding='utf-8') rv = q['RV_VALUE'][0] z = q['Z_VALUE'][0] rvz_qual = q['RVZ_QUAL'][0] rvz_type = q['RVZ_TYPE'][0] except RemoteServiceError:
import os import logging from astropy.io import fits import numpy as np from astroquery.simbad import Simbad import pandas as pd from kglib import stellar_data from .HelperFunctions import convert_to_hex Simbad.TIMEOUT = 60 try: Simbad.add_votable_fields('sp', 'flux(V)', 'flux(K)', 'plx') except KeyError: pass data_cache = {} class stardata: def __init__(self): self.main_id = '' self.spectype = "" self.Vmag = 0.0 self.Kmag = 0.0 self.ra = "" self.dec = "" self.par = 0.0 # parallax in milli-arcseconds
from astroquery.simbad import Simbad from astropy import coordinates from astropy import units as u S = Simbad() S.add_votable_fields('id(Gal|RAFGL|IRAS|1)') S.add_votable_fields('otype') tbl = S.query_region(coordinates.Galactic(49*u.deg,-0.3*u.deg), radius=1.5*u.deg) with open('/Users/adam/work/w51/simbad_HII_regions.reg','w') as outf: print >>outf,'global color=white\nfk5' for line in tbl[(tbl['OTYPE'] == 'HII')]: ra,dec = line['RA'].replace(" ",":"), line['DEC'].replace(" ",":") if ra.count(":") == 2 and dec.count(":") == 2: print >>outf,"point(%s,%s) # text={%s} point=cross" % (ra,dec,line['ID_Gal_RAFGL_IRAS_1'] if '[' in line['MAIN_ID'] else line['MAIN_ID'])
if hdulist[0].header['FILTER1'].strip() == filterType or hdulist[0].header['FILTER2'].strip() == filterType: filterFiles.append(file) hdulist.close() objectFiles = [] flatDarkBiasFiles = [] for file in filterFiles: hdulist = fits.open(file) if hdulist[0].header['IMAGETYP'].strip() == 'object': objectFiles.append(file) else: flatDarkBiasFiles.append(file) hdulist.close() if not exists(directory + 'star_names_list_pm.dat'): starNamesListPM = open(directory + 'star_names_list_pm.dat', 'w') simbad = Simbad() simbad.add_votable_fields('pm') newList = False if not exists(directory + 'star_names_list.dat'): starNamesList = open(directory + 'star_names_list.dat', 'w') newList = True for file in objectFiles: hdulist = fits.open(file) objectID = hdulist[0].header['OBJECT'].strip() objectQuery = simbad.query_object(objectID) if objectQuery is None: if newList: # noinspection PyUnboundLocalVariable starNamesList.write(objectID + ' | ' + hdulist[0].header['TELRA'].strip() + ' | ' + hdulist[0].header['TELDEC'].strip() + ' | WCS | auto\n') starNamesListPM.write(objectID + ' | 0 | 0\n') else:
def load_exo_dict(planet_name=None): """Loads in empty exoplanet dictionary for pandexo input Loads in empty exoplanet dictionary so that the user can manually edit different planet parameters. Must be done for every bash run. User must edit each keys within the dictionary. Parameters ---------- planet_name : str (Optional) Planet name e.g. 'HD 189733 b' or 'HD189733b' Returns ------- dict Empty dictionary to be filled out by the user before running PandExo Example ------- >>> exo_dict = load_exo_dict() >>> exo_dict['planet']['transit_duration'] = 2*60*60 #2 hours """ with open( os.path.join(os.path.dirname(__file__), "reference", "exo_input.json")) as data_file: pandexo_input = json.load(data_file) if not isinstance(planet_name, type(None)): planet_data = get_target_data(planet_name)[0] pandexo_input['star']['type'] = 'phoenix' pandexo_input['star']['temp'] = planet_data['Teff'] pandexo_input['star']['metal'] = planet_data['Fe/H'] pandexo_input['star']['logg'] = planet_data['stellar_gravity'] Simbad.add_votable_fields('flux(H)') Simbad.add_votable_fields('flux(J)') star_name = planet_name[:-1] jmag = Simbad.query_object(star_name)['FLUX_J'][0] if np.ma.is_masked(jmag): # Remove 'A' from star_name for systems with binary stars (e.g., WASP-77A) star_name = star_name[:-1] jmag = Simbad.query_object(star_name)['FLUX_J'][0] hmag = Simbad.query_object(star_name)['FLUX_H'][0] pandexo_input["star"]["mag"] = jmag pandexo_input["star"]["ref_wave"] = 1.25 pandexo_input["star"]["jmag"] = jmag pandexo_input["star"]["hmag"] = hmag #optinoal star radius pandexo_input["star"]["radius"] = planet_data['Rs'] pandexo_input["star"]["r_unit"] = planet_data['Rs_unit'][ 0] + planet_data['Rs_unit'][1:].lower() #optional planet radius/mass pandexo_input["planet"]["radius"] = planet_data['Rp'] pandexo_input["planet"]["r_unit"] = planet_data['Rp_unit'][ 0] + planet_data['Rp_unit'][1:].lower() pandexo_input["planet"]["mass"] = planet_data['Mp'] pandexo_input["planet"]["m_unit"] = planet_data['Mp_unit'][ 0] + planet_data['Mp_unit'][1:].lower() pandexo_input["planet"]["transit_duration"] = planet_data[ 'transit_duration'] pandexo_input["planet"]["td_unit"] = planet_data[ 'transit_duration_unit'] depth = pandexo_input["planet"]["radius"]**2 / ( (pandexo_input["star"]["radius"] * u.Unit(pandexo_input["star"]["r_unit"])).to( u.Unit(pandexo_input["planet"]["r_unit"]))).value**2 pandexo_input["planet"]["depth"] = depth if planet_data['inclination'] == None: inc = 90 else: inc = planet_data['inclination'] pandexo_input["planet"]["i"] = inc pandexo_input["planet"]["ars"] = planet_data['a/Rs'] period = planet_data['orbital_period'] period_unit = planet_data['orbital_period_unit'] pandexo_input["planet"]["period"] = (period * u.Unit(period_unit)).to( u.Unit('day')).value pandexo_input["planet"]["ecc"] = planet_data['eccentricity'] pandexo_input["planet"]["ecc"] = planet_data['eccentricity'] try: pandexo_input["planet"]["w"] = float(planet_data['omega']) except: pandexo_input["planet"]["w"] = 90. return pandexo_input
try: objname = dbobjinfo.get_targetname(mycursor, objname) objd = dbobjinfo.get_object(mycursor, objname) except dbobjinfo.ObjDataError as e: print("Error with object", objname, ":", e.args[0], file=sys.stderr) sys.exit(31) lookupnames = dict() for n in objd.get_names(mycursor): lookupnames[n] = 1 multsp = re.compile(" {2,}") marks = re.compile("b'(.*)'") sb = Simbad() sb.add_votable_fields('main_id', 'id', 'otype', 'dec','distance','pmra','pmdec', 'rv_value') for f in 'urigzHJK': sb.add_votable_fields('flux(' + f + ')', 'flux_error(' + f + ')') qres = sb.query_region(objname, radius=radius * u.arcmin) if qres is None: print("Cannot find", name, "in Simbad", file=sys.stderr) sys.exit(50) namesadded = [] for qr in qres: name = multsp.sub(" ", marks.sub(lambda m: m.group(1), str(qr['MAIN_ID']))) if name in lookupnames: continue lookupnames[name] = 1
pname = nobj.objname if pname != name: print("Already had", name, "as alias of", pname, file=sys.stderr) else: print("Already had", name, file=sys.stderr) errors += 1 continue except dbobjinfo.ObjDataError: pass if errors > 0: print("Aborting due to errors", file=sys.stderr) sys.exit(10) sb = Simbad() sb.add_votable_fields('main_id','otype','ra','dec','distance','pmra','pmdec', 'rv_value') for name in objnames: qres = sb.query_object(name) if qres is None: print("Cannot find", name, "in Simbad", file=sys.stderr) errors += 1 continue q0 = qres[0] qname = q0['MAIN_ID'] if dbobjinfo.is_defined(mycursor, str(qname)): print(name, "is already defined as", qname, file=sys.stderr) errors += 1 continue otype = q0['OTYPE']
DEC = list(c.dec.dms) DEC[0] = str(int(DEC[0])).zfill(2) DEC[1] = str(abs(int(DEC[1]))).zfill(2) DEC[2] = str(abs(round(DEC[2], 2))).zfill(4) if int(DEC[0]) > 0: DEC[0] = '+'+DEC[0] if len(DEC[2]) == 4: DEC[2] += '0' DEC = "{0} {1} {2}".format(*DEC) # Search in Simbad the parallax, Vmag and spectral type customSimbad = Simbad() # customSimbad.add_votable_fields('plx','plx_error','flux(V)','flux_error(V)','sptype','otype','ids','dist') customSimbad.add_votable_fields('plx', 'plx_error', 'flux(V)', 'flux_error(V)', 'sptype', 'otype', 'ids') result = customSimbad.query_region(coord.SkyCoord(ra=c.ra, dec=c.dec, frame='icrs'), radius='15s') empty = 'NULL' # Here comes the user interface part... puts(colored.black('\nStandard parameters\n')) # The metallicity error if ~np.isnan(exo.star_metallicity_error_min.values[0]) and ~np.isnan(exo.star_metallicity_error_max.values[0]): errFeH_exo = (abs(exo.star_metallicity_error_min.values[0]) + abs(exo.star_metallicity_error_max.values[0])) / 2.0
#!/usr/bin/python3 import sys import numpy as np from astropy.io import ascii from astroquery.simbad import Simbad # Configure necessary parameters of Simbad query Simbad.add_votable_fields('flux(J)') Simbad.add_votable_fields('flux(H)') Simbad.add_votable_fields('flux(K)') Simbad.remove_votable_fields('coordinates') Simbad.remove_votable_fields('main_id') # Make column with full names of stars to send it to Simbad main_file = ascii.read(sys.argv[1]) main_file['HIP_ID_STR'] = np.array( list(map(lambda x: 'hip' + x, main_file['HIP_ID'].astype('str')))) # Query and conjunction new_columns = Simbad.query_objects(main_file['HIP_ID_STR']) main_file.add_columns(new_columns.columns.values()) main_file.write(sys.argv[1], format='ascii.basic') sys.exit(0)
from astroquery.simbad import Simbad from PyQt5.QtWidgets import QDialog, QDialogButtonBox, QMessageBox from pyui.object_properties_dialog import Ui_ObjectPropertiesDialog import re from PyQt5.QtCore import Qt, QObject, pyqtSignal, QDateTime from astropy.coordinates import SkyCoord from astropy import units as u from object_properties import ObjectProperties Simbad.add_votable_fields('otype(V)') Simbad.add_votable_fields('sptype') class ObjectPropertiesDialog(QDialog): def __init__(self, settings, object_properties): super(ObjectPropertiesDialog, self).__init__() self.ui = Ui_ObjectPropertiesDialog() self.ui.setupUi(self) self.settings = settings self.object_properties = object_properties enable_simbad_button = lambda: self.ui.simbad.setEnabled( len(self.ui.name.currentText())) self.ui.name.editTextChanged.connect( lambda txt: enable_simbad_button()) self.ui.name.lineEdit().returnPressed.connect(self.simbad_query) self.ui.simbad.clicked.connect(self.simbad_query) self.accepted.connect(self.save_properties) enable_simbad_button() self.ui.name.setFocus() self.ui.name.setEditText(object_properties.name) self.ui.names.setText(object_properties.names)
# -*- coding: utf-8 -*- """ Created on Sun May 24 20:23:58 2020 @author: PC """ from astroquery.simbad import Simbad from astropy.coordinates import SkyCoord import matplotlib.pyplot as plt simbad = Simbad() simbad.add_votable_fields('flux(V)') # simbadのデータは星の他に星団や銀河や星雲も含まれていますが、otype='star'を指定することで星だけに絞ります # simbadから等級5以下の星を取 hoshi = simbad.query_criteria('Vmag<5', otype='star') print(hoshi) print(hoshi[hoshi['FLUX_V'] < 0.2]) sc = SkyCoord(ra=hoshi['RA'], dec=hoshi['DEC'], unit=['hourangle', 'deg']) seiza = sc.get_constellation() ra, dec = sc.ra, sc.dec z = (seiza[:, None] == np.unique(seiza)).argmax(1) iro = np.stack([z / 87, z % 5 / 4, 1 - z % 4 / 4], 1) s = (5 - hoshi['FLUX_V']) * 3 plt.figure(figsize=[8, 4]) # オリオン座
import os import time import datetime from tqdm import tqdm from astropy.io import ascii import astropy.table as T from astropy import units as u from astropy import coordinates from astropy.coordinates import SkyCoord from astroquery.simbad import Simbad # --- setup a custom simbad query with the relevant fields cSimbad = Simbad() cSimbad.remove_votable_fields('coordinates') cSimbad.add_votable_fields('otype(3)', 'z_value', 'ra(d)', 'dec(d)') #%% # --- helper routing def timestamp(): """ return a handy string with the current time """ return(datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')) #%% # --- helper routine
class STELA(): """ Class that governs the alignment of telescope, star positions, catalogs, and star identification Quantities and objects: STELA.naked: catalog of nearest stars, brightes in sky STELA.ard_pos: last stored position of arduino STELA.ard_targ: last stored arduino target Functions: STELA.setup_cats: Setup catalog files. STELA.setup_serial: Initiate serial connection with Arduino. STELA.get_ref_stars:ls Given an estimated latitude and longitude, returns the three brightest stars in the sky to align. STELA.gen_mock_obs: For testing triangulation STELA.triangulate: After calling get_ref_stars, and measuring the differences in alt-az coordinates of the three points, STELA.triangulate can locate the new latitude and longitude that accounts for the error in telescope positioning. STELA.set_targ: Sends target alt azimuth coordinate to arduino. STELA.get_pos: Reads current arduino poisition. """ def __init__(self): self.DATA_DIREC = DATA_PATH self.simbad = Simbad() self.simbad.TIMEOUT = 1000000 self.simbad.remove_votable_fields('coordinates') self.simbad.add_votable_fields('id(NAME)', 'ids', 'id(NGC)', 'id(M)', 'id(HD)', 'ra', 'dec', 'otype(V)', 'sp', 'plx', 'z_value', 'flux(V)', 'distance') self.reset_cats = False self.__triangulation_class = Triangulate() self.Transform = Transform() def setup_cats(self, reset_cats=False): """ Sets up the necessary catalogs, prints them to a file. (No parameters) """ self.__online = self.connect() if self.__online == False: print 'WARNING: No internet connection. Running offline mode.' print "" # Download necessary catalogs catlabels = ["GJ", "New Galactic Catalog", "Messier", "Henry Draper"] cats = ["gj", "ngc", "m", "hr"] catobjs = [] # If user requests fresh import, do it if reset_cats == True and self.__online == True: print "Deleting old catalog..." for c in cats: os.system('rm ' + os.path.join(self.DATA_DIREC, c.lower() + ".dat")) elif reset_cats == True: print "Requested refresh of catalogs but no internet connection. Find one!" for i in range(len(cats)): fp = os.path.join(self.DATA_DIREC, cats[i].lower() + '.dat') if os.path.exists(fp) == False: if self.__online == False: raise RuntimeError( "No saved catalogs, run once with internet") print "Downloading " + catlabels[i] + " data..." cat = self.simbad.query_catalog(cats[i].upper()) cat.remove_columns([ "Distance_merr", "Distance_Q", "Distance_perr", "Distance_bibcode" ]) select = np.array(cat["RA"] != '') * np.array(cat["DEC"] != '') catobjs += [cat[select]] catobjs[-1].write(fp, format='ascii') print "Done!" else: print catlabels[i] + " catalog file found." catobjs += [Table.read(fp, format='ascii')] class cats(): pass self.catalogs = cats() [ self.catalogs.gj, self.catalogs.ngc, self.catalogs.m, self.catalogs.hd ] = catobjs catobjs = None # Create catalog of naked eye stars (used in calibration) naked_fp = os.path.join(self.DATA_DIREC, 'naked.dat') if os.path.exists(naked_fp) == False: print "Setting up naked eye catalogs" # remove objects with no recorded magnitude select = np.ones(len(self.catalogs.gj), dtype='bool') select[np.where(np.isnan(np.array( self.catalogs.gj['FLUX_V'])))[0]] = False select[np.where(self.catalogs.gj['FLUX_V'] > 5)[0]] = False naked = self.catalogs.gj[select] print len(naked) self.catalogs.naked = Table(np.unique(naked[:800])) print len(self.catalogs.naked) self.catalogs.naked.sort("FLUX_V") # Write it to the catalogs folder self.catalogs.naked.write(naked_fp, format='ascii') else: self.catalogs.naked = Table.read(naked_fp, format='ascii') print "Done. \n" def setup_serial(self): """ Searches for a serial connection on the coms. ttyS* ports corresponding to usb COM numbers in /dev/ folder must be fully read/write/ex permissable. If failed, returns a Runtime Error. Some ports just don't work so switching USB ports might solve any problems.""" ports_closed = [] portsopen = 0 # First, try the expected filepath for a pi try: self.__ser = serial.Serial( "/dev/serial/by-id/usb-Arduino_LLC_Arduino_Micro-if00") print "Found the Arduino Micro." return except: pass # Then, try all of the ttyS* paths (useful on windows) for i in range(20): # New path to try path = "/dev/ttyS" + str(i) try: # Send message, if recieve correct response, keep serial information ser = serial.Serial(path) ser.write('setup') if ser.readline()[:5] == 'STELA': print 'Found STELA arduino running on on COM' + str(i) self.__ser = ser portsopen += 1 break # SerialException could be a sign that permissions need to be changed except serial.SerialException as err: if err.args[0] == 13: ports_closed += [i] # IOError means there was no response from the port. except IOError: pass # Next, check the pi directory where serial ports are stored if os.path.exists("/dev/serial/by-id"): for i in os.listdir("/dev/serial/by-id"): print "trying other paths..." try: ser = serial.Serial("/dev/serial/by-id/" + i) ser.write("setup") if ser.readline()[:5] == "STELA": print "Found connection with: " + i self.__ser = ser portsopen = 1 break except: pass # If no serial port, raise error and if permission issues were found. if portsopen == 0: if len(ports_closed) > 0: msg = ("Connection Failed. Unable to access ports: " + str(ports_closed) + ". Try changing permissions.") else: msg = "Connection Failed. Try different usb port." raise RuntimeError(msg) def search(self, string, list_results=False): """ Search stored catologs for a string. Looks for hits in the IDS column. Input ------ string: string The search string. Case does not matter, but any misspellings will not fly. Optional ------ list_results: bool Whether or not to return a list of all hits. If not, returns the best match. Output ------ data: dictionary or list of dictionaries A dictionary containing all of the information found in the catologs. If list_results == True, a list of dictionaries for each hit. """ print 'Searching for: "' + string + '"\n' # Check if online or not self.__online = self.connect(verbose=False) matches = Table(self.catalogs.m[0]) matches.remove_row(0) scores = [] for cat in [ self.catalogs.m, self.catalogs.gj, self.catalogs.ngc, self.catalogs.hd ]: # Load string of all names names = cat["IDS"] arr = names.view(type=np.recarray) # Look for hits in each item of the catalog string_low = string.lower() low = np.array([s.lower() for s in arr]) score_l = [] for l in low: allnames = np.array(l.split("|")) sc = [] for a in allnames: if a[:4] == "name": sc += [utils.score(string_low, a[5:])] elif a[:2] == "m " or a[:2] == "hd" or a[:3] == "ngc": sc += [utils.score(string_low, a)] else: sc += [-10.] score_l += [max(sc)] where = np.where(np.array(score_l) > 0.5)[0] if len(where) > 0: [matches.add_row(cat[i]) for i in where] scores += [score_l[i] for i in where] if len(matches) > 0: ind = scores.index(max(scores)) result = matches[ind] else: result = None """ NEED PLANET SEARCHING """ # Check connectivity if self.__online == True and type(result) == type(None): result = self.simbad.query_object(string) if isinstance(result, type(None)): return {"Error": "No object found"} if list_results == False or len(result) == 1: return self.__parse_result(result) else: info = [] for i in range(len(result)): info += [self.__parse_result(result[i])] return {"list": info} def __parse_result(self, row): """ Used to turn the catolog entries into dictionaries of information. Input ------ row: astropy row or single entry table The table to convert. Output ------ data: dic [keys=("Name","Otype","ra","dec","Distance","Mag","Sptype","Redshift","Luminosity") """ # Attempt to convert a row to a table (tables can be converted to arrays, but rows not) as_table = Table(row) # Extract information to single variables [ main, name, ids, idngc, idm, idhd, ra, dec, otype, sptype, plx, redshift, mag, dist, distu, distmeth ] = as_table.as_array()[0] # Make a string of all valid names usenames = "" for i in [name, idm, idngc, idhd]: if i != '' and i != 0: usenames += i + ", " data = {"Name": usenames[:-2]} # Go through the list, check if variables have information, and add them to dictionary if # information is found if mag != None: data["Mag"] = "%.3f" % mag if redshift > 0.001: data["Redshift"] = "%.3f" % redshift if otype != None: data["Otype"] = otype else: data["Otype"] = "Unknown" if sptype != '': data["Sptype"] = str(sptype) if plx > 0: # Distance calculations from parallax data["Plx"] = str(plx) distpc = 1000. / plx distly = distpc * 3.2616 data["Distance"] = "%.2f pc, %.2f ly" % (distpc, distly) if redshift != None: # Distance estimates from redshift data["redshift"] = redshift if plx > 0 and mag != None: # Luminosity estimates Msun = 4.74 absmag = mag - 5 * (np.log10(distpc) - 1) L = 10**(1. / 2.5 * (Msun - absmag)) data["Luminosity"] = "%.2f" % L if dist > 0: data["Distance"] = "%.2f %s" % (dist, distu) # Add right ascencion and declination information data["ra"] = "%s hrs" % ra data["dec"] = "%s deg" % dec data["celcoor"] = [utils.hourangle(ra), utils.degree(dec)] if "location" in dir(self): loc = self.location if "home" in dir(self): loc = self.home altaz = self.Transform.cel2altaz(data["celcoor"], loc)[0] data["altaz"] = altaz data["az"] = "%.2f deg" % altaz[0] data["alt"] = "%.2f deg" % altaz[1] # This is for a string with all of the information. Goes down the list, if a key exists, adds # infomation to string. Useful for displaying everything easily. order = [ "Name", "Otype", "ra", "dec", "az", "alt", "Mag", "Distance", "Sptype", "Luminosity", "Redshift" ] outstring = '' for key in order: if key in data.keys(): outstring += key + ": " + data[key] + "\n" data["String"] = outstring return data def set_time(self, datetime): """ Sets the system time. Input ------ datetime: string (format) """ l = datetime.split("-") date_str = l[1] + l[2] + l[3] + l[4] + l[0] + "." + l[5] if os.environ["USER"] == 'pi': os.system("sudo date " + date_str) else: print "Not setting time." def set_targ(self, targ): """ Sends the target coordinates in the arduino. Input ------ targ: ndarray [args, shape=(2), dtype=float] New target coordinates for the arduino. """ msg = 'set_targ:' + str(targ) self.__ser.write(msg) def get_pos(self, return_targ=False): """ Gets the current arduino position and target. Optional ------ return_targ: bool If true, returns both the arduino postion and the current arduino target. Output ------ ard_pos: ndarray [args, shape=(2), dtype=float] The postion sent back from the arduino """ now = ephem.now() # Send request to arduino through serial, read response self.__ser.write('info') msg = self.__ser.readline() # Find alt-az information, break message string into sections pos_str = msg[msg.find('[') + 1:msg.find(']')] targ_str = msg[msg.find('[', 11) + 1:msg.find(']', msg.find(']') + 1)] # Set class objects using parsed string self.ard_pos = np.fromstring(pos_str, sep=', ') self.ard_targ = np.fromstring(targ_str, sep=', ') # Save time of update self.update_time = now # Return if return_targ == True: return self.ard_pos, self.ard_targ return self.ard_pos def set_pos(self, newpos): """ Resets the position of the arduino to specified coordinates. Inputs ------ newpos: ndarray or list [args, shape=(2), dtype=float] The coordinates to use to reset the position. """ # create message and send it msg = 'set_pos:' + str(newpos) self.__ser.write(msg) def get_ref_stars(self): """ Given an estimation of longitude and latitude, identifies 3 target stars to use as triangulation coordinates Input: ------ lon_est: float The current longitude at which the telescope is set up lat_est: float The current latitude at which the telescope is set up Optional: ------ representation: string The preferred representation of the coordinates ('SkyCoord' or 'String') Output: ------ altaz_calib: list [args, shape=(3,2), dtype=float] The estimated positions in the altitude azimuth coordinate frame. Can be used to point telescope to approximate position of stars. """ [lon_est, lat_est] = self.location # Coordinates of all visible stars ra = self.catalogs.naked["RA"].data dec = self.catalogs.naked["DEC"].data # One by one, compares catalog entries to the earth normal vector for any that should be # visible in the night sky. After this check, compares entry to other accepted reference stars. # If it's too close to others, reject it. coors = [] earthnorm = self.Transform.earthnorm2icrs(self.location) for i in range(len(self.catalogs.naked)): obj = [utils.hourangle(ra[i]), utils.degree(dec[i])] if self.Transform.separation(earthnorm, obj) < 60: # If star is 30 degrees above horizon... if sum([self.Transform.separation(c, obj) < 20 for c in coors]) == 0: # Check if star is at least 20 degrees away from the other reference stars... coors += [obj] if len(coors) >= 3: # If we already now have 3 reference stars, we are good. break # Convert to earth altaz frame altaz_calib = [ self.Transform.cel2altaz(c, self.location)[0] for c in coors ] # set class objects self.altaz_calib = altaz_calib self.cel_calib = coors return altaz_calib def triangulate(self, v2_v1, v3_v2, iterations=5, verbose=True): """ Used to triangulate the true latitude and longitude corresponding to the norm of the telescope position. Input ------ v2_v1: list [args,len=2,dtype=float] The difference in [azimuth,altitude] between object 2 and object 1 v3_v2: list [args,len=2,dtype=float] The difference in [azimuth,anow haveude] between object 3 and object 2 """ # Get reference star coordinates v = np.array(self.cel_calib) # Triangulate using the triangulation class (nested in try:except for safety) loc, self.loc_errs = self.__triangulation_class.triangulate( v[0], v[1], v[2], v2_v1, v3_v2, iterations=iterations, verbose=verbose) zero = self.Transform.earthnorm2icrs([0, 0]) [self.lon, self.lat] = loc - zero self.home_coors = [self.lon, self.lat] self.tel_pos = self.Transform.cel2altaz(v[2], self.home_coors) try: self.set_pos(v[2]) except: pass self.calibrated = True def save(self): """Saves some of the data to a file.""" [lon, lat] = self.location savedata = { 'location': [lon.value, lat.value], 'location_units': [lon.unit.to_string(), lat.unit.to_string()] } with open(self.savefile, 'w') as file: file.write(json.dumps(savedata)) def load(self): """Loads data from the file.""" with open(self.savefile, 'r') as file: data = json.loads(file.read()) loc = data['location'] loc_u = data['location_units'] self.location = [loc[0] * Unit(loc_u[0]), loc[1] * Unit(loc_u[1])] def connect(self, verbose=True): """Tests the internet connection. Optional ------ verbose: bool If true, prints out process. """ if verbose == True: print "Testing internet connection..." try: urllib2.urlopen('http://216.58.192.142', timeout=1) if verbose == True: print "Connection succeeded!" return True except urllib2.URLError as err: if verbose == True: print "Connection failed." return False except Exception as e: print e return False
import glob from collections import OrderedDict # Third-party import numpy as np import astropy.coordinates as coord from astropy.time import Time import astropy.units as u from astropy.io import fits from astropy.table import Table from astropy.utils.console import ProgressBar from astroquery.simbad import Simbad from astroquery.gaia import Gaia Simbad.add_votable_fields('rv_value', 'rvz_qual', 'rvz_bibcode') gaia_query = """ SELECT TOP 10 j_m, j_msigcom, h_m, h_msigcom, ks_m, ks_msigcom FROM gaiadr1.tmass_original_valid JOIN gaiadr1.tmass_best_neighbour USING (tmass_oid) JOIN gaiadr1.tgas_source USING (source_id) WHERE source_id = {0:d} """ # Project from comoving_rv.db import Session, Base, db_connect, get_best_rv from comoving_rv.db.model import (Run, Observation, TGASSource, SimbadInfo, SpectralLineInfo, PriorRV) from comoving_rv.velocity import bary_vel_corr, kitt_peak from comoving_rv.log import logger
def MAGIC_Field_CR(ra_pos, dec_pos): import numpy as np from astroquery.vizier import Vizier import astropy.units as u import astropy.coordinates as coord from PyAstronomy import pyasl import matplotlib.pyplot as plt #from tabulate import tabulate from astropy.table import Table, Column, MaskedColumn, QTable from quantiphy import Quantity from astropy.io import ascii Vizier.ROW_LIMIT = -1 result = Vizier.query_region(coord.SkyCoord(ra=ra_pos, dec=dec_pos, unit=(u.deg, u.deg), frame='icrs'), width="7d", catalog="V/125") if result == []: data = np.array([ra_pos, dec_pos, 0, 0, 0, 0, 0, 0]) #data = data.transpose return data t = result['V/125/obcat'] #t.columns #use ALS IDs to ensure uniqueness ALS0 = np.array(t['ALS']) ra = np.array(t['RAJ2000']) dec = np.array(t['DEJ2000']) #ALS0[0:3] t.columns #Section 3 of Jupyter Notebook from astroquery.simbad import Simbad #Right now that's B, V, sptype, but later might want more... customSimbad = Simbad() customSimbad.add_votable_fields('sptype', 'fe_h', 'flux(V)', 'flux(B)', 'flux(U)') vmag = np.zeros(len(ALS0)) bmag = np.zeros(len(ALS0)) st = np.empty(len(ALS0), dtype='S2') #vmag = np.zeros(200) #bmag = np.zeros(200) for ii in range(len(ALS0)): result_table = customSimbad.query_object('ALS' + np.array2string(ALS0[ii])) #print(str(result_table[0][11])[0:2]) #print(ALS0[ii]) if result_table is None: #print('None 2') vmag[ii] = np.nan bmag[ii] = np.nan st[ii] = 'XX' else: vmag[ii] = np.asarray(result_table['FLUX_V']) bmag[ii] = np.asarray(result_table['FLUX_B']) st[ii] = str(result_table[0][11])[0:2] #print('bmag1') #print(bmag) idx = (np.isnan(vmag)) #print('idx1') #print(idx) vmag = vmag[~idx] bmag = bmag[~idx] st = st[~idx] ra = ra[~idx] dec = dec[~idx] idx = (np.isnan(bmag)) #print('idx2') #print(idx) vmag = vmag[~idx] bmag = bmag[~idx] st = st[~idx] ra = ra[~idx] dec = dec[~idx] #print('bmag2') #print(bmag) #print(bmag.size) if bmag.size == 0 or vmag.size == 0: #print('in if') data = np.array([ra_pos, dec_pos, 0, 0, 0, 0, 0, 0]) #data = data.transpose return data #Start of section 4 in Jupyter notebook #collect spectral type, V magnitude information for each star #Use SIMBAD spectral types, recorded in st string array #Do some temporary cleanup here. For stars with generic OB type, assign type O5V. For Wolf-Rayet stars (W..), #also assign type O5V. Note that this is definitely too cool, but right now don't have the models to assign a hotter type st_vals = list() for ii in range(len(st)): temp1 = np.array2string(st[ii])[2:4] if len(temp1) == 2 and temp1[1] == "'": temp1 = temp1[0] + '5' if temp1 == "OB": temp1 = "O5" if temp1[0] == "W": temp1 = "O5" if temp1[0] == "'": temp1 = "O5" if len(temp1) == 1 and temp1[1] == "'": temp1 = "G5" temp1 = temp1 + 'V' st_vals.append(temp1) st_vals = np.asarray(st_vals) len(st_vals) #MeanStars is a python package which includes Mamajek mean stars catalog from MeanStars import MeanStars ms = MeanStars() ms_st = ms.data #ms_st are spectral types from Mamajek mean stars catalog ms_st = ms_st['SpT'] #ms_temp = ms_st['Teff'] #ms_temp are temperatures from Mamajek catalog ms_temp = ms.data['Teff'] #match up rows in Mamajek catalog with observed STs sloc = [] for x in range(len(st_vals)): sloc_temp = np.nonzero(st_vals[x] == ms_st) sloc.append(sloc_temp[0]) #star_temp = temperature of stars suitable for calling to function #Note for stars with no temperature value, assign T<10,000K so they will be ignored later #For stars with T>40000, assign 40000 (model fits for >40,000 are broken for now) star_temp = [] for x in range(len(st_vals)): star_temp.append(ms_temp[sloc[x]]) if len(star_temp[x]) == 0: star_temp[x] = 9999 if star_temp[x] > 40000: star_temp[x] = 40000 #Estimate count rate for each star based on spectral type, magnitude, model atmosphere fits #Polynomial fits to the atmosphere fits derived from my MATLAB code (which needs to be ported to Python!) #cr1 -0.3375 -34.1223 227.7543 -172.6182 34.0610 #cr2 3.2407 -51.6510 219.8193 -91.3053 5.2321 cr1 = np.zeros(len(st_vals)) cr2 = np.zeros(len(st_vals)) for x in range(len(st_vals)): cr2[x] = (2.512**-bmag[x]) * 1e4 * np.polyval( [-0.3375, -34.1223, 227.7543, -172.6182, 34.0610], 1e-4 * star_temp[x]) cr1[x] = (2.512**-bmag[x]) * 1e4 * np.polyval( [3.2407, -51.6510, 219.8193, -91.3053, 5.2321], 1e-4 * star_temp[x]) #plt.figure(1) #plt.plot(star_temp,cr1,'.') #plt.show() #Summed total count rates over field in both bands, as well as max local CRs in field in both bands #print('cr1') #print(cr1) tot_cr1 = np.nansum(cr1) tot_cr2 = np.nansum(cr2) count1 = np.count_nonzero(cr1 > 100) count2 = np.count_nonzero(cr2 > 100) #np.nanmax(cr1) #np.nanmax(cr2) np.nanmedian(cr1) #np.nanmedian(cr2) #Histogram of count rates in field #plt.figure(2) #plt.hist(np.log10(cr1[~np.isnan(cr1)]),bins=40) #plt.show() #Scatter plot #pyastro and future import was moved to the beginning of the file #plt.plot(ra,dec,'x') #plt.show() ra_d = np.zeros(len(ra)) dec_d = np.zeros(len(dec)) for ii in range(len(ra)): temp = str(ra[ii]) temp2 = str(dec[ii]) ra_d[ii], dec_d[ii] = pyasl.coordsSexaToDeg(temp[0:-1] + " " + temp2[0:-1]) #plt.figure(3) #plt.scatter(ra_d,dec_d,cr1*0.01,alpha=0.3) #plt.axis('square') #plt.xlabel('RA') #plt.ylabel('Dec') #plt.show() #Number of stars with T>10000 tstar = np.asarray(star_temp) len(tstar[tstar > 10000]) b_i, v_i = cr1, cr2 #print(b_i, v_i) maxcr1 = np.max(b_i) #x=f"{maxcr1.value:0.03f}" maxcr2 = np.max(v_i) in_cr = maxcr1 + maxcr2 data = np.array( [ra_pos, dec_pos, maxcr1, maxcr2, tot_cr1, tot_cr2, count1, count2]) #data = data.transpose #print(data) #print(maxcr2) #data=(np.array(x,dtype=object,copy=False, order='C')) #fopen = open("sample.txt", "a") #print(fopen) #np.savetxt("sample.txt", data, fmt='%10.5f', newline=' ') #np.savetxt("Datamagic3",data, fmt='%10.5f',newline=' ') # data=(np.array(x,dtype=object,copy=False, order='C') #ascii.write(data, 'values.dat', names=['x'], overwrite=True) #ascii.write(data,'values.csv',format='csv',fast_writer=False) # print(x) # y = maxcr2 #data1=QTable([maxcr1], names=['Maxcr1']) #lines = ['in_CR & maxCr1 & maxCr2 ','----------------------- & ----------------- & -------------',' 32876.33701130775 & 18225.588784508154 & 14650.748916622626'] # data = ascii.read(lines, data_start=2, delimiter='&') # print(data) # plt.hist(np.log10(cr1[~np.isnan(cr1)]),bins=40) # return plt.hist(np.log10(cr1[~np.isnan(cr1)]),bins=40) return data
def do_simbad(catalog): # Simbad.list_votable_fields() # Some coordinates that SIMBAD claims belong to the SNe actually belong to # the host. task_str = catalog.get_current_task_str() simbadmirrors = ['http://simbad.harvard.edu/simbad/sim-script', 'http://simbad.u-strasbg.fr/simbad/sim-script'] simbadbadcoordbib = ['2013ApJ...770..107C'] simbadbadnamebib = ['2004AJ....127.2809W', '2005MNRAS.364.1419Z', '2015A&A...574A.112D', '2011MNRAS.417..916G', '2002ApJ...566..880G'] simbadbannedcats = ['[TBV2008]', 'OGLE-MBR'] customSimbad = Simbad() customSimbad.ROW_LIMIT = -1 customSimbad.TIMEOUT = 120 customSimbad.add_votable_fields('otype', 'sptype', 'sp_bibcode', 'id') table = [] for mirror in simbadmirrors: customSimbad.SIMBAD_URL = mirror try: table = customSimbad.query_criteria('maintype=No* | maintype="No?"') except: continue else: break if not table: catalog.log.warning('SIMBAD unable to load, probably offline.') # 2000A&AS..143....9W for brow in pbar(table, task_str): row = {x: re.sub(r'b\'(.*)\'', r'\1', str(brow[x])) for x in brow.colnames} # Skip items with no bibliographic info aside from SIMBAD, too # error-prone if row['OTYPE'] == 'Candidate_No*' and not row['SP_TYPE']: continue if (not row['COO_BIBCODE'] and not row['SP_BIBCODE'] and not row['SP_BIBCODE_2']): continue if any([x in row['MAIN_ID'] for x in simbadbannedcats]): continue if row['COO_BIBCODE'] and row['COO_BIBCODE'] in simbadbadnamebib: continue name = single_spaces(re.sub(r'\[[^)]*\]', '', row['MAIN_ID']).strip()) if name == 'SN': continue if is_number(name): continue name = catalog.add_entry(name) source = (catalog.entries[name] .add_source(name='SIMBAD astronomical database', bibcode="2000A&AS..143....9W", url="http://simbad.u-strasbg.fr/", secondary=True)) aliases = row['ID'].split(',') for alias in aliases: if any([x in alias for x in simbadbannedcats]): continue ali = single_spaces(re.sub(r'\[[^)]*\]', '', alias).strip()) if is_number(ali): continue ali = name_clean(ali) catalog.entries[name].add_quantity(NOVA.ALIAS, ali, source) if row['COO_BIBCODE'] and row['COO_BIBCODE'] not in simbadbadcoordbib: csources = ','.join( [source, catalog.entries[name].add_source( bibcode=row['COO_BIBCODE'])]) catalog.entries[name].add_quantity(NOVA.RA, row['RA'], csources) catalog.entries[name].add_quantity(NOVA.DEC, row['DEC'], csources) if row['SP_BIBCODE']: ssources = uniq_cdl([source, catalog.entries[name] .add_source(bibcode=row['SP_BIBCODE'])] + ([catalog.entries[name] .add_source(bibcode=row['SP_BIBCODE_2'])] if row['SP_BIBCODE_2'] else [])) catalog.entries[name].add_quantity( NOVA.CLAIMED_TYPE, (row['SP_TYPE'] .replace('SN.', '') .replace('SN', '') .replace('(~)', '') .strip(': ')), ssources) catalog.journal_entries() return
if len(RA[2]) == 4: RA[2] += '0' RA = "{0} {1} {2}".format(*RA) DEC = list(c.dec.dms) DEC[0] = str(int(DEC[0])).zfill(2) DEC[1] = str(abs(int(DEC[1]))).zfill(2) DEC[2] = str(abs(round(DEC[2], 2))).zfill(4) if int(DEC[0]) > 0: DEC[0] = '+'+DEC[0] if len(DEC[2]) == 4: DEC[2] += '0' DEC = "{0} {1} {2}".format(*DEC) # search in Simbad the parallax, Vmag and spectral type customSimbad = Simbad() customSimbad.add_votable_fields('plx','plx_error','flux(V)','flux_error(V)','sptype','otype','ids','dist') result = customSimbad.query_region(coord.SkyCoord(ra=c.ra, dec=c.dec,frame='icrs'),radius='15s') empty='NULL' # Here comes the user interface part... puts(colored.black('\nStandard parameters\n')) # The metallicity if ~np.isnan(exo.star_metallicity_error_min.values[0]) and ~np.isnan(exo.star_metallicity_error_max.values[0]): errFeH_exo=(exo.star_metallicity_error_min.values[0]+exo.star_metallicity_error_max.values[0])/2 elif ~np.isnan(exo.star_metallicity_error_min.values[0]): errFeH_exo=exo.star_metallicity_error_min.values[0] elif ~np.isnan(exo.star_metallicity_error_max.values[0]): errFeH_exo=exo.star_metallicity_error_max.values[0] else:
except: contrast = 0.0 #print(name,c.to_string('hmsdms')) # if True: if theta > thetamin and theta < thetamax and contrast < contmax and contrast > contmin: ra = str(dat["RA"][i]) dec = str(dat["DEC"][i]) c = SkyCoord(ra + " " + dec, unit=(u.deg, u.deg)) # c = SkyCoord(ra, dec, unit=(u.hourangle, u.deg)) altitude = c.transform_to(frame) if np.max(altitude.alt[nightmask]) > maxalt * u.deg: try: Simbad.SIMBAD_URL = "http://simbad.u-strasbg.fr/simbad/sim-script" Simbad.add_votable_fields("flux(V)", "flux(R)", "flux(J)", "flux(H)", "flux(K)") result_table = Simbad.query_object(name) V = result_table["FLUX_V"].item() R = result_table["FLUX_R"].item() J = result_table["FLUX_J"].item() H = result_table["FLUX_H"].item() K = result_table["FLUX_K"].item() except: print("NO SIMBAD name=", name) try: Simbad.SIMBAD_URL = "http://simbad.u-strasbg.fr/simbad/sim-script" Simbad.add_votable_fields("sp") result_table = Simbad.query_object(name)
def plot_decam_footprint(cat_data, ra=0., dec=0., target='', filter='', title='DECam'): if cat_data.__class__.__name__ == 'Table': if filter!='': gv=(cat_data['filter']==filter) if np.sum(gv)==0: print 'There are no observations in the filter ', filter return else: gv=np.arange(len(cat_data)) ra=np.asarray(cat_data['ra'][gv]) dec=np.asarray(cat_data['dec'][gv]) program=cat_data['dtpi'][gv]+' '+cat_data['dtpropid'][gv] exptime=np.asarray(cat_data['exposure'][gv]) title=target+' '+filter else: ra=np.asarray(ra) dec=np.asarray(dec) program='' decam_corners=np.array([[1652.0,-2994.2],[1652.0,-3521.1],[585.1,-3521.1], #shape 1 [585.1,-2994.2],[-583.4,-2991.8], #Missing chip South [-583.4,-3521.6],[-1651.3,-3521.6],[-1651.3,-2991.8], #shape 2 [-2210.7,-2930.6],[-2210.7,-2400.3], #shape 6 [-2769.5,-2339.3],[-2769.5,-1808.5], #shape 11 [-3322.1,-1746.9],[-3322.1,-1217.0], # shape 17 [-3329.6,-1156.4],[-3329.6,-626.1], # shape 23 [-3887.0,-564.0],[-3887.0,-33.4], #shape 30 [-3886.2,28.5],[-3886.2,557.9], #shape 37 [-3328.0,621.2],[-3328.0,1150.2], #shape 43 [-3328.0,1212.0],[-3328.0,1741.0], #shape 49 [-2769.6,1805.1],[-2769.6,2333.2], #shape 54 [-2210.4,2397.3],[-2210.4,2925.0], #shape 58 [-1651.7,2989.0],[-1651.7,3516.3],[-583.1,3516.3], #shape 60 [-583.1,2989.0],[583.8,2987.6], # Missing chip North [583.8,3517.3],[1652.8,3517.3],[1652.8,2987.6], #shape 59 [2211.8,2926.8],[2211.8,2396.0], #shape 55 [2770.8,2335.2],[2770.8,1803.6], #shape 50 [3330.1,1743.0],[3330.1,1212.0], #shape 44 [3329.7,1151.8],[3329.7,620.6], #shape 38 [3887.7,558.8],[3887.7,29.4], #shape 31 [3887.1,-32.9],[3887.1,-562.9], #shape 24 [3328.7,-626.1],[3328.7,-1155.1], #shape 18 [3328.0,-1217.6],[3328.0,-1745.7], #shape 12 [2769.3,-1810.1],[2769.3,-2336.9], #shape 7 [2210.3,-2401.9],[2210.3,-2928.9], #shape 3 [1652.0,-2994.2],[1652.0,-3521.1] #shape 1 ]) decam_corners[:,0]=decam_corners[:,0]*-1 for i in range(decam_corners.shape[0]-1): if np.abs(decam_corners[i,1]-decam_corners[i+1,1])<100: decam_corners[i:i+2,1]=np.mean(decam_corners[i:i+2,1]) i=i+1 program_uniq=np.unique(program) # color_uniq= ['red','green','blue','yellow','cyan','magenta'] color_uniq= plt.cm.jet(np.linspace(0,1,len(program_uniq))) # print 'List of PI and Observing programs' # print program_uniq fig, ax = plt.subplots(figsize=(8,8)) program_legend=[] program_label=[] for i in range(len(program_uniq)): gv=(program==program_uniq[i]) x=ra[gv] y=dec[gv] t=exptime[gv] label=program_uniq[i] color=color_uniq[i] # text_coo=(np.median(ra[gv]),np.median(dec[gv])) # ax.text(text_coo[0], text_coo[1], text, horizontalalignment='left') patches=[] for j in range(len(x)): corners=decam_corners/3600. # Convert from arcseconds to degrees corners[:,0]=x[j]+corners[:,0]/np.cos(np.radians(y[j])) corners[:,1]=y[j]+corners[:,1] polygon=Polygon(corners,closed=True) patches.append(polygon) p = PatchCollection(patches, alpha=1./len(x), color=color) ax.add_collection(p) program_legend.append(Line2D([0], [0], linestyle="none", marker="o", alpha=0.4, markersize=10, markerfacecolor=color)) program_label.append(label) coo=np.concatenate((np.transpose([x]), np.transpose([y])), axis=1) # print label, coo, len(coo) if len(coo)>1: init = np.max(pdist(coo)) # print 'Affinity init value ', init # af = AffinityPropagation(affinity="euclidean", damping=0.95).fit(coo) # af = AffinityPropagation(preference=-1*init).fit(coo) # cluster_centers_indices = af.cluster_centers_indices_ # labels = af.labels_ ms = MeanShift(bandwidth=0.5, bin_seeding=True) ms.fit(coo) ms_labels = ms.labels_ n_tiles = len(np.unique(ms_labels)) print 'Program: ', label, ' - N of tiles: ', n_tiles for i in range(n_tiles): class_members = (ms_labels == i) tile_ra=np.median(coo[class_members,0]) tile_dec=np.median(coo[class_members,1]) tile_exptime=np.sum(t[class_members]) tile_n_images=np.sum(class_members) print("Tile {:d} - Coo: {:.4f} {:.4f} - N images: {:d} - Total Exposure: {:.1f} s".format(*(i+1,tile_ra,tile_dec, tile_n_images, tile_exptime))) else: tile_ra=x[0] tile_dec=y[0] tile_exptime=t[0] # print tile_ra, tile_dec, tile_exptime print 'Program: ', label, ' - N of tiles: ', 1 print("Tile {:d} - Coo: {:.4f} {:.4f} - Exposure: {:.1f} s".format(*(1,tile_ra,tile_dec,tile_exptime))) print '---' ax.legend(program_legend, program_label, numpoints=1, loc="center left", bbox_to_anchor=(1., 0.5)) delta_x=np.abs( max(ra)-min(ra) + 2*1.2) # /np.cos(np.radians(np.mean(dec))) ) delta_y=np.abs( max(dec)-min(dec) + 2*1.2 ) delta_xy = np.max([delta_x,delta_y]) plot_xrange=list( np.mean([min(ra),max(ra)]) + delta_xy/(2*np.cos(np.radians(np.mean(dec))))*np.array([1,-1]) ) plot_yrange=list( np.mean([min(dec),max(dec)]) + delta_xy/2*np.array([-1,1]) ) # plot_xrange=(min(ra)-1.2/np.cos(np.radians(np.mean(dec))),max(ra)+1.2/np.cos(np.radians(np.mean(dec)))) # plot_yrange=(min(dec)-1.2, max(dec)+1.2) ax.set_xlim(plot_xrange) ax.set_ylim(plot_yrange) ax.set_title(title) ax.set_xlabel('R.A. (deg)') ax.set_ylabel('Dec (deg)') if target!='': customSimbad = Simbad() customSimbad.add_votable_fields('ra(d)','dec(d)','flux(V)','flux(K)') result = customSimbad.query_object(target) ax.scatter(result['RA_d'][0], result['DEC_d'][0], s=100, c='yellow', marker="*") ax.text(result['RA_d'][0], result['DEC_d'][0]-np.abs(plot_yrange[1]-plot_yrange[0])/50, target, horizontalalignment='center', verticalalignment='top') plt.show()
def do_simbad(catalog): task_str = catalog.get_current_task_str() keys = list(catalog.entries.keys()) customSimbad = Simbad() customSimbad.ROW_LIMIT = -1 customSimbad.TIMEOUT = 120 customSimbad.add_votable_fields('otype', 'sptype', 'sp_bibcode', 'id') warnings.filterwarnings("ignore") Mnames, Mradec = [], [] for oname in pbar(keys, task_str): # Some events may be merged in cleanup process, skip them if # non-existent. try: name = catalog.add_entry(oname) except Exception: catalog.log.warning( '"{}" was not found, suggests merge occurred in cleanup ' 'process.'.format(oname)) continue if (FASTSTARS.RA not in catalog.entries[name] or FASTSTARS.DEC not in catalog.entries[name]): continue else: Mnames.append(name) radec = str(catalog.entries[name][FASTSTARS.RA][0]['value']) + str( catalog.entries[name][FASTSTARS.DEC][0]['value']) c = coord(radec, unit=(un.hourangle, un.deg), frame='icrs') cnttry = 0 foundstar = False while foundstar == False and cnttry < 10: try: cnttry += 1 time.sleep(0.1) result = customSimbad.query_region(c, radius='0d0m5s') aliases = re.sub(r'b\'(.*)\'', r'\1', str(result['ID'].tolist()[0])).split(',') except TypeError: #print(radec,cnttry) continue foundstar = True if foundstar == True: source = (catalog.entries[name].add_source( name='SIMBAD astronomical database', bibcode="2000A&AS..143....9W", url="http://simbad.u-strasbg.fr/", secondary=True)) for alias in aliases: ali = single_spaces( re.sub(r'\[[^)]*\]', '', alias).strip()) if is_number(ali.replace(' ', '')): continue if ali[:4] == "HVS ": continue ali = name_clean(ali) catalog.entries[name].add_quantity(FASTSTARS.ALIAS, ali, source) catalog.journal_entries() return
import time from xml.etree import ElementTree from io import BytesIO from PIL import Image import base64 from alerce.core import Alerce # whether to report photozs to TNS and skyportal report_photoz_TNS = False report_photoz_skyportal = False # add redshift to Simbad query customSimbad = Simbad() customSimbad.add_votable_fields('z_value') customSimbad.add_votable_fields('rv_value') customSimbad.add_votable_fields('rvz_type') customSimbad.add_votable_fields('rvz_error') customSimbad.add_votable_fields('rvz_qual') customSimbad.TIMEOUT = 5 # 5 seconds # timeout for Ned customNed = Ned() customNed.TIMEOUT = 5 class alerce_tns(Alerce): 'module to interact with alerce api to send TNS report' def __init__(self, **kwargs):
from astropy import coordinates from astroquery.simbad import Simbad customSimbad = Simbad() # We've seen errors where ra_prec was NAN, but it's an int: that's a problem # this is a workaround we adapted customSimbad.add_votable_fields('ra(d)', 'dec(d)') customSimbad.remove_votable_fields('coordinates') C = coordinates.SkyCoord(0, 0, unit=('deg', 'deg'), frame='icrs') result = customSimbad.query_region(C, radius='2 degrees') result[:5].pprint() """ MAIN_ID RA_d DEC_d ------------- ----------- ------------ ALFALFA 5-186 0.00000000 0.00000000 ALFALFA 5-188 0.00000000 0.00000000 ALFALFA 5-206 0.00000000 0.00000000 ALFALFA 5-241 0.00000000 0.00000000 ALFALFA 5-293 0.00000000 0.00000000 """
aux_path = config['DATA']['aux_path'] vlass_path = config['DATA']['vlass_path'] cutout_cache = config['DATA']['cutout_cache'] on_system = config['DATA']['on_system'] if on_system == 'ada': SURVEYS = pd.read_json('./config/surveys.json') elif on_system == 'nimbus': SURVEYS = pd.read_json('./config/surveys_nimbus.json') else: raise Exception( "Need to set on_system to either 'ada' or 'nimbus' in config/config.ini" ) SURVEYS.set_index('survey', inplace=True) Simbad.add_votable_fields('otype', 'ra(d)', 'dec(d)', 'parallax', 'pmdec', 'pmra', 'distance', 'sptype', 'distance_result') class FITSException(Exception): pass class Cutout: def __init__(self, survey, position, radius, **kwargs): self.survey = survey self.position = position self.ra = self.position.ra.to_value(u.deg) self.dec = self.position.dec.to_value(u.deg) self.radius = radius self.basesurvey = kwargs.get('basesurvey', 'racsI') self.psf = kwargs.get('psf')
def __init__(self, ixchel): self.logger = logging.getLogger('Celestial') self.ixchel = ixchel self.config = ixchel.config Simbad.add_votable_fields('fluxdata(V)')
width = u.Quantity(5, u.arcsec) height = u.Quantity(5, u.arcsec) #GAIA r = Gaia.query_object_async(coordinate=c, width=width, height=height) plx = None if len(r["parallax"]) == 0: sw = False elif type(r["parallax"][0]) == np.float64: plx = r["parallax"][0] sw = True else: sw = False print("GAIA", plx) Simbad.SIMBAD_URL = "http://simbad.u-strasbg.fr/simbad/sim-script" Simbad.add_votable_fields("parallax", "flux(V)", "flux(R)", "flux(J)", "flux(H)", "flux(K)", "pmra", "pmdec") result_table = Simbad.query_region(c, radius='0d0m5s') print(result_table) print(radec) if result_table is None: plxs = np.nan magcom = "|||||" else: plxs = result_table["PLX_VALUE"][0] V = result_table["FLUX_V"][0] R = result_table["FLUX_R"][0] J = result_table["FLUX_J"][0] H = result_table["FLUX_H"][0] K = result_table["FLUX_K"][0] magcom = "|" + str(V) + "|" + str(R) + "|" + str(J) + "|" + str(
Vizier.ROW_LIMIT = -1 catalog = Vizier.get_catalogs("VI/49")[1]#This selects the 2nd of three tables that were found by the key-word search. This table contains relevant data catalog.remove_columns(['cst','type']) coords = SkyCoord(catalog['RAJ2000'],catalog['DEJ2000'],unit="deg") const = coords.get_constellation() catalog.add_column(const,name="Constellation", index = 2) catalog.write("constellation_borders.csv",format="csv",overwrite="True") print('\n') print('Done') print('\n') print('Downloading Messier Catalogue...') #the next three lines are to simplify the output table Simbad.reset_votable_fields() Simbad.remove_votable_fields('coordinates') Simbad.add_votable_fields('otype(3)', 'ra(d;A;ICRS;J2000;2000)', 'dec(d;D;ICRS;J2000;2000)','flux(B)','flux(V)')#These are all the columns added to the table result_table = Simbad.query_catalog("Messier")#This asks the SIMBAD database to list all objects from the messier catalog result_table['FLUX_V'].name = 'V' result_table['OTYPE_3']=[x.decode('utf8') for x in result_table['OTYPE_3']] result_table['MAIN_ID']=[x.decode('utf8') for x in result_table['MAIN_ID']] result_table['RA_d_A_ICRS_J2000_2000'].name = "RAJ2000" result_table['DEC_d_D_ICRS_J2000_2000'].name = "DEJ2000" result_table['B-V'] = result_table['FLUX_B'] - result_table['V'] result_table.remove_column('FLUX_B') coords = SkyCoord(result_table['RAJ2000'],result_table['DEJ2000'],unit="deg") const = coords.get_constellation() const_abr = coords.get_constellation(short_name = "True") result_table.add_column(const,name="Constellation", index = 2)
newitem['name'] = item['name'] newitem['alias'] = [x['value'] for x in item['alias']] newitem['ra'] = item['ra'][0]['value'] newitem['dec'] = item['dec'][0]['value'] if 'redshift' in item: newitem['redshift'] = item['redshift'][0]['value'] # Temporary fix for David's typo if newitem['dec'].count('.') == 2: newitem['dec'] = newitem['dec'][:newitem['dec'].rfind('.')] newcatalog.append(newitem) coo = coord([x['ra'] for x in newcatalog], [x['dec'] for x in newcatalog], unit = (un.hourangle, un.deg)) for ci, co in enumerate(tqdm(coo)): customSimbad = Simbad() customSimbad.add_votable_fields('otype', 'z_value') regstr = 'region(ICRS, ' + co.to_string('hmsdms') + ', 1m)' print(regstr) result_table = customSimbad.query_criteria(regstr, otype='Galaxy') if result_table: print(newcatalog[ci]) if 'redshift' in newcatalog[ci]: print(newcatalog[ci]['redshift']) print(result_table) # Convert to array since that's what datatables expects #dupes = list(dupes.values()) #jsonstring = json.dumps(dupes, indent='\t', separators=(',', ':'), ensure_ascii=False) #with open('../dupes.json', 'w') as f: # f.write(jsonstring)