rule_downstream.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
"""
Created on Sat May  9 21:21:36 2020
 
@author: cd
"""
 
import abc
import numpy as np
from efo.rule import RuleBase
from efo.time import TimeBase
from efo.junction import JunctionRegulated
from efo.qin import QinRouted
from efo.rule_compliance import RuleComplianceBase
 
 
class RuleDwnstrmBase(RuleComplianceBase):
    def __init__(self, name, time, junctions):
        self.junctionsjunctions = junctions
        super().__init__(name, time)
 
    @classmethod
    def __subclasshook__(cls, C):
        if cls is RuleDwnstrmBase:
            attrs = set(dir(C))
            if set(cls.__abstractmethods__) <= attrs:
                return True
        return NotImplemented
 
 
class RuleDwnStrmConstLag(RuleDwnstrmBase):
    # TODO: This class does not need constants so maybe not in RuleMinBase
    def __init__(self, name, time, junctions,*, ruleType=RuleComplianceBase.MAX):
        # Call super class constructor
        # TODO: Error check to make sure that all are Junctions
        super().__init__(name, time, junctions)
        # Set class variable
        self.ruleTyperuleType = ruleType
        # Calc the max lag time for the junctions
        self.maxLagmaxLag = 0
        for curJnc in self.junctionsjunctions[1:]:
            for curQin in curJnc.qIn:
                if isinstance(curQin, QinRouted):
                    self.maxLagmaxLag += curQin.reachUs.lagTime
                    
    # TODO: May not need rlsProposed here if we are just always evaluating zero release
    def _calc_delta(self, rlsProposed):
        qDelta = np.empty([self.maxLagmaxLag+1, len(self.junctionsjunctions[1:])])
        for i in range(0, self.maxLagmaxLag+1):
            self.junctionsjunctions[0].set_qout(qOutSpecified=rlsProposed, tsOffset=i)
            for j, curJnc in enumerate(self.junctionsjunctions[1:]):
                if isinstance(curJnc, JunctionRegulated):
                    qDelta[i, j] = curJnc.calc_delta(ruleType=self.ruleTyperuleType, tsOffset=i)
                else:
                    qDelta[i, j] = np.nan
                    curJnc.calc_qout()
        # TODO: Would be cool to track which junction is setting release
        return qDelta
        
    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)
        qDelta = self._calc_delta_calc_delta(rlsProposed=0.) if self.ruleTyperuleType==RuleComplianceBase.MIN\
            else -self._calc_delta_calc_delta(rlsProposed=0.)
        maxDelta = np.nanmax(qDelta[:])
        self.qCompCurqCompCur = max(0., maxDelta)
        return self.qCompCurqCompCur
 
    # 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_qcomp()
    #     return min(rlsProposed, qComp) if self.ruleType==RuleComplianceBase.MAX else max(rlsProposed, qComp)