sensotwin.lifetime_extrapolation.simulation.lib.createElementStackingTable

 1import os
 2import pandas as pd
 3
 4def f_createElementStackingTable(working_dir = '/.'):
 5    '''
 6    Uses the .dat file of a CCX result to create 
 7    a temporary element stacking table summarising 
 8    the mapping of previous shell elements (S8R) to
 9    now solid elements (C3D20R). Always operates on
10    the first .dat file found in the current working
11    directory.
12
13    Parameters:
14    - working_dir (string):
15        Working directory to execute file in.
16
17    Returns:
18    - None
19    '''
20
21    # get dat file
22    current_dir = working_dir
23    all_files = os.listdir(current_dir)
24    dat_file = [x for x in all_files if x.endswith('.dat')][0]
25
26    # find start and ending line index for stress section
27    with open(os.path.join(current_dir, dat_file), 'r') as raw_input:
28        input_lines = raw_input.readlines()
29        # find first and last line of interesting 'S'-block
30        for i,line in enumerate(input_lines):
31            if line.find('stresses') != -1:
32                starter_idx = i + 2
33            if line.find('strains') != -1:
34                end_idx = i - 1
35        end_idx = len(input_lines)
36
37    # read in data from dat file
38    stress_data = pd.read_csv(os.path.join(current_dir, dat_file), sep=r"\s+", skiprows=starter_idx, nrows=end_idx-starter_idx, header=None)
39    element_layer_data = stress_data.iloc[:,0:2]
40    element_layer_data.columns = ['element','integration_point']
41
42    # get number of layers per element
43    layers_per_element = []
44    for i in range(max(element_layer_data.element)):
45        n_elements = int(element_layer_data.loc[element_layer_data['element'] == i+1].size/16) # 16 integration points per element
46        layers_per_element.append(n_elements)
47
48    element_ids = []
49    for i,element in enumerate(layers_per_element):
50        for j in range(element):
51            element_ids.append(i)
52
53    with open(os.path.join(current_dir, 'element_layer_assignment.out.txt'),'w') as output_file:
54        for element in element_ids:
55            output_file.write(str(element) + '\n')
56
57def main():
58    f_createElementStackingTable()
59
60if __name__ == '__main__':
61    main()
def f_createElementStackingTable(working_dir='/.'):
 5def f_createElementStackingTable(working_dir = '/.'):
 6    '''
 7    Uses the .dat file of a CCX result to create 
 8    a temporary element stacking table summarising 
 9    the mapping of previous shell elements (S8R) to
10    now solid elements (C3D20R). Always operates on
11    the first .dat file found in the current working
12    directory.
13
14    Parameters:
15    - working_dir (string):
16        Working directory to execute file in.
17
18    Returns:
19    - None
20    '''
21
22    # get dat file
23    current_dir = working_dir
24    all_files = os.listdir(current_dir)
25    dat_file = [x for x in all_files if x.endswith('.dat')][0]
26
27    # find start and ending line index for stress section
28    with open(os.path.join(current_dir, dat_file), 'r') as raw_input:
29        input_lines = raw_input.readlines()
30        # find first and last line of interesting 'S'-block
31        for i,line in enumerate(input_lines):
32            if line.find('stresses') != -1:
33                starter_idx = i + 2
34            if line.find('strains') != -1:
35                end_idx = i - 1
36        end_idx = len(input_lines)
37
38    # read in data from dat file
39    stress_data = pd.read_csv(os.path.join(current_dir, dat_file), sep=r"\s+", skiprows=starter_idx, nrows=end_idx-starter_idx, header=None)
40    element_layer_data = stress_data.iloc[:,0:2]
41    element_layer_data.columns = ['element','integration_point']
42
43    # get number of layers per element
44    layers_per_element = []
45    for i in range(max(element_layer_data.element)):
46        n_elements = int(element_layer_data.loc[element_layer_data['element'] == i+1].size/16) # 16 integration points per element
47        layers_per_element.append(n_elements)
48
49    element_ids = []
50    for i,element in enumerate(layers_per_element):
51        for j in range(element):
52            element_ids.append(i)
53
54    with open(os.path.join(current_dir, 'element_layer_assignment.out.txt'),'w') as output_file:
55        for element in element_ids:
56            output_file.write(str(element) + '\n')

Uses the .dat file of a CCX result to create a temporary element stacking table summarising the mapping of previous shell elements (S8R) to now solid elements (C3D20R). Always operates on the first .dat file found in the current working directory.

Parameters:

  • working_dir (string): Working directory to execute file in.

Returns:

  • None
def main():
58def main():
59    f_createElementStackingTable()