Example #1
0
    def read_canal_data(self):

        #-------------------------------------------------------------------
        # Note:  Q_canals is same at upstream and downstream ends, but the
        #        downstream end lags the upstream end by the travel time
        #        from in_ID to out_ID.  As a result, the duration and Q
        #        vector for the downstream end are computed from those of
        #        the upstream end, and the travel time, td, as:
        #            Q_out   = [0,  Q_in]
        #            dur_out = [td, dur_in]
        #            dur_sum_out = [0, dur_sum_in] + td

        #        Rather than create the dur_sum_canals_out and
        #        Q_canals_out vectors, can construct them in Update_Canals.
        #-------------------------------------------------------------------
        if (self.comp_status == 'Disabled'): return
        if not (self.use_canals): return

        #---------------------------
        # Can canal_file be found ?
        #---------------------------
        f = glob.glob(self.canal_file)
        c = len(f)
        if (c == 0):
            msg = array(['ERROR: canal file not found. ', ' ', \
                         'The file: ', '  ' + self.canal_file, \
                         'was not found in the working directory. ', \
                         ' '])
            result = GUI_Message(msg, INFO=True)
            self.use_canals = False
            return

        #-----------------------------
        # Count lines in source_file
        #-----------------------------
        #Count_Lines, n_lines, canal_file, /SILENT
        #n_IDs = (n_lines / 6L)

        #------------------------------------
        # Read the lines with the nd values
        # and find the max, called nd_max
        #------------------------------------
        nd = np.int32(0)
        nd_max = np.int32(0)
        n_IDs = np.int32(0)  #******
        line1 = ''
        line2 = ''
        line3 = ''
        line5 = ''
        line6 = ''

        file_unit = open(self.canal_file, 'r')
        while not (idl_func.eof(file_unit)):
            line1 = idl_func.readf(file_unit, line1)
            line2 = idl_func.readf(file_unit, line2)
            line3 = idl_func.readf(file_unit, line3)
            nd = idl_func.readf(file_unit, nd)
            line5 = idl_func.readf(file_unit, line5)
            line6 = idl_func.readf(file_unit, line6)
            #-----------------------------------------
            nd_max = np.maximum(nd_max, nd)
            n_IDs = (n_IDs + np.int32(1))  #***
        file_unit.close()

        #--------------------
        # Initialize arrays
        #--------------------
        self.canal_in_IDs = np.zeros([n_IDs], dtype='Int32')
        self.canal_out_IDs = np.zeros([n_IDs], dtype='Int32')
        self.canal_t_vals = np.zeros([n_IDs], dtype='Int32')
        self.nd_vals = np.zeros([n_IDs], dtype='Int32')  #*****
        self.dur_canals = np.zeros([nd_max, n_IDs], dtype='Float32')
        self.Q_canals_in = np.zeros([nd_max, n_IDs], dtype='Float32')

        #--------------------
        # Open file to read
        #--------------------
        file_unit = open(self.canal_file, 'r')

        #----------------------
        # Read data from file
        #----------------------
        ID = np.int32(0)
        nd = np.int32(0)
        k = np.int32(0)
        tval = np.float32(0.0)
        while not (idl_func.eof(file_unit)):
            ID = idl_func.readf(file_unit, ID)
            self.canal_in_IDs[k] = ID
            #-----------------------------------
            ID = idl_func.readf(file_unit, ID)
            self.canal_out_IDs[k] = ID
            #--------------------------------------
            tval = idl_func.readf(file_unit, tval)
            self.canal_t_vals[k] = tval
            #-----------------------------------
            nd = idl_func.readf(file_unit, nd)
            self.nd_vals[k] = nd
            #-----------------------------------
            durs = np.zeros([nd], dtype='Float32')
            durs = idl_func.readf(file_unit, durs)
            self.dur_canals[np.int32(0):((nd - np.int32(1))) + 1, k] = durs
            #-----------------------------------
            Q = np.zeros([nd], dtype='Float32')
            Q = idl_func.readf(file_unit, Q)
            self.Q_canals_in[np.int32(0):((nd - np.int32(1))) + 1, k] = Q
            #-----------------------------------
            k = (k + np.int32(1))

        #-----------------------
        # Close the input file
        #-----------------------
        file_unit.close()

        #------------------------------------
        # Compute partial sums of durations
        #------------------------------------
        dur_sum_canals_in = np.zeros([nd_max + np.int32(1), n_IDs],
                                     dtype='Float32')
        for k in xrange(n_IDs):
            for i in xrange(nd_max):
                dur_sum_canals_in[i + 1,
                                  k] = dur_sum_canals_in[i, k] + dur_canals[i,
                                                                            k]
        dur_sum_canals_in = dur_sum_canals_in[1:(nd_max) +
                                              1, :]  #(remove leading 0)
        self.dur_sum_canals_in = dur_sum_canals_in
Example #2
0
    def read_canal_data(self):

        # -------------------------------------------------------------------
        # Note:  Q_canals is same at upstream and downstream ends, but the
        #        downstream end lags the upstream end by the travel time
        #        from in_ID to out_ID.  As a result, the duration and Q
        #        vector for the downstream end are computed from those of
        #        the upstream end, and the travel time, td, as:
        #            Q_out   = [0,  Q_in]
        #            dur_out = [td, dur_in]
        #            dur_sum_out = [0, dur_sum_in] + td

        #        Rather than create the dur_sum_canals_out and
        #        Q_canals_out vectors, can construct them in Update_Canals.
        # -------------------------------------------------------------------
        if self.comp_status == "Disabled":
            return
        if not (self.use_canals):
            return

        # ---------------------------
        # Can canal_file be found ?
        # ---------------------------
        f = glob.glob(self.canal_file)
        c = len(f)
        if c == 0:
            msg = array(
                [
                    "ERROR: canal file not found. ",
                    " ",
                    "The file: ",
                    "  " + self.canal_file,
                    "was not found in the working directory. ",
                    " ",
                ]
            )
            result = GUI_Message(msg, INFO=True)
            self.use_canals = False
            return

        # -----------------------------
        # Count lines in source_file
        # -----------------------------
        # Count_Lines, n_lines, canal_file, /SILENT
        # n_IDs = (n_lines / 6L)

        # ------------------------------------
        # Read the lines with the nd values
        # and find the max, called nd_max
        # ------------------------------------
        nd = np.int32(0)
        nd_max = np.int32(0)
        n_IDs = np.int32(0)  # ******
        line1 = ""
        line2 = ""
        line3 = ""
        line5 = ""
        line6 = ""

        file_unit = open(self.canal_file, "r")
        while not (idl_func.eof(file_unit)):
            line1 = idl_func.readf(file_unit, line1)
            line2 = idl_func.readf(file_unit, line2)
            line3 = idl_func.readf(file_unit, line3)
            nd = idl_func.readf(file_unit, nd)
            line5 = idl_func.readf(file_unit, line5)
            line6 = idl_func.readf(file_unit, line6)
            # -----------------------------------------
            nd_max = np.maximum(nd_max, nd)
            n_IDs = n_IDs + np.int32(1)  # ***
        file_unit.close()

        # --------------------
        # Initialize arrays
        # --------------------
        self.canal_in_IDs = np.zeros([n_IDs], dtype="Int32")
        self.canal_out_IDs = np.zeros([n_IDs], dtype="Int32")
        self.canal_t_vals = np.zeros([n_IDs], dtype="Int32")
        self.nd_vals = np.zeros([n_IDs], dtype="Int32")  # *****
        self.dur_canals = np.zeros([nd_max, n_IDs], dtype="Float32")
        self.Q_canals_in = np.zeros([nd_max, n_IDs], dtype="Float32")

        # --------------------
        # Open file to read
        # --------------------
        file_unit = open(self.canal_file, "r")

        # ----------------------
        # Read data from file
        # ----------------------
        ID = np.int32(0)
        nd = np.int32(0)
        k = np.int32(0)
        tval = np.float32(0.0)
        while not (idl_func.eof(file_unit)):
            ID = idl_func.readf(file_unit, ID)
            self.canal_in_IDs[k] = ID
            # -----------------------------------
            ID = idl_func.readf(file_unit, ID)
            self.canal_out_IDs[k] = ID
            # --------------------------------------
            tval = idl_func.readf(file_unit, tval)
            self.canal_t_vals[k] = tval
            # -----------------------------------
            nd = idl_func.readf(file_unit, nd)
            self.nd_vals[k] = nd
            # -----------------------------------
            durs = np.zeros([nd], dtype="Float32")
            durs = idl_func.readf(file_unit, durs)
            self.dur_canals[np.int32(0) : ((nd - np.int32(1))) + 1, k] = durs
            # -----------------------------------
            Q = np.zeros([nd], dtype="Float32")
            Q = idl_func.readf(file_unit, Q)
            self.Q_canals_in[np.int32(0) : ((nd - np.int32(1))) + 1, k] = Q
            # -----------------------------------
            k = k + np.int32(1)

        # -----------------------
        # Close the input file
        # -----------------------
        file_unit.close()

        # ------------------------------------
        # Compute partial sums of durations
        # ------------------------------------
        dur_sum_canals_in = np.zeros([nd_max + np.int32(1), n_IDs], dtype="Float32")
        for k in xrange(n_IDs):
            for i in xrange(nd_max):
                dur_sum_canals_in[i + 1, k] = dur_sum_canals_in[i, k] + dur_canals[i, k]
        dur_sum_canals_in = dur_sum_canals_in[1 : (nd_max) + 1, :]  # (remove leading 0)
        self.dur_sum_canals_in = dur_sum_canals_in
Example #3
0
    def read_sink_data(self):

        #----------------------------------------------------------------
        # Notes:  This assumes that sink_file is organized as follows:
        #            ID         (sink pixel ID as long integer)
        #            nd         (number of durations and Q values)
        #            durations  (vector of durations in minutes)
        #            Q_sinks    (vector of discharges in m^3/sec)
        #----------------------------------------------------------------
        if (self.comp_status == 'Disabled'): return
        if not (self.use_sinks): return

        #---------------------------
        # Can sink_file be found ?
        #---------------------------
        f = glob.glob(self.sink_file)
        c = len(f)
        if (c == 0):
            msg = array(['ERROR: sink file not found. ', ' ', \
                         'The file: ', '  ' + self.sink_file, \
                         'was not found in the working directory. ', \
                         ' '])
            result = GUI_Message(msg, INFO=True)
            self.use_sinks = False
            return

        #-----------------------------
        # Count lines in source_file
        #-----------------------------
        #Count_Lines, n_lines, self.sink_file, /SILENT
        #n_IDs = (n_lines / 4L)

        #------------------------------------
        # Read the lines with the nd values
        # and find the max, called nd_max
        #------------------------------------
        nd = np.int32(0)
        nd_max = np.int32(0)
        n_IDs = np.int32(0)  #******
        line1 = ''
        line3 = ''
        line4 = ''
        #---------------------------
        file_unit = open(self.sink_file, 'r')
        while not (idl_func.eof(file_unit)):
            line1 = idl_func.readf(file_unit, line1)
            nd = idl_func.readf(file_unit, nd)
            line3 = idl_func.readf(file_unit, line3)
            line4 = idl_func.readf(file_unit, line4)
            #-----------------------------------------
            nd_max = (np.maximum(nd_max, nd))
            n_IDs = (n_IDs + np.int32(1))  #***
        file_unit.close()

        #--------------------
        # Initialize arrays
        #--------------------
        self.sink_IDs = np.zeros([n_IDs], dtype='Int32')
        self.nd_vals = np.zeros([n_IDs], dtype='Int32')  #*****
        self.dur_sinks = np.zeros([nd_max, n_IDs], dtype='Float32')
        self.Q_sinks = np.zeros([nd_max, n_IDs], dtype='Float32')

        #--------------------
        # Open file to read
        #--------------------
        file_unit = open(self.sink_file, 'r')

        #----------------------
        # Read data from file
        #----------------------
        ID = np.int32(0)
        nd = np.int32(0)
        k = np.int32(0)
        while not (idl_func.eof(file_unit)):
            ID = idl_func.readf(file_unit, ID)
            self.sink_IDs[k] = ID
            #----------------------------------
            nd = idl_func.readf(file_unit, nd)
            self.nd_vals[k] = nd
            #----------------------------------
            durs = np.zeros([nd], dtype='Float32')
            durs = idl_func.readf(file_unit, durs)
            self.dur_sinks[np.int32(0):((nd - np.int32(1))) + 1, k] = durs
            #----------------------------------
            Q = zeros([nd], dtype='Float32')
            Q = idl_func.readf(file_unit, Q)
            self.Q_sinks[np.int32(0):((nd - np.int32(1))) + 1, k] = Q
            #----------------------------------
            k = (k + np.int32(1))

        #-----------------------
        # Close the input file
        #-----------------------
        file_unit.close()

        #------------------------------------
        # Compute partial sums of durations
        #------------------------------------
        dur_sum_sinks = zeros([nd_max + np.int32(1), n_IDs], dtype='Float32')
        for k in xrange(n_IDs):
            for i in xrange(nd_max):
                dur_sum_sinks[i + 1, k] = dur_sum_sinks[i, k] + dur_sinks[i, k]
        dur_sum_sinks = dur_sum_sinks[1:(nd_max) +
                                      1, :]  #(remove leading zero)
        self.dur_sum_sinks = dur_sum_sinks
Example #4
0
    def read_sink_data(self):

        # ----------------------------------------------------------------
        # Notes:  This assumes that sink_file is organized as follows:
        #            ID         (sink pixel ID as long integer)
        #            nd         (number of durations and Q values)
        #            durations  (vector of durations in minutes)
        #            Q_sinks    (vector of discharges in m^3/sec)
        # ----------------------------------------------------------------
        if self.comp_status == "Disabled":
            return
        if not (self.use_sinks):
            return

        # ---------------------------
        # Can sink_file be found ?
        # ---------------------------
        f = glob.glob(self.sink_file)
        c = len(f)
        if c == 0:
            msg = array(
                [
                    "ERROR: sink file not found. ",
                    " ",
                    "The file: ",
                    "  " + self.sink_file,
                    "was not found in the working directory. ",
                    " ",
                ]
            )
            result = GUI_Message(msg, INFO=True)
            self.use_sinks = False
            return

        # -----------------------------
        # Count lines in source_file
        # -----------------------------
        # Count_Lines, n_lines, self.sink_file, /SILENT
        # n_IDs = (n_lines / 4L)

        # ------------------------------------
        # Read the lines with the nd values
        # and find the max, called nd_max
        # ------------------------------------
        nd = np.int32(0)
        nd_max = np.int32(0)
        n_IDs = np.int32(0)  # ******
        line1 = ""
        line3 = ""
        line4 = ""
        # ---------------------------
        file_unit = open(self.sink_file, "r")
        while not (idl_func.eof(file_unit)):
            line1 = idl_func.readf(file_unit, line1)
            nd = idl_func.readf(file_unit, nd)
            line3 = idl_func.readf(file_unit, line3)
            line4 = idl_func.readf(file_unit, line4)
            # -----------------------------------------
            nd_max = np.maximum(nd_max, nd)
            n_IDs = n_IDs + np.int32(1)  # ***
        file_unit.close()

        # --------------------
        # Initialize arrays
        # --------------------
        self.sink_IDs = np.zeros([n_IDs], dtype="Int32")
        self.nd_vals = np.zeros([n_IDs], dtype="Int32")  # *****
        self.dur_sinks = np.zeros([nd_max, n_IDs], dtype="Float32")
        self.Q_sinks = np.zeros([nd_max, n_IDs], dtype="Float32")

        # --------------------
        # Open file to read
        # --------------------
        file_unit = open(self.sink_file, "r")

        # ----------------------
        # Read data from file
        # ----------------------
        ID = np.int32(0)
        nd = np.int32(0)
        k = np.int32(0)
        while not (idl_func.eof(file_unit)):
            ID = idl_func.readf(file_unit, ID)
            self.sink_IDs[k] = ID
            # ----------------------------------
            nd = idl_func.readf(file_unit, nd)
            self.nd_vals[k] = nd
            # ----------------------------------
            durs = np.zeros([nd], dtype="Float32")
            durs = idl_func.readf(file_unit, durs)
            self.dur_sinks[np.int32(0) : ((nd - np.int32(1))) + 1, k] = durs
            # ----------------------------------
            Q = zeros([nd], dtype="Float32")
            Q = idl_func.readf(file_unit, Q)
            self.Q_sinks[np.int32(0) : ((nd - np.int32(1))) + 1, k] = Q
            # ----------------------------------
            k = k + np.int32(1)

        # -----------------------
        # Close the input file
        # -----------------------
        file_unit.close()

        # ------------------------------------
        # Compute partial sums of durations
        # ------------------------------------
        dur_sum_sinks = zeros([nd_max + np.int32(1), n_IDs], dtype="Float32")
        for k in xrange(n_IDs):
            for i in xrange(nd_max):
                dur_sum_sinks[i + 1, k] = dur_sum_sinks[i, k] + dur_sinks[i, k]
        dur_sum_sinks = dur_sum_sinks[1 : (nd_max) + 1, :]  # (remove leading zero)
        self.dur_sum_sinks = dur_sum_sinks