ANYstructure 5.2.0__py3-none-any.whl

anystruct/example_data_puls.py

@@ -0,0 +1,46 @@
+'''
+Contains examples to be used for testing.
+'''
+
+
+ex1 = {'Identification': 'Panel 1', 'Length of panel': 3000, 'Stiffener spacing': 700, 'Plate thickness': 15,
+       'Number of primary stiffeners': 20, 'Stiffener type (L,T,F)': 'T', 'Stiffener boundary': 'C',
+       'Stiff. Height': 350, 'Web thick.': 12,'Flange width': 150, 'Flange thick.': 18, 'Tilt angle': 0,
+       'Number of sec. stiffeners': 0, 'Modulus of elasticity': 2.1e11/1e6, "Poisson's ratio": 0.33,
+       'Yield stress plate': 355, 'Yield stress stiffener': 355, 'Axial stress': 80, 'Trans. stress 1': 60,
+       'Trans. stress 2': 50, 'Shear stress': 10, 'Pressure (fixed)': 0.08, 'In-plane support': 'Int'}
+
+ex2 = {'Identification': 'Panel 2', 'Length of panel': 3500, 'Stiffener spacing': 700, 'Plate thickness': 15,
+       'Number of primary stiffeners': 20, 'Stiffener type (L,T,F)': 'T', 'Stiffener boundary': 'C',
+       'Stiff. Height': 350, 'Web thick.': 12,'Flange width': 150, 'Flange thick.': 18, 'Tilt angle': 0,
+       'Number of sec. stiffeners': 0, 'Modulus of elasticity': 2.1e11/1e6, "Poisson's ratio": 0.33,
+       'Yield stress plate': 355, 'Yield stress stiffener': 355, 'Axial stress': 80, 'Trans. stress 1': 60,
+       'Trans. stress 2': 50, 'Shear stress': 10, 'Pressure (fixed)': 0.08, 'In-plane support': 'Int'}
+
+ex3 = {'Identification': 'Panel 3', 'Length of panel': 4000, 'Stiffener spacing': 700, 'Plate thickness': 15,
+       'Number of primary stiffeners': 20, 'Stiffener type (L,T,F)': 'T', 'Stiffener boundary': 'C',
+       'Stiff. Height': 350, 'Web thick.': 12,'Flange width': 150, 'Flange thick.': 18, 'Tilt angle': 0,
+       'Number of sec. stiffeners': 0, 'Modulus of elasticity': 2.1e11/1e6, "Poisson's ratio": 0.33,
+       'Yield stress plate': 355, 'Yield stress stiffener': 355, 'Axial stress': 80, 'Trans. stress 1': 60,
+       'Trans. stress 2': 50, 'Shear stress': 10, 'Pressure (fixed)': 0.08, 'In-plane support': 'Int'}
+
+ex4 = {'Identification': 'Panel 4', 'Length of panel': 3000, 'Stiffener spacing': 700, 'Plate thickness': 15,
+       'Number of primary stiffeners': 20, 'Stiffener type (L,T,F)': 'T', 'Stiffener boundary': 'C',
+       'Stiff. Height': 400, 'Web thick.': 12,'Flange width': 150, 'Flange thick.': 18, 'Tilt angle': 0,
+       'Number of sec. stiffeners': 0, 'Modulus of elasticity': 2.1e11/1e6, "Poisson's ratio": 0.33,
+       'Yield stress plate': 355, 'Yield stress stiffener': 355, 'Axial stress': 80, 'Trans. stress 1': 60,
+       'Trans. stress 2': 50, 'Shear stress': 10, 'Pressure (fixed)': 0.08, 'In-plane support': 'Int'}
+
+ex5 = {'Identification': 'Panel 5', 'Length of panel': 3500, 'Stiffener spacing': 700, 'Plate thickness': 15,
+       'Number of primary stiffeners': 20, 'Stiffener type (L,T,F)': 'T', 'Stiffener boundary': 'C',
+       'Stiff. Height': 350, 'Web thick.': 12,'Flange width': 150, 'Flange thick.': 25, 'Tilt angle': 0,
+       'Number of sec. stiffeners': 0, 'Modulus of elasticity': 2.1e11/1e6, "Poisson's ratio": 0.33,
+       'Yield stress plate': 355, 'Yield stress stiffener': 355, 'Axial stress': 80, 'Trans. stress 1': 60,
+       'Trans. stress 2': 50, 'Shear stress': 10, 'Pressure (fixed)': 0.08, 'In-plane support': 'Int'}
+
+ex6 = {'Identification': 'Panel 6', 'Length of panel': 4000, 'Stiffener spacing': 800, 'Plate thickness': 20,
+       'Number of primary stiffeners': 20, 'Stiffener type (L,T,F)': 'T', 'Stiffener boundary': 'C',
+       'Stiff. Height': 350, 'Web thick.': 12,'Flange width': 150, 'Flange thick.': 18, 'Tilt angle': 0,
+       'Number of sec. stiffeners': 0, 'Modulus of elasticity': 2.1e11/1e6, "Poisson's ratio": 0.33,
+       'Yield stress plate': 355, 'Yield stress stiffener': 355, 'Axial stress': 80, 'Trans. stress 1': 60,
+       'Trans. stress 2': 50, 'Shear stress': 10, 'Pressure (fixed)': 0.08, 'In-plane support': 'Int'}

anystruct/excel_inteface.py

@@ -0,0 +1,244 @@
+'''
+This file open up excel PULS file
+1. read and write to the file.
+2. run macros.
+3. get the results.
+'''
+
+import numpy as np
+from xlwings import App, Book
+
+class ExcelInterface():
+    ''' This class open a ExcelInterface work.
+        Input and output structure data and results.
+        Running macros.
+    '''
+    def __init__(self, path_and_file_to_book: str = None, visible = True, read_only = False):
+        '''
+        :param path_and_file_to_book:  Path and file name or just filename in base directory.
+        :param visible: If excel shall open in windows or run in the background.
+        '''
+        super(ExcelInterface, self).__init__()
+        self.app = App(visible=visible)
+        self.book = Book(path_and_file_to_book, read_only=read_only)
+
+        self.names_sp = {'Identification': 1, 'Length of panel': 3, 'Stiffener spacing': 4, 'Plate thickness': 5,
+                      'Number of primary stiffeners': 6, 'Stiffener type (L,T,F)': 7, 'Stiffener boundary': 8,
+                      'Stiff. Height': 9, 'Web thick.': 10,'Flange width': 11, 'Flange thick.': 12, 'Tilt angle': 13,
+                      'Number of sec. stiffeners': 14, 'Modulus of elasticity': 21, "Poisson's ratio": 22,
+                      'Yield stress plate': 23, 'Yield stress stiffener': 24, 'Axial stress': 25, 'Trans. stress 1': 26,
+                      'Trans. stress 2': 27, 'Shear stress': 28, 'Pressure (fixed)': 29, 'In-plane support': 30}
+
+        self.names_up = {'Identification': 1, 'Length of plate': 3, 'Width of c': 4, 'Plate thickness': 5,
+                         'Modulus of elasticity': 6, "Poisson's ratio":7, 'Yield stress plate': 8,
+                         'Axial stress 1': 9, 'Axial stress 2': 10,'Trans. stress 1': 11,
+                         'Trans. stress 2': 12, 'Shear stress': 13, 'Pressure (fixed)': 14, 'In-plane support': 15,
+                         'Rot left': 16, 'Rot right': 17, 'Rot upper': 18, 'Rot lower': 19}
+
+    def close_book(self, save = False):
+        ''' Closing ass and book. '''
+        if save:
+            self.book.save()
+        self.book.close()
+        self.app.kill()
+
+    def read_data(self, row_number: int = 1, column_number: int = 1):
+        ''' Read one cell in the sheet
+            Row and columns starts at 1 (not 0 as in python general)
+        '''
+        return self.book.sheets[1].range((row_number, column_number)).value
+
+    def set_cell_value(self, row_number: int = 1, column_number: int = 1, cell_value = None, sheet_num = 1):
+        '''
+        Set values of a cell.
+        :param row_number:
+        :param column_number:
+        :param cell_value:
+        :return:
+        '''
+        #print('Row', row_number, 'Col', column_number, 'Cell', cell_value)
+        self.book.sheets[sheet_num].range((row_number, column_number)).value = cell_value
+
+    def set_one_row(self, row_number: int = 20, data_dict: dict = None):
+        '''
+        Set one row of values
+        :param row_number: The row to set.
+        :param data_dict: Data for one panel.
+        :return:
+        '''
+        for name, col_num in self.names_sp.items():
+            self.set_cell_value(row_number, col_num, data_dict[name])
+
+    def set_multiple_rows(self, start_row:int = 20, data_dict: dict = None):
+        '''
+
+        :param start_row: First row to input.
+        :param list_of_dicts: The data to be set.
+        :return:
+        '''
+
+        row_number = start_row
+        for id, data in data_dict.items():
+            self.set_one_row(row_number, data)
+            row_number += 1
+
+    def set_multiple_rows_batch(self, data_dict: dict = None):
+        '''
+
+        :param start_row: First row to input.
+        :param list_of_dicts: The data to be set.
+        :return:
+        '''
+
+        sp_dict, up_dict = dict(), dict()
+        for key, val in data_dict.items():
+            if val['sp or up'] == 'SP':
+                sp_dict[key] = val
+            else:
+                up_dict[key] = val
+        if len(sp_dict)>0:
+            for name, col_num in self.names_sp.items():
+                start_row = 20
+                self.book.sheets[1].range((start_row, col_num)).options(expand='table', transpose=True).value = \
+                    [val[name] for val in sp_dict.values()]
+        if len(up_dict) > 0:
+            for name, col_num in self.names_up.items():
+                start_row = 21
+                self.book.sheets[4].range((start_row, col_num)).options(expand='table', transpose=True).value = \
+                    [val[name] for val in up_dict.values()]
+
+        return len(sp_dict)>0, len(up_dict)>0
+
+    def calculate_panels(self, sp = True, up = False):
+        ''' Calculate the panels in the sheet. '''
+        if sp:
+            run_macro_sp = self.app.macro('Sheet1.cmdCalculatePanels_Click')
+            run_macro_sp()
+        if up:
+            run_macro_up = self.app.macro('Sheet3.CalculatePanelsU3')
+            run_macro_up()
+
+    def get_results_one_cell(self, row_number: int = 1, column_number: int = 1):
+        ''' Return the results in one cell of a calculated panel. '''
+        return self.book.sheets[2].range((row_number, column_number)).value
+
+    def get_results_one_row(self, row_number: int = 15):
+        '''
+        Return one row.
+        :param row_number:
+        :return: dict : [value, unit] e.g. [3000, 'mm']
+        '''
+        return_dict = dict()
+        return_dict['Identification'] = self.get_results_one_cell(row_number, column_number=1)
+        # print('start')
+        # for idx in range(3,74):
+        #     if self.get_results_one_cell(11, column_number=idx) != None:
+        #         return_dict[self.get_results_one_cell(11, column_number=idx)] = {}
+        # print('stop')
+        current_top_row = ''
+        for idx in range(3,74):
+            if self.get_results_one_cell(11, column_number=idx) != None:
+                current_top_row = self.get_results_one_cell(11, column_number=idx)
+                return_dict[current_top_row] = {}
+
+            return_dict[current_top_row][self.get_results_one_cell(12, column_number=idx)] = \
+                [self.get_results_one_cell(row_number, column_number=idx),
+                 self.get_results_one_cell(14, column_number=idx)]
+        return return_dict
+
+    def get_all_results_batch(self, sp = True, up = False):
+
+        spup = {(True, True) : ['SP', 'UP'], (True, False) : ['SP'], (False, True) : ['UP']}
+
+        return_dict = {}
+        for run in spup[(sp, up)]:
+            all_ids  = self.book.sheets[2 if run == 'SP' else 5].range('A15').expand().value
+            if type(all_ids) != list:
+                all_ids = [all_ids]
+            all_data = np.array(self.book.sheets[2 if run == 'SP' else 5].range('C12').expand().value)
+            all_top_names = np.array(self.book.sheets[2 if run == 'SP' else 5].range('C11:BU11' if run == 'SP' else 'C11:AS11').value)
+            all_names = all_data[0]
+            all_data = all_data[3:]
+            all_units = np.array(self.book.sheets[2 if run == 'SP' else 5].range('C14:BU14'if run == 'SP' else 'C14:AS14').value)
+            current_top_row = ''
+
+            for data_idx, id in enumerate(all_ids):
+                return_dict[id] = {}
+                return_dict[id]['Identification'] = id
+                same, same_idx = False, 2
+                for top_name, name, data, unit in zip(all_top_names, all_names, all_data[data_idx], all_units):
+                    if top_name != None:
+                        current_top_row = top_name
+                        return_dict[id][current_top_row] = {}
+                    if name in return_dict[id][current_top_row].keys():
+                        same = True
+                        name = name + ' ' +str(same_idx)
+                        same_idx += 1
+                    elif same == True and name not in return_dict[id][current_top_row].keys():
+                        same = False
+                        same_idx = 2
+                    return_dict[id][current_top_row][name] = [data, unit]
+                if run == 'UP':
+                    return_dict[id]['Ultimate capacity']['Actual usage Factor'] = \
+                        return_dict[id]['Ultimate capacity']['Usage factor']
+                    return_dict[id]['Ultimate capacity']['Allowable usage factor'] = \
+                        return_dict[id]['Ultimate capacity']['Alowable usage']
+                    return_dict[id]['Buckling strength']['Actual usage Factor'] = \
+                        return_dict[id]['Buckling strength']['Usage factor']
+                    return_dict[id]['Buckling strength']['Allowable usage factor'] = \
+                        return_dict[id]['Buckling strength']['Alowable usage']
+
+                    return_dict[id]['Ultimate capacity'].pop('Usage factor')
+                    return_dict[id]['Ultimate capacity'].pop('Alowable usage')
+                    return_dict[id]['Buckling strength'].pop('Usage factor')
+                    return_dict[id]['Buckling strength'].pop('Alowable usage')
+        return return_dict
+
+    def get_all_results(self):
+        '''
+        Return all results in run.
+        :return:
+        '''
+
+        return_dict, found_last, row_number = dict(), False, 15
+        while found_last is False:
+            this_row = self.get_results_one_row(row_number)
+            if this_row['Identification'] is not None:
+                return_dict[row_number] = this_row
+                row_number += 1
+            else:
+                found_last = True
+
+        return return_dict
+
+    def get_sheet_data(self, sheet = 'flat_plate'):
+        map = {'flat_plate': 0, 'cylinder': 1}
+        if sheet not in list(map.keys()):
+            return None
+
+        this_sheet = self.book.sheets[map[sheet]]
+        return this_sheet.used_range.value
+
+if __name__ == '__main__':
+    # ex1 = {'line25': {'Identification': 'line25', 'Length of plate': 3, 'Width of c': 800.0, 'Plate thickness': 20.0,
+    #                   'Modulus of elasticity': 210000.0, "Poisson's ratio": 0.3, 'Yield stress plate': 355.0,
+    #                   'Axial stress 1': 60.0, 'Axial stress 2': 60.0, 'Trans. stress 1': 0, 'Trans. stress 2': 0,
+    #                   'Shear stress': 10.0, 'Pressure (fixed)': 0.0, 'In-plane support': 'GL', 'Rot left': 'SS',
+    #                   'Rot right': 'SS', 'Rot upper': 'SS', 'Rot lower': 'SS', 'sp or up': 'UP'}}
+    # my_puls = ExcelInterface(r'C:\Github\ANYstructure\ANYstructure\PULS\PulsExcel_new - Copy.xlsm',
+    #                     visible=True)
+    # my_puls.set_multiple_rows_batch(ex1)
+    # my_puls.set_multiple_rows(20, [ex.ex1, ex.ex2, ex.ex3, ex.ex4, ex.ex5, ex.ex6])
+    # my_puls.calculate_panels()
+    #my_puls.set_one_row(data_dict=ex.ex1['line1'])
+    # [print(key, value) for key, value in my_puls.get_all_results().items()]
+    # my_puls.close_book()
+    my_input = ExcelInterface(r'C:\Github\ANYstructure\anystruct\excel_input_example.xlsx',
+                              visible=False)
+    data = my_input.get_sheet_data()
+
+    for dom, l1x, l1y, l2x, l2y, pl_t, pl_s, web_h, web_th, fl_b, fl_th, sig_x1, sig_x2, sig_y1, sig_y2, tau_xy in data[1:]:
+        print(dom, l1x, l1y, l2x, l2y, pl_t, pl_s, web_h, web_th, fl_b, fl_th, sig_x1, sig_x2, sig_y1, sig_y2, tau_xy)
+
+
+

anystruct/fatigue_window.py

@@ -0,0 +1,352 @@
+# This is fatigue properties are defined.
+import tkinter as tk
+
+try:
+    import anystruct.example_data as test
+    import anystruct.SN_curve_parameters as sn
+except ModuleNotFoundError:
+    import ANYstructure.anystruct.example_data as test
+    import ANYstructure.anystruct.SN_curve_parameters as sn
+
+
+class CreateFatigueWindow():
+    '''
+    This class initiates the GUI used to define stresses for the selected structure.
+    '''
+    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:
+            if app._line_to_struc[app._active_line][0] is None:
+                return
+            elif app._line_to_struc[app._active_line][0].Stiffener is None:
+                return
+            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].Stiffener
+            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:
+            if load == None:
+                continue
+            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:
+            if comp == None:
+                continue
+            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)
+
+    def get_pressure_point_coord_from_two_points(self,p1,p2):
+        ''' Finding the coordinates to use in pressure calculations '''
+
+        if p1[1] <= p2[1]:
+            start_point = p1
+            end_point = p2
+        else:
+            start_point = p2
+            end_point = p1
+
+        vector = [end_point[0]-start_point[0], end_point[1]-start_point[1]]
+
+        return start_point[0]+vector[0]*1/3, start_point[1]+vector[1]*1/3
+
+    def change_sn_curve(self,event):
+        '''
+        Action when changing the structure type
+        :return:
+        '''
+        self.new_sn_curve.set(event)
+
+    def save_and_close(self):
+        '''
+        Save and close
+        :return:
+        '''
+        if __name__ == '__main__':
+            self._frame.destroy()
+            return
+        # order of return is (Loaded,Ballast,Part)
+        temp_dict = {'SN-curve':self.new_sn_curve.get(),
+                     'SCF':self.new_k_factor.get(),
+                     'Design life':self.new_design_life.get(),
+                     'n0':self.new_no_of_cycles.get(),
+                     'Weibull':(self.new_weibull_loa.get(),self.new_weibull_bal.get(),self.new_weibull_prt.get()),
+                     'Period':(self.new_period_loa.get(),self.new_period_bal.get(),self.new_period_prt.get()),
+                     'Fraction':(self.new_fraction_loa.get(),self.new_fraction_bal.get(),self.new_fraction_prt.get()),
+                     'CorrLoc':(self.new_corr_loc_loa.get(),self.new_corr_loc_bal.get(),self.new_corr_loc_prt.get()),
+                     'Order':('Loaded','Ballast','Part'),
+                     'Accelerations':(self.new_az_loa.get(),self.new_az_bal.get(),self.new_az_prt.get()),
+                     'DFF': self.new_dff.get()}
+
+        self.app.on_close_fatigue_window(temp_dict)
+        self._frame.destroy()
+
+
+if __name__ == '__main__':
+    root = tk.Tk()
+    my_app = CreateFatigueWindow(root,app=None)
+    root.mainloop()