def helper_cassini_mission_phase_name(**kwargs):
metadata = kwargs['metadata']
obs_general_row = metadata['obs_general_row']
time1 = obs_general_row['time1']
for phase, start_time, stop_time in _CASSINI_PHASE_NAME_MAPPING:
start_time_sec = julian.tai_from_iso(start_time)
stop_time_sec = julian.tai_from_iso(stop_time)
if start_time_sec <= time1 < stop_time_sec:
return phase.upper()
return None
def DATETIME(value, offset=0):
"""Convert the given date/time string to a year-month-day format with a
trailing "Z". The date can be in year-month-day or year-dayofyear
format. The time component (following a capital 'T') is unchanged. If
the value is "UNK", then "UNK" is returned."""
if isinstance(value, float):
return julian.ymdhms_format_from_tai(value + offset, 'T', 3, 'Z')
if value.strip() == 'UNK': return 'UNK'
(date,hms) = value.split('T') # fails if not exactly two parts
parts = date.split('-')
if len(parts) == 3 and offset == 0:
return date + 'T' + hms + ('Z' if not hms.endswith('Z') else '')
if len(parts) == 2 and offset == 0:
# Note that strftime does not support dates before 1900. Some
# erroneous dates in some labels have erroneous years. This is a
# workaround.
day = time.strptime('19' + date[2:], '%Y-%j')
date = parts[0][:2] + time.strftime('%Y-%m-%d', day)[2:]
return date + 'T' + hms + ('Z' if not hms.endswith('Z') else '')
tai = julian.tai_from_iso(value) + offset
parts = value.split('.')
digits = len(parts[-1]) if len(parts) > 1 else 0
return julian.ymdhms_format_from_tai(tai, 'T', digits, 'Z')
def populate_obs_mission_cassini_ert2(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
# STOP_TIME isn't available for COUVIS
stop_time = index_row.get('EARTH_RECEIVED_STOP_TIME', None)
if stop_time is None:
return None
try:
ert_sec = julian.tai_from_iso(stop_time)
except Exception as e:
import_util.log_nonrepeating_warning(
f'Bad earth received stop time format "{stop_time}": {e}')
return None
cassini_row = metadata['obs_mission_cassini_row']
start_time_sec = cassini_row['ert1']
if start_time_sec is not None and ert_sec < start_time_sec:
import_util.log_warning(
f'cassini_ert1 ({start_time_sec}) and cassini_ert2 ({ert_sec}) '
+f'are in the wrong order - setting to ert1')
ert_sec = start_time_sec
return ert_sec
def populate_obs_general_HSTx_time2_OBS(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
stop_time = import_util.safe_column(index_row, 'STOP_TIME')
if stop_time is None:
return None
try:
stop_time_sec = julian.tai_from_iso(stop_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad stop time format "{stop_time}": {e}')
return None
general_row = metadata['obs_general_row']
start_time_sec = general_row['time1']
if start_time_sec is not None and stop_time_sec < start_time_sec:
start_time = import_util.safe_column(index_row, 'START_TIME')
import_util.log_warning(f'time1 ({start_time}) and time2 ({stop_time}) '
f'are in the wrong order - setting to time1')
stop_time_sec = start_time_sec
return stop_time_sec
def populate_obs_general_GOSSI_time2(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
stop_time = import_util.safe_column(index_row, 'IMAGE_TIME')
if stop_time is None:
return None
try:
stop_time_sec = julian.tai_from_iso(stop_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad image time format "{stop_time}": {e}')
return None
general_row = metadata['obs_general_row']
start_time_sec = general_row['time1']
if start_time_sec is not None and stop_time_sec < start_time_sec:
start_time = import_util.safe_column(index_row, 'START_TIME')
import_util.log_warning(f'time1 ({start_time}) and time2 ({stop_time}) '
f'are in the wrong order - setting to time1')
stop_time_sec = start_time_sec
return stop_time_sec
def helper_cassini_planet_id(**kwargs):
"""Find the planet associated with an observation. This is based on the
mission phase (as encoded in the observation time so it works with all
instruments)."""
metadata = kwargs['metadata']
index_row = metadata['index_row']
obs_general_row = metadata['obs_general_row']
time_sec2 = obs_general_row['time2']
jup = julian.tai_from_iso('2000-262T00:32:38.930')
sat = julian.tai_from_iso('2003-138T02:16:18.383')
if time_sec2 is None or time_sec2 < jup:
return None
if time_sec2 < sat:
return 'JUP'
return 'SAT'
def get_start_stop_times_old(lookup: Lookup) -> Dict[str, str]:
# TODO Remove this after get_start_stop_times() is fixed.
date_obs, time_obs, exptime = lookup.keys(["DATE-OBS", "TIME-OBS", "EXPTIME"])
start_date_time = f"{date_obs}T{time_obs}Z"
stop_date_time_float = julian.tai_from_iso(start_date_time) + float(exptime)
stop_date_time = julian.iso_from_tai(stop_date_time_float, suffix="Z")
return {
"start_date_time": start_date_time,
"stop_date_time": stop_date_time,
"exposure_duration": exptime,
}
def populate_obs_pds_HSTx_product_creation_time_OBS(**kwargs):
metadata = kwargs['metadata']
index_label = metadata['index_label']
pct = index_label['PRODUCT_CREATION_TIME']
try:
pct_sec = julian.tai_from_iso(pct)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad product creation time format "{pct}": {e}')
return None
return pct_sec
def populate_obs_pds_VGISS_product_creation_time(**kwargs):
metadata = kwargs['metadata']
supp_index_row = metadata['supp_index_row']
if supp_index_row is None:
return None
pct = supp_index_row['PRODUCT_CREATION_TIME']
try:
pct_sec = julian.tai_from_iso(pct)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad product creation time format "{pct}": {e}')
return None
return pct_sec
def populate_obs_pds_GOSSI_product_creation_time(**kwargs):
# For GOSSI the PRODUCT_CREATION_TIME is provided in the volume label file,
# not the individual observation rows
metadata = kwargs['metadata']
index_label = metadata['index_label']
pct = index_label['PRODUCT_CREATION_TIME']
try:
pct_sec = julian.tai_from_iso(pct)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad product creation time format "{pct}": {e}')
return None
return pct_sec
def populate_obs_pds_GOSSI_product_creation_time(**kwargs):
# For GOSSI the PRODUCT_CREATION_TIME is provided in the volume label file,
# not the individual observation rows
metadata = kwargs['metadata']
index_label = metadata['index_label']
pct = index_label['PRODUCT_CREATION_TIME']
try:
pct_sec = julian.tai_from_iso(pct)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad product creation time format "{pct}": {e}')
return None
return pct_sec
def INIT_SCLKS():
global NEW_SCLK_FROM_TAI, NEW_TAI_FROM_SCLK
global OLD_SCLK_FROM_TAI, OLD_TAI_FROM_SCLK
if NEW_SCLK_FROM_TAI is not None: return
tk = textkernel.from_file('cas00172.tsc')
coeffts = np.array(tk['SCLK'][1]['COEFFICIENTS_82']).reshape(-1,3)
sclk = (coeffts[:,0] + tk['SCLK_PARTITION_START_82']) / 256.
tai = julian.tai_from_tdt(coeffts[:,1])
tai_end = julian.tai_from_iso(EOM)
rate_end = coeffts[-1,2]
sclk_end = sclk[-1] + (tai_end - tai[-1]) / rate_end
sclk = np.array(list(sclk) + [sclk_end])
tai = np.array(list(tai) + [tai_end])
cas00172 = tabulation.Tabulation(tai, sclk)
NEW_SCLK_FROM_TAI = tabulation.Tabulation(tai, sclk)
NEW_TAI_FROM_SCLK = tabulation.Tabulation(sclk, tai)
tk = textkernel.from_file('cas00171.tsc')
coeffts = np.array(tk['SCLK'][1]['COEFFICIENTS_82']).reshape(-1,3)
sclk = (coeffts[:,0] + tk['SCLK_PARTITION_START_82']) / 256.
tai = julian.tai_from_tdb(coeffts[:,1])
tai_end = julian.tai_from_iso(EOM)
rate_end = coeffts[-1,2]
sclk_end = sclk[-1] + (tai_end - tai[-1]) / rate_end
sclk = np.array(list(sclk) + [sclk_end])
tai = np.array(list(tai) + [tai_end])
cas00171 = tabulation.Tabulation(tai, sclk)
OLD_SCLK_FROM_TAI = tabulation.Tabulation(tai, sclk)
OLD_TAI_FROM_SCLK = tabulation.Tabulation(sclk, tai)
def populate_obs_pds_VGISS_product_creation_time(**kwargs):
metadata = kwargs['metadata']
supp_index_row = metadata['supp_index_row']
if supp_index_row is None:
return None
pct = supp_index_row['PRODUCT_CREATION_TIME']
try:
pct_sec = julian.tai_from_iso(pct)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad product creation time format "{pct}": {e}')
return None
return pct_sec
def populate_obs_mission_voyager_ert(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
ert_time = index_row['EARTH_RECEIVED_TIME']
if ert_time.startswith('UNK'):
return None
try:
ert_sec = julian.tai_from_iso(ert_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad earth received time format "{ert_time}": {e}')
return None
return ert_sec
def populate_obs_mission_voyager_ert(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
ert_time = index_row['EARTH_RECEIVED_TIME']
if ert_time.startswith('UNK'):
return None
try:
ert_sec = julian.tai_from_iso(ert_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad earth received time format "{ert_time}": {e}')
return None
return ert_sec
def populate_obs_mission_hubble_publication_date(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
pub_date = index_row['PUBLICATION_DATE']
if pub_date is None:
return None
try:
pub_date_sec = julian.tai_from_iso(pub_date)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad publication date format "{pub_date}": {e}')
return None
return pub_date_sec
def populate_obs_general_HSTx_time1_OBS(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
start_time = import_util.safe_column(index_row, 'START_TIME')
if start_time is None:
return None
try:
start_time_sec = julian.tai_from_iso(start_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad start time format "{start_time}": {e}')
return None
return start_time_sec
def populate_obs_mission_cassini_ert1(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
# START_TIME isn't available for COUVIS
start_time = index_row.get('EARTH_RECEIVED_START_TIME', None)
if start_time is None:
return None
try:
ert_sec = julian.tai_from_iso(start_time)
except Exception as e:
import_util.log_nonrepeating_warning(
f'Bad earth received start time format "{start_time}": {e}')
return None
return ert_sec
def populate_obs_general_GOSSI_time1(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
stop_time = import_util.safe_column(index_row, 'IMAGE_TIME')
exposure = import_util.safe_column(index_row, 'EXPOSURE_DURATION')
if exposure is None or stop_time is None:
exposure = 0
try:
stop_time_sec = julian.tai_from_iso(stop_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad image time format "{stop_time}": {e}')
return None
return stop_time_sec-exposure/1000
def populate_obs_general_GOSSI_time1_OBS(**kwargs):
metadata = kwargs['metadata']
index_row = metadata['index_row']
stop_time = import_util.safe_column(index_row, 'IMAGE_TIME')
exposure = import_util.safe_column(index_row, 'EXPOSURE_DURATION')
if exposure is None or stop_time is None:
exposure = 0
try:
stop_time_sec = julian.tai_from_iso(stop_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad image time format "{stop_time}": {e}')
return None
return stop_time_sec - exposure / 1000
def populate_obs_general_VGISS_time1(**kwargs):
metadata = kwargs['metadata']
supp_index_row = metadata['supp_index_row']
if supp_index_row is None:
return None
start_time = import_util.safe_column(supp_index_row, 'START_TIME')
if start_time is None:
return None
try:
start_time_sec = julian.tai_from_iso(start_time)
except Exception as e:
import_util.log_nonrepeating_error(
f'Bad start time format "{start_time}": {e}')
return None
return start_time_sec
profile_label = profile_index_table.info.label.as_dict()
tol_fp = open('Final-Cassini-TOL.txt', 'r')
tol_fp.readline() # Header
tol_list = []
while True:
line = tol_fp.readline().strip()
if line == '':
break
fields = line.split('\t')
obs_id = fields[0]
if (not obs_id.startswith('RSS') or not obs_id.endswith('PRIME')
or not 'OCC' in obs_id):
continue
start_time = julian.tai_from_iso(fields[3])
end_time = julian.tai_from_iso(fields[6])
tol_list.append((obs_id, start_time, end_time))
tol_fp.close()
print('TOL entries:', len(tol_list))
output_fp = open(supp_index_tab_filename, 'w')
for row in profile_rows:
filespec = row['FILE_SPECIFICATION_NAME']
data_label_filename = vol_root + '/' + filespec
data_label = pdstable.PdsTableInfo(data_label_filename).label.as_dict()
lowest_detectable_opacity = data_label['LOWEST_DETECTABLE_OPACITY']
# 1980-11-12T05:15:45.520
# South
# 1980-11-13T04:19:30.640
# North
# 1981-08-26T04:18:21.080
# South
# 1985-11-06T17:22:30.040
# North
# 1986-01-24T17:10:13.320
# South
# We don't cache these dates because they're only computed once, and calling
# julian.tai_from_iso directly allows us to do an easy vectorization of a list
# of dates.
THRESHOLD_START_TIME_VG_AT_NORTH = julian.tai_from_iso([
'1980-11-12T05:15:45.520', '1980-11-13T04:19:30.640',
'1981-08-26T04:16:45.080', '1985-11-06T17:22:30.040',
'1986-01-24T17:10:13.320'
])
# This class handles everything that the instruments VGISS, VGPPS, VGRSS,
# and VGUVS have in common in the VG_28xx reflection/occultation profile
# volumes.
class ObsInstrumentVG28xx(ObsMissionVoyager):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#############################
### OVERRIDE FROM ObsBase ###
#############################
def cached_tai_from_iso(s):
return julian.tai_from_iso(s)
def __init__(self,
label_file,
times=[],
columns=[],
nostrip=[],
callbacks={}):
"""Constructor for a PdsTable object.
Input:
label_file the path to the PDS label of the table file, or else
the contents of the label as a list of strings.
columns an optional list of the names of the columns to
return. If the list is empty, then every column is
returned.
times an optional list of the names of time columns to be
stored as floats in units of seconds TAI rather than
as strings.
nostrip an optional list of the names of string columns that
are not to be stripped of surrounding whitespace.
callbacks an optional dictionary that returns a callback
function given the name of a column. If a callback
is provided for any column, then the function is
called on the string value of that column before it
is parsed. This can be used to update known syntax
errors in a particular table.
"""
# Parse the label
self.info = PdsTableInfo(label_file)
# Select the columns
if len(columns) == 0:
keys = [info.name for info in self.info.column_info_list]
else:
keys = columns
# Load the table data
file = open(self.info.table_file_path, "r")
lines = file.readlines()
file.close()
table = np.array(lines, dtype=self.info.dtype0)
# Extract the substring arrays and save in a dictionary and list...
self.column_list = []
self.column_dict = {}
for key in keys:
column_info = self.info.column_info_dict[key]
column = table[key]
# For multiple items...
if column_info.items > 1:
# Replace the column substring with a list of sub-substrings
column.dtype = np.dtype(column_info.dtype1)
items = []
for i in range(column_info.items):
item = column["item_" + str(i)]
items.append(item)
# Apply the callback function if necessary for each tem
if key in callbacks:
old_items = items
items = []
callback = callbacks[key]
for item in old_items:
rows = []
for row in item:
rows.append(callback(str(row)))
rows = np.array(rows)
items.append(np.array(rows))
# Strip strings...
if column_info.dtype2 is None and key not in nostrip:
old_items = items
items = []
for item in old_items:
rows = []
for row in item:
rows.append(str(row).strip())
rows = np.array(rows)
items.append(np.array(rows))
# ...or convert other data types
else:
old_items = items
items = []
for item in old_items:
items.append(item.astype(column_info.dtype2))
column = np.array(items).swapaxes(0, 1)
# Apply the callback function if necessary
else:
if key in callbacks:
callback = callbacks[key]
rows = []
for row in column:
rows.append(callback(str(row)))
column = np.array(rows)
# Strip strings...
if column_info.dtype2 is None:
if key not in nostrip:
rows = []
for row in column:
rows.append(str(row).strip())
column = np.array(rows)
# ...or convert other data types
else:
try:
column = column.astype(column_info.dtype2)
except ValueError:
warnings.warn("Illegal " + column_info.dtype2 +
" format in column " + column_info.name +
"; values were not converted to numeric")
# Convert time columns if necessary
if key in times:
column = julian.tai_from_iso(column)
self.column_list.append(column)
self.column_dict[key] = column
################################################################################
# obs_instrument_cocirs_cube.py
#
# Defines the ObsInstrumentCOCIRSCube class, which encapsulates fields in the
# common, obs_mission_cassini, and obs_instrument_cocirs tables for volumes
# COCIRS_[01]xxx.
################################################################################
import julian
import opus_support
from obs_mission_cassini import ObsMissionCassini
_EQUINOX_DATE = julian.tai_from_iso('2009-08-11T01:40:08.914')
class ObsInstrumentCOCIRSCube(ObsMissionCassini):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def _get_cube_map_projection(self):
return self._index_col('PRODUCT_ID')[-1].lower()
def _is_ring_map_projection(self):
return self._get_cube_map_projection() == 'r'
def _is_equi_map_projection(self):
return self._get_cube_map_projection() == 'e'
# Equinox: 2009-08-11T01:40:08.914
lowest_detectable_opacity = data_label['LOWEST_DETECTABLE_OPACITY']
highest_detectable_opacity = data_label['HIGHEST_DETECTABLE_OPACITY']
spacecraft_clock_start_count = data_label['SPACECRAFT_CLOCK_START_COUNT']
spacecraft_clock_stop_count = data_label['SPACECRAFT_CLOCK_STOP_COUNT']
if lowest_detectable_opacity > highest_detectable_opacity:
print(f'{filespec} Opacities are in wrong order {lowest_detectable_opacity} {highest_detectable_opacity}')
(lowest_detectable_opacity, highest_detectable_opacity) = (highest_detectable_opacity, lowest_detectable_opacity)
if spacecraft_clock_stop_count < spacecraft_clock_start_count:
# print(f'{clean_filespec} *** Spacecraft clock count in wrong order {spacecraft_clock_start_count} {spacecraft_clock_stop_count} - swapping')
spacecraft_clock_start_count, spacecraft_clock_stop_count = (
spacecraft_clock_stop_count, spacecraft_clock_start_count
)
start_time_sec = julian.tai_from_iso(start_time)
stop_time_sec = julian.tai_from_iso(stop_time)
if stop_time_sec - start_time_sec > 86400 * 10:
print(f'{clean_filespec} *** Bad start/stop time {start_time} {stop_time} - looking at data file')
# start_time_sec = None
# stop_time_sec = None
with open(data_label_info.table_file_path, 'r') as tab_fp:
csv_reader = csv.reader(tab_fp, delimiter=',')
tab_rows = [[y.strip('"').strip() for y in x] for x in csv_reader]
tab_start_time_sec = julian.tai_from_tdb(float(tab_rows[0][6]))
tab_ring_start_time_sec = julian.tai_from_tdb(float(tab_rows[0][7]))
tab_stop_time_sec = julian.tai_from_tdb(float(tab_rows[-1][6]))
tab_ring_stop_time_sec = julian.tai_from_tdb(float(tab_rows[-1][7]))
if tab_start_time_sec > tab_stop_time_sec:
(tab_start_time_sec, tab_stop_time_sec) = (tab_stop_time_sec, tab_start_time_sec)
def write_uvis_pds4_label(datafile, pds3_label):
# Read the PDS3 label and the VICAR header, fixing known syntax errors
label_text = open(pds3_label).read()
label_text = label_text.replace('\r','') # pyparsing is not set up for <CR>
label = pdsparser.PdsLabel.from_string(label_text).as_dict()
# Define the lookup dictionary
lookup = label.copy()
is_qube = ('QUBE' in label)
lookup['is_qube'] = is_qube
if is_qube:
lookup.update(label['QUBE'])
pds3_filename = label['^QUBE']
elif ('SPECTRUM' in label):
lookup.update(label['SPECTRUM'])
pds3_filename = label['^SPECTRUM']
else:
lookup.update(label['TIME_SERIES'])
pds3_filename = label['^TIME_SERIES']
# Define all the derived quantities
lookup['datafile'] = datafile
basename = os.path.basename(datafile)
lookup['basename'] = basename
inst = basename.split('_')[-1][:-4]
lookup['inst'] = inst
desc = lookup['DESCRIPTION']
k = desc.find('The purpose of this observation')
if k < 0:
purpose_str = ''
else:
purpose_str = desc[k:]
lookup['purpose_str'] = purpose_str
lookup['purpose'] = uvis_purpose(purpose_str, lookup['TARGET_NAME'])
observation_id = OBSERVATION_IDS[basename[:14]]
lookup['OBSERVATION_ID'] = observation_id
# For EUV/FUV...
if inst in ('euv', 'fuv'):
# Find window(s)
if 'UL_CORNER_SPATIAL' in lookup:
lookup['UL_CORNER_LINE'] = [lookup['UL_CORNER_SPATIAL' ]]
lookup['UL_CORNER_BAND'] = [lookup['UL_CORNER_SPECTRAL']]
lookup['LR_CORNER_LINE'] = [lookup['LR_CORNER_SPATIAL' ]]
lookup['LR_CORNER_BAND'] = [lookup['LR_CORNER_SPECTRAL']]
lookup['BAND_BIN'] = [1]
lookup['LINE_BIN'] = [1]
if not isinstance(lookup['UL_CORNER_LINE'], list):
lookup['UL_CORNER_LINE'] = [lookup['UL_CORNER_LINE']]
lookup['UL_CORNER_BAND'] = [lookup['UL_CORNER_BAND']]
lookup['LR_CORNER_LINE'] = [lookup['LR_CORNER_LINE']]
lookup['LR_CORNER_BAND'] = [lookup['LR_CORNER_BAND']]
lookup['BAND_BIN'] = [lookup['BAND_BIN']]
lookup['LINE_BIN'] = [lookup['LINE_BIN']]
# Locate the calibration file(s)
lookup['calibration_files'] = []
for version in ('3','4','5'):
calpath = (datafile.replace('data_raw_','calibration_data_')[:-8] +
'_cal_' + version + datafile[-8:])
if os.path.exists(calpath):
lookup['calibration_files'].append(os.path.basename(calpath))
# For HDAC, determine mode
if inst == 'hdac':
if sum(lookup['D_LEVEL']) + sum(lookup['H_LEVEL']) == 0:
lookup['mode'] = 'photometer'
else:
lookup['mode'] = 'modulation'
# For HDAC in modulation mode, count trailing zeros
if inst == 'hdac':
if lookup['mode'] == 'modulation':
data = np.fromfile(datafile, dtype='uint16')
nonzeros = len(data)
while data[nonzeros-1] == 0:
nonzeros -= 1
zeros = len(data) - nonzeros
if zeros:
print '%d trailing HDAC zeros found:' % zeros, datafile
lookup['zeros'] = zeros
lookup['nonzeros'] = nonzeros
else:
lookup['zeros'] = 0
lookup['nonzeros'] = lookup['ROWS']
# For HDAC, determine the duration
if inst == 'hdac':
lookup['duration'] = lookup['nonzeros'] * 0.125
# For HSP, determine start time, reference time, duration
if inst == 'hsp':
texp = lookup['SAMPLING_PARAMETER_INTERVAL'] / 1000.
lookup['texp'] = texp
INIT_SCLKS()
old_start_tai = julian.tai_from_iso(lookup['START_TIME']) - texp
start_sclk = OLD_SCLK_FROM_TAI(old_start_tai)
new_start_tai = NEW_TAI_FROM_SCLK(start_sclk)
lookup['shift_secs'] = new_start_tai - old_start_tai
stop_sclk = start_sclk + texp * lookup['ROWS']
new_stop_tai = NEW_TAI_FROM_SCLK(stop_sclk)
lookup['delta'] = (new_stop_tai - new_start_tai) / lookup['ROWS']
lookup['new_start_tai'] = new_start_tai
lookup['new_stop_tai'] = new_stop_tai
lookup['start_sclk'] = start_sclk
# Special care for target identifications
target_info = uvis_target_info(label['TARGET_NAME'], observation_id,
purpose_str, datafile)
target_names = []
target_alts = []
target_naif_ids = []
target_types = []
target_lids = []
primary_names = []
primary_naif_ids = []
primary_lids = []
for k in range(len(target_info)):
target_names.append(target_info[k][0])
target_alts.append(target_info[k][1])
target_naif_ids.append(get_naif_id(target_info[k][1]))
target_types.append(target_info[k][2])
primary_names.append(target_info[k][3])
target_lids.append(target_info[k][4])
if primary_names[-1] == 'N/A':
primary_naif_ids.append('N/A')
primary_lids.append('N/A')
else:
primary_info = TARGET_DICT[primary_names[-1].upper()]
primary_naif_ids.append(get_naif_id(primary_info[1]))
primary_lids.append(primary_info[4])
lookup['target_names' ] = target_names
lookup['target_alts' ] = target_alts
lookup['target_naif_ids' ] = target_naif_ids
lookup['target_types' ] = target_types
lookup['target_lids' ] = target_lids
lookup['primary_names' ] = primary_names
lookup['primary_naif_ids'] = primary_naif_ids
lookup['primary_lids' ] = primary_lids
# Write the label
labelfile = datafile[:-4] + '.xml'
if inst in ('euv', 'fuv'):
EUV_FUV_TEMPLATE.write(lookup, labelfile)
elif inst == 'hdac':
HDAC_TEMPLATE.write(lookup, labelfile)
else:
HSP_TEMPLATE.write(lookup, labelfile)
def __init__(self, label_file, times=[], columns=[], nostrip=[],
callbacks={}):
"""Constructor for a PdsTable object.
Input:
label_file the path to the PDS label of the table file, or else
the contents of the label as a list of strings.
columns an optional list of the names of the columns to
return. If the list is empty, then every column is
returned.
times an optional list of the names of time columns to be
stored as floats in units of seconds TAI rather than
as strings.
nostrip an optional list of the names of string columns that
are not to be stripped of surrounding whitespace.
callbacks an optional dictionary that returns a callback
function given the name of a column. If a callback
is provided for any column, then the function is
called on the string value of that column before it
is parsed. This can be used to update known syntax
errors in a particular table.
"""
# Parse the label
self.info = PdsTableInfo(label_file)
# Select the columns
if len(columns) == 0:
keys = [info.name for info in self.info.column_info_list]
else:
keys = columns
# Load the table data
file = open(self.info.table_file_path, "r")
lines = file.readlines()
file.close()
table = np.array(lines, dtype=self.info.dtype0)
# Extract the substring arrays and save in a dictionary and list...
self.column_list = []
self.column_dict = {}
for key in keys:
column_info = self.info.column_info_dict[key]
column = table[key]
# For multiple items...
if column_info.items > 1:
# Replace the column substring with a list of sub-substrings
column.dtype = np.dtype(column_info.dtype1)
items = []
for i in range(column_info.items):
item = column["item_" + str(i)]
items.append(item)
# Apply the callback function if necessary for each tem
if callbacks.has_key(key):
old_items = items
items = []
callback = callbacks[key]
for item in old_items:
rows = []
for row in item:
rows.append(callback(str(row)))
rows = np.array(rows)
items.append(np.array(rows))
# Strip strings...
if column_info.dtype2 is None and key not in nostrip:
old_items = items
items = []
for item in old_items:
rows = []
for row in item:
rows.append(str(row).strip())
rows = np.array(rows)
items.append(np.array(rows))
# ...or convert other data types
else:
old_items = items
items = []
for item in old_items:
items.append(item.astype(column_info.dtype2))
column = np.array(items).swapaxes(0,1)
# Apply the callback function if necessary
else:
if callbacks.has_key(key):
callback = callbacks[key]
rows = []
for row in column:
rows.append(callback(str(row)))
column = np.array(rows)
# Strip strings...
if column_info.dtype2 is None:
if key not in nostrip:
rows = []
for row in column:
rows.append(str(row).strip())
column = np.array(rows)
# ...or convert other data types
else:
try:
column = column.astype(column_info.dtype2)
except ValueError:
warnings.warn("Illegal " + column_info.dtype2 +
" format in column " + column_info.name +
"; values were not converted to numeric")
# Convert time columns if necessary
if key in times:
column = julian.tai_from_iso(column)
self.column_list.append(column)
self.column_dict[key] = column
def tai_from_iso(string):
return julian.tai_from_iso(string, strip=True)
