Esempio n. 1
0
 def __init__(self, d):
     self.custom_struct = d['custom_struct']
     d['dimensions'][3] = 1
     if d['custom_struct']:
         self.solver = SolveExpTh(d)
     else:
         self.solver = Solve(d)
     self.first_launch = True
     self.batch_size = d['samples']
     self.forecast_size = d['pred_steps']
     self.operator_view = OperatorViewWindow(warn=self.Y_C, fail=self.Y_D, callback=self,
                                             descriptions=[u'прибыль\ от\ перевозки,\ грн', u'запас\ хода,\ м',
                                                           u'Запасенная\ в\ АБ\ энергия,\ Дж'])
     self.current_iter = 1
     self.y_influenced = None
     self.data_window = None
     self.tablewidget = d['tablewidget']
     self.reason = np.array([],dtype = str) # init warning reason
     self.plotdata = dict()
     self.lbl = d['lbl']
Esempio n. 2
0
 def __init__(self, d):
     self.custom_struct = d['custom_struct']
     d['dimensions'][3] = 1
     if d['custom_struct']:
         self.solver = SolveExpTh(d)
     else:
         self.solver = Solve(d)
     self.first_launch = True
     self.batch_size = d['samples']
     self.forecast_size = d['pred_steps']
     self.operator_view = OperatorViewWindow(warn=self.Y_C, fail=self.Y_D, callback=self,
                                             descriptions=[u'прибыль\ от\ перевозки,\ грн', u'запас\ хода,\ м',
                                                           u'Запасенная\ в\ АБ\ энергия,\ Дж'])
     self.current_iter = 1
     self.y_influenced = None
     self.data_window = None
     self.tablewidget = d['tablewidget']
     self.reason = np.array([],dtype = str) # init warning reason
     self.plotdata = dict()
     self.lbl = d['lbl']
Esempio n. 3
0
class SolverManager(object):
    Y_C = np.array([[930], [1000], [5000000]])  # warning value
    Y_D = np.array([[0.0], [0.0], [0.0]])  # failure value

    def __init__(self, d):
        self.custom_struct = d['custom_struct']
        d['dimensions'][3] = 1
        if d['custom_struct']:
            self.solver = SolveExpTh(d)
        else:
            self.solver = Solve(d)
        self.first_launch = True
        self.batch_size = d['samples']
        self.forecast_size = d['pred_steps']
        self.operator_view = OperatorViewWindow(warn=self.Y_C, fail=self.Y_D, callback=self,
                                                descriptions=[u'прибыль\ от\ перевозки,\ грн', u'запас\ хода,\ м',
                                                              u'Запасенная\ в\ АБ\ энергия,\ Дж'])
        self.current_iter = 1
        self.y_influenced = None
        self.data_window = None
        self.tablewidget = d['tablewidget']
        self.reason = np.array([],dtype = str) # init warning reason
        self.plotdata = dict()
        self.lbl = d['lbl']

    def prepare(self, filename):
        self.time, self.data = read_data(filename)
        increment = self.time[-1] - self.time[-2]
        self.time = np.append(self.time, np.arange(1, 1 + self.forecast_size) * increment + self.time[-1])
        self.N_all_iter = len(self.time)
        self.plotdata['rdr'] = []
        self.operator_view.show()
        self.operator_view.status_bar.showMessage('Loaded successfully.', 1000)

    def start_machine(self):
        self.operator_view.start_process()

    def launch(self):
        if self.current_iter + self.batch_size <= len(self.data):
            self.fit(self.current_iter, self.batch_size)
            self.current_iter += 1
        else:
            self.operator_view.timer.stop()
            self.finalizer()

    def finalizer(self):
        plt.plot(self.time[self.batch_size:-self.forecast_size], self.plotdata['rdr'])

    def fit(self, shift, n):
        self.data_window = self.data[shift:shift + n]
        self.solver.load_data(self.data_window[:, :-2])  # y2 and y3 not used
        self.solver.prepare()
        self.predict()
        self.check_sensors_consistency()
        self.risk()  # really suspicious realisation
        self.y_influenced = [y * (1 - self.f) for y in self.y_forecasted]
        if self.first_launch:
            self.operator_view.initial_graphics_fill(real_values=self.data_window[:, -3:],
                                                     predicted_values=self.y_forecasted,
                                                     risk_values=self.y_influenced,
                                                     time_ticks=self.time[shift:shift + n + self.solver.pred_step])
            self.first_launch = False
        else:
            self.operator_view.update_graphics(self.data_window[-1, -3:], self.y_forecasted, self.y_influenced,
                                               self.time[shift + n - 1:shift + n + self.solver.pred_step])
        self.y_current = np.array([self.solver.Y_[-1,0], self.solver.X_[0][-1,3], self.solver.X_[1][-1,2]])
        self.rdr_calc()
        self.current_data()
        self.table_data_forecasted()

    def check_sensors_consistency(self):
        mask_positive = np.array([True, True, True, True, True, True, False,
                                  True, True, True, True, True, False,
                                  False, True, True, True, False])
        result_positive = (self.data_window[:, :-3] < 0).max(axis=0) * mask_positive
        if result_positive.any():
            self.operator_view.status_bar.showMessage('SensSensors {} have problems'.format(
                    str(np.where(result_positive)[0].tolist())), 1000)
        else:
            self.operator_view.status_bar.showMessage('OK',1000)



    def risk(self):
        self.p = prob(self.y_forecasted, self.Y_C, self.Y_D)
        self.f = 1 - (1 - self.p[0, :]) * (1 - self.p[1, :]) * (1 - self.p[2, :])
        #calculate reason warning situation
        self.reason = np.array([],dtype = str)
        for i in range(self.forecast_size):
            string = ''
            for j in range(3):
                if self.p[j, i] > 0:
                    string = string + reason[j]
            if string == '':
                self.reason = np.append(self.reason, '-')
            else:
                self.reason = np.append(self.reason, string)
        assert len(self.reason) == self.forecast_size

        self.danger_rate = np.array([classify_danger_rating(i) for i in self.f])

    def predict(self):
        self.y_forecasted = [self.solver.YF, self.solver.XF[0][3], self.solver.XF[1][2]]
        return

    def table_data_forecasted(self):
        t = self.time[self.batch_size + self.current_iter: self.batch_size + self.current_iter + self.solver.pred_step]
        y1 = self.y_forecasted[0]
        y2 = self.y_forecasted[1]
        y3 = self.y_forecasted[2]
        state = self.danger_rate[:, 1]
        risk = self.f
        reason =self.reason
        rate = self.danger_rate[:, 0]
        data = np.array([t, y1, y2, y3, state, risk, reason, rate]).T
        assert data.shape == (self.solver.pred_step, 8)
        for i ,j in enumerate(data):
            insert_data(self.tablewidget, i, j)
        return

    def current_data(self):
        lblText(self.lbl['time'], self.time[self.batch_size + self.current_iter -1])
        lblText(self.lbl['y1'], self.y_current[0])
        lblText(self.lbl['y2'], self.y_current[1])
        lblText(self.lbl['y3'], self.y_current[2])
        lblText(self.lbl['rmr'], self.rdr)


    def rdr_calc(self):
        self.rdr = np.inf
        rdr = np.inf
        for i in range(3):
            if self.y_current[i] <= self.Y_C[i,0]:
                rdr = 0
                continue
            s = ( self.y_current[i] - self.Y_C[i,0] ) - calculate_rdr_delta(self.y_influenced[i])
            if s <= 0:
                rdr = 0
                continue
            t =(self.y_current[i] - self.Y_C[i,0])/ calculate_rdr_delta(self.y_influenced[i]) * 16
            if t < rdr:
            if t < rdr:
                rdr = t
            if rdr<0:
                rdr = 0
        if rdr != np.inf:
            self.rdr = rdr
        self.plotdata['rdr'].append(self.rdr)
Esempio n. 4
0
class SolverManager(object):
    Y_C = np.array([[930], [1000], [5000000]])  # warning value
    Y_D = np.array([[0.0], [0.0], [0.0]])  # failure value

    def __init__(self, d):
        self.custom_struct = d['custom_struct']
        d['dimensions'][3] = 1
        if d['custom_struct']:
            self.solver = SolveExpTh(d)
        else:
            self.solver = Solve(d)
        self.first_launch = True
        self.batch_size = d['samples']
        self.forecast_size = d['pred_steps']
        self.operator_view = OperatorViewWindow(warn=self.Y_C, fail=self.Y_D, callback=self,
                                                descriptions=[u'прибыль\ от\ перевозки,\ грн', u'запас\ хода,\ м',
                                                              u'Запасенная\ в\ АБ\ энергия,\ Дж'])
        self.current_iter = 1
        self.y_influenced = None
        self.data_window = None
        self.tablewidget = d['tablewidget']
        self.reason = np.array([],dtype = str) # init warning reason
        self.plotdata = dict()
        self.lbl = d['lbl']

    def prepare(self, filename):
        self.time, self.data = read_data(filename)
        increment = self.time[-1] - self.time[-2]
        self.time = np.append(self.time, np.arange(1, 1 + self.forecast_size) * increment + self.time[-1])
        self.N_all_iter = len(self.time)
        self.plotdata['rdr'] = []
        self.operator_view.show()
        self.operator_view.status_bar.showMessage('Loaded successfully.', 1000)

    def start_machine(self):
        self.operator_view.start_process()

    def launch(self):
        if self.current_iter + self.batch_size <= len(self.data):
            self.fit(self.current_iter, self.batch_size)
            self.current_iter += 1
        else:
            self.operator_view.timer.stop()
            self.finalizer()

    def finalizer(self):
        plt.plot(self.time[self.batch_size:-self.forecast_size], self.plotdata['rdr'])

    def fit(self, shift, n):
        self.data_window = self.data[shift:shift + n]
        self.solver.load_data(self.data_window[:, :-2])  # y2 and y3 not used
        self.solver.prepare()
        self.predict()
        self.check_sensors_consistency()
        self.risk()  # really suspicious realisation
        self.y_influenced = [y * (1 - self.f) for y in self.y_forecasted]
        if self.first_launch:
            self.operator_view.initial_graphics_fill(real_values=self.data_window[:, -3:],
                                                     predicted_values=self.y_forecasted,
                                                     risk_values=self.y_influenced,
                                                     time_ticks=self.time[shift:shift + n + self.solver.pred_step])
            self.first_launch = False
        else:
            self.operator_view.update_graphics(self.data_window[-1, -3:], self.y_forecasted, self.y_influenced,
                                               self.time[shift + n - 1:shift + n + self.solver.pred_step])
        self.y_current = np.array([self.solver.Y_[-1,0], self.solver.X_[0][-1,3], self.solver.X_[1][-1,2]])
        self.rdr_calc()
        self.current_data()
        self.table_data_forecasted()

    def check_sensors_consistency(self):
        mask_positive = np.array([True, True, True, True, True, True, False,
                                  True, True, True, True, True, False,
                                  False, True, True, True, False])
        result_positive = (self.data_window[:, :-3] < 0).max(axis=0) * mask_positive
        if result_positive.any():
            self.operator_view.status_bar.showMessage('Sensors {} have problems'.format(
                    str(np.where(result_positive)[0].tolist())), 1000)
        else:
            self.operator_view.status_bar.showMessage('OK',1000)



    def risk(self):
        self.p = prob(self.y_forecasted, self.Y_C, self.Y_D)
        self.f = 1 - (1 - self.p[0, :]) * (1 - self.p[1, :]) * (1 - self.p[2, :])
        #calculate reason warning situation
        self.reason = np.array([],dtype = str)
        for i in range(self.forecast_size):
            string = ''
            for j in range(3):
                if self.p[j, i] > 0:
                    string = string + reason[j]
            if string == '':
                self.reason = np.append(self.reason, '-')
            else:
                self.reason = np.append(self.reason, string)
        assert len(self.reason) == self.forecast_size

        self.danger_rate = np.array([classify_danger_rating(i) for i in self.f])

    def predict(self):
        self.y_forecasted = [self.solver.YF, self.solver.XF[0][3], self.solver.XF[1][2]]
        return

    def table_data_forecasted(self):
        t = self.time[self.batch_size + self.current_iter: self.batch_size + self.current_iter + self.solver.pred_step]
        y1 = self.y_forecasted[0]
        y2 = self.y_forecasted[1]
        y3 = self.y_forecasted[2]
        state = self.danger_rate[:, 1]
        risk = self.f
        reason =self.reason
        rate = self.danger_rate[:, 0]
        data = np.array([t, y1, y2, y3, state, risk, reason, rate]).T
        assert data.shape == (self.solver.pred_step, 8)
        for i ,j in enumerate(data):
            insert_data(self.tablewidget, i, j)
        return

    def current_data(self):
        lblText(self.lbl['time'], self.time[self.batch_size + self.current_iter -1])
        lblText(self.lbl['y1'], self.y_current[0])
        lblText(self.lbl['y2'], self.y_current[1])
        lblText(self.lbl['y3'], self.y_current[2])
        lblText(self.lbl['rmr'], self.rdr)


    def rdr_calc(self):
        self.rdr = np.inf
        rdr = np.inf
        for i in range(3):
            if self.y_current[i] <= self.Y_C[i,0]:
                rdr = 0
                continue
            s = calculate_rdr_delta(self.y_current[i], self.y_influenced[i], self.Y_C[i,0])
            if s <= 0 or s == np.inf:
                continue
            t =(self.y_current[i] - self.Y_C[i,0])/s
            if t < rdr:
                rdr = t
        if rdr != np.inf:
            self.rdr = rdr
        self.plotdata['rdr'].append(self.rdr)