AlarmStates.py

Go to the documentation of this file.

#!/usr/bin/env python
#
#                               Copyright 2006
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#
#

__facility__ = "Online"
__abstract__ = "Classes for determining alarm states"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "12/29/2005" # Created
__updated__  = ("$Date: 2006/04/28 01:20:18 $").split(' ')[1]
__version__  = "$Revision: 1.3 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from ISOC.TlmUtils.TlmInterface      import LimitState


class AlarmState(LimitState):
  """!\brief Settable limit state class
  """
  def __init__(self, state=LimitState.NoLimit):
    """!\brief AlarmState constructor

    \param  state  Starting state.  Default: LimitState.Unknown
    """
    LimitState.__init__(self)

    if state is not None:
      self.__setState(state)
    else:
      self.__state = self.Unknown

  def setState(self, newState):
    """!\brief Set the current state

    \param newState   A LimitState member or an integer

    \return  Can throw an exception if newState isn't allowed.
    """
    self.__setState(newState)

  def stateEnum(self):
    """!\brief return the current integer state value

    \return  Integer state value
    """
    return self.__state

  def state(self):
    """!\brief Return a string defining the current state

    \return String state value
    """
    return self.stateName(self.__state)

  def __setState(self, newState):
    if isinstance(newState, AlarmState):
      self.__state = newState.__state
    elif type(newState) == type(LimitState.NoLimit) and \
             self.stateName(newState) is not None:
      self.__state = newState
    else:
      raise RuntimeError("Attempt to set an invalid state: %s" % newState)

  def __cmp__(self, state):
    """!\brief Comparison operator.  Allows state1 < state2
    """
    return cmp(self.__state, state.__state)



class AlarmedItem(object):
  """!\brief Basic hierarchical state item
  """

  def __init__(self, parent=None, state = AlarmState.Unknown):
    """!\brief AlarmedItem constructor

    \param parent   Item's parent.  Default: None (No Parent)
    \param state    Item's starting state.  Default: AlarmState.Unknown
    """

    self.__parent      = parent
    if self.__parent is not None and type(self.__parent) == type(self):
      self.__parent.newChild(self)

    if state is not None:
      self.__state = AlarmState(state)
    else:
      self.__state = AlarmState()  # defaults to Unknown

    self.__children    = []
    self.__enabled     = True

  def parent(self):
    """!\brief return the parent AlarmedItem

    \return An AlarmedItem object, or None
    """
    if type(self.__parent) == type(self):
      return self.__parent
    else:
      return None

  def state(self):
    """!\brief return the state of this object

    \return An AlarmState object
    """
    return self.__state

  def children(self):
    """!\brief return the children of this object

    \return a List of AlarmedItem objects
    """
    # Note, JHP:  override this method when using QListView objects
    return self.__children

  def newChild(self, child):
    """!\brief Add a child to the set of this object children

    \param child
    """
    if child not in self.__children:
      self.__children.append(child)

  def isEnabled(self):
    """!\brief Is this item enabled?

    \return boolean
    """
    return self.__enabled

  def enable(self, enableChildren=True):
    """!\brief Enable alarms on this object and all its children

    \param enableChildren  Enable the children also (Default: True)
    """
    self.__enabled = True
    self.setState(self.__state)
    if enableChildren:
      self.iterateChildren( self.__class__.enable, enableChildren )

  def disable(self, disableChildren=True):
    """!\brief Disable alarms on this object and all its children

    \param disableChildren  Disable the children also (Default: True)
    """
    self.__enabled = False
    self.setState(self.__state)
    if disableChildren:
      self.iterateChildren( self.__class__.disable, disableChildren )

  def iterateChildren(self, callback, *args):
    """!\brief iterate over the children of this method, calling a function on each

    \param callback  A method
    \param *args     Arguments to be used for *each* callback
    """
    if self.children() is None:
      return None
    if args == ():
      return map( callback, self.children() )
    else:
      return map( callback, self.children(), args*len(self.children()) )

  def setState(self, state , forceUpdate = False):
    """!\brief Set the state of the current object and propogate to parent if need be

    \param state  Either an integer or an AlarmState object
    """
    oldState = self.__state
    # set the current state
    self.__state = AlarmState(state)
    # propogate to parent.  Check types because we can be in qlistview.

    parent = self.__parent
    if (parent is not None and \
      oldState != self.__state )\
      or forceUpdate:
      while parent is not None:
        try:
          psNow = parent.state()
          psRec = parent.childStateSum()
      # set parent's state new state is worse.
          if psRec != psNow:
            parent.setState(psRec)
          parent = parent.__parent
        except:
          break

  def childStateSum(self):
    """!\brief Recalculate this object's state from its children

    """
    # If I have children, calculate the worstState from them. Else use mine.
    worstState = min(AlarmState(AlarmState.InLimits),self.state())
    if self.children() == []:
      if self.isEnabled():
        worstState = self.state()
    else:
      if self.isEnabled():
        # Only look at child states if parent state is not disabled
        for state in self.iterateChildren( self.__class__.childStateSum ):
          if state > worstState:
            worstState = state
    return worstState


if __name__ == '__main__':

  # regression test to make sure that inheritance works.
  a = AlarmedItem(state=0)
  print 'a:',a,dir(a)

  b = [ AlarmedItem(a,state=0), AlarmedItem(a,state=0) ]
  print 'b:', b

  c = [ AlarmedItem(b[0],state=0), AlarmedItem(b[1],state=0) ]

  print 'c:',c

  print 'a.state():',a.state(), dir(a.state())

  print a.state().state(),\
        map(AlarmState.state, map(AlarmedItem.state, b)), \
        map(AlarmState.state, map(AlarmedItem.state, c))


  a.setState(AlarmState.HiRed)
#  c[0].setState(AlarmState.HiRed)
#  b[1].setState(AlarmState.HiRed)

  print a.state().state(),\
        map(AlarmState.state, map(AlarmedItem.state, b)), \
        map(AlarmState.state, map(AlarmedItem.state, c))


  a.setState(AlarmState.InLimits)
#  c[0].setState(AlarmState.InLimits)

  print a.state().state(),\
        map(AlarmState.state, map(AlarmedItem.state, b)), \
        map(AlarmState.state, map(AlarmedItem.state, c))

---