sensotwin.lifetime_extrapolation.simulation.lib.extractStresses

  1from . import readVTT
  2from pathlib import Path
  3import numpy as np
  4import vtk
  5from vtk.util import numpy_support as vtknp
  6import os
  7
  8def f_extractStresses(working_dir = './'):
  9    '''
 10    Converts point data results from convertFRDtoVTK.py
 11    to cell data results in a new .vtu file. Copies
 12    the U field as point data for usage of warpByVector.
 13    Uses element_layer_assignment.out.txt from 
 14    createElementStackingTable.py to add the following
 15    fields:
 16    
 17    - ID: cell ID
 18    - ELID: element IDs of shell model
 19    - LAYID: layer id starting from the outer-most layer
 20    - ANGLEDEG: angle of layer in deg
 21    - THICKMM: thickness of layer in mm
 22    - LAYID_<material>: LAYID for every material
 23
 24    Always operates on the first .vtu file found in the
 25    current working directory.
 26
 27    Parameters:
 28    - working_dir (string):
 29        Working directory to execute file in.
 30
 31    Returns:
 32    - None
 33    '''
 34    current_dir = working_dir
 35    all_files = os.listdir(current_dir)
 36    all_vtu_files = [x for x in all_files if x.endswith('.vtu')]
 37    filename = all_vtu_files[0]
 38
 39    base_dir = Path(current_dir).parent.parent
 40
 41    # read in composite_layup_db.vtt
 42    reader = readVTT.f_readVTTFile(os.path.join(base_dir, 'IN', 'composite_layup_db.vtt'))
 43    table = vtk.vtkTable()
 44    table.DeepCopy(reader.GetOutput())
 45    layup_df = readVTT.f_convertVtkTableToPandasDF(table)
 46
 47
 48    reader = vtk.vtkXMLUnstructuredGridReader()
 49    reader.SetFileName(os.path.join(current_dir, filename))
 50    reader.Update()
 51
 52    point_data = reader.GetOutput()
 53
 54    # convert point data to cell data to operate on elements
 55    p2c_converter = vtk.vtkPointDataToCellData()
 56    p2c_converter.SetInputData(point_data)
 57    p2c_converter.Update()
 58    cell_data = p2c_converter.GetOutput()
 59
 60    # add U as point data for "warp-by-vector" filter
 61    array = point_data.GetPointData().GetArray('U')
 62    dataset = cell_data.GetPointData()
 63    dataset.AddArray(array)
 64    dataset.Modified()
 65
 66    # create new array with cell ids
 67    n_cells = cell_data.GetNumberOfCells()
 68    cell_ids = np.array([x for x in range(n_cells)])
 69
 70    array = vtknp.numpy_to_vtk(cell_ids)
 71    array.SetName("ID")
 72    dataset = cell_data.GetCellData()
 73    dataset.AddArray(array)
 74    dataset.Modified()
 75
 76    # create new array with element ids and layer ids from shell model
 77    with open(os.path.join(current_dir, 'element_layer_assignment.out.txt'),'r') as input_file:
 78        input_lines = input_file.readlines()
 79    element_ids = [int(x.strip('\n')) for x in input_lines]
 80
 81    layer_ids = []
 82    for i in range(max(element_ids)+1):
 83        n_layers = element_ids.count(i)
 84        for j in range(n_layers):
 85            layer_ids.append(j)
 86
 87    array = vtknp.numpy_to_vtk(element_ids)
 88    array.SetName("ELID")
 89    dataset = cell_data.GetCellData()
 90    dataset.AddArray(array)
 91    dataset.Modified()
 92
 93    array = vtknp.numpy_to_vtk(layer_ids)
 94    array.SetName("LAYID")
 95    dataset = cell_data.GetCellData()
 96    dataset.AddArray(array)
 97    dataset.Modified()
 98
 99    # create new array with orientation
100    orientations = list(layup_df['layer_angle_deg'])
101    array = vtknp.numpy_to_vtk(orientations)
102    array.SetName("ANGLEDEG")
103    dataset = cell_data.GetCellData()
104    dataset.AddArray(array)
105    dataset.Modified()
106
107    # create new array with thickness
108    thicknesses = list(layup_df['layer_thickness_mm'])
109    array = vtknp.numpy_to_vtk(thicknesses)
110    array.SetName("THICKMM")
111    dataset = cell_data.GetCellData()
112    dataset.AddArray(array)
113    dataset.Modified()
114
115    # create new array for material with layer id
116    unique_materials = list(set(layup_df['layer_material']))
117
118    for material in unique_materials:
119        array_name = 'LAYID_' + material
120        element_labels_with_material = layup_df.loc[layup_df['layer_material'] == material]
121        current_material_assignment = []
122        for element_id in range(len(layup_df.index)):
123            if element_id in element_labels_with_material.index:
124                current_material_assignment.append(layer_ids[element_id])
125            else:
126                current_material_assignment.append(np.nan)
127        
128        array = vtknp.numpy_to_vtk(current_material_assignment)
129        array.SetName(array_name)
130        dataset = cell_data.GetCellData()
131        dataset.AddArray(array)
132        dataset.Modified()
133
134    # write to new .vtu file
135    writer = vtk.vtkXMLUnstructuredGridWriter()
136    writer.SetFileName(os.path.join(current_dir, filename.strip('.vtu') + '_processed.vtu'))
137    writer.CompressorType = 'NONE'
138    writer.SetInputData(cell_data)
139    writer.Write()
140
141def main():
142    f_extractStresses()
143
144if __name__ == '__main__':
145    main()
def f_extractStresses(working_dir='./'):
  9def f_extractStresses(working_dir = './'):
 10    '''
 11    Converts point data results from convertFRDtoVTK.py
 12    to cell data results in a new .vtu file. Copies
 13    the U field as point data for usage of warpByVector.
 14    Uses element_layer_assignment.out.txt from 
 15    createElementStackingTable.py to add the following
 16    fields:
 17    
 18    - ID: cell ID
 19    - ELID: element IDs of shell model
 20    - LAYID: layer id starting from the outer-most layer
 21    - ANGLEDEG: angle of layer in deg
 22    - THICKMM: thickness of layer in mm
 23    - LAYID_<material>: LAYID for every material
 24
 25    Always operates on the first .vtu file found in the
 26    current working directory.
 27
 28    Parameters:
 29    - working_dir (string):
 30        Working directory to execute file in.
 31
 32    Returns:
 33    - None
 34    '''
 35    current_dir = working_dir
 36    all_files = os.listdir(current_dir)
 37    all_vtu_files = [x for x in all_files if x.endswith('.vtu')]
 38    filename = all_vtu_files[0]
 39
 40    base_dir = Path(current_dir).parent.parent
 41
 42    # read in composite_layup_db.vtt
 43    reader = readVTT.f_readVTTFile(os.path.join(base_dir, 'IN', 'composite_layup_db.vtt'))
 44    table = vtk.vtkTable()
 45    table.DeepCopy(reader.GetOutput())
 46    layup_df = readVTT.f_convertVtkTableToPandasDF(table)
 47
 48
 49    reader = vtk.vtkXMLUnstructuredGridReader()
 50    reader.SetFileName(os.path.join(current_dir, filename))
 51    reader.Update()
 52
 53    point_data = reader.GetOutput()
 54
 55    # convert point data to cell data to operate on elements
 56    p2c_converter = vtk.vtkPointDataToCellData()
 57    p2c_converter.SetInputData(point_data)
 58    p2c_converter.Update()
 59    cell_data = p2c_converter.GetOutput()
 60
 61    # add U as point data for "warp-by-vector" filter
 62    array = point_data.GetPointData().GetArray('U')
 63    dataset = cell_data.GetPointData()
 64    dataset.AddArray(array)
 65    dataset.Modified()
 66
 67    # create new array with cell ids
 68    n_cells = cell_data.GetNumberOfCells()
 69    cell_ids = np.array([x for x in range(n_cells)])
 70
 71    array = vtknp.numpy_to_vtk(cell_ids)
 72    array.SetName("ID")
 73    dataset = cell_data.GetCellData()
 74    dataset.AddArray(array)
 75    dataset.Modified()
 76
 77    # create new array with element ids and layer ids from shell model
 78    with open(os.path.join(current_dir, 'element_layer_assignment.out.txt'),'r') as input_file:
 79        input_lines = input_file.readlines()
 80    element_ids = [int(x.strip('\n')) for x in input_lines]
 81
 82    layer_ids = []
 83    for i in range(max(element_ids)+1):
 84        n_layers = element_ids.count(i)
 85        for j in range(n_layers):
 86            layer_ids.append(j)
 87
 88    array = vtknp.numpy_to_vtk(element_ids)
 89    array.SetName("ELID")
 90    dataset = cell_data.GetCellData()
 91    dataset.AddArray(array)
 92    dataset.Modified()
 93
 94    array = vtknp.numpy_to_vtk(layer_ids)
 95    array.SetName("LAYID")
 96    dataset = cell_data.GetCellData()
 97    dataset.AddArray(array)
 98    dataset.Modified()
 99
100    # create new array with orientation
101    orientations = list(layup_df['layer_angle_deg'])
102    array = vtknp.numpy_to_vtk(orientations)
103    array.SetName("ANGLEDEG")
104    dataset = cell_data.GetCellData()
105    dataset.AddArray(array)
106    dataset.Modified()
107
108    # create new array with thickness
109    thicknesses = list(layup_df['layer_thickness_mm'])
110    array = vtknp.numpy_to_vtk(thicknesses)
111    array.SetName("THICKMM")
112    dataset = cell_data.GetCellData()
113    dataset.AddArray(array)
114    dataset.Modified()
115
116    # create new array for material with layer id
117    unique_materials = list(set(layup_df['layer_material']))
118
119    for material in unique_materials:
120        array_name = 'LAYID_' + material
121        element_labels_with_material = layup_df.loc[layup_df['layer_material'] == material]
122        current_material_assignment = []
123        for element_id in range(len(layup_df.index)):
124            if element_id in element_labels_with_material.index:
125                current_material_assignment.append(layer_ids[element_id])
126            else:
127                current_material_assignment.append(np.nan)
128        
129        array = vtknp.numpy_to_vtk(current_material_assignment)
130        array.SetName(array_name)
131        dataset = cell_data.GetCellData()
132        dataset.AddArray(array)
133        dataset.Modified()
134
135    # write to new .vtu file
136    writer = vtk.vtkXMLUnstructuredGridWriter()
137    writer.SetFileName(os.path.join(current_dir, filename.strip('.vtu') + '_processed.vtu'))
138    writer.CompressorType = 'NONE'
139    writer.SetInputData(cell_data)
140    writer.Write()

Converts point data results from convertFRDtoVTK.py to cell data results in a new .vtu file. Copies the U field as point data for usage of warpByVector. Uses element_layer_assignment.out.txt from createElementStackingTable.py to add the following fields:

  • ID: cell ID
  • ELID: element IDs of shell model
  • LAYID: layer id starting from the outer-most layer
  • ANGLEDEG: angle of layer in deg
  • THICKMM: thickness of layer in mm
  • LAYID_: LAYID for every material

Always operates on the first .vtu file found in the current working directory.

Parameters:

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

Returns:

  • None
def main():
142def main():
143    f_extractStresses()