from jplephem.spk import SPK kernel = SPK.open('de430.bsp') print(kernel) position = kernel[0,4].compute(2457061.5) print(position)
def _get_kernel(value): """ Try importing jplephem, download/retrieve from cache the Satellite Planet Kernel corresponding to the given ephemeris. """ if value is None or value.lower() == 'builtin': return None try: from jplephem.spk import SPK except ImportError: raise ImportError("Solar system JPL ephemeris calculations require " "the jplephem package " "(https://pypi.org/project/jplephem/)") if value.lower() == 'jpl': value = DEFAULT_JPL_EPHEMERIS if value.lower() in ('de430', 'de432s'): value = ('https://naif.jpl.nasa.gov/pub/naif/generic_kernels' '/spk/planets/{:s}.bsp'.format(value.lower())) elif os.path.isfile(value): return SPK.open(value) else: try: urlparse(value) except Exception: raise ValueError( '{} was not one of the standard strings and ' 'could not be parsed as a file path or URL'.format(value)) return SPK.open(download_file(value, cache=True))
def __init__(self, path): self.path = path self.filename = os.path.basename(path) self.spk = SPK.open(path) self.segments = [_Segment(s) for s in self.spk.segments] self.codes = set(s.center for s in self.segments).union( s.target for s in self.segments)
def __init__(self, sc_inertia, wheel_inertias, As, C_principal_body, wheel_rates=array([0, 0, 0, 0]), mode="Nadir"): self.As = As #assumes 4 wheels self.As_bar_inv = inv(vstack([self.As, array([1, -1, 1, -1])])) self.J = sc_inertia * 1.05 self.Ics = wheel_inertias self.kp = 1 self.kd = 1 self.wheel_rates = wheel_rates self.mode = mode self.C_princ_body = C_principal_body # Load .bsp containing JPL ephemerides: self.kernel = SPK.open('de430.bsp') # Constants for each relevant celestial body: self.EARTH = 3 self.MOON = 301 self.SUN = 10 self.CENTER = 0
def __init__(self, time, ephemerides): """Create an Ephemerides-instance that calculates ephemerides for the given time epochs. It is possible to not specify the time epochs when creating the instance (set `time=None`). In this case `time` must be supplied as a parameter to each call calculating ephemerides. The SPK-file is read and parsed at the creation of this instance. In particular the names and ids of the available objects are read. Args: time (Time): Time epochs for which to calculate ephemerides. ephemerides (String): Name of ephemerides to use. """ self.time = time self.ephemerides = ephemerides # Open the SPK-file corresponding to the ephemerides eph_filepath = config.files.path( "ephemerides", file_vars=dict(ephemerides=ephemerides), download_missing=True) self._spk = SPK.open(eph_filepath) # TODO: Close file in destructor dependencies.add(eph_filepath, label="ephemerides") # Parse segments in SPK file self._names, self._segments = self._parse_segments()
def __init__(self, path): self.path = path self.filename = os.path.basename(path) self.spk = SPK.open(path) self.segments = [SPICESegment(self, s) for s in self.spk.segments] self.codes = set(s.center for s in self.segments).union( s.target for s in self.segments)
def main(): for size in 10, 1000, 100000: jd = np.linspace(2414992.5, 2471184.50, size) kernel = SPK.open('de432.bsp') ephem = Ephemeris(de421) mars = kernel[0,4] print(size) print('-- old code (2 successive runs):') t0 = time() ephem.position('mars', jd) print(time() - t0) t0 = time() ephem.position('mars', jd) print(time() - t0) print('-- new SPK-powered code (2 successive runs):') t0 = time() mars.compute(jd) print(time() - t0) t0 = time() mars.compute(jd) print(time() - t0) print()
def _get_kernel(value): """ Try importing jplephem, download/retrieve from cache the Satellite Planet Kernel corresponding to the given ephemeris. """ if value is None or value.lower() == 'builtin': return None if value.lower() == 'jpl': value = DEFAULT_JPL_EPHEMERIS if value.lower() in ('de430', 'de432s'): value = ('http://naif.jpl.nasa.gov/pub/naif/generic_kernels' '/spk/planets/{:s}.bsp'.format(value.lower())) else: try: six.moves.urllib.parse.urlparse(value) except Exception: raise ValueError('{} was not one of the standard strings and ' 'could not be parsed as a URL'.format(value)) try: from jplephem.spk import SPK except ImportError: raise ImportError("Solar system JPL ephemeris calculations require " "the jplephem package " "(https://pypi.python.org/pypi/jplephem)") return SPK.open(download_file(value, cache=True))
def _sun_coor(julian): """Return the sun's coordinates. Parameters ---------- julian : np.ndarray 1-D array containing Julian times in the J2000 epoch. Returns ------- Coordinate Coordinate object containing the sun's position. """ ephem = pkg_resources.resource_filename(__name__, '../data/de421.bsp') kernal = SPK.open(ephem) ssb2sunb = kernal[0, 10].compute(julian) ssb2eb = kernal[0, 3].compute(julian) eb2e = kernal[3, 399].compute(julian) e2sun = (ssb2sunb - ssb2eb - eb2e).T SPK.close(kernal) sun_coor = Coordinate(e2sun, "gcrs", julian) return sun_coor
def __init__(self, filename): self.filename = filename self.spk = SPK.open(filename) self.segments = [Segment(s.center, s.target, _build_compute(s)) for s in self.spk.segments] self.codes = set(s.center for s in self.segments).union( s.target for s in self.segments)
def main(): for size in 10, 1000, 100000: jd = np.linspace(2414992.5, 2471184.50, size) kernel = SPK.open('de421.bsp') ephem = Ephemeris(de421) mars = kernel[0,4] print(size) print('-- old code (2 successive runs):') t0 = time() ephem.position('mars', jd) print(time() - t0) t0 = time() ephem.position('mars', jd) print(time() - t0) print('-- new SPK-powered code (2 successive runs):') t0 = time() mars.compute(jd) print(time() - t0) t0 = time() mars.compute(jd) print(time() - t0) print()
def __init__(self, spk, units): self.kernel = SPK.open(spk) self.r_unit = units[0] self.v_unit = units[1] self.graph = nx.Graph() for edge in self.kernel.pairs: self.graph.add_edge(*edge) self.paths = nx.shortest_path(self.graph)
def __init__(self, spk, units): self.kernel = SPK.open(spk) self.r_unit = units[0] self.v_unit = units[1] self.graph = nx.Graph() for edge in self.kernel.pairs: self.graph.add_edge(*edge) self.paths = nx.shortest_path(self.graph)
def setUp(self): try: self.spk = SPK.open('de421.bsp') except IOError: raise SkipTest('the "de421.bsp" SPK file is not available') segment = self.spk[0,1] self.jalpha = segment.start_jd self.jomega = segment.end_jd
def v_earth(source): kernel = SPK.open('de435.bsp') time = source.obstime.jd position, velocity = kernel[0, 3].compute_and_differentiate(time) position2, velocity2 = kernel[3, 399].compute_and_differentiate(time) velocity = velocity - velocity2 source = source.cartesian return np.dot(((velocity * 1000 * u.meter / u.day).to(u.meter / u.second)).T, source.xyz)
def jpl(number, jd): kernel = SPK.open('/Users/baotong/desktop/pulsar/de430.bsp') position, velocity = kernel[0, number].compute_and_differentiate(jd) #position=np.array(position) #velocity=np.array(velocity) velocity = velocity / 86400.0 return [position, velocity]
def setUp(self): try: self.spk = SPK.open('de421.bsp') except IOError: raise SkipTest('the "de421.bsp" SPK file is not available') segment = self.spk[0, 1] self.jalpha = segment.start_jd self.jomega = segment.end_jd
def load_kernel(): from jplephem.spk import SPK kernel_path = Path(__file__).parent / 'data' / 'de432s.bsp' if not kernel_path.exists(): raise FileNotFoundError( f'kernel data file {kernel_path} not found, ' 'run "python setup.py build" to install it locally') kernel = SPK.open(kernel_path) return kernel
def __init__(self, filename): self.filename = filename self.spk = SPK.open(filename) self.segments = [ Segment(s.center, s.target, _build_compute(s)) for s in self.spk.segments ] self.codes = set(s.center for s in self.segments).union(s.target for s in self.segments)
def __init__(self, mass, position=None): if not os.path.isfile('de430.bsp'): raise ValueError('de430.bsp Was not found!') self.kernel = SPK.open('de430.bsp') self.mass = np.longdouble(mass) self.hist = [[], [], []] if position is not None: self.pos = position else: self.pos = []
def __init__(self, path): self.path = path self.filename = os.path.basename(path) self.spk = SPK.open(path) self.segments = [ Segment(s.center, s.target, _build_compute(s)) for s in self.spk.segments ] self.codes = set(s.center for s in self.segments).union(s.target for s in self.segments)
def __init__(self, mass, position=None): if not os.path.isfile('de430.bsp'): raise ValueError('de430.bsp Was not found!') self.kernel = SPK.open('de430.bsp') self.mass = np.longdouble(mass) self.hist = [[], [], []] if position is not None: self.pos = position else: self.pos = []
def get_jwst_position(times, jwstpos, debug=False): """Get the position of JWST. This returns the pair of relative positions to the barycenter and heliocenter in that order as a tuple of two arrays with 3 components Parameters ---------- times : float, or 1-D ndarray of float A time or an array of times, in MJD (TT). jwstpos : 1-D array, or None `jwstpos` is a 3 element vector (list, tuple, whatever) in km if it is provided. debug : bool This is for testing. If `debug` is `True`, the values returned will be the barycenter of the Earth and the center of the Sun (km), both with respect to the solar-system barycenter. Returns ------- jwst_bary_vectors : ndarray, float Equatorial (ICRS) rectangular coordinates of JWST with respect to the solar-system barycenter, in km. If `times` is a float, `jwst_bary_vectors` will have shape (3,); otherwise, it will have shape (3, nt), where `nt` is the length of the input `times`. jwst_sun_vectors : ndarray, float Equatorial (ICRS) rectangular coordinates of JWST with respect to the center of the Sun, in km. If `times` is a float, `jwst_sun_vectors` will have shape (3,); otherwise, it will have shape (3, nt), where `nt` is the length of the input `times`. """ ekernel = SPK.open(os.path.join(EPHEMERIS_PATH, 'de430.bsp')) # JPL ephemeris uses JD_tt based times barysun_baryearth_pos = ekernel[0, 3].compute(times + JDOFFSET) barysun_centersun_pos = ekernel[0, 10].compute(times + JDOFFSET) baryearth_centerearth_pos = ekernel[3, 399].compute(times + JDOFFSET) ekernel.close() if debug: return barysun_baryearth_pos, barysun_centersun_pos barysun_centerearth_pos = barysun_baryearth_pos + baryearth_centerearth_pos centersun_centerearth_pos = barysun_centerearth_pos - barysun_centersun_pos if jwstpos is not None: centerearth_jwst = jwstpos else: centerearth_jwst = jwst_ephem_interp(times) return (barysun_centerearth_pos + centerearth_jwst), \ (centersun_centerearth_pos + centerearth_jwst)
def __init__(self, filename='de430.bsp'): self._kernel = SPK.open(filename) self._PlanetDict = { "Mercury": 1, "Venus": 2, "Earth": 3, "Mars": 4, "Jupiter": 5, "Saturn": 6, "Uranus": 7, "Neptune": 8, "Pluto": 9, "Sun": 10 }
def open(self): """Open the files """ segments = [] files = config.get("env", "jpl", fallback=[]) if not files: raise JplConfigError("No JPL file defined") # Extraction of segments from each .bsp file for filepath in files: filepath = Path(filepath) if filepath.suffix.lower() != ".bsp": continue segments.extend(SPK.open(str(filepath)).segments) if not segments: raise JplError("No segment loaded") # list of available segments self.segments = dict(((s.center, s.target), s) for s in segments) # This variable will contain the Target of reference from which # all relations between frames are linked targets = {} for center_id, target_id in self.segments.keys(): center_name = target_names.get(center_id, "Unknown") target_name = target_names.get(target_id, "Unknown") # Retrieval of the Target object representing the center if it exists # or creation of said object if it doesn't. center = targets.setdefault(center_id, Target(center_name, center_id)) target = targets.setdefault(target_id, Target(target_name, target_id)) # Link between the Target objects (see Node2) center + target # We take the Earth target and make it the top of the structure. # That way, it is easy to link it to the already declared earth-centered reference frames # from the `frames.frame` module. self.top = targets[399]
def position_sun_moon(bspFileName, time): jd = julian.to_jd(time, fmt='jd') kernel = SPK.open(bspFileName) positionMoon = kernel[3, 301].compute(jd) positionSun = kernel[0, 10].compute(jd) positionSun -= kernel[0, 3].compute(jd) positionSun -= kernel[3, 399].compute(jd) positionSun = positionSun * 1000 positionMoon = positionMoon * 1000 return positionSun, positionMoon
def open(self): """Open the files """ segments = [] files = config.get('env', 'jpl', fallback=[]) if not files: raise JplConfigError("No JPL file defined") # Extraction of segments from each .bsp file for filepath in files: filepath = Path(filepath) if filepath.suffix.lower() != ".bsp": continue segments.extend(SPK.open(str(filepath)).segments) if not segments: raise JplError("No segment loaded") # list of available segments self.segments = dict(((s.center, s.target), s) for s in segments) # This variable will contain the Target of reference from which # all relations between frames are linked targets = {} for center_id, target_id in self.segments.keys(): center_name = target_names.get(center_id, 'Unknown') target_name = target_names.get(target_id, 'Unknown') # Retrieval of the Target object representing the center if it exists # or creation of said object if it doesn't. center = targets.setdefault(center_id, Target(center_name, center_id)) target = targets.setdefault(target_id, Target(target_name, target_id)) # Link between the Target objects (see Node2) center + target # We take the Earth target and make it the top of the structure. # That way, it is easy to link it to the already declared earth-centered reference frames # from the `frames.frame` module. self.top = targets[399]
def get_ephemerides(eph_date): #Can be downloaded from ftp://ssd.jpl.nasa.gov/pub/eph/planets/bsp eph = SPK.open('../input/de430.bsp') solar_system = OrderedDict() solar_system['date'] = eph_date.datetime.strftime('%Y-%m-%d') solar_system['Sun'] = np.hstack(eph[0,10].compute_and_differentiate(eph_date.jd)) solar_system['Mercury'] = np.hstack(eph[0,1].compute_and_differentiate(eph_date.jd)) solar_system['Venus'] = np.hstack(eph[0,2].compute_and_differentiate(eph_date.jd)) solar_system['Earth'] = np.hstack(eph[0,3].compute_and_differentiate(eph_date.jd)) solar_system['Mars'] = np.hstack(eph[0,4].compute_and_differentiate(eph_date.jd)) solar_system['Jupiter'] = np.hstack(eph[0,5].compute_and_differentiate(eph_date.jd)) solar_system['Saturn'] = np.hstack(eph[0,6].compute_and_differentiate(eph_date.jd)) solar_system['Uranus'] = np.hstack(eph[0,7].compute_and_differentiate(eph_date.jd)) solar_system['Neptune'] = np.hstack(eph[0,8].compute_and_differentiate(eph_date.jd)) return solar_system
def _load_kernel_local(ephem, path=''): load_kernel = False # a flag for checking if the kernel has been loaded if path.endswith("%s.bsp" % ephem): custom_path = path else: custom_path = os.path.join(path, "%s.bsp" % ephem) search_list = [custom_path, datapath("%s.bsp" % ephem)] for p in search_list: if load_kernel: break try:# Bipass the astropy kernel loading system. coor.solar_system_ephemeris._kernel = SPK.open(p) coor.solar_system_ephemeris._value = p coor.solar_system_ephemeris._kernel.origin = coor.solar_system_ephemeris._value load_kernel = True except: load_kernel = False return load_kernel
def _load_kernel_local(ephem, path=''): load_kernel = False # a flag for checking if the kernel has been loaded if path.endswith("%s.bsp" % ephem): custom_path = path else: custom_path = os.path.join(path, "%s.bsp" % ephem) search_list = [custom_path, datapath("%s.bsp" % ephem)] for p in search_list: if load_kernel: break try:# Bipass the astropy kernel loading system. coor.solar_system_ephemeris._kernel = SPK.open(p) coor.solar_system_ephemeris._value = p coor.solar_system_ephemeris._kernel.origin = coor.solar_system_ephemeris._value load_kernel = True except: load_kernel = False return load_kernel
def Position_and_Velocity_Celestial_Body(celestial_body, time): # The JPL ephemeris index of the celestial body jpli = celestial_body.jplephem_index # Path to ephemeris file path_ephem = Directory + '/Information/Celestial_Bodies/Ephemerides/de430.bsp' # The ephemeris kernel kernel = SPK.open(path_ephem) # The position and velocity pv = np.vstack(kernel[jpli].compute_and_differentiate(time)) # If the ephemeris was wrt to its local barcyentre if not jpli[0] == 0: # Compute barycentric position rather pv = np.add(pv, np.vstack( kernel[0, jpli[0]].compute_and_differentiate(time))) pass # Convert km to m pv[0, :] = np.multiply(pv[0, :], 1e3) # Convert km/day to m/s pv[1, :] = np.multiply(pv[1, :], 0.0115741) # Return a (2,3) numpy array return pv
def get_jwst_position(times, jwstpos, debug=False): ''' This returns the pair of relative positions to the barycenter and heliocenter in that order as a tuple of two arrays with 3 components ''' ekernel = SPK.open(os.path.join(EPHEMERIS_PATH, 'de430.bsp')) # JPL ephemeris uses JD_tt based times barysun_baryearth_pos = ekernel[0, 3].compute(times + JDOFFSET) barysun_centersun_pos = ekernel[0, 10].compute(times + JDOFFSET) baryearth_centerearth_pos = ekernel[3, 399].compute(times + JDOFFSET) ekernel.close() if debug: return barysun_baryearth_pos, barysun_centersun_pos barysun_centerearth_pos = barysun_baryearth_pos + baryearth_centerearth_pos centersun_centerearth_pos = barysun_centerearth_pos - barysun_centersun_pos if jwstpos is not None: centerearth_jwst = jwstpos else: centerearth_jwst = jwst_ephem_interp(times) return (barysun_centerearth_pos + centerearth_jwst), \ (centersun_centerearth_pos + centerearth_jwst)
def objPosVel2SSB(objname, t, ephem): """This function computes a solar system object position and velocity respect to solar system barycenter using astropy coordinates get_body_barycentric() method. Parameters ---------- objname: str Solar system object name. Current support solar system bodies are listed in astropy.coordinates.olar_system_ephemeris.bodies attribution. t: Astropy.time.Time object Observation time in Astropy.time.Time object format. ephem: str The ephem to for computing solar system object position and velocity """ ephem = ephem.lower() objname = objname.lower() # Use astropy to compute postion. try: pos = coor.get_body_barycentric(objname, t, ephemeris=ephem) except ValueError: pos = coor.get_body_barycentric(objname, t, ephemeris= kernel_link_base + "%s.bsp" % ephem) # Use jplephem to compute velocity. # TODO: Astropy 1.3 will have velocity calculation availble. kernel = SPK.open(datapath("%s.bsp" % ephem)) # Compute vel from planet barycenter to solar system barycenter lcod = len(str(jpl_obj_code[objname])) tjd1 = t.tdb.jd1 tjd2 = t.tdb.jd2 # Planets with barycenter computing if lcod == 3: _, vel_pbary_ssb = kernel[0,jpl_obj_code[objname]/100].compute_and_differentiate(tjd1, tjd2) _, vel_p_pbary = kernel[jpl_obj_code[objname]/100, jpl_obj_code[objname]].compute_and_differentiate(tjd1, tjd2) vel = vel_pbary_ssb + vel_p_pbary # Planets without barycenter computing else: _, vel = kernel[0,jpl_obj_code[objname]].compute_and_differentiate(tjd1, tjd2) return PosVel(pos.xyz, vel / SECS_PER_DAY * u.km/u.second, origin='ssb', obj=objname)
def objPosVel2SSB(objname, t, ephem): """This function computes a solar system object position and velocity respect to solar system barycenter using astropy coordinates get_body_barycentric() method. Parameters ---------- objname: str Solar system object name. Current support solar system bodies are listed in astropy.coordinates.olar_system_ephemeris.bodies attribution. t: Astropy.time.Time object Observation time in Astropy.time.Time object format. ephem: str The ephem to for computing solar system object position and velocity """ ephem = ephem.lower() objname = objname.lower() # Use astropy to compute postion. try: pos = coor.get_body_barycentric(objname, t, ephemeris=ephem) except ValueError: pos = coor.get_body_barycentric(objname, t, ephemeris= kernel_link_base + "%s.bsp" % ephem) # Use jplephem to compute velocity. # TODO: Astropy 1.3 will have velocity calculation availble. kernel = SPK.open(datapath("%s.bsp" % ephem)) # Compute vel from planet barycenter to solar system barycenter lcod = len(str(jpl_obj_code[objname])) tjd1 = t.tdb.jd1 tjd2 = t.tdb.jd2 # Planets with barycenter computing if lcod == 3: _, vel_pbary_ssb = kernel[0,jpl_obj_code[objname]/100].compute_and_differentiate(tjd1, tjd2) _, vel_p_pbary = kernel[jpl_obj_code[objname]/100, jpl_obj_code[objname]].compute_and_differentiate(tjd1, tjd2) vel = vel_pbary_ssb + vel_p_pbary # Planets without barycenter computing else: _, vel = kernel[0,jpl_obj_code[objname]].compute_and_differentiate(tjd1, tjd2) return PosVel(pos.xyz, vel / SECS_PER_DAY * u.km/u.second, origin='ssb', obj=objname)
def spk(self): if not hasattr(self, "_spk"): self._spk = [] files = config.get("env", "jpl", "files", fallback=[]) if not files: raise JplConfigError("No JPL file defined") # Extraction of segments from each .bsp file for filepath in files: filepath = Path(filepath) if filepath.suffix.lower() != ".bsp": continue if not filepath.exists(): log.warning(f"File not found : {filepath}") continue self._spk.append(SPK.open(str(filepath))) return self._spk
dq[i, j] = dq[i, j] + (fi1 - fi2) / (xi2 - xi1) y[k] = q[-1, -1] dy[k] = dq[-1, -1] return y, dy homedir = os.environ['HOME'] cache_dir = os.path.join(homedir, '.pypride') cats_dir = os.path.join(cache_dir, 'cats') eph_dir = os.path.join(cache_dir, 'jpl_eph') kernels = { 'de403': SPK.open(os.path.join(eph_dir, 'de403.bsp')), 'de405': SPK.open(os.path.join(eph_dir, 'de405.bsp')), 'de421': SPK.open(os.path.join(eph_dir, 'de421.bsp')), 'de430': SPK.open(os.path.join(eph_dir, 'de430.bsp')) } def pleph(jd, ntarg: int, ncent: int = 12, namfil: str = 'de430'): """ Mimic the old fortran subroutine: ! THIS SUBROUTINE READS THE JPL PLANETARY EPHEMERIS ! AND GIVES THE POSITION AND VELOCITY OF THE POINT 'NTARG' ! WITH RESPECT TO 'NCENT'. ! NTARG = INTEGER NUMBER OF 'TARGET' POINT. !
from poliastro.twobody import Orbit from poliastro.bodies import Earth, Sun from poliastro.constants import J2000 from poliastro.ephem import Ephem from poliastro.plotting import OrbitPlotter3D from poliastro.frames import Planes from astropy import units, time from poliastro.util import time_range # download higher precision ephemerides from astropy.coordinates import solar_system_ephemeris solar_system_ephemeris.set("jpl") from jplephem.spk import SPK kernel = SPK.open('de430.bsp') # Constants k = 0.017202099 # AU^(3/2)/solar day c = 173.1446 # AU/day r = 6371 # This is in km - convert to AU later km2au = 1 / 149597870700e-3 # km/au def toDecimal(sexagismal): # Convert RA and Dec to decimal hours and degrees if in sexagismal if sexagismal[0] > 1: time = sexagismal[0] time += (sexagismal[1] / float(60)) time += (sexagismal[2] / float(3600)) else:
#jd = 2455843.318098123185 jd = 2455843.318098123 print("JD:", "{:10.10f}".format(jd)) vsop_file = os.path.join('share', 'VSOP87D.ear') # Load VSOP data vsop_data = VSOP87(vsop_file) jpl_ephem_file = os.path.join('share', 'de430.bsp') # Load JPL ephemerids files jpl_data = SPK.open(jpl_ephem_file) # Calculate ecliptic coordinates L, B, r_au = calcEarthEclipticCoordVSOP(jd, vsop_data) print() print('VSOP87, J2000:') # Convert ecliptic coordinates to Cartesian coordinates x, y, z = wmpl.Utils.TrajConversions.ecliptic2RectangularCoord(L, B, r_au) # Precess VSOP coordinates to J2000 x, y, z = wmpl.Utils.TrajConversions.eclipticRectangularPrecession(jd, wmpl.Utils.TrajConversions.J2000_JD.days, \ x, y, z)
def __init__(self, settlingTime=1., thrust=450., slewIsp=4160., scMass=6000.,\ dryMass=3400., coMass=5800., occulterSep=55000., skIsp=220.,\ defburnPortion=0.05, spkpath=None, forceStaticEphem=False,\ **specs): # default Observatory values # instrument settling time after repoint (days) self.settlingTime = float(settlingTime)*u.day # occulter slew thrust (mN) self.thrust = float(thrust)*u.mN # occulter slew specific impulse (s) self.slewIsp = float(slewIsp)*u.s # occulter (maneuvering sc) initial (wet) mass (kg) self.scMass = float(scMass)*u.kg # occulter (maneuvering sc) dry mass (kg) self.dryMass = float(dryMass)*u.kg # telescope (or non-maneuvering sc) mass (kg) self.coMass = float(coMass)*u.kg # occulter-telescope distance (km) self.occulterSep = float(occulterSep)*u.km # station-keeping Isp (s) self.skIsp = float(skIsp)*u.s # default burn portion self.defburnPortion = float(defburnPortion) # set values derived from quantities above # slew flow rate (kg/day) self.flowRate = (self.thrust/const.g0/self.slewIsp).to('kg/day') #if jplephem is available, we'll use that for propagating solar system bodies #otherwise, use static ephemeris if not forceStaticEphem: try: from jplephem.spk import SPK self.havejplephem = True except ImportError: print "WARNING: Module jplephem not found, using static solar system ephemeris." self.havejplephem = False else: self.havejplephem = False print "Using static solar system ephemeris." # populate outspec for att in self.__dict__.keys(): dat = self.__dict__[att] self._outspec[att] = dat.value if isinstance(dat,u.Quantity) else dat # define function for calculating obliquity of the ecliptic # (arg Julian centuries from J2000) self.obe = lambda TDB: 23.439279 - 0.0130102*TDB - 5.086e-8*(TDB**2) + \ 5.565e-7*(TDB**3) + 1.6e-10*(TDB**4) + 1.21e-11*(TDB**5) # if you have jplephem, load spice file, otherwise load static ephem if self.havejplephem: if (spkpath is None) or not(os.path.exists(spkpath)): # if the path does not exist, load the default de432s.bsp classpath = os.path.split(inspect.getfile(self.__class__))[0] classpath = os.path.normpath(os.path.join(classpath,'..','Observatory')) filename = 'de432s.bsp' spkpath = os.path.join(classpath, filename) self.kernel = SPK.open(spkpath) else: """All ephemeride data from Vallado Appendix D.4 Values are: a e I O w lM sma eccentricity inclination long. ascending node long. perihelion mean longitude AU N/A deg deg deg deg """ # Store Mercury ephemerides data (ecliptic) Mercurya = 0.387098310 Mercurye = [0.20563175, 0.000020406, -0.0000000284, -0.00000000017] Mercuryi = [7.004986, -0.0059516, 0.00000081, 0.000000041] MercuryO = [48.330893, -0.1254229, -0.00008833, -0.000000196] Mercuryw = [77.456119, 0.1588643, -0.00001343, 0.000000039] MercurylM = [252.250906, 149472.6746358, -0.00000535, 0.000000002] Mercury = self.SolarEph(Mercurya, Mercurye, Mercuryi, MercuryO, Mercuryw, MercurylM) # Store Venus epemerides data (ecliptic) Venusa = 0.723329820 Venuse = [0.00677188, -0.000047766, 0.0000000975, 0.00000000044] Venusi = [3.394662, -0.0008568, -0.00003244, 0.000000010] VenusO = [76.679920, -0.2780080, -0.00014256, -0.000000198] Venusw = [131.563707, 0.0048646, -0.00138232, -0.000005332] VenuslM = [181.979801, 58517.8156760, 0.00000165, -0.000000002] Venus = self.SolarEph(Venusa, Venuse, Venusi, VenusO, Venusw, VenuslM) # Store Earth ephemerides data (ecliptic) Eartha = 1.000001018 Earthe = [0.01670862, -0.000042037, -0.0000001236, 0.00000000004] Earthi = [0., 0.0130546, -0.00000931, -0.000000034] EarthO = [174.873174, -0.2410908, 0.00004067, -0.000001327] Earthw = [102.937348, 0.3225557, 0.00015026, 0.000000478] EarthlM = [100.466449, 35999.3728519, -0.00000568, 0.] Earth = self.SolarEph(Eartha, Earthe, Earthi, EarthO, Earthw, EarthlM) # Store Mars ephemerides data (ecliptic) Marsa = 1.523679342 Marse = [0.09340062, 0.000090483, -0.0000000806, -0.00000000035] Marsi = [1.849726, -0.0081479, -0.00002255, -0.000000027] MarsO = [49.558093, -0.2949846, -0.00063993, -0.000002143] Marsw = [336.060234, 0.4438898, -0.00017321, 0.000000300] MarslM = [355.433275, 19140.2993313, 0.00000261, -0.000000003] Mars = self.SolarEph(Marsa, Marse, Marsi, MarsO, Marsw, MarslM) # Store Jupiter ephemerides data (ecliptic) Jupitera = [5.202603191, 0.0000001913] Jupitere = [0.04849485, 0.000163244, -0.0000004719, -0.00000000197] Jupiteri = [1.303270, -0.0019872, 0.00003318, 0.000000092] JupiterO = [100.464441, 0.1766828, 0.00090387, -0.000007032] Jupiterw = [14.331309, 0.2155525, 0.00072252, -0.000004590] JupiterlM = [34.351484, 3034.9056746, -0.00008501, 0.000000004] Jupiter = self.SolarEph(Jupitera, Jupitere, Jupiteri, JupiterO, Jupiterw, JupiterlM) # Store Saturn ephemerides data (ecliptic) Saturna = [9.554909596, -0.0000021389] Saturne = [0.05550862, -0.000346818, -0.0000006456, 0.00000000338] Saturni = [2.488878, 0.0025515, -0.00004903, 0.000000018] SaturnO = [113.665524, -0.2566649, -0.00018345, 0.000000357] Saturnw = [93.056787, 0.5665496, 0.00052809, 0.000004882] SaturnlM = [50.077471, 1222.1137943, 0.00021004, -0.000000019] Saturn = self.SolarEph(Saturna, Saturne, Saturni, SaturnO, Saturnw, SaturnlM) # Store Uranus ephemerides data (ecliptic) Uranusa = [19.218446062, -0.0000000372, 0.00000000098] Uranuse = [0.04629590, -0.000027337, 0.0000000790, 0.00000000025] Uranusi = [0.773196, -0.0016869, 0.00000349, 0.000000016] UranusO = [74.005947, 0.0741461, 0.00040540, 0.000000104] Uranusw = [173.005159, 0.0893206, -0.00009470, 0.000000413] UranuslM = [314.055005, 428.4669983, -0.00000486, 0.000000006] Uranus = self.SolarEph(Uranusa, Uranuse, Uranusi, UranusO, Uranusw, UranuslM) # Store Neptune ephemerides data (ecliptic) Neptunea = [30.110386869, -0.0000001663, 0.00000000069] Neptunee = [0.00898809, 0.000006408, -0.0000000008] Neptunei = [1.769952, 0.0002257, 0.00000023, -0.000000000] NeptuneO = [131.784057, -0.0061651, -0.00000219, -0.000000078] Neptunew = [48.123691, 0.0291587, 0.00007051, 0.] NeptunelM = [304.348665, 218.4862002, 0.00000059, -0.000000002] Neptune = self.SolarEph(Neptunea, Neptunee, Neptunei, NeptuneO, Neptunew, NeptunelM) # Store Pluto ephemerides data (ecliptic) Plutoa = [39.48168677, -0.00076912] Plutoe = [0.24880766, 0.00006465] Plutoi = [17.14175, 0.003075] PlutoO = [110.30347, -0.01036944] Plutow = [224.06676, -0.03673611] PlutolM = [238.92881, 145.2078] Pluto = self.SolarEph(Plutoa, Plutoe, Plutoi, PlutoO, Plutow, PlutolM) #store all as dictionary: self.planets = {'Mercury': Mercury, 'Venus': Venus, 'Earth': Earth, 'Mars': Mars, 'Jupiter': Jupiter, 'Saturn': Saturn, 'Uranus': Uranus, 'Neptune': Neptune, 'Pluto': Pluto}
""" if "de421.bsp" in kernel_filenames: kernel = "de421.bsp" elif kernel_filenames: kernel = kernel_filenames[0] else: kernel = None return kernel kernel_fname = select_kernel( glob.glob(os.path.join(SPK_LOCAL_DIR, "*.bsp"))) if kernel_fname: default_kernel = SPK.open(kernel_fname) else: warnings.warn("""No SPICE kernels found under ~/.poliastro. Please download them manually or using poliastro download-spk [-d NAME] to provide a default kernel, else pass a custom one as an argument to `planet_ephem`.""") default_kernel = None def download_kernel(name): """Downloads SPICE kernel by name. The function will try the top SPK path first, and then the old versions
def __init__(self): self.jpl = SPK.open('/home/amigos/python/jpl_ephem/de430.bsp') # from https://pypi.python.org/pypi/jplephem self.geomech = geomech.geomech_monitor_client('172.20.0.12',8101)
from jplephem.spk import SPK ################# ## JPL KERNELS ## ################# modpath = os.path.abspath(os.path.dirname(__file__)) planetdatafile = os.path.join(modpath, 'data/de430.bsp') # we'll try to load the SPK kernel. if that fails, we'll download it direct from # JPL so the source distribution is kept small try: # load the JPL kernel jplkernel = SPK.open(planetdatafile) HAVEKERNEL = True except Exception: # this is so we don't download the JPL kernel when this module is imported # as part of a docs build on RTD import os RTD_INVOCATION = os.environ.get('RTD_IGNORE_HTLS_FAIL') if not RTD_INVOCATION: # this function is used to check progress of the download def on_download_chunk(transferred, blocksize, totalsize): progress = transferred * blocksize / float(totalsize) * 100.0 print('{progress:.1f}%'.format(progress=progress), end='\r')
import numpy as np from numpy import * from poliastro.twobody import Orbit, classical from poliastro.bodies import Earth, Sun from poliastro.neos import neows from poliastro.plotting import OrbitPlotter from astropy import units, time # download higher precision ephemerides from astropy.coordinates import solar_system_ephemeris solar_system_ephemeris.set("jpl") from jplephem.spk import SPK kernel = SPK.open('C:\\Users\\user\\Downloads\\de430.bsp') # Constants k = 0.017202099 # AU^(3/2)/solar day c = 173.1446 # AU/day r = 6371 # This is in km - convert to AU later km2au = 1 / 149597870700e-3 # km/au def toDecimal(sexagismal): # Convert RA and Dec to decimal hours and degrees if in sexagismal if sexagismal[0] > 1: time = sexagismal[0] time += (sexagismal[1] / float(60)) time += (sexagismal[2] / float(3600)) else:
def ephem(iaucode, peph, objcode, timefile, kern=None, output='sky'): ############## Reading planetary kernel ############################################## if peph[-3:] != 'bsp': peph = peph + '.bsp' if not os.path.isfile(peph): raise OSError('Planetary Kernel {} not found'.format(peph[:-4])) kernel = SPK.open(peph) ########## Reading Time File ####################################################### if isinstance(timefile, str): ## if input is a file jd = np.loadtxt(timefile) time = Time(jd, format='jd', scale='utc') elif isinstance(timefile, Time): ## if input is Time Object of Astropy time = timefile else: ## if input is an array or a number time = Time(timefile, format='jd', scale='utc') timetdb = time.tdb ####################### look for object kernel ########################################### objt, objn, objm, objk = objs(objcode, kern) objk = objk + '.bsp' if not os.path.isfile(objk): raise OSError('Object Kernel {} not found'.format(objk[:-4])) kernelobj = SPK.open(objk) ######## Checking if it is geocenter or not and getting topocentric vectors ############ ##### Running low yet, have to see for many times ####### if not isinstance(iaucode, str): iaucode = str(iaucode) if iaucode.lower() not in ['g', 'geocenter']: ### not geocenter gcrsx, gcrsy, gcrsz = [], [], [] site, siten = sitios(iaucode) for i in time.utc: itrs = site.get_itrs(obstime=i) gcrs = itrs.transform_to(GCRS(obstime=i)) gcrsx.append(gcrs.cartesian.x.value) gcrsy.append(gcrs.cartesian.y.value) gcrsz.append(gcrs.cartesian.z.value) gcrsx = gcrsx*u.m gcrsy = gcrsy*u.m gcrsz = gcrsz*u.m else: ### geocenter siten = 'Geocenter' ######################################################################################### ## compute vector Solar System Barycenter -> Earth Geocenter -> Topocenter if iaucode.lower() in ['g', 'geocenter']: geop = kernel[0,3].compute(timetdb.jd) + kernel[3,399].compute(timetdb.jd) else: geop = kernel[0,3].compute(timetdb.jd) + kernel[3,399].compute(timetdb.jd) + np.array([gcrsx.to(u.km).value,gcrsy.to(u.km).value,gcrsz.to(u.km).value]) ########### Calculates time delay ########################################### # delt = light time # n = number of loops necessary delt = 0*u.s n = 0 while True: ### calculates new time tempo = timetdb - delt ### calculates vector Solar System Baricenter -> Object positm = np.array([0.0, 0.0, 0.0]) if objk == ephs['lau'] + '.bsp': objtj, objnj, objmj, objkj = objs(599) kernelj = SPK.open(objkj + '.bsp') objp = kernel[0,5].compute(tempo.jd) + kernelj[5,599].compute(tempo.jd)[0:3] + compute(kernelobj,599,objn,tempo.jd)[0:3] elif objt in ['s', 'p']: cc = objn//100 objp = kernel[0,cc].compute(tempo.jd) + compute(kernelobj,cc,objn,tempo.jd)[0:3] elif objt in ['t', 'c']: objp = kernel[0,10].compute(tempo.jd) + compute(kernelobj,10,objn,tempo.jd)[0:3] ### calculates vector Earth Geocenter -> Object position = (objp - geop) ### calculates linear distance Earth Geocenter -> Object dist = np.linalg.norm(position, axis=0)*u.km ### calculates new light time delt = (dist/const.c).decompose() n = n + 1 ### if difference between new and previous light time is smaller than 0.001 sec, than continue. if np.all(np.absolute(((timetdb - tempo) - delt).sec) < 0.001): break ############################################################################## ### Creating SkyCoord Object with the coordinates for each instant coord = SkyCoord(position[0], position[1], position[2], frame='icrs', unit=u.km, representation='cartesian') ### returning values if output == 'radec': return coord.spherical.lon.hourangle, coord.spherical.lat.deg elif output == 'sky': return SkyCoord(ra=coord.spherical.lon, dec=coord.spherical.lat, distance=coord.spherical.distance) elif output == 'xyz': return coord.cartesian.x, coord.cartesian.y, coord.cartesian.z elif isinstance(output, str): f = open(output, 'w') f.write('Object={}, Kernel={}+{}, Site={}\n\n'.format(objn, objk[:-4], peph[:-4], siten)) for i in np.arange(len(time)): f.write(' {:013.10f} {:+013.9f} {:16.8f} {:16.8f}\n'.format(coord[i].spherical.lon.hourangle, coord[i].spherical.lat.deg, time[i].utc.jd, time[i].tdb.jd)) f.close()
__version__ = '0.7.0' # Configure logging logger = logging.getLogger(__name__) # Find path to ephemeris from environmental variable. JDOFFSET = 2400000.5 try: EPHEMERIS_PATH = os.environ['JPL_EPHEMERIS'] except KeyError: raise KeyError('Environmental variable JPL_EPHEMERIS not found') ekernel = SPK.open(os.path.join(EPHEMERIS_PATH, 'de430.bsp')) # The following three functions are only needed if reading from a file # Currently it is obtained from a DMS database def read_jwst_ephemeris(times): ''' Returns the x,y,z positions of JWST with respect to the earth's center for the times provided. Times should be in JD. ''' f = open(os.path.join(EPHEMERIS_PATH, 'ephem_10days.txt'), 'r') # First get header info. mdict = get_jwst_ephem_metadata(f) if ((mdict['CENTER_NAME'] != 'Earth') or (mdict['OBJECT_NAME'] != 'JWST') or (mdict['REF_FRAME'] != 'EME2000') or
body = Pck()[name] body.propagate = lambda date: get_orbit(name, date) return body if __name__ == '__main__': # pragma: no cover import sys config.update({ 'eop': { 'missing_policy': "pass" } }) for file in sys.argv[1:]: print(file) print("*" * len(file)) for segment in SPK.open(file).segments: start = Date(segment.start_jd - Date.JD_MJD) end = Date(segment.end_jd - Date.JD_MJD) center = target_names[segment.center] target = target_names[segment.target] print("from {start:{fmt}} to {end:{fmt}} : {center} -> {target}".format( start=start, end=end, center=center, target=target, fmt="%Y-%m-%d" )) print()
__version__ = '0.7.0' # Configure logging logger = logging.getLogger(__name__) # Find path to ephemeris from environmental variable. JDOFFSET = 2400000.5 try: EPHEMERIS_PATH = os.environ['JPL_EPHEMERIS'] except KeyError: raise KeyError('Environmental variable JPL_EPHEMERIS not found') ekernel = SPK.open(os.path.join(EPHEMERIS_PATH, 'de430.bsp')) # The following three functions are only needed if reading from a file # Currently it is obtained from a DMS database def read_jwst_ephemeris(times): ''' Returns the x,y,z positions of JWST with respect to the earth's center for the times provided. Times should be in JD. ''' f = open(os.path.join(EPHEMERIS_PATH, 'ephem_10days.txt'), 'r') # First get header info. mdict = get_jwst_ephem_metadata(f) if ((mdict['CENTER_NAME'] != 'Earth') or (mdict['OBJECT_NAME'] != 'JWST') or (mdict['REF_FRAME'] != 'EME2000')
# asteroid database: path_to_database = config.get("Path", "asteroid_database_path") f_database = os.path.join(path_to_database, "ELEMENTS.NUMBR") try: asteroid = asteroid_data_load(_f_database=f_database, asteroid_name=name) # print(asteroid) except Exception: # print error code 2 (failed to load asteroid database) and exit print(2, ra_apr, dec_apr, ra_rate_apr, dec_rate_apr) raise SystemExit try: # init jplephem: f_spk = config.get("Path", "jpl_ephem_spk_kernel") kernel = SPK.open(f_spk) except Exception: # print error code 3 (failed to load JPL DE ephemeris) and exit print(3, ra_apr, dec_apr, ra_rate_apr, dec_rate_apr) raise SystemExit try: ra, dec, ra_rate, dec_rate = get_current_state_asteroid(_asteroid=asteroid, _kernel=kernel) print(0, ra, dec, ra_rate, dec_rate) except Exception: # print error code 4 (calculation failed) and exit print(4, ra_apr, dec_apr, ra_rate_apr, dec_rate_apr) raise SystemExit else: """ planets and moons """