Optimization - Algorithm for finding load set combination that returns the maximum Von Mises stress

Question

I recently stumbled upon an optimization problem while working on structural analysis. While I'm confident in my MATLAB skills as an aerospace engineer, I must admit my theoretical knowledge in optimization is not extensive. Here's the challenge I'm facing:

I have a structure loaded with NU unitary loads, each impacting the structure independently. This setup allows me to calculate stress components for each finite element. The stress components (sigma_u_xx, sigma_u_yy, and sigma_u_xy) for NE elements are represented as matrices:

sigma_u_xx = rand(NE,NU)
sigma_u_yy = rand(NE,NU)
sigma_u_xy = rand(NE,NU)

Based on the problem's linearity, scaling the unit loads by a factor x linearly affects the stress components. This means I can analyze a small set of unit loads (even a hundred is considered small) and combine them linearly to obtain stresses for real load cases. For each unit load, there are only two possible choices for the coefficient of linear combination (x):

For each element, I compute the resultant stress components as a linear combination of the unit loads:

for e = 1:NE
  sigma_tot_xx(e) = sigma_u_xx(e,:)*x
  sigma_tot_yy(e) = sigma_u_yy(e,:)*x
  sigma_tot_xy(e) = sigma_u_xy(e,:)*x
end

Then, for any x, I evaluate the Von Mises stress using the formula:

sigma_VM = sqrt(sigma_tot_xx.^2 + sigma_tot_yy.^2 - sigma_tot_xx.*sigma_tot_yy + 3.*sigma_tot_xy)

But here's where I'm struggling: finding the combination of x that maximizes the Von Mises stress for each element.

One approach is to generate every possible combination of x using a Cartesian product, evaluate the objective function sigma_VM, and save the maximum value. However, this brute-force method becomes impractical when NU exceeds 30 due to its complexity, which is O(2^NU), if I'm correct.

I'm wondering if this problem fits into a specific class of optimization problems, and if there are more efficient algorithms to solve it. And if such algorithms exist, do they converge to a global maximum?

Alternatively, is there a way to exclude some combinations a priori without testing them? I assume this is what optimization algorithms aim to do.

Perhaps it's easier to reason about just one element, as the results are extensible to any NE. Any help or guidance would be greatly appreciated.

P.S. Even if I expressed some concepts in MATLAB, my question is more about theroy rather than coding. Any example in any programming language is welcome.