network.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
"""
Created on Tue May 19 07:25:09 2020
 
@author: cd
"""
 
 
import abc
import numpy as np
from efo.time import TimeBase, TimeFcst
from efo.junction import ReservoirJunction
import concurrent.futures
 
 
class NetworkBase(metaclass=abc.ABCMeta):
    # TODO: May not need constants
    def __init__(self, name, time, junctions):
        self.namename = name
        self.junctionsjunctions = junctions
        self.nJunctionsnJunctions = len(junctions)
        # self.compQvals = compQvals
        # TODO: Should use error handling instead
        if issubclass(type(time), TimeBase):
            self.TT = time
        super().__init__()
 
    # TODO: May want to override the iterate function for this
    # TODO: This could be lambda expression so it could be multi-purpose
    @abc.abstractmethod
    def process_junctions(self):
        pass
 
    @classmethod
    def __subclasshook__(cls, C):
        if cls is NetworkBase:
            attrs = set(dir(C))
            if set(cls.__abstractmethods__) <= attrs:
                return True
        return NotImplemented
    
    
class Network(NetworkBase):
    def __init__(self, name, time, junctions):
        # Call super class constructor
        super().__init__(name, time, junctions)
 
    def process_junctions(self):
        qOutReturn = np.empty(self.nJunctionsnJunctions)
        storReturn = np.empty(self.nJunctionsnJunctions)
        storReturn[:] = np.nan
        for i, curJnc in enumerate(self.junctionsjunctions):
            qOutReturn[i] = curJnc.calc_qout()
            if issubclass(type(curJnc), ReservoirJunction):
                storReturn[i] = curJnc.stor[self.TT.step]
        # return (qOutReturn, storReturn)
 
 
# This provides a link between your network and your forecast network
class NetworkFcst(Network):
    def __init__(self, name, timeFcst, junctions, fcstJunctions):
        # Call super class constructor
        # TODO: Need to make sure that time is type timeFcst
        # TODO: fcstJunctions and junctions should be a linked list
        super().__init__(name, timeFcst, junctions)
        # Sub class properties
        # TODO: This is temporary until we can create a build method
        # self.fcstJunctions = fcstJunctions
        self.fcstNetworkfcstNetwork = Network('fcstNework', timeFcst, fcstJunctions)
        # TODO: Would be good to use some sort of mapping object to link junctions
        # TODO: Seems like python linked lists might be good for this
        
    def build_fcst_junctions(self):
        # TODO: This will build forecast juctions from regular juctions using shallow (maybe deep) copy methods
        # TODO: Will have to redefine qIn objects with the passed forecasted flows
        # TODO: Will have have to also shallow copy reaches
        # TODO: Might be able to deep copy and then redefine everything with setter methods
        pass
    
    def set_init_cond(self):
        # TODO: To start just going to initialize qOut to zero
        # TODO: Junctions should have some sort of setter method for this
        for i in range(len(self.fcstNetwork.junctions)):
            self.fcstNetwork.junctions[i].qOut[0] = self.junctions[i].qOut[max(0, self.T.Tcont.step-1)]
            # if issubclass(type(curJnc), ReservoirJunction):
            if issubclass(type(self.fcstNetwork.junctions[i]), ReservoirJunction):
                self.fcstNetwork.junctions[i].stor[0] = \
                    self.junctions[i].stor[max(0, self.T.Tcont.step-1)]
                self.fcstNetwork.junctions[i].rlsCtrl[0] = \
                    self.junctions[i].rlsCtrl[max(0, self.T.Tcont.step-1)]
                if self.fcstNetwork.junctions[i].outletUnCtrl:
                    self.fcstNetwork.junctions[i].rlsUnCtrl[0] = \
                        self.junctions[i].rlsUnCtrl[max(0, self.T.Tcont.step-1)]
 
    def process_fcst_junctions(self):
        self.fcstNetworkfcstNetwork.process_junctions()
        # with concurrent.futures.ProcessPoolExecutor() as executor:
        #     # for i, curPrime in enumerate(executor.map(self.task.is_prime, self.primes)):
        #     #     isPrime[i]=curPrime
        #     #     print('%d is prime: %s' % (PRIMES[i], isPrime[i]))
        #     executor.map
        
    def get_storage(self):
        pass
        
        
# TODO: Not sure we need an EFO of networks
# TODO: Efo network will keep track of the efo res and other junctions
# This provides a link between your network and your forecast network           
# class NetworkEfo(NetworkBase):
#     def __init__(self, name, timeFcst, junctions, fcstNetworks):
#         # Call super class constructor
#         super().__init__(name, name, timeFcst, junctions)
#         # Sub class properties
#         # TODO: This is temporary until we can create a build method
#         self.fcstNetworks = fcstNetworks
        
#     def build_fcst_networks(self):
#         # TODO: This should build an ensemble of forecst networks with passed hindcasts and junctions
#         # TODO: For reservoirs this would have to assume not uncontrolled spillway
#         # TODO: Since your forecast reservoirs and your simulation reservoir assumptiong
#         # may be different you may not be able to use a generalized function like this