def read(self, json_data, hdf5_data):
super().read(json_data, hdf5_data)
self._fields = json_data[self.name]["fields"]
scale = json_data[self.name].get("scale", "tai") # TODO: 'tai' used earlier, `get` for backwards compatibility
# should be `json_data[self.name]['scale']` but will
# cause old datasets to become unreadable
time_values = hdf5_data[self.name][...]
self._data = time.Time(val=time_values[:, 0], val2=time_values[:, 1], format="jd", scale=scale)
def header_line(self):
"""Mandatory header line
"""
now = time.Time(datetime.now(), scale="utc").yydddsssss
start = min(self.dset.time).yydddsssss
end = max(self.dset.time).yydddsssss
file_agency = config.tech.sinex.file_agency.str.upper()
data_agency = config.tech.sinex.data_agency.str.upper()
num_params = self.dset.meta["statistics"]["number of unknowns"]
constraint = "2"
self.fid.write(
f"%=SNX 2.02 {file_agency:<3} {now} {data_agency:<3} {start} {end} R {num_params:>5} {constraint} S E C \n"
)
def extend(self, other_table):
"""Add observations from another time table at the end of this table
Fields in only one of the tables are handled by filling with empty strings.
TODO: Make sure time scale is handled correctly
Args:
other_table (TimeTable): The other table.
"""
self._data = time.Time(
np.hstack((self._data.utc.jd1, other_table.data.utc.jd1)),
np.hstack((self._data.utc.jd2, other_table.data.utc.jd2)),
format="jd",
scale="utc",
)
self._num_obs += other_table.num_obs
def calculate_initial_values(eph):
"""Computing initial values for position and velocity in GCRS system
This is for later use in orbit integration, from tables in the prediction files. Use a lagrange polynomial in
order to interpolate in the tables.
Args:
eph: Dict containing ephemeris information
Returns:
eph: Dict where the initial position and velocity is added
"""
pos_gcrs = np.empty((3, 0))
times = np.empty((0))
table_of_positions = sorted(eph.data["positions"].items())
mjd1, mjd2 = zip(*[t for t, d in table_of_positions])
for pos_time, (_, data) in zip(
time.Time(val=mjd1, val2=mjd2, format="mjd", scale="utc"),
table_of_positions):
diffsec = (pos_time.utc.datetime - eph.rundate).total_seconds()
# Only look at points close to rundate (start of integration)
# if abs(diffsec) > 4000:
# continue
# Table given in ITRF coordinate system. Convert to GCRS, where the integration of the satellite orbit will
# be done
pos_gcrs = np.hstack(
(pos_gcrs, np.transpose([pos_time.itrs2gcrs @ data["pos"]])))
times = np.hstack((times, diffsec))
log.info(
"Interpolating data from prediction file in order to get initial pos/vel"
)
pos_gcrs_ip, vel_gcrs_ip = interpolation.interpolate_with_derivative(
times,
np.transpose(pos_gcrs),
np.array([0.0]),
kind="lagrange",
window=10,
bounds_error=False)
eph["initial_pos"] = pos_gcrs_ip[0]
eph["initial_vel"] = vel_gcrs_ip[0]
return eph
def add(self, fieldname, val, scale, write_level=None, **kwargs):
super().add(fieldname, write_level)
self._data = time.Time(val, scale=scale, **kwargs)
self._fields = [fieldname]
self._units[fieldname] = scale # Use time scale as unit, mainly for visualizing time scale