from jplephem.spk import SPK
kernel = SPK.open('de430.bsp')
print(kernel)
position = kernel[0,4].compute(2457061.5)
print(position)
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 _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 test_single_position(self):
kernel = SPK(NAIF_DAF(open('de405.bsp', 'rb')))
x, y, z = kernel[0,4].compute(2457061.5)
# Expect rough agreement with a DE430 position from our README:
self.assertAlmostEqual(x, 2.05700211e+08, delta=2.0)
self.assertAlmostEqual(y, 4.25141646e+07, delta=2.0)
self.assertAlmostEqual(z, 1.39379183e+07, delta=2.0)
kernel.close()
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('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 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,
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 _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 __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, 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 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 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 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 __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 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 bsp_expiration(fileobj):
"""
Return the expiration date for a .bsp file.
"""
daf_object = DAF(fileobj)
spk_object = SPK(daf_object)
dates = [segment.end_jd for segment in spk_object.segments]
# We take the closest end date, to expire the file as soon as it's obsolete
end_jd = min(dates)
return calendar_date(end_jd)
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, 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 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 __init__(self, file):
if isinstance(file, str):
file = open(file, 'rb')
self.spk = SPK(file)
segments = [Segment(s.center, s.target, _build_compute(s))
for s in self.spk.segments]
codes = set(s.center for s in segments).union(
s.target for s in segments)
for code in codes:
body = Body(code, segments)
self[code] = body
raw_name = target_names.get(code, None)
if raw_name is None:
continue
name = raw_name.lower().replace(' ', '_')
setattr(self, name, body)
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 get_summary(url, spk=True):
''' simple function to retrieve the header of a BSP file and return SPK object'''
# connect to file at URL
bspurl = urllib2.urlopen(url)
# retrieve the "tip" of a file at URL
bsptip = bspurl.read(10**5) # first 100kB
# save data in fake file object (in-memory)
bspstr = StringIO(bsptip)
# load into DAF object
daf = DAF(bspstr)
# return either SPK or DAF object
if spk:
# make a SPK object
spk = SPK(daf)
# return representation
return spk
else:
# return representation
return daf
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
__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')
__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
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')
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)
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}
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()
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()
# 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 """
"""
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
