gConstraint.py

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

__facility__ = "Online"
__abstract__ = "Classes for defining constraints"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/03/20 00:58:14 $").split(' ')[1]
__version__  = "$Revision: 2.3 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import exceptions
import gGroup

True  = (0 < 1)
False = not True

class gConstraintViolation(exceptions.Exception):
  """\brief Constraint Violation Class

  Exception class used in constraint classes
  """
  def __init__(self, args=None):
    self.args = args


class GconstraintBase(object):
  """\brief Base constraint class for use when no constraint is appropriate.
  """
  def __init__(self):
    pass

  def evaluate(self, value):
    return (value, False)

class Gconstraint(GconstraintBase):
  """\brief Base class for describing constraints
  """
  def __init__(self, name, subsystem, category, enabled, continuous = False):
    """ Constructor.
      \param name       Constraint name
      \param subsystem  Subsystem gGroup to which the constraint belongs
      \param category   Category gGroup to which the constraint belongs
      \param enabled    Flag indicating whether constraint is enabled
      \param continuous Flag indicating whether constraint can fire repeatedly
    """
    self.__name       = name
    self.__subsystem  = subsystem
    self.__category   = category
    self.__enabled    = enabled
    self.__continuous = continuous
    self.__fired      = False

  def _eval_(self, value):
    """Dummy evaluation method to be overridden through inheritance to implement
    the application specific constraint evaluation"""
    return (value, False)

  def evaluate(self, value):
    """This method is called to evaluate the constraint on 'value'"""
    if self.__subsystem.enabled() and \
       self.__category.enabled()  and \
       self.__enabled:
      return self._eval_(value)
    else:
      return (value, False)

  def name(self):
    """Method to retrieve the constraint's name"""
    return self.__name

  def subsystem(self):
    """Method for discovering this constraint's subsystem"""
    return self.__subsystem

  def category(self):
    """Method for discovering this constraint's category"""
    return self.__category

  def enabled(self):
    """Method for discovering whether this constraint is enabled"""
    return self.__enabled

  def enable(self):
    """Method used to enable evaluation of this constraint"""
    self.__enabled = True

  def disable(self):
    """Method used to disable evaluation of this constraint"""
    self.__enabled = False

  def reset(self):
    """Method used to reenable evaluation of this constraint in the case of
    noncontinuous mode after it has been violated"""
    self.__fired = False

  def reject(self, message):
    """Method optionally used by the constraint evaluation implementation to
    signal a constraint violation"""
    if self.__continuous or not self.__fired:
      self.__fired = True
      raise gConstraintViolation, message


class GconstraintLimitRE(Gconstraint):
  """\brief On Constraint Limit Raise Exception

  Constraint class that determines whether to raise an exception
  based on the passed in value being within given limits.
  """
  def __init__(self, name, subsystem, category, enabled, continuous,
               low, high):
    Gconstraint.__init__(self, name, subsystem, category, enabled, continuous)
    self.__low  = low
    self.__high = high

  def _eval_(self, value):
    if value < self.__low or value > self.__high:
      self.reject("%s constraint: value is driven out of range" % self._Gconstraint__name)
      return (value, True)
    return (value, False)


class GconstraintLimit(Gconstraint):
  """\brief Limit Constraint

  Constraint class that limits a passed in value to given limits.  If the
  value is outside of the constraint limits, it is pegged to the nearest limit.
  """
  def __init__(self, name, subsystem, category, enabled, continuous,
               low, high):
    Gconstraint.__init__(self, name, subsystem, category, enabled, continuous)
    self.__low  = low
    self.__high = high

  def _eval_(self, value):
    if   value < self.__low:
      print "%s constraint: value is driven to the low constraint"  % self.name()
      return    (self.__low,  False)
    elif value > self.__high:
      print "%s constraint: value is driven to the high constraint" % self.name()
      return    (self.__high, False)
    else:
      return    (value,       False)

class GconstraintLimitPegRE(Gconstraint):
  """\brief Pegged Limit Constraint

  Constraint class that limits a passed in value to given limits.  If the
  value is outside of the constraint limits, it raises an exception AND the
  value is pegged to the nearest limit.
  """
  def __init__(self, name, subsystem, category, enabled, continuous,
               low, high):
    Gconstraint.__init__(self, name, subsystem, category, enabled, continuous)
    self.__low  = low
    self.__high = high

  def _eval_(self, value):
    if   value < self.__low:
      violMsg =  "Driven to low constraint"
      self.reject(violMsg)
      return    (self.__low,  True)
    elif value > self.__high:
      violMsg =  "Driven to high constraint"
      self.reject(violMsg)
      return    (self.__high, True)
    else:
      return    (value,       False)

---