Commit ba23dd94 authored by Mohit's avatar Mohit
Browse files

Modified files using composition.

parent 1168075b

parse/ActiveStandby.py

0 → 100644
+92 −0
Original line number Diff line number Diff line 
import sys

import math

import numpy as np

import matplotlib.pyplot as plt

from Plot import Plot





class ActiveStandby():



    def __init__(self, parameters):



        # Parameters

        self.alpha = []

        self.N = []

        self.M_RA = []

        self.M = 0.0

        self.T_E = 0.0

        self.T_a = 0.0

        self.T_i_d_r = 0.0

        self.T_f = 0.0

        self.alpha_Length = 0

        self.N_Length = 0

        self.M_RA_Length = 0



        self.T = []

        self.R = []

        self.A = []



        self.store_param(parameters)

        self.calculate_performance()

        self.calculate_reliability()

        self.calculate_availability()



    # Store data in parameters

    def store_param(self, parameters):



        if not set(["alpha", "N", "M", "T_E", "T_a", "T_i_d_r", "M", "T_f", "M_RA"]).issubset(parameters):

            sys.exit("Active/Standby parameters missing. Check XML file!!!")



        self.alpha = list(np.float_(parameters["alpha"].split()))

        self.N = list(np.float_(parameters["N"].split()))

        self.M_RA = list(np.float_(parameters["M_RA"].split()))

        self.M = float(parameters["M"])

        self.T_E = float(parameters["T_E"])

        self.T_a = float(parameters["T_a"])

        self.T_i_d_r = float(parameters["T_i_d_r"])

        self.T_f = float(parameters["T_f"])

        self.alpha_Length = len(parameters["alpha"].split())

        self.N_Length = len(parameters["N"].split())

        self.M_RA_Length = len(parameters["M_RA"].split())



    # Calculate and plot Active/Standby  performance

    def calculate_performance(self):



        for i in range(self.alpha_Length):

            T_values = []

            for j in range(self.N_Length):

                T_val = self.alpha[i]*self.T_E+(1-self.alpha[i])*self.N[j] * \

                    self.T_E+self.T_a+self.T_i_d_r+self.T_E/self.M*(self.T_f)

                T_values.append(T_val)

            self.T.append(T_values)



    # Calculate and plot Active/Standby reliability

    def calculate_reliability(self):



        for i in range(self.M_RA_Length):

            R_values = []

            for j in range(self.N_Length):

                R_val = 1-(1-math.exp(-self.T[i][0]/self.M_RA[i]))**self.N[j]

                R_values.append(R_val)

            self.R.append(R_values)



    # Calculate and plot Active/Standby availability

    def calculate_availability(self):



        for i in range(self.M_RA_Length):

            A_values = []

            for j in range(self.N_Length):

                A_val = 1-(1-self.M_RA[i]/(self.M_RA[i] +

                                           self.T_E/self.M*(self.T_f)))**self.N[j]

                A_values.append(A_val)

            self.A.append(A_values)



    # Plot performance, reliability, and availability

    def plot_all(self):



        Plot("α", "Hours", "Active Standby Performance",

                  self.alpha, self.T, "activeStandby")

        Plot("MTTF", "", "Active Standby Reliability",

             self.M_RA, self.R, "activeStandby")

        Plot("MTTF", "", "Active Standby Availability",

             self.M_RA, self.A, "activeStandby")

parse/Extract.py

0 → 100644
+16 −0
Original line number Diff line number Diff line 
import xml.etree.ElementTree as ET





class Extract():



    def __init__(self, root, rdp):



        # Pattern parameters

        self.parameters = {}

        self.extract_param(root, rdp)



    # Extract parameters

    def extract_param(self, root, rdp):



        for tag in root.findall(".//*[@name="+rdp+"]/"):

            self.parameters[tag.tag] = tag.text

parse/Extract.pyc

0 → 100644
+898 B

File added.

No diff preview for this file type.

View file

parse/FECC.py

0 → 100644
+76 −0
Original line number Diff line number Diff line 
import sys

import math

import numpy as np

import matplotlib.pyplot as plt

from Plot import Plot





class FECC():



    def __init__(self, parameters):



        # Parameters

        self.M = []

        self.T_E = 0.0

        self.T_a = 0.0

        self.T_en_d = 0.0

        self.T_c = 0.0

        self.M_Length = 0

        self.M_U = 0.0



        self.T = []

        self.R = []

        self.A = []



        self.store_param(parameters)

        self.calculate_performance()

        self.calculate_reliability()

        self.calculate_availability()



    # Store data in parameters



    def store_param(self, parameters):



        if not set(["T_E", "T_a", "T_en_d", "M", "T_c", "M_U"]).issubset(parameters):

            sys.exit(

                "Forward Error Correction Code parameters missing. Check XML file!!!")



        self.M = list(np.float_(parameters["M"].split()))

        self.T_E = float(parameters["T_E"])

        self.T_a = float(parameters["T_a"])

        self.T_en_d = float(parameters["T_en_d"])

        self.T_c = float(parameters["T_c"])

        self.M_U = float(parameters["M_U"])

        self.M_Length = len(parameters["M"].split())



    # Calculate and plot Forward Error Correction Code performance

    def calculate_performance(self):



        for i in range(self.M_Length):

            T_val = self.T_E+self.T_a + self.T_en_d + \

                self.T_E/self.M[i]*(self.T_c)

            self.T.append(T_val)



    # Calculate and plot Forward Error Correction Code reliability

    def calculate_reliability(self):



        for i in range(self.M_Length):

            R_val = math.exp(-self.T[i]/self.M_U)

            self.R.append(R_val)



    # Calculate and plot Forward Error Correction Code availability

    def calculate_availability(self):



        for i in range(self.M_Length):

            A_val = self.T_E/self.T[i]

            self.A.append(A_val)



    # Plot performance, reliability, and availability

    def plot_all(self):



        Plot("MTTF", "Hours",

             "Forward Error Correction Code Performance", self.M, self.T, "fecc")

        Plot(

            "MTTF", "", "Forward Error Correction Code Reliability", self.M, self.R, "fecc")

        Plot(

            "MTTF", "", "Forward Error Correction Code Availability", self.M, self.A, "fecc")

parse/Monitoring.py

0 → 100644
+69 −0
Original line number Diff line number Diff line 
import sys

import math

import numpy as np

import matplotlib.pyplot as plt

from Plot import Plot





class Monitoring():



    def __init__(self, parameters):



        # Parameters

        self.M = []

        self.T_E = 0.0

        self.T_m = 0.0

        self.T_a = 0.0

        self.T_n = 0.0

        self.M_Length = 0



        self.T = []

        self.R = []

        self.A = []



        self.store_param(parameters)

        self.calculate_performance()

        self.calculate_reliability()

        self.calculate_availability()



    # Store data in parameters

    def store_param(self, parameters):



        if not set(["T_E", "T_m", "T_a", "T_n", "M"]).issubset(parameters):

            sys.exit("Monitoring parameters missing. Check XML file!!!")



        self.M = list(np.float_(parameters["M"].split()))

        self.T_E = float(parameters["T_E"])

        self.T_m = float(parameters["T_m"])

        self.T_a = float(parameters["T_a"])

        self.T_n = float(parameters["T_n"])

        self.M_Length = len(parameters["M"].split())



    # Calculate and plot monitoring performance

    def calculate_performance(self):



        for i in range(self.M_Length):

            T_val = self.T_E+self.T_m+self.T_E/self.M[i]*(self.T_a+self.T_n)

            self.T.append(T_val)



    # Calculate and plot monitoring reliability

    def calculate_reliability(self):



        for i in range(self.M_Length):

            R_val = math.exp(-self.T[i]/self.M[i])

            self.R.append(R_val)



    # Calculate and plot monitoring availability

    def calculate_availability(self):



        for i in range(self.M_Length):

            A_val = self.T_E/self.T[i]

            self.A.append(A_val)



    # Plot performance, reliability, and availability

    def plot_all(self):



        Plot("MTTF", "Hours", "Monitoring Performance",

             self.M, self.T, "monitoring")

        Plot("MTTF", "", "Monitoring Reliability", self.M, self.R, "monitoring")

        Plot("MTTF", "", "Monitoring Availability", self.M, self.A, "monitoring")