new_cmap = colors.LinearSegmentedColormap.from_list(

"trunc({n},{a:.2f},{b:.2f})".format(n=cmap.name, a=minval, b=maxval),

cmap(np.linspace(minval, maxval, n)),

)

# Visualize truss

@staticmethod

def plotTruss(myBCs, a, forces, threshold, vol, tk, foldername=False):

"""Plot the ground stucture optimization solution"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure

fig = plt.figure()

plt.clf()

plt.axis("off")

plt.axis("equal")

plt.title("Final Structure - Vol = %.3f" % (vol))

candidates = myBCs.ground_structure[a >= threshold, :]

q = forces[a >= threshold]

a = a[a >= threshold]

c = np.empty(a.size, dtype=object)

tol = np.max(q) * 1e-04

c[:] = "grey" # no force

c[q > tol] = accent_r_1 # tension

c[q < -tol] = accent_b_1 # compression

linewidth = a * tk

# boundaries

if not myBCs.isLshape:

plt.plot(

[0, 0], [0, myBCs.L[1]], "lightgray", linestyle="dotted", linewidth=0.2

)

plt.plot(

[0, myBCs.L[0]],

[myBCs.L[1], myBCs.L[1]],

"lightgray",

linestyle="dotted",

linewidth=0.2,

)

plt.plot(

[myBCs.L[0], myBCs.L[0]],

[myBCs.L[1], 0],

"lightgray",

linestyle="dotted",

linewidth=0.2,

)

plt.plot(

[myBCs.L[0], 0], [0, 0], "lightgray", linestyle="dotted", linewidth=0.2

)

# optimized beams

for i in range(len(a)):

pos = nodes[candidates[i, [0, 1]].astype(int), :]

plt.plot(pos[:, 0], pos[:, 1], c[i], linewidth=linewidth[i])

# plt.scatter(pos[:, 0], pos[:, 1], c = 'black', marker = 'o', edgecolors = 'none', zorder=2, s=5) # enforce the scatter plot after the plot

fig.tight_layout()

if foldername == False:

plt.show()

else:

# tikzplotlib.save(foldername+'fig1-Topology.tex')

# plt.savefig(foldername+'fig1-Topology.pgf')

plt.savefig(foldername + "fig1-Topology.pdf")

# Visualize deformed truss

@staticmethod

def plotTrussDeformation(

myBCs, a, q, u, threshold, magnitude, tk, foldername, axis

):

"""Plot the ground stucture optimization solution"""

nodes = myBCs.nodes

u = u.reshape(-1, 2)

candidates = myBCs.ground_structure[a >= threshold, :]

q = q[a >= threshold]

a = a[a >= threshold]

fig = plt.figure()

plt.clf()

plt.axis("off")

plt.axis("equal")

plt.title("Final Structure deformation - Magnitude %i" % (magnitude))

if not myBCs.isLshape:

plt.plot([0, 0], [0, myBCs.L[1]], "lightgray")

plt.plot([0, myBCs.L[0]], [myBCs.L[1], myBCs.L[1]], "lightgray")

plt.plot([myBCs.L[0], myBCs.L[0]], [myBCs.L[1], 0], "lightgray")

plt.plot([myBCs.L[0], 0], [0, 0], "lightgray")

# optimized beams

for i in [i for i in range(len(a)) if a[i] >= threshold]:

c = "black"

pos = (

nodes[candidates[i, [0, 1]].astype(int), :]

+ magnitude * u[candidates[i, [0, 1]].astype(int), :]

)

plt.plot(pos[:, 0], pos[:, 1], c, linewidth=a[i] * tk)

plt.scatter(

pos[:, 0], pos[:, 1], c="black", marker="o", edgecolors="none", zorder=2

) # enforce the scatter plot after the plot

fig.tight_layout()

if not axis:

plt.title(" ")

if foldername == False:

plt.show()

else:

# tikzplotlib.save(foldername+'fig6-U_NoAxis-Mag={0}.tex'.format(magnitude))

plt.savefig(foldername + "fig5-U_NoAxis-Mag={0}.pdf".format(magnitude))

# plt.savefig(foldername+'fig6-U_NoAxis-Mag={0}.pgf'.format(magnitude))

else:

plt.title(" ")

if foldername == False:

plt.show()

else:

# tikzplotlib.save(foldername+'fig6-U_Axis-Mag={0}.tex'.format(magnitude))

plt.savefig(foldername + "fig6-U_Axis-Mag={0}.pdf".format(magnitude))

# plt.savefig(foldername+'fig6-U_Axis-Mag={0}.pgf'.format(magnitude))

@staticmethod

def plotTrussRF(myBCs, a, q, threshold, stress_t, stress_c, tk, foldername=False):

"""Plot the ground stucture optimization solution efficency, defined as the percentage of the max charge"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a >= threshold]

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("Reserve Factor")

q[abs(q) < max(abs(q)) * 10e-3] = 0 # eliminates 0/0 cases

efficency = q[a >= threshold] / a[a >= threshold]

efficency[efficency > 0] /= stress_t

efficency[efficency < 0] /= stress_c

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

norm = plt.Normalize(efficency.min(), efficency.max())

lc = mc.LineCollection(segments, cmap=Blue_mono, norm=norm)

lc.set_array(efficency)

lc.set_linewidth(a[a >= threshold] * tk)

line = ax.add_collection(lc)

fig.colorbar(line, ax=[ax], location="bottom", orientation="horizontal")

fig.tight_layout()

# optimized beams

if foldername == False:

plt.show()

else:

# tikzplotlib.save(foldername+'fig7-safety.tex')

plt.savefig(foldername + "fig7-safety.pdf")

# plt.savefig(foldername+'fig7-safety.pgf')

@staticmethod

def plotTrussStress(myBCs, a, q, threshold, s_t, s_c, tk, foldername=False):

"""Plot the ground stucture optimization solution stress"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a >= threshold]

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("ABS stress")

q = q[a >= threshold]

a = a[a >= threshold]

stress = q / a

# Round to a specified number of significant digits

significant_digits = 4

decimals = (

significant_digits - int(math.floor(math.log10(np.abs(np.max(stress))))) - 1

)

stress = np.around(stress, decimals=decimals)

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

norm = plt.Normalize(s_c, s_t)

lc = mc.LineCollection(segments, cmap="coolwarm", norm=norm)

lc.set_array(stress[a >= threshold])

lc.set_linewidth(a[a >= threshold] * tk)

line = ax.add_collection(lc)

fig.colorbar(line, ax=[ax], location="bottom", orientation="horizontal")

if foldername == False:

plt.show()

else:

# tikzplotlib.save(foldername+'fig2-stress.tex')

plt.savefig(foldername + "fig2-stress.pdf")

# plt.savefig(foldername+'fig2-stress.pgf')

# Visualize initial truss

@staticmethod

def plotGroundStructure(

myBCs, plot_nodes=False, foldername=False, load_case=-1, mag=0.1

):

nodes = myBCs.nodes

candidates = myBCs.ground_structure

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("Starting Ground Structure - N. Elements = " + str(len(candidates)))

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

lc = mc.LineCollection(segments, colors=accent_b_2)

ax.add_collection(lc)

if plot_nodes:

for i in range(len(segments)):

pos = nodes[candidates[i, [0, 1]].astype(int), :]

plt.scatter(

pos[:, 0],

pos[:, 1],

c=accent_r_1,

marker="o",

edgecolors="none",

zorder=100000,

s=5,

) # enforce the scatter plot after the plot

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

# BCs

fixed_nodes = np.unique(myBCs.fixed_dofs // 2)

x, y = myBCs.nodes[fixed_nodes, :][:, [0, 1]].T

ax.scatter(x, y, s=15, c=accent_b_1, alpha=1, zorder=2)

# Loads

if load_case != -1:

load_nodes = np.nonzero(myBCs.R[:, load_case])[0] // 2

x, y = myBCs.nodes[load_nodes, :][:, [0, 1]].T

R = myBCs.R[:, load_case].copy()

else:

load_nodes = np.nonzero(myBCs.R)[0] // 2

x, y = myBCs.nodes[load_nodes, :][:, [0, 1]].T

R = myBCs.R.copy()

magnit = R[R != 0]

direction = myBCs.force_dofs % 2

v = np.zeros((load_nodes.shape[0], 2))

v[range(load_nodes.shape[0]), direction] = magnit

# normalization of v

v_norm = np.max(np.abs(myBCs.R))

v = v / v_norm * mag * np.max(myBCs.L)

ax.quiver(x, y, v[:, 0], v[:, 1], color="red", zorder=30, linewidth=0.7)

fig.tight_layout()

if foldername == False:

plt.show()

else:

if load_case != -1:

plt.savefig(foldername + "fig0-GS-LC{:03d}.pdf".format(load_case + 1))

else:

plt.savefig(foldername + "fig0-GS.pdf")

@staticmethod

def plotTrussBucklingCheck(

myBCs, a, forces, threshold, s_buck, tk, foldername=False

):

"""Plot the ground stucture optimization solution"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a >= threshold, :]

q = forces[a >= threshold]

# Critical force

q_crit = (

-s_buck

* a[a >= threshold] ** 2

/ myBCs.ground_structure_length[a >= threshold] ** 2

)

a = a[a >= threshold]

color = np.empty(a.size, dtype=object)

color[q < q_crit * 1.01] = accent_r_1 # Buckled

color[q > q_crit * 1.01] = "grey" # Ok

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("Buckling check")

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

# boundaries

if not myBCs.isLshape:

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

lc = mc.LineCollection(segments, colors=color)

lc.set_linewidth(a[a >= threshold] * tk)

ax.add_collection(lc)

fig.tight_layout()

if foldername == False:

plt.show()

else:

plt.savefig(foldername + "fig3-B_check.pdf")

@staticmethod

def plotTrussBuckling(myBCs, a, forces, threshold, s_buck, tk, foldername=False):

"""Plot the ground stucture optimization solution"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a >= threshold, :]

q = forces[a >= threshold]

# Critical force

q_crit = (

-s_buck

* a[a >= threshold] ** 2

/ myBCs.ground_structure_length[a >= threshold] ** 2

)

buck = q / q_crit

buck[buck < 0] = 0 # Member in tension cannot buckle

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("Buckling SF")

# boundaries

if not myBCs.isLshape:

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

ax.set_xlim(np.min(nodes[:, 0]), np.max(nodes[:, 0] * 1.05))

ax.set_ylim(np.min(nodes[:, 1]), np.max(nodes[:, 1] * 1.05))

norm = plt.Normalize(0, 1)

lc = mc.LineCollection(segments, cmap=Blue_mono, norm=norm)

lc.set_array(buck)

lc.set_linewidth(a[a >= threshold] * tk)

line = ax.add_collection(lc)

fig.colorbar(line, ax=[ax], location="bottom", orientation="horizontal")

fig.tight_layout()

if foldername == False:

plt.show()

else:

plt.savefig(foldername + "fig4-B.pdf")

########### Multiload

# Visualize truss

@staticmethod

def plotTruss_ML(myBCs, a, forces, threshold, vol, tk, foldername=False):

"""Plot the ground stucture optimization solution"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure

fig = plt.figure()

plt.clf()

plt.axis("off")

plt.axis("equal")

plt.title("Final Structure - Vol = %.3f" % (vol))

candidates = myBCs.ground_structure[a >= threshold, :]

q = forces[a >= threshold, :]

grey = np.prod(forces, axis=1)[a >= threshold]

a = a[a >= threshold]

c = np.empty(a.size, dtype=object)

tol = np.max(q) * 1e-04

c[:] = "grey" # no force

c[(q[:, 0] > tol) & (grey > tol)] = accent_r_1 # tension

c[(q[:, 0] < -tol) & (grey > tol)] = accent_b_1 # compression

linewidth = a * tk

# boundaries

if not myBCs.isLshape:

plt.plot(

[0, 0], [0, myBCs.L[1]], "lightgray", linestyle="dotted", linewidth=0.2

)

plt.plot(

[0, myBCs.L[0]],

[myBCs.L[1], myBCs.L[1]],

"lightgray",

linestyle="dotted",

linewidth=0.2,

)

plt.plot(

[myBCs.L[0], myBCs.L[0]],

[myBCs.L[1], 0],

"lightgray",

linestyle="dotted",

linewidth=0.2,

)

plt.plot(

[myBCs.L[0], 0], [0, 0], "lightgray", linestyle="dotted", linewidth=0.2

)

# optimized beams

for i in range(len(a)):

pos = nodes[candidates[i, [0, 1]].astype(int), :]

plt.plot(pos[:, 0], pos[:, 1], c[i], linewidth=linewidth[i])

plt.scatter(

pos[:, 0], pos[:, 1], c="black", marker="o", edgecolors="none", zorder=2

) # enforce the scatter plot after the plot

fig.tight_layout()

if foldername == False:

plt.show()

else:

# tikzplotlib.save(foldername+'fig1-Topology.tex')

plt.savefig(foldername + "fig1-Topology.pgf")

plt.savefig(foldername + "fig1-Topology.pdf")

@staticmethod

def plotTrussMulti_ML(myBCs, a_unred, forces, threshold, tk, foldername=False):

"""Plot the ground stucture optimization solution stress"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a_unred >= threshold]

n_load_cases = forces.shape[-1]

for i in range(n_load_cases):

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

q = forces[:, i]

q = q[a_unred >= threshold]

a = a_unred[a_unred >= threshold]

c = np.empty(a.size, dtype=object)

c[:] = "darkgrey" # no force

c[(q > 1e-5 * max(q))] = accent_r_1 # tension

c[(q < 1e-5 * min(q))] = accent_b_1 # compression

linewidth = a * tk

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

lc = mc.LineCollection(segments, colors=c)

lc.set_linewidth(linewidth)

line = ax.add_collection(lc)

if foldername == False:

plt.show()

else:

plt.savefig(foldername + "fig1-Topology-LC{:03d}.pdf".format(i + 1))

@staticmethod

def plotTrussStress_ML(

myBCs, a_unred, forces, threshold, s_t, s_c, tk, foldername=False

):

"""Plot the ground stucture optimization solution stress"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a_unred >= threshold]

n_load_cases = forces.shape[-1]

for i in range(n_load_cases):

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("ABS stress")

q = forces[:, i]

q = q[a_unred >= threshold]

a = a_unred[a_unred >= threshold]

stress = q / a

# Round to a specified number of significant digits

significant_digits = 4

decimals = (

significant_digits

- int(math.floor(math.log10(np.abs(np.max(stress)))))

- 1

)

stress = np.around(stress, decimals=decimals)

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

norm = plt.Normalize(s_c, s_t)

lc = mc.LineCollection(segments, cmap="coolwarm", norm=norm)

lc.set_array(stress[a >= threshold])

lc.set_linewidth(a[a >= threshold] * tk)

line = ax.add_collection(lc)

fig.colorbar(line, ax=[ax], location="bottom", orientation="horizontal")

if foldername == False:

plt.show()

else:

plt.savefig(foldername + "fig2-stress-LC{:03d}.pdf".format(i + 1))

@staticmethod

def plotTrussBuckling_ML(

myBCs, a_unred, forces, threshold, s_buck, tk, foldername=False

):

"""Plot the ground stucture optimization solution stress"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a_unred >= threshold]

n_load_cases = forces.shape[-1]

for i in range(n_load_cases):

fig, ax = plt.subplots()

plt.axis("off")

plt.axis("equal")

plt.title("Buckling SF")

# Critical force

q = forces[:, i]

q = q[a_unred >= threshold]

a = a_unred[a_unred >= threshold]

q_crit = (

-s_buck

* a**2

/ myBCs.ground_structure_length[a_unred >= threshold] ** 2

)

buck = q / q_crit

buck[buck < 0] = 0 # Member in tension cannot buckle

points = nodes[candidates[:, [0, 1]].astype(int), :].reshape(-1, 1, 2)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

ax.set_xlim(

np.min(nodes[:, 0]), np.max(nodes[:, 0] + 0.05 * np.max(nodes[:, 0]))

)

ax.set_ylim(

np.min(nodes[:, 1]), np.max(nodes[:, 1] + 0.05 * np.max(nodes[:, 1]))

)

norm = plt.Normalize(0, 1)

lc = mc.LineCollection(segments, cmap=Blue_mono, norm=norm)

lc.set_array(buck)

lc.set_linewidth(a * tk)

line = ax.add_collection(lc)

fig.colorbar(line, ax=[ax], location="bottom", orientation="horizontal")

if foldername == False:

plt.show()

else:

plt.savefig(foldername + "fig4-B-LC{:03d}.pdf".format(i + 1))

@classmethod

def plotRoutine(

cls,

myBCs,

a,

q,

U,

vol,

stress_tension_max,

stress_compression_max,

tol,

s_buck,

obj_hist,

obj_hist_LP,

cellsEquals,

foldername,

LP,

GIF,

a_cell=False,

):

thick = 5 / max(a)

tol *= max(a)

if LP:

folder = foldername + "/LP/"

if not os.path.isdir(folder):

os.makedirs(folder)

else:

folder = foldername + "/"

cls.plotGroundStructure(myBCs, False, folder)

cls.plotTruss(myBCs, a, q, max(a) * tol, vol, thick, folder)

cls.plotTrussStress(

myBCs,

a,

q,

max(a) * tol,

stress_tension_max,

stress_compression_max,

thick,

folder,

)

if sum(U) != 0:

cls.plotTrussDeformation(

myBCs, a, q, U, max(a) * tol, 1, folder, axis=False

)

cls.plotTrussRF(

myBCs,

a,

q,

max(a) * tol,

stress_tension_max,

stress_compression_max,

thick,

folder,

)

if np.any(obj_hist) != False:

plotObjHistory(obj_hist, folder)

if np.any(obj_hist_LP) != False:

plotObjHistory_combined(obj_hist, obj_hist_LP, folder)

if GIF:

generateGIF(folder, "animation")

@classmethod

def plotRoutineBuckling(

cls,

myBCs,

a,

q,

U,

vol,

stress_tension_max,

stress_compression_max,

tol,

s_buck,

obj_hist,

obj_hist_LP,

cellsEquals,

foldername,

LP,

GIF,

a_cell=False,

):

thick = 5 / max(a)

if LP:

folder = foldername + "/LP/"

if not os.path.isdir(folder):

os.makedirs(folder)

else:

folder = foldername + "/"

cls.plotGroundStructure(myBCs, True, folder)

cls.plotTruss(myBCs, a, q, max(a) * tol, vol, thick, folder)

cls.plotTrussStress(

myBCs,

a,

q,

max(a) * tol,

stress_tension_max,

stress_compression_max,

thick,

folder,

)

cls.plotTrussBucklingCheck(myBCs, a, q, max(a) * tol, s_buck, thick, folder)

cls.plotTrussBuckling(myBCs, a, q, max(a) * tol, s_buck, thick, folder)

if sum(U) != 0:

cls.plotTrussDeformation(

myBCs, a, q, U, max(a) * tol, 1, thick, folder, axis=False

)

cls.plotTrussRF(

myBCs,

a,

q,

max(a) * tol,

stress_tension_max,

stress_compression_max,

thick,

folder,

)

if np.any(obj_hist) != False:

plotObjHistory(obj_hist, folder)

if np.any(obj_hist_LP) != False:

plotObjHistory_combined(obj_hist, obj_hist_LP, folder)

if GIF:

generateGIF(folder, "animation")

@classmethod

def plotRoutineBuckling_ML(

cls,

myBCs,

a,

q,

U,

vol,

stress_tension_max,

stress_compression_max,

tol,

s_buck,

obj_hist,

foldername,

LP,

GIF,

obj_hist_LP=False,

eq_hist=False,

s_c_hist=False,

s_t_hist=False,

comp_hist=False,

buck_hist=False,

):

thick = 5 / max(a)

tol *= max(a)

if LP:

folder = foldername + "/LP/"

if not os.path.isdir(folder):

os.makedirs(folder)

else:

folder = foldername + "/"

n_load_cases = myBCs.R.shape[1]

for i in range(n_load_cases):

cls.plotGroundStructure(myBCs, foldername=folder, load_case=i, mag=0.1)

cls.plotTruss_ML(myBCs, a, q, tol, vol, thick, foldername=folder)

cls.plotTrussMulti_ML(myBCs, a, q, tol, thick, foldername=folder)

cls.plotTrussStress_ML(

myBCs,

a,

q,

tol,

stress_tension_max,

stress_compression_max,

thick,

foldername=folder,

)

cls.plotTrussBuckling_ML(myBCs, a, q, tol, s_buck, thick, foldername=folder)

if np.sum(U[:]) != 0:

cls.plotTrussDeformation(

myBCs, a, q, U, tol, 1, thick, foldername=folder, axis=False

)

if np.any(obj_hist) != False:

plotObjHistory(obj_hist, foldername=folder)

if np.any(eq_hist) != False:

plotConstHistory(

eq_hist, s_c_hist, s_t_hist, comp_hist, buck_hist, folder

)

if np.any(obj_hist_LP) != False:

plotObjHistory_combined(obj_hist, obj_hist_LP, folder)

if GIF:

# Visualize truss

@staticmethod

def plotTruss(myBCs, a, forces, threshold, vol, tk, foldername=False, gif=False):

"""Plot the ground stucture optimization solution"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a >= threshold, :]

q = forces[a >= threshold]

a = a[a >= threshold]

color = np.empty(a.size, dtype=object)

fig = plt.figure()

ax = fig.add_subplot(projection="3d", proj_type="ortho")

plt.axis("off")

plt.title("Final Structure - Vol = %.3f" % (vol))

# optimized beams

tol = np.max(q) * 1e-04

color[:] = "grey" # no force

color[q > tol] = accent_r_1 # tension

color[q < -tol] = accent_b_1 # compression

linewidth = a * tk

points = nodes[candidates[:, [0, 1]].astype(int), :][:, :, [0, 1, 2]].reshape(

-1, 1, 3

)

# Normalization to [0-Dim]

points[:, :, 0] = points[:, :, 0] - np.min(points[:, :, 0])

points[:, :, 1] = points[:, :, 1] - np.min(points[:, :, 1])

points[:, :, 2] = points[:, :, 2] - np.min(points[:, :, 2])

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

lc = Line3DCollection(segments, colors=color)

lc.set_linewidth(linewidth)

ax.add_collection3d(lc, zs=nodes[:, 2], zdir="z")

xx = myBCs.L[0]

yy = myBCs.L[1]

zz = myBCs.L[2]

# draw cube

r1 = [0, xx]

r2 = [0, yy]

r3 = [0, zz]

for s, e in combinations(np.array(list(product(r1, r2, r3))), 2):

s = np.array(s)

e = np.array(e)

if (

np.linalg.norm(s - e) == r1[1]

or np.linalg.norm(s - e) == r2[1]

or np.linalg.norm(s - e) == r3[1]

):

ax.plot3D(

*zip(s, e), color="lightgrey", linestyle="dotted", linewidth=0.2

)

ax.set_xlim([0, myBCs.L[0] * 1.05])

ax.set_ylim([0, myBCs.L[1] * 1.05])

ax.set_zlim([0, myBCs.L[2] * 1.05])

ax.set_box_aspect((myBCs.L[0] * 1.05, myBCs.L[1] * 1.05, myBCs.L[2] * 1.05))

fig.tight_layout()

if foldername != False:

plt.savefig(foldername + "fig1-Topology.pdf")

# Orthogonal views

plt.title(" ")

ax.view_init(azim=0, elev=0) # x-z plane

plt.savefig(foldername + "fig1-Topology_xz.pdf")

ax.view_init(azim=-90, elev=90) # x-y plane

plt.savefig(foldername + "fig1-Topology_xy.pdf")

ax.view_init(azim=-90, elev=0) # y-z plane

plt.savefig(foldername + "fig1-Topology_yz.pdf")

ax.view_init(azim=-70, elev=30) # view 1

plt.savefig(foldername + "fig1-Topology_ortho1.pdf")

ax.view_init(azim=70, elev=30) # view 1

plt.savefig(foldername + "fig1-Topology_ortho2.pdf")

else:

plt.show()

if gif:

fig.tight_layout()

plt.title(" ")

if not os.path.isdir(foldername + "/" + "gif_tmp_top"):

os.makedirs(foldername + "/" + "gif_tmp_top")

for ii in range(0, 360, 2):

ax.view_init(elev=25.0, azim=ii)

plt.savefig(

foldername

+ "/"

+ "gif_tmp_top"

+ "/"

+ "gif{0:03d}.png".format(ii),

dpi=300,

)

# Visualize the reserve factor

@staticmethod

def plotTrussRF(myBCs, a, q, threshold, stress_t, stress_c, tk, foldername):

"""Plot the ground stucture optimization solution reserve factor, defined as the percentage of the max charge"""

nodes = myBCs.nodes

candidates = myBCs.ground_structure[a >= threshold]

fig = plt.figure()

ax = fig.add_subplot(projection="3d")

plt.axis("off")

plt.title("Reserve factor")

q = q[a >= threshold]

a = a[a >= threshold]

q[abs(q) < max(abs(q)) * 10e-3] = 0 # eliminates 0/0 cases

efficency = q / a

efficency[efficency > 0] /= stress_t

efficency[efficency < 0] /= stress_c

points = nodes[candidates[:, [0, 1]].astype(int), :][:, :, [0, 1, 2]].reshape(

-1, 1, 3

)

segments = np.concatenate([points[:-1:2], points[1::2]], axis=1)

norm = plt.Normalize(efficency.min(), efficency.max())

lc = Line3DCollection(segments, cmap="RdYlGn", norm=norm)

lc.set_array(efficency[a >= threshold])

lc.set_linewidth(a[a >= threshold] * tk)

line = ax.add_collection(lc)

fig.colorbar(line, ax=ax)