reach.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
"""
Created on Sat May  9 23:06:00 2020
 
@author: cd
"""
 
import abc
import numpy as np
from efo.time import TimeBase
 
 
class ReachBase(metaclass=abc.ABCMeta):
    # TODO: May not need constants
    def __init__(self, name, time, junctionUs):
        self.namename = name
        # TODO: Should use error handling instead
        self.junctionUsjunctionUs = junctionUs
        if issubclass(type(time), TimeBase):
            self.TT = time
            self.qOutqOut = np.empty(time.nSteps)
        super().__init__()
 
    @abc.abstractmethod
    def calc_qout(self):
        pass
 
    @classmethod
    def __subclasshook__(cls, C):
        if cls is ReachBase:
            attrs = set(dir(C))
            if set(cls.__abstractmethods__) <= attrs:
                return True
        return NotImplemented
 
 
class ReachConstLag(ReachBase):
    def __init__(self, name, time, junctionUs, lagTime):
        # Call super class constructor
        # TODO: Error check to make sure that all are Junctions
        super().__init__(name, time, junctionUs)
        self.lagTimelagTime = lagTime
 
    def calc_qout(self, *, tsOffset=0):
        # qOut = self.junctionUs.qOut[
        #     min(self.T.nSteps-1, max(0, self.T.step - self.lagTime + tsOffset))]
        qOut = self.junctionUsjunctionUs.get_qout(tsOffset = tsOffset - self.lagTimelagTime)
        self.qOutqOut[min(self.TT.end, self.TT.step + tsOffset)] = qOut
        return qOut
    
 
# TODO: This needs to be completed for downstream control
# class ReachLagK(ReachBase):
#     def __init__(self, name, time, junctionUs, lag, K):
#         # Call super class constructor
#         # TODO: Error check to make sure that all are Junctions
#         super().__init__(name, time, junctionUs)
#         self.lag = lag
#         self.K = K
        
#     def set_init_cond(self, qOutPrev, qInLagPrev):
#         self.qOutPrev = qOutPrev
#         self.qInLagPrev = qInLagPrev
        
#     def get_lagged_qin(self, nDateCur, qInLagCur):
#         qLag = 0.;
#         for i in range(qInLagCurv.shape[0])-1:
#             if (qInLagCurv[i,1] - nDateCur < 0 & qInLagCurv[i+1,1] - nDateCur > 0) or \
#                 (qInLagCurv[i,1] - nDateCur > 0 & qInLagCurv[i+1,1] - nDateCur < 0):
#                 qLag = qLag + qInLagCurv[i,2] + \
#                     (qInLagCurv[i+1,2]-qInLagCurv[i,2])/(qInLagCurv[i+1,1]-qInLagCurv[i,1])*\
#                     (nDateCur-qInLagCurv[i,1])
#             elif qInLagCurv[i,1] == nDateCur:
#                 qLag = qLag + qInLagCurv[i,2]
#         if qLag == 0.:
#             qLag = qInLagCurv[1,2]
#         elif qLag < 0.:
#             rowCurLag = find(qInLagCurv[:,1] <= nDateCur,1,'last')
#             qLag = qInLagCurv(rowCurLag,2)
 
#     def calc_qout(self, *, tsOffset=0):
#         qIn = self.junctionUs.get_qout(tsOffset = tsOffset)
#         lag = interp1(self.lagK.(lagKName)[:,1], self.lagK.(lagKName)[:,2], qIn,'linear')/24
#         if np.isnan(lag):
#             rowLagTbl = find(self.lagK.(lagKName)[:,1] <= qIn,1,'last')
#             lag = self.lagK.(lagKName)[rowLagTbl,2]/24
#         nDateCur = datenum(vToday)
#         tsLag = nDateCur + lag
#         qInLagCur = [self.qInLagPrev{3,junctionNum}; [tsLag qIn]]
#         qInLag1 = self.get_lagged_qin(nDateCur-self.constants.dT,qInLagCur)
#         qInLag2 = self.get_lagged_qin(nDateCur,qInLagCur)
#         K1 = interp1(self.lagK.(lagKName)[:,1],self.lagK.(lagKName)[:,3],qInLag1,'pchip')
#         K2 = interp1(self.lagK.(lagKName)[:,1],self.lagK.(lagKName)[:,3],qInLag2,'pchip')
#         K = mean([K1;K2])
#         if np.isnan(K):
#             rowLagTbl = find(self.lagK.(lagKName)[:,1] <= qIn,1,'last')
#             K = self.lagK.(lagKName)[rowLagTbl,3]
#             if K < 0.01:
#                 qOut = qIn
#             else:
#                 try
#                     qOut = (qInLag1 + qInLag2)*(1/(2*K+1)) + \
#                         ((2*K-1)/(2*K+1))*self.qOutPrev(ts,junctionNum)
#                 catch
#                     ts
#                 if qOut < 0.:
#                     qOut = mean([qInLag1;qInLag2])
#         self.qOutPrev(ts+1,junctionNum) = qOut
#         iGrtrCurTs =  \
#             qInLagCur(:,1) >= nDateCur-self.constants.dT
#         self.qInLagPrev{1,junctionNum} = self.qInLagPrev{2,junctionNum}
#         self.qInLagPrev{2,junctionNum} = self.qInLagPrev{3,junctionNum}
#         self.qInLagPrev{3,junctionNum} = qInLagCur(iGrtrCurTs,:)
#         return qOut