Shiny

kadi/commands/commands.py

@@ -5,7 +5,7 @@
 import numpy as np
 
 from astropy.table import Table, Row, Column, vstack
-from Chandra.Time import DateTime
+from Chandra.Time import DateTime, date2secs
 import pickle
 
 from ..paths import IDX_CMDS_PATH, PARS_DICT_PATH
@@ -90,26 +90,35 @@ def get_cmds(start=None, stop=None, inclusive_stop=False, **kwargs):
       >>> print(cmds)
 
     :param start: DateTime format (optional) Start time, defaults to beginning
-        of available commands (2002:001) :param stop: DateTime format (optional)
-        Stop time, defaults to end of available commands :param kwargs: key=val
-        keyword argument pairs
+        of available commands (2002:001)
+    :param stop: DateTime format (optional) Stop time, defaults to end of available
+        commands
+    :param inclusive_stop: bool, include commands at exactly ``stop`` if True.
+    :param kwargs: key=val keyword argument pairs for filtering
 
     :returns: :class:`~kadi.commands.commands.CommandTable` of commands
     """
     cmds = _find(start, stop, inclusive_stop, **kwargs)
     out = CommandTable(cmds)
     out['params'] = None if len(out) > 0 else Column([], dtype=object)
 
+    # Convert 'date' from bytestring to unicode. This allows
+    # date2secs(out['date']) to work and will generally reduce weird problems.
+    out.convert_bytestring_to_unicode()
+
+    out.add_column(date2secs(out['date']), name='time', index=6)
+    out['time'].info.format = '.3f'
+
     return out
 
 
-def get_cmds_from_backstop(backstop, remove_starcat=True):
+def get_cmds_from_backstop(backstop, remove_starcat=False):
     """
     Initialize a ``CommandTable`` from ``backstop``, which can either
     be a string file name or a backstop table from ``parse_cm.read_backstop``.
 
     :param backstop: str or Table
-    :param remove_starcat: remove star catalog command parameters (default=True)
+    :param remove_starcat: remove star catalog command parameters (default=False)
     :returns: :class:`~kadi.commands.commands.CommandTable` of commands
     """
     if isinstance(backstop, Path):
@@ -133,6 +142,7 @@ def get_cmds_from_backstop(backstop, remove_starcat=True):
     out['tlmsid'] = np.chararray.encode(bs['tlmsid'])
     out['scs'] = bs['scs'].astype(np.uint8)
     out['step'] = bs['step'].astype(np.uint16)
+    out['time'] = date2secs(bs['date'])
     # Set timeline_id to 0, does not match any real timeline id
     out['timeline_id'] = np.zeros(n_bs, dtype=np.uint32)
     out['vcdu'] = bs['vcdu'].astype(np.int32)
@@ -154,7 +164,14 @@ def get_cmds_from_backstop(backstop, remove_starcat=True):
             params['event_type'] = params['type']
             del params['type']
 
-    return CommandTable(out)
+    out = CommandTable(out)
+    out['time'].info.format = '.3f'
+
+    # Convert 'date' from bytestring to unicode. This allows
+    # date2secs(out['date']) to work and will generally reduce weird problems.
+    out.convert_bytestring_to_unicode()
+
+    return out
 
 
 def _find(start=None, stop=None, inclusive_stop=False, **kwargs):
@@ -217,6 +234,7 @@ def _find(start=None, stop=None, inclusive_stop=False, **kwargs):
                     par_ok |= (idx_cmds['idx'] == idx)
             ok &= par_ok
     cmds = idx_cmds[ok]
+
     return cmds
 
 
@@ -258,7 +276,7 @@ def __str__(self):
 
         out = ('{} {} '.format(self['date'], self['type'])
                + ' '.join('{}={}'.format(key, self[key]) for key in keys
-                          if key not in ('type', 'date')))
+                          if key not in ('type', 'date', 'time')))
         return out
 
     def __sstr__(self):
@@ -354,3 +372,17 @@ def add_cmds(self, cmds):
         out.sort(['date', 'step', 'scs'])
 
         return out
+
+    def as_list_of_dict(self):
+        """Convert CommandTable to a list of dict (ala Ska.ParseCM)
+
+        The command ``params`` are embedded as a dict for each command.
+
+        :return: list of dict
+        """
+        self.fetch_params()
+
+        names = self.colnames
+        cmds_list = [{name: cmd[name] for name in names} for cmd in self]
+
+        return cmds_list

kadi/commands/states.py

@@ -13,8 +13,7 @@
 
 from astropy.table import Table, Column
 
-from Chandra.cmd_states import decode_power
-from Chandra.Time import DateTime
+from Chandra.Time import DateTime, date2secs, secs2date
 import Chandra.Maneuver
 from Quaternion import Quat
 import Ska.Sun
@@ -920,6 +919,63 @@ def callback(cls, date, transitions, state, idx):
 ###################################################################
 # ACIS transitions
 ###################################################################
+def decode_power(mnem):
+    """
+    Decode number of chips and feps from a ACIS power command
+    Return a dictionary with the number of chips and their identifiers
+
+    Example::
+
+    >>> decode_power("WSPOW08F3E")
+    {'ccd_count': 5,
+     'ccds': 'I0 I1 I2 I3 S3 ',
+     'clocking': 0,
+     'fep_count': 5,
+     'feps': '1 2 3 4 5 ',
+     'vid_board': 1}
+
+    :param mnem: power command string
+
+    """
+    fep_info = {'fep_count': 0,
+                'ccd_count': 0,
+                'feps': '',
+                'ccds': '',
+                'vid_board': 1,
+                'clocking': 0}
+
+    # Special case WSPOW000XX to turn off vid_board
+    if mnem.startswith('WSPOW000'):
+        fep_info['vid_board'] = 0
+
+    # the hex for the commanding is after the WSPOW
+    powstr = mnem[5:]
+    if (len(powstr) != 5):
+        raise ValueError("%s in unexpected format" % mnem)
+
+    # convert the hex to decimal and "&" it with 63 (binary 111111)
+    fepkey = int(powstr, 16) & 63
+    # count the true binary bits
+    for bit in range(0, 6):
+        if (fepkey & (1 << bit)):
+            fep_info['fep_count'] = fep_info['fep_count'] + 1
+            fep_info['feps'] = fep_info['feps'] + str(bit) + ' '
+
+    # convert the hex to decimal and right shift by 8 places
+    vidkey = int(powstr, 16) >> 8
+
+    # count the true bits
+    for bit in range(0, 10):
+        if (vidkey & (1 << bit)):
+            fep_info['ccd_count'] = fep_info['ccd_count'] + 1
+            # position indicates I or S chip
+            if (bit < 4):
+                fep_info['ccds'] = fep_info['ccds'] + 'I' + str(bit) + ' '
+            else:
+                fep_info['ccds'] = fep_info['ccds'] + 'S' + str(bit - 4) + ' '
+
+    return fep_info
+
 
 class ACISTransition(BaseTransition):
     """
@@ -1258,6 +1314,13 @@ def get_states(start=None, stop=None, state_keys=None, cmds=None, continuity=Non
     # Final datestop far in the future
     datestop[-1] = stop
     out.add_column(Column(datestop, name='datestop'), 1)
+
+    # Add corresponding tstart, tstop
+    out.add_column(Column(date2secs(out['datestart']), name='tstart'), 2)
+    out.add_column(Column(date2secs(out['datestop']), name='tstop'), 3)
+    out['tstart'].info.format = '.3f'
+    out['tstop'].info.format = '.3f'
+
     out['trans_keys'] = [st.trans_keys for st in states]
 
     if reduce:
@@ -1313,9 +1376,10 @@ def reduce_states(states, state_keys, merge_identical=False):
         has_transition |= has_transitions[key]
 
     # Create output with only desired state keys and only states with a transition
-    out = states[['datestart', 'datestop'] + list(state_keys)][has_transition]
-    out['datestop'][:-1] = out['datestart'][1:]
-    out['datestop'][-1] = states['datestop'][-1]
+    out = states[['datestart', 'datestop', 'tstart', 'tstop'] + list(state_keys)][has_transition]
+    for dt in ('date', 't'):
+        out[f'{dt}stop'][:-1] = out[f'{dt}start'][1:]
+        out[f'{dt}stop'][-1] = states[f'{dt}stop'][-1]
 
     trans_keys_list = [TransKeysSet() for _ in range(len(out))]
     for key in state_keys:
@@ -1406,7 +1470,8 @@ def get_continuity(date=None, state_keys=None, lookbacks=(7, 30, 180, 1000)):
                 # the stop time and did not get processed.
                 continuity_transitions.extend(states.meta['continuity_transitions'])
 
-            colnames = set(states.colnames) - set(['datestart', 'datestop', 'trans_keys'])
+            colnames = set(states.colnames) - set(['datestart', 'datestop',
+                                                   'tstart', 'tstop', 'trans_keys'])
             for colname in colnames:
                 if states[colname][-1] is not None:
                     # Reduce states to only the desired state_key
@@ -1451,13 +1516,25 @@ def get_continuity(date=None, state_keys=None, lookbacks=(7, 30, 180, 1000)):
 def interpolate_states(states, times):
     """Interpolate ``states`` table at given times.
 
-    :param states: states (np.recarray)
-    :param times: times (np.array or list)
+    :param states: states (astropy states Table)
+    :param times: times (np.array or any DateTime compatible input)
 
     :returns: ``states`` view at ``times``
     """
-    indexes = np.searchsorted(states['tstop'], times)
-    return states[indexes]
+    from astropy.table import Column
+    if not isinstance(times, np.ndarray) or times.dtype.kind != 'f':
+        times = DateTime(times).secs
+
+    try:
+        tstops = states['tstop']
+    except (ValueError, KeyError):
+        tstops = date2secs(states['datestop'])
+
+    indexes = np.searchsorted(tstops, times)
+    out = states[indexes]
+    out.add_column(Column(secs2date(times), name='date'), index=0)
+
+    return out
 
 
 def _unique(seq):
@@ -1515,5 +1592,7 @@ def get_chandra_states(main_args=None):
     state_keys = opt.state_keys.split(',') if opt.state_keys else None
     states = get_states(start, stop, state_keys, merge_identical=opt.merge_identical)
     del states['trans_keys']
+    del states['tstart']
+    del states['tstop']
 
     ascii.write(states, output=opt.outfile, format='fixed_width', delimiter='')

kadi/commands/tests/test_commands.py

@@ -6,6 +6,7 @@
 # Use data file from parse_cm.test for get_cmds_from_backstop test.
 # This package is a dependency
 import parse_cm.tests
+from Chandra.Time import secs2date
 
 # Import cmds module directly (not kadi.cmds package, which is from ... import cmds)
 from .. import commands
@@ -65,7 +66,7 @@ def test_get_cmds_zero_length_result():
     cmds = commands.get_cmds(date='2017:001:12:00:00')
     assert len(cmds) == 0
     assert cmds.colnames == ['idx', 'date', 'type', 'tlmsid', 'scs',
-                             'step', 'timeline_id', 'vcdu', 'params']
+                             'step', 'time', 'timeline_id', 'vcdu', 'params']
 
 
 def test_get_cmds_inclusive_stop():
@@ -81,12 +82,22 @@ def test_get_cmds_inclusive_stop():
     assert np.all(cmds['date'] == [start, stop])
 
 
+def test_cmds_as_list_of_dict():
+    cmds = commands.get_cmds('2020:140', '2020:141')
+    cmds_list = cmds.as_list_of_dict()
+    assert isinstance(cmds_list, list)
+    assert isinstance(cmds_list[0], dict)
+    cmds_rt = commands.CommandTable(cmds)
+    assert set(cmds_rt.colnames) == set(cmds.colnames)
+    for name in cmds.colnames:
+        assert np.all(cmds_rt[name] == cmds[name])
+
+
 def test_get_cmds_from_backstop_and_add_cmds():
     bs_file = Path(parse_cm.tests.__file__).parent / 'data' / 'CR182_0803.backstop'
-    bs_cmds = commands.get_cmds_from_backstop(bs_file)
+    bs_cmds = commands.get_cmds_from_backstop(bs_file, remove_starcat=True)
 
-    cmds = commands.get_cmds(start='2018:182:00:00:00',
-                             stop='2018:182:08:00:00')
+    cmds = commands.get_cmds(start='2018:182:00:00:00', stop='2018:182:08:00:00')
 
     assert len(bs_cmds) == 674
     assert len(cmds) == 56
@@ -95,6 +106,9 @@ def test_get_cmds_from_backstop_and_add_cmds():
     for bs_col, col in zip(bs_cmds.itercols(), cmds.itercols()):
         assert bs_col.dtype == col.dtype
 
+    assert np.all(secs2date(cmds['time']) == cmds['date'])
+    assert np.all(secs2date(bs_cmds['time']) == bs_cmds['date'])
+
     new_cmds = cmds.add_cmds(bs_cmds)
     assert len(new_cmds) == len(cmds) + len(bs_cmds)
 
@@ -104,7 +118,7 @@ def test_get_cmds_from_backstop_and_add_cmds():
     assert np.all(bs_cmds['params'][ok] == {})
 
     # Accept MP_STARCAT commands
-    bs_cmds = commands.get_cmds_from_backstop(bs_file, remove_starcat=False)
+    bs_cmds = commands.get_cmds_from_backstop(bs_file)
     ok = bs_cmds['type'] == 'MP_STARCAT'
     assert np.count_nonzero(ok) == 15
     assert np.all(bs_cmds['params'][ok] != {})