rule_compliance.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
"""
Created on Sat May  9 13:10:31 2020
 
@author: cd
"""
 
import abc
from efo.rule import RuleBase
from efo.qin import QinSpecified
import numpy as np
from efo.lookup import LkupTbl, LkupTblAnn, LkupTblElev, LkupTblInterp
 
# TODO: Should compliance rules also return a max or min?
 
class RuleComplianceBase(RuleBase):
    MIN = int(0)
    MAX = int(1)
    CTRL_RLS = int(0)
    TOT_RLS = int(1)
    
    def __init__(self, name, time, *, ruleType=MIN, rlsType=CTRL_RLS):
        super().__init__(name, time)
        self.ruleTyperuleType = ruleType
        self.rlsTyperlsType = rlsType
        self.qCompCurqCompCur = 0. if ruleType == RuleComplianceBase.MIN else np.inf
 
    @abc.abstractmethod
    def get_qcomp(self, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        return
 
    @classmethod
    def __subclasshook__(cls, C):
        if cls is RuleComplianceBase:
            attrs = set(dir(C))
            if set(cls.__abstractmethods__) <= attrs:
                return True
        return NotImplemented
        
    def calc_release(self, rlsProposed, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None):
        rlsProposed = super().calc_release(
            rlsProposed, rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn)
        qComp = self.get_qcompget_qcomp(stor=stor, rlsUnCtrl=rlsUnCtrl, rlsPrev=rlsPrev, qIn=qIn)
        release = min(rlsProposed, qComp) if self.ruleTyperuleType==RuleComplianceBase.MAX else max(rlsProposed, qComp)
        self.release[self.T.step] = release
        return release
    
 
class RuleMinQ(RuleComplianceBase):
    def __init__(self, name, time, minQ, rlsType=RuleComplianceBase.CTRL_RLS):
        # Call super class constructor
        # TODO: Error check to make sure that the minQ is a float
        super().__init__(name, time, ruleType=RuleComplianceBase.MIN)
        # Class properties
        self.minQminQ = minQ
    
    # TODO: Could this be a property?
    def get_qcomp(self, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        self.qCompCurqCompCurqCompCur = self.minQminQ
        return self.qCompCurqCompCurqCompCur
 
 
class RuleMaxQ(RuleComplianceBase):
    def __init__(self, name, time, maxQ, pctBuffer=0., rlsType=RuleComplianceBase.CTRL_RLS):
        # Call super class constructor
        super().__init__(name, time, ruleType=RuleComplianceBase.MAX)
        # Class properties
        # TODO: Error check to make sure that the minQ is a float
        self.pctBufferpctBuffer = pctBuffer
        self.maxQmaxQ = maxQ - maxQ*pctBuffer
 
    def get_qcomp(self, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        self.qCompCurqCompCurqCompCur = self.maxQmaxQ
        return self.qCompCurqCompCurqCompCur
 
 
# TODO: This should subclass something that requires storage to get a qMax for error handling
class RuleMaxLkupTblElev(RuleComplianceBase):
    def __init__(self, name, time, hypso, xElev, yQ, rlsType=RuleComplianceBase.CTRL_RLS):
        # Call super class constructor
        super().__init__(name, time, ruleType=RuleComplianceBase.MAX)
        # Build lookup table
        self.compQTblcompQTbl = LkupTblElev(name+'_table', hypso, xElev, yQ)
 
    def get_qcomp(self, *, stor, rlsUnCtrl, rlsPrev=None, qIn=None, tsOffset=0):
        qCompLkUp = self.compQTblcompQTbl.get_val(stor)
        if self.rlsTyperlsTyperlsType == RuleMaxLkupTblElev.TOT_RLS:
            self.qCompCurqCompCurqCompCur = max(0., qCompLkUp - rlsUnCtrl)
        else:
            self.qCompCurqCompCurqCompCur = qCompLkUp
        return self.qCompCurqCompCurqCompCur
 
 
class RuleMinAnnSched(RuleComplianceBase):
    def __init__(self, name, time, monDayHr, minQsched, rlsType=RuleComplianceBase.CTRL_RLS, *,
                 typ='step', timeUnit=None, hydroCond=None):
         # Call super class constructor
        super().__init__(name, time, ruleType=RuleComplianceBase.MIN)
        # Class properties
        self.compQschedcompQsched = LkupTblAnn(name+'_sched',time, monDayHr, minQsched,
                                     typ=typ, timeUnit=timeUnit)
        self.hydroCondhydroCond = hydroCond
 
    def get_qcomp(self, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        curDT = self.T.get_datetime_offset(tsOffset)
        if self.hydroCondhydroCond is None:
            qCompSched = self.compQschedcompQsched.get_val(curDT)
        else:
            hc = self.hydroCondhydroCond.get_hydrologic_cond(tsOffset=tsOffset)
            qCompSched = self.compQschedcompQsched.get_val(curDT, self.hydroCondhydroCond.curCond)
        self.qCompCurqCompCurqCompCur = qCompSched
        return self.qCompCurqCompCurqCompCur
        
 
class RuleMaxAnnSched(RuleMinAnnSched):
    def __init__(self, name, time, monDayHr, maxQsched, rlsType=RuleComplianceBase.CTRL_RLS, *,
                 typ='step', timeUnit=None, hydroCond=None):
        # Call super class constructor
        super().__init__(name, time, monDayHr, maxQsched, rlsType=rlsType,
                         typ=typ, timeUnit=timeUnit, hydroCond=hydroCond)
        # Class properties
        self.ruleTyperuleTyperuleType=RuleComplianceBase.MAX
        self.compQschedcompQschedcompQsched = LkupTblAnn(name+'_sched',time, monDayHr, maxQsched,
                                     typ=typ, timeUnit=timeUnit)
        self.hydroCondhydroCondhydroCond = hydroCond
    
 
class RuleDiversionNetwork(RuleComplianceBase):
    def __init__(self, name, time, *,
                 ruleMax, jncDiversion, rlsType=RuleComplianceBase.CTRL_RLS):
        # Call super class constructor
        super().__init__(name, time, ruleType=RuleComplianceBase.MAX)
        self.ruleMaxDivruleMaxDiv = ruleMax
        self.jncDiversionjncDiversion = jncDiversion
        self.qInSpecifiedqInSpecified = QinSpecified(name+'_qInSpecified',time)
        self.qInSpecifiedqInSpecified.set_qin(tsOffset=0, qSpecified=0.)
        self.jncDiversionjncDiversion.append_qin(self.qInSpecifiedqInSpecified)
        
    def get_qcomp(self, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        qMaxDiv = self.ruleMaxDivruleMaxDiv.get_qcomp(rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn, tsOffset=tsOffset)
        qDemand = -self.jncDiversionjncDiversion.calc_delta(ruleType=self.ruleTyperuleType, tsOffset=tsOffset)
        self.qCompCurqCompCurqCompCur = min(qMaxDiv, qDemand)
        return self.qCompCurqCompCurqCompCur
    
    def calc_release(self, rlsProposed, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None):
        rlsProposed = super().calc_release(
            rlsProposed, rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn)
        qDiv = min(self.get_qcompget_qcompget_qcomp(rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn), rlsProposed)
        self.qInSpecifiedqInSpecified.set_qin(tsOffset=0, qSpecified=qDiv)
        return qDiv
 
 
class RuleDiversionNetwork_old(RuleComplianceBase):
    def __init__(self, name, time, *,
                 ruleMax, jncDiversion=None):
        # Call super class constructor
        super().__init__(name, time, ruleType=RuleComplianceBase.MAX)
        self.ruleMaxruleMax = ruleMax
        self.jncDiversionjncDiversion = jncDiversion
        
    def get_qcomp(self, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        # super().get_qcomp(rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn, tsOffset=tsOffset)
        self.qCompCurqCompCurqCompCur = self.ruleMaxruleMax.get_qcomp(tsOffset=tsOffset)
        return self.qCompCurqCompCurqCompCur
    
    def calc_release(self, rlsProposed, *, rlsPrev=None, rlsUnCtrl=None, stor=None, qIn=None):
        rlsProposed = super().calc_release(
            rlsProposed, rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn)
        # TODO: Since the downstream rule is a min rule this a temporary fix to max it a max rule
        # TODO: Also it seems that qComp it being called many times
        qDiv = self.ruleMaxruleMax.calc_release(rlsProposed,
                                          rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn)
        self.jncDiversionjncDiversion.set_qout(qOutSpecified=qDiv)
        return qDiv
 
 
class HydrologicCond:
    def __init__(self, name):
        self.namename = name
        # Set class properties
        self._curCond_curCond = np.nan
 
    @property
    def curCond(self):
        return self._curCond_curCond
 
    @curCond.setter
    def curCond(self, curHydroCond):
        self._curCond_curCond = curHydroCond
        
        
class RuleMaxLkupTbl(RuleComplianceBase):
    def __init__(self, name, time, xQinMax, yRls, *, typ='step'):
         # Call super class constructor
        super().__init__(name, time, ruleType=RuleComplianceBase.MAX)
        if typ=='interp':
            self.qInMaxTblqInMaxTbl = LkupTblInterp(name+'_QinMax', xQinMax, yRls)
        else:
            self.qInMaxTblqInMaxTbl = LkupTbl(name+'_QinMax', xQinMax, yRls)
 
    def get_qcomp(self, *, qIn, rlsPrev=None, rlsUnCtrl=None, stor=None, tsOffset=0):
        self.qCompCurqCompCurqCompCur = self.qInMaxTblqInMaxTbl.get_val(qIn)
        return self.qCompCurqCompCurqCompCur
 
 
# TODO: This should be an abstract class in it's own module with it's subclasses
class RuleRampRate(RuleComplianceBase):
    def __init__(self, name, time, rlsSched, rampSched, ruleType, timeUnit='h', nHrs=1):
         # Call super class constructor
        super().__init__(name, time, ruleType=ruleType, rlsType=RuleComplianceBase.CTRL_RLS)
        if timeUnit != time.timeUnit or nHrs != time.nHrs:
            if timeUnit == 'h': rampSched = rampSched*(time.nHrs/nHrs)
        # Create lookup table
        self.rampTblrampTbl = LkupTbl(name+'_RampSched',rlsSched, rampSched)
 
    # TODO: This should be moved to the RuleIncreaseRateChng subclass
    def get_qcomp(self, *, rlsPrev, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        self.qCompCurqCompCurqCompCur = rlsPrev + self.rampTblrampTbl.get_val(rlsPrev)
        return self.qCompCurqCompCurqCompCur
 
 
class RuleDecreaseRateChng(RuleRampRate):
    def __init__(self, name, time, rlsSched, drocSched, timeUnit='h', nHrs=1):
        # Call super class constructor
        super().__init__(name, time, rlsSched, drocSched, ruleType=RuleComplianceBase.MIN)
        # self.ruleType = RuleComplianceBase.MIN
        
    def get_qcomp(self, *, rlsPrev, rlsUnCtrl=None, stor=None, qIn=None, tsOffset=0):
        self.qCompCurqCompCurqCompCurqCompCur = rlsPrev - self.rampTblrampTbl.get_val(rlsPrev)
        return self.qCompCurqCompCurqCompCurqCompCur
 
 
class RuleIncreaseRateChng(RuleRampRate):
    def __init__(self, name, time, rlsSched, irocSched, timeUnit='h', nHrs=1):
        # Call super class constructor
        super().__init__(name, time, rlsSched, irocSched, ruleType=RuleComplianceBase.MAX)