rule_flood.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
"""
Created on Fri May  8 05:59:04 2020
 
@author: cd
"""
 
 
import abc
import numpy as np
from efo.rule import RuleBase
from efo.lookup import LkupTblAnn
from efo.time import TimeBase
 
# TODO: Need to figure out how to subclass the Rule super class or just use
# the Rule class for typing as just an abstract class that is not sub-classed
# just need to make sure all rules have a calc_release method
class RuleFloodBase(RuleBase):
    def __init__(self, name, time, constants):
        self.constantsconstants = constants
        super().__init__(name, time)
 
    @classmethod
    def __subclasshook__(cls,C):
        if cls is RuleFloodBase:
            attrs = set(dir(C))
            if set(cls.__abstractmethods__) <= attrs:
                return True
        return NotImplemented
        
        
class RuleFloodGuideCurve(RuleFloodBase):
    def __init__(self, name, time, constants, hypso, monDayHr, guideCurve, *,
                 typ='interp', timeUnit=None, isElev=True):
        # Call super class constructor
        super().__init__(name, time, constants)
        # Class properties
        if isElev is True:
            # Convert elev to storage
            guideCurve = np.interp(guideCurve, hypso.elev, hypso.stor)
        # Build lookup table
        self.set_guide_curveset_guide_curve(name, time, monDayHr, guideCurve,
                             typ=typ, timeUnit=timeUnit)
        self.tsGuideCurvetsGuideCurve = np.empty(self.T.nSteps)
 
    def set_guide_curve(self, name, time, monDayHr, guideCurve, *,
                        typ='interp', timeUnit=None):
        # TODO: If timeUnitOvrd == 'Y' then set the guide curve to a single value
        # TODO: Use error handling to check values passed
        self.guideCurveTblguideCurveTbl = LkupTblAnn(name+'_guideCurve', time, monDayHr, guideCurve,
                             typ=typ, timeUnit=timeUnit)
 
    def calc_release(self, rlsProposed, rlsUnCtrl, stor, rlsPrev=None, qIn=None):
        rlsProposed = super().calc_release(
            rlsProposed, rlsPrev=rlsPrev, rlsUnCtrl=rlsUnCtrl, stor=stor, qIn=qIn)
        # Initialize flood release to zero
        self.release[self.T.step] = 0.
        # Check if storage exceeds guide curve
        self.tsGuideCurvetsGuideCurve[self.T.step] = self.guideCurveTblguideCurveTbl.get_val(self.T.curDT)
        if stor > self.tsGuideCurvetsGuideCurve[self.T.step]:
            self.release[self.T.step] = (
                stor - self.tsGuideCurvetsGuideCurve[self.T.step])*self.constantsconstants.af2cfs
        return max(self.release[self.T.step], rlsProposed)