Coverage for lasso/dimred/test_plot_creator.py: 94%
52 statements
« prev ^ index » next coverage.py v7.2.4, created at 2023-04-28 18:42 +0100
1import math
2import os
3import random
5import numpy as np
6import plotly.graph_objects as go
8from lasso.dyna.d3plot import ArrayType, D3plot
11def create_fake_d3plots(
12 path: str,
13 element_shell_node_indexes: np.ndarray,
14 bend_multiplicator: float,
15 n_nodes_x: int = 500,
16 n_nodes_y: int = 10,
17 n_timesteps: int = 5,
18):
19 """
20 Creates a number of artificial D3plots to be used in testing
21 """
23 # if bend_multiplicator > 0:
24 # bend_loc_x = int(n_nodes_x/10)
25 # bend_start = bend_loc_x - int(bend_loc_x/2)
26 # bend_end = bend_loc_x + int(bend_loc_x/2)
27 # else:
28 # bend_loc_x = n_nodes_x - int(n_nodes_x/10)
29 # bend_start = bend_loc_x - int(n_nodes_x/20)
30 # bend_end = bend_loc_x + int(n_nodes_x/20)
32 x_coords = np.arange(n_nodes_x)
33 y_coords = np.arange(n_nodes_y)
34 # z_bend_mat = np.stack(
35 # [np.array([1+math.sin(x*2*math.pi/(bend_end - bend_start))
36 # for x in range(bend_end - bend_start)]
37 # )
38 # for _ in range(n_nodes_y)]).reshape(((bend_end - bend_start)*n_nodes_y))
40 z_bend_mat = np.stack(
41 [
42 np.array([1 + math.sin(x * math.pi / n_nodes_x) for x in range(n_nodes_x)])
43 for _ in range(n_nodes_y)
44 ]
45 ).reshape((n_nodes_x * n_nodes_y,))
46 node_coordinates = np.zeros((n_nodes_x * n_nodes_y, 3))
48 # fill in y coords
49 for n in range(n_nodes_y):
50 node_coordinates[n * n_nodes_x : n_nodes_x + n * n_nodes_x, 1] = y_coords[n]
51 node_coordinates[n * n_nodes_x : n_nodes_x + n * n_nodes_x, 0] = x_coords
52 # fill in x coords
53 # for n in range(n_nodes_x):
54 # node_coordinates[n*n_nodes_y:n_nodes_y+n*n_nodes_y, 0] = x_coords[n]
56 node_displacement = np.zeros((n_timesteps, n_nodes_x * n_nodes_y, 3))
58 for t in range(n_timesteps):
59 node_displacement[t] = node_coordinates
60 # node_displacement[t, bend_start*n_nodes_y:bend_end*n_nodes_y, 2] = \
61 # z_bend_mat * bend_multiplicator * t
62 node_displacement[t, :, 2] = z_bend_mat * bend_multiplicator * t
64 # print(node_displacement.shape)
66 plot = D3plot()
67 plot.arrays[ArrayType.node_displacement] = node_displacement
68 plot.arrays[ArrayType.node_coordinates] = node_coordinates
69 plot.arrays[ArrayType.element_shell_node_indexes] = element_shell_node_indexes
70 plot.arrays[ArrayType.element_shell_part_indexes] = np.full(
71 (element_shell_node_indexes.shape[0]), 0
72 )
74 # we could create an artificial array element_shell_is_alive to test the
75 # correct part extraction process not neccessary currently
77 os.makedirs(path, exist_ok=True)
78 plot.write_d3plot(os.path.join(path, "plot"))
79 # plotUtilFunc(node_displacement)
82def plot_util_func(xyz_array: np.array):
83 trace = go.Scatter3d(
84 x=xyz_array[-1, :, 0],
85 y=xyz_array[-1, :, 1],
86 z=xyz_array[-1, :, 2],
87 mode="markers",
88 text=np.arange(xyz_array.shape[1]),
89 )
90 fig = go.Figure([trace])
91 fig.show()
94def create_element_shell_node_indexes(n_nodes_x: int = 500, n_nodes_y: int = 10) -> np.ndarray:
95 """
96 returns a element_shell_node_indexes array
97 """
99 new_shell_node_indexes = np.full(
100 ((n_nodes_x - 1) * (n_nodes_y - 1), 4), np.array([0, 1, n_nodes_x + 1, n_nodes_x])
101 )
102 mod = np.full((4, n_nodes_x - 1), np.arange(n_nodes_x - 1))
103 for i in range(n_nodes_y - 1):
104 new_shell_node_indexes[(n_nodes_x - 1) * i : (n_nodes_x - 1) + ((n_nodes_x - 1) * i)] += (
105 mod + i * n_nodes_x
106 ).T
108 return new_shell_node_indexes
111def create_2_fake_plots(folder: str, n_nodes_x: int, n_nodes_y: int, n_timesteps=5):
112 """
113 creates 2 faked plots
115 Parameters
116 ----------
117 folder: str
118 folder path
119 n_nodes_x: int
120 how many nodes in x
121 n_nodes_y: int
122 how many nodes in y
123 n_timesteps: int, default: 5
124 how many timesteps
125 """
127 randy_random = random.Random("The_Seed")
128 plot_name = "SVDTestPlot{i}"
130 element_shell_node_indexes = create_element_shell_node_indexes(
131 n_nodes_x=n_nodes_x, n_nodes_y=n_nodes_y
132 )
134 create_fake_d3plots(
135 path=os.path.join(folder, plot_name.format(i="00")),
136 element_shell_node_indexes=element_shell_node_indexes,
137 bend_multiplicator=5 * (1 + randy_random.random()),
138 n_nodes_x=n_nodes_x,
139 n_nodes_y=n_nodes_y,
140 n_timesteps=n_timesteps,
141 )
143 create_fake_d3plots(
144 path=os.path.join(folder, plot_name.format(i="01")),
145 element_shell_node_indexes=element_shell_node_indexes,
146 bend_multiplicator=5 * (1 + randy_random.random()),
147 n_nodes_x=n_nodes_x,
148 n_nodes_y=n_nodes_y,
149 n_timesteps=n_timesteps,
150 )
153def create_50_fake_plots(folder: str, n_nodes_x: int, n_nodes_y: int, n_timesteps=5):
154 """
155 creates 50 faked plots, 25 bending up, 25 bending down
157 Parameters
158 ----------
159 folder: str
160 folder path
161 n_nodes_x: int
162 how many nodes in x
163 n_nodes_y: int
164 how many nodes in y
165 n_timesteps: int, default: 5
166 how many timesteps
167 """
169 # init random
170 randy_random = random.Random("The_Seed")
172 plot_name = "SVDTestPlot{i}"
174 # doesn't change for each plot with same dimensions, so only created once
175 element_shell_node_indexes = create_element_shell_node_indexes(
176 n_nodes_x=n_nodes_x, n_nodes_y=n_nodes_y
177 )
179 # 25 plots bending up
180 for i in range(25):
181 nr = str(i)
182 if i < 10:
183 nr = "0" + str(i)
184 create_fake_d3plots(
185 path=os.path.join(folder, plot_name.format(i=nr)),
186 element_shell_node_indexes=element_shell_node_indexes,
187 bend_multiplicator=5 * (1 + randy_random.random()),
188 n_nodes_x=n_nodes_x,
189 n_nodes_y=n_nodes_y,
190 n_timesteps=n_timesteps,
191 )
193 # 25 plots bending down
194 for i in range(25):
195 create_fake_d3plots(
196 path=os.path.join(folder, plot_name.format(i=i + 25)),
197 element_shell_node_indexes=element_shell_node_indexes,
198 bend_multiplicator=-5 * (1 + randy_random.random()),
199 n_nodes_x=n_nodes_x,
200 n_nodes_y=n_nodes_y,
201 n_timesteps=n_timesteps,
202 )
205# TODO: Remove after fixing D3plot writing two files issue
206# if __name__ == "__main__":
207# create_2_fake_plots("../delteThisPlease/", 200, 10)