예제 #1
0
    def get_damage_slope2(self, idx, curve, int_press, ext_press):
        m2, log_m2, k, slope = snc.get_paramter(curve,'m2'), snc.get_paramter(curve,'log a2'),\
                               snc.get_paramter(curve,'k'), snc.get_paramter(curve,'slope')
        cycles = self._design_life*365*24*3600/self._period[idx]
        thk_eff = math.log10(max(1,self.plate_th/25)) * k
        slope_ch = math.exp( math.log( math.pow(10, log_m2-m2*thk_eff)/slope) / m2)
        gammm2 = self.__get_gamma2(idx)
        weibull = self._weibull[idx]
        stress_frac = self.__get_stress_fraction(idx, int_press, ext_press)

        # finding GAMMADIST
        if stress_frac == 0:
            return 0
        x, alpha = math.pow(slope_ch/stress_frac, weibull),1 + m2/weibull
        gamma_val = gammadist.cdf(x,alpha)

        return cycles / math.pow(10, log_m2-m2*thk_eff) * math.pow(stress_frac, m2)*gammm2*(gamma_val)\
               *self._fraction[idx]
예제 #2
0
    def get_damage_slope1(self, idx, curve, int_press=0, ext_press=0):
        m1, log_a1, k, slope = snc.get_paramter(curve,'m1'), snc.get_paramter(curve,'log a1'),\
                               snc.get_paramter(curve,'k'), snc.get_paramter(curve,'slope')
        cycles = self._design_life*365*24*3600/self._period[idx]
        thk_eff = math.log10(max(1,self.plate_th/0.025)) * k
        slope_ch = math.exp( math.log( math.pow(10, log_a1-m1*thk_eff)/slope) / m1)
        gamma1 = self.__get_gamma1(idx)
        weibull = self._weibull[idx]
        stress_frac = self.__get_stress_fraction(idx, int_press, ext_press)
        # print('Internal pressure: ', int_press)
        # print('External pressure: ', ext_press)
        # finding GAMMADIST
        if stress_frac == 0:
            return 0

        x, alpha = math.pow(slope_ch/stress_frac, weibull),1 + m1/weibull
        gamma_val = gammadist.cdf(x,alpha)

        return cycles / math.pow(10, log_a1-m1*thk_eff) * math.pow(stress_frac, m1)*gamma1*(1-gamma_val)\
               *self._fraction[idx]
예제 #3
0
    def __init__(self, master, app=None):
        super(CreateFatigueWindow, self).__init__()
        if __name__ == '__main__':
            self._initial_structure_obj = test.get_structure_object()
            self.load_objects = [
                test.get_loa_fls_load(),
                test.get_loa_uls_load(),
                test.get_bal_fls_load(),
                test.get_bal_uls_load()
            ]
            self.active_line = 'line1'
            points = test.line_dict['line1']
            coords = (test.point_dict['point' + str(points[0])],
                      test.point_dict['point' + str(points[1])])
            self.pressure_coords = self.get_pressure_point_coord_from_two_points(
                coords[0], coords[1])
            self.comp_objects = [test.get_tank_object()]
            self._initial_fatigue_obj = test.get_fatigue_object()

        else:
            self.app = app
            self.active_line = app._active_line
            points = app._line_dict[self.active_line]
            coords = (app._point_dict['point' + str(points[0])],
                      app._point_dict['point' + str(points[1])])
            self.pressure_coords = self.get_pressure_point_coord_from_two_points(
                coords[0], coords[1])
            self._initial_structure_obj = app._line_to_struc[
                app._active_line][0]
            self.load_objects = app._line_to_struc[app._active_line][3]
            self.comp_objects = [
                app._tank_dict['comp' + str(comp_i)]
                for comp_i in app.get_compartments_for_line(app._active_line)
            ]
            self._initial_fatigue_obj = app._line_to_struc[self.active_line][2]

        self._frame = master
        self._frame.wm_title("Specify fatigue properties here.")
        self._frame.geometry('1300x810')
        self._frame.grab_set()

        tk.Label(
            self._frame,
            text='-- Fatigue calculation for plates according to DNVGL-RP-C203, '
            'Section 5 Simplified fatigue analysis --',
            font='Verdana 15 bold').place(x=10, y=10)

        ent_w = 10

        self.new_sn_curve = tk.StringVar()
        self.new_k_factor = tk.DoubleVar()
        self.new_no_of_cycles = tk.DoubleVar()
        self.new_design_life = tk.DoubleVar()
        self.new_dff = tk.DoubleVar()

        self.new_weibull_loa = tk.DoubleVar()
        self.new_weibull_bal = tk.DoubleVar()
        self.new_weibull_prt = tk.DoubleVar()

        self.new_period_loa = tk.DoubleVar()
        self.new_period_bal = tk.DoubleVar()
        self.new_period_prt = tk.DoubleVar()

        self.new_corr_loc_loa = tk.DoubleVar()
        self.new_corr_loc_bal = tk.DoubleVar()
        self.new_corr_loc_prt = tk.DoubleVar()

        self.new_fraction_loa = tk.DoubleVar()
        self.new_fraction_bal = tk.DoubleVar()
        self.new_fraction_prt = tk.DoubleVar()

        self.new_az_loa = tk.DoubleVar()
        self.new_az_bal = tk.DoubleVar()
        self.new_az_prt = tk.DoubleVar()

        sn_curves = sn.get_all_curves()

        self.ent_sn_curve = tk.OptionMenu(self._frame,
                                          self.new_sn_curve,
                                          command=self.change_sn_curve,
                                          *sn_curves)
        self.ent_dff = tk.Entry(self._frame,
                                textvariable=self.new_dff,
                                width=ent_w)
        self.ent_k_factor = tk.Entry(self._frame,
                                     textvariable=self.new_k_factor,
                                     width=ent_w)
        self.ent_no_of_cycles = tk.Entry(self._frame,
                                         textvariable=self.new_no_of_cycles,
                                         width=ent_w)
        self.ent_new_design_life = tk.Entry(self._frame,
                                            textvariable=self.new_design_life,
                                            width=ent_w)

        self.ent_weibull_loa = tk.Entry(self._frame,
                                        textvariable=self.new_weibull_loa,
                                        width=ent_w)
        self.ent_weibull_bal = tk.Entry(self._frame,
                                        textvariable=self.new_weibull_bal,
                                        width=ent_w)
        self.ent_weibull_prt = tk.Entry(self._frame,
                                        textvariable=self.new_weibull_prt,
                                        width=ent_w)

        self.ent_period_loa = tk.Entry(self._frame,
                                       textvariable=self.new_period_loa,
                                       width=ent_w)
        self.ent_period_bal = tk.Entry(self._frame,
                                       textvariable=self.new_period_bal,
                                       width=ent_w)
        self.ent_period_prt = tk.Entry(self._frame,
                                       textvariable=self.new_period_prt,
                                       width=ent_w)

        self.ent_corr_loc_loa = tk.Entry(self._frame,
                                         textvariable=self.new_corr_loc_loa,
                                         width=ent_w)
        self.ent_corr_loc_bal = tk.Entry(self._frame,
                                         textvariable=self.new_corr_loc_bal,
                                         width=ent_w)
        self.ent_corr_loc_prt = tk.Entry(self._frame,
                                         textvariable=self.new_corr_loc_prt,
                                         width=ent_w)

        self.ent_fraction_loa = tk.Entry(self._frame,
                                         textvariable=self.new_fraction_loa,
                                         width=ent_w)
        self.ent_fraction_bal = tk.Entry(self._frame,
                                         textvariable=self.new_fraction_bal,
                                         width=ent_w)
        self.ent_fraction_prt = tk.Entry(self._frame,
                                         textvariable=self.new_fraction_prt,
                                         width=ent_w)

        self.ent_acc_loa = tk.Entry(self._frame,
                                    textvariable=self.new_az_loa,
                                    width=ent_w)
        self.ent_acc_bal = tk.Entry(self._frame,
                                    textvariable=self.new_az_bal,
                                    width=ent_w)
        self.ent_acc_prt = tk.Entry(self._frame,
                                    textvariable=self.new_az_prt,
                                    width=ent_w)

        start_x, start_y, dx, dy = 20, 100, 150, 35

        loaded_exist = False
        ballast_exist = False
        part_exist = False
        fls_exist = (loaded_exist, ballast_exist, part_exist)

        # Frames to hide loaded, ballast or part
        loa_fr = tk.Frame(self._frame,
                          width=100,
                          height=170,
                          bg="gray25",
                          colormap="new")
        bal_fr = tk.Frame(self._frame,
                          width=100,
                          height=170,
                          bg="gray25",
                          colormap="new")
        prt_fr = tk.Frame(self._frame,
                          width=100,
                          height=170,
                          bg="gray25",
                          colormap="new")

        for load in self.load_objects:
            if load != None:
                if load.get_limit_state() == 'FLS':
                    if load.get_load_condition() == 'loaded':
                        loaded_exist = True
                    elif load.get_load_condition() == 'ballast':
                        ballast_exist = True
                    elif load.get_load_condition() == 'part':
                        part_exist = True
                    else:
                        pass
            fls_exist = (loaded_exist, ballast_exist, part_exist)

        if self._initial_fatigue_obj == None:
            self.new_sn_curve.set('Ec')
            self.new_k_factor.set(1)
            self.new_no_of_cycles.set(10000)
            self.new_design_life.set(20)
            self.new_dff.set(2)
            if any(fls_exist):
                if loaded_exist:
                    self.new_fraction_loa.set(1 / fls_exist.count(True))
                    self.new_weibull_loa.set(0.8)
                    self.new_period_loa.set(8)
                    self.new_corr_loc_loa.set(0.5)
                    self.new_az_loa.set(0.5)
                if ballast_exist:
                    self.new_fraction_bal.set(1 / fls_exist.count(True))
                    self.new_weibull_bal.set(0.8)
                    self.new_period_bal.set(8)
                    self.new_corr_loc_bal.set(0.5)
                    self.new_az_bal.set(0.5)
                if part_exist:
                    self.new_fraction_prt.set(1 / fls_exist.count(True))
                    self.new_weibull_prt.set(0.8)
                    self.new_period_prt.set(8)
                    self.new_corr_loc_prt.set(0.5)
                    self.new_az_prt.set(0.5)
        else:
            fat_prop = self._initial_fatigue_obj.get_fatigue_properties()
            self.new_sn_curve.set(fat_prop['SN-curve'])
            self.new_k_factor.set(fat_prop['SCF'])
            self.new_no_of_cycles.set(fat_prop['n0'])
            self.new_design_life.set(fat_prop['Design life'])
            self.new_dff.set(fat_prop['DFF'])
            if any(fls_exist):
                if loaded_exist:
                    self.new_fraction_loa.set(fat_prop['Fraction'][0])
                    self.new_weibull_loa.set(fat_prop['Weibull'][0])
                    self.new_period_loa.set(fat_prop['Period'][0])
                    self.new_corr_loc_loa.set(fat_prop['CorrLoc'][0])
                    self.new_az_loa.set(fat_prop['Accelerations'][0])
                if ballast_exist:
                    self.new_fraction_bal.set(fat_prop['Fraction'][1])
                    self.new_weibull_bal.set(fat_prop['Weibull'][1])
                    self.new_period_bal.set(fat_prop['Period'][1])
                    self.new_corr_loc_bal.set(fat_prop['CorrLoc'][1])
                    self.new_az_bal.set(fat_prop['Accelerations'][1])
                if part_exist:
                    self.new_fraction_prt.set(fat_prop['Fraction'][2])
                    self.new_weibull_prt.set(fat_prop['Weibull'][2])
                    self.new_period_prt.set(fat_prop['Period'][2])
                    self.new_corr_loc_prt.set(fat_prop['CorrLoc'][2])
                    self.new_az_prt.set(fat_prop['Accelerations'][2])

        all_acc = (self.new_az_loa.get(), self.new_az_bal.get(),
                   self.new_az_prt.get())

        count = 1
        for load in self.load_objects:
            press = []
            if load.get_limit_state() == 'FLS':
                tk.Label(self._frame, text=str(count)+'. '+load.get_name(), font='Verdana 8')\
                    .place(x=start_x + 5 * dx, y=start_y + (5+count) * dy)
                idx = 0
                for exist in fls_exist:
                    if exist:
                        press.append(
                            round(
                                load.get_calculated_pressure(
                                    self.pressure_coords, all_acc[idx],
                                    self._initial_structure_obj.
                                    get_structure_type()), 1))
                        idx += 1

                tk.Label(self._frame, text=press, font='Verdana 8') \
                    .place(x=start_x + 6.5 * dx, y=start_y + (5 + count) * dy)
                count += 1
        press = []
        for comp in self.comp_objects:

            tk.Label(self._frame, text=str(count) + '. ' +str(comp.get_name()), font='Verdana 8') \
                .place(x=start_x + 5 * dx, y=start_y + (5 + count) * dy)

            idx = 0

            if fls_exist[0] and comp.is_loaded_condition():
                press.append(
                    round(
                        comp.get_calculated_pressure(self.pressure_coords,
                                                     all_acc[0]), 1))
            if fls_exist[1] and comp.is_ballast_condition():
                press.append(
                    round(
                        comp.get_calculated_pressure(self.pressure_coords,
                                                     all_acc[1]), 1))
            if fls_exist[2] and any(
                [comp.is_loaded_condition(),
                 comp.is_ballast_condition()]):
                press.append(
                    round(
                        comp.get_calculated_pressure(self.pressure_coords,
                                                     all_acc[2]), 1))

            tk.Label(self._frame, text=press, font='Verdana 8') \
                .place(x=start_x + 6.5 * dx, y=start_y + (5 + count) * dy)

            count += 1

        tk.Label(self._frame, text='Design life:', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 0*dy)
        tk.Label(self._frame, text='Design Fatigue Factor (DFF):', font='Verdana 8 bold') \
            .place(x=start_x+ 3*dx , y=start_y + 0*dy)
        tk.Label(self._frame, text='SN-curve:', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 1*dy)
        tk.Label(self._frame, text='Cycles in return period, n0', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 2*dy)
        tk.Label(self._frame, text='Stress Concentration Factor, SCF', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 3*dy)

        tk.Label(self._frame, text='Loaded', font='Verdana 8 bold') \
            .place(x=start_x+2*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Ballast', font='Verdana 8 bold') \
            .place(x=start_x+3*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Part', font='Verdana 8 bold') \
            .place(x=start_x+4*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Defined loads', font='Verdana 8 bold') \
            .place(x=start_x+5*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Resulting pressures', font='Verdana 8 bold') \
            .place(x=start_x+6.5*dx , y=start_y + 5*dy)

        tk.Label(self._frame, text='Fraction (sum of bal/part/loa is 1)', font='Verdana 8 bold') \
            .place(x=start_x, y=start_y + 6 * dy)
        tk.Label(self._frame, text='Weibull', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 7*dy)
        tk.Label(self._frame, text='Period', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 8*dy)
        tk.Label(self._frame, text='Corr. loc.', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 9*dy)
        tk.Label(self._frame, text='Accelerations', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 10*dy)

        self.ent_new_design_life.place(x=start_x + 2 * dx, y=start_y + 0 * dy)
        self.ent_dff.place(x=start_x + 5 * dx, y=start_y + 0 * dy)
        self.ent_sn_curve.place(x=start_x + 2 * dx, y=start_y + 1 * dy)
        self.ent_no_of_cycles.place(x=start_x + 2 * dx, y=start_y + 2 * dy)
        self.ent_k_factor.place(x=start_x + 2 * dx, y=start_y + 3 * dy)

        self.ent_fraction_loa.place(x=start_x + 2 * dx, y=start_y + 6 * dy)
        self.ent_fraction_bal.place(x=start_x + 3 * dx, y=start_y + 6 * dy)
        self.ent_fraction_prt.place(x=start_x + 4 * dx, y=start_y + 6 * dy)

        self.ent_weibull_loa.place(x=start_x + 2 * dx, y=start_y + 7 * dy)
        self.ent_weibull_bal.place(x=start_x + 3 * dx, y=start_y + 7 * dy)
        self.ent_weibull_prt.place(x=start_x + 4 * dx, y=start_y + 7 * dy)

        self.ent_period_loa.place(x=start_x + 2 * dx, y=start_y + 8 * dy)
        self.ent_period_bal.place(x=start_x + 3 * dx, y=start_y + 8 * dy)
        self.ent_period_prt.place(x=start_x + 4 * dx, y=start_y + 8 * dy)

        self.ent_corr_loc_loa.place(x=start_x + 2 * dx, y=start_y + 9 * dy)
        self.ent_corr_loc_bal.place(x=start_x + 3 * dx, y=start_y + 9 * dy)
        self.ent_corr_loc_prt.place(x=start_x + 4 * dx, y=start_y + 9 * dy)

        self.ent_acc_loa.place(x=start_x + 2 * dx, y=start_y + 10 * dy)
        self.ent_acc_bal.place(x=start_x + 3 * dx, y=start_y + 10 * dy)
        self.ent_acc_prt.place(x=start_x + 4 * dx, y=start_y + 10 * dy)

        # if not loaded_exist:
        #     loa_fr.place(x=start_x + 2 * dx, y=start_y + 6 * dy)
        # elif not ballast_exist:
        #     bal_fr.place(x=start_x + 3 * dx, y=start_y + 6 * dy)
        # elif not part_exist:
        #     prt_fr.place(x=start_x + 4 * dx, y=start_y + 6 * dy)

        self._close_and_save = tk.Button(self._frame,
                                         text='Return fatigue parameters',
                                         command=self.save_and_close,
                                         bg='green',
                                         font='Verdana 15',
                                         fg='yellow')
        self._close_and_save.place(x=start_x + dx, y=start_y + dy * 15)
예제 #4
0
 def __get_gamma2(self, idx):
     return math.exp(
         gammaln(
             snc.get_paramter(self._sn_curve, 'm2') / self._weibull[idx] +
             1))