def __DetermineConstraintBorders(self, len_obj, len_eqs, len_ineqs):
pos_obj = cm.ScalarVectorProduct(-len_obj,self.dir_obj_o)
pos_eqs = []
pos_ineqs = []
for i in range(self.num_eqs):
pos_eqs.append(cm.ScalarVectorProduct(-len_eqs[i],self.dir_eqs_o[i]))
for i in range(self.num_ineqs):
pos_ineqs.append(cm.ScalarVectorProduct(-len_ineqs[i],self.dir_ineqs_o[i]))
return pos_obj, pos_eqs, pos_ineqs
def __ComputeShapeUpdate(self, dX_bar, step_length):
# Compute update in regular units
dX = cm.ScalarVectorProduct(step_length,dX_bar)
WriteListToNodalVariable(dX, self.design_surface, KSO.SHAPE_UPDATE)
self.optimization_utilities.AddFirstVariableToSecondVariable(self.design_surface, KSO.SHAPE_UPDATE, KSO.SHAPE_CHANGE)
return dX
def __ConvertToLengthDirectionFormat(value, gradient, modified_gradient):
norm_inf = cm.NormInf3D(modified_gradient)
if norm_inf > 1e-12:
direction = cm.ScalarVectorProduct(-1/norm_inf,modified_gradient)
length = -value/cm.Dot(gradient, direction)
else:
KM.Logger.PrintWarning("ShapeOpt::AlgorithmTrustRegion", "Vanishing norm-infinity for gradient detected!")
direction = modified_gradient
length = 0.0
return direction, length
def __init__(self, identifier, response_settings, model):
super().__init__(identifier, response_settings, model)
self.plane_origin = []
for i in range(0, 3):
self.plane_origin.append(
self.response_settings["plane_origin"][i].GetDouble())
self.plane_normal = []
for i in range(0, 3):
self.plane_normal.append(
self.response_settings["plane_normal"][i].GetDouble())
self.plane_normal = cm.ScalarVectorProduct(
1.0 / cm.Norm2(self.plane_normal), self.plane_normal)
def RunProjection(self, len_obj, threshold):
# Adjust halfspaces according input
adj_len_obj, adj_len_eqs, adj_len_ineqs = self.__AdjustHalfSpacesAndHyperplanes(len_obj, threshold)
# Determine position of border of halfspaces and hyperplanes
pos_obj_o, pos_eqs_o, pos_ineqs_o = self.__DetermineConstraintBorders(adj_len_obj, adj_len_eqs, adj_len_ineqs)
# Project current position onto intersection of
current_position = cm.ZeroVector(self.num_unknowns)
dlambda_hp = self.__ProjectToHyperplanes(current_position, self.dir_eqs_o, pos_eqs_o)
# Project position and direction of halfspaces onto intersection of hyperplanes
zero_position_eqs_o = cm.ZeroMatrix(self.num_unknowns,self.num_eqs)
pos_obj_hp = self.__ProjectToHyperplanes(pos_obj_o, cm.HorzCat(self.dir_eqs_o, self.dir_obj_o), cm.HorzCat(pos_eqs_o, pos_obj_o))
dir_obj_hp = self.__ProjectToHyperplanes(self.dir_obj_o, self.dir_eqs_o, zero_position_eqs_o)
pos_ineqs_hp = []
dir_ineqs_hp = []
for itr in range(self.num_ineqs):
pos_ineqs_hp_i = self.__ProjectToHyperplanes(pos_ineqs_o[itr], cm.HorzCat(self.dir_eqs_o, self.dir_ineqs_o[itr]), cm.HorzCat(pos_eqs_o, pos_ineqs_o[itr]))
dir_ineqs_hp_i = self.__ProjectToHyperplanes(self.dir_ineqs_o[itr], self.dir_eqs_o, zero_position_eqs_o)
pos_ineqs_hp.append(pos_ineqs_hp_i)
dir_ineqs_hp.append(dir_ineqs_hp_i)
# Project onto adjusted halfspaces along the intersection of hyperplanes
dX_o, _, _, exit_code = self.__ProjectToHalfSpaces(dlambda_hp, cm.HorzCat(pos_ineqs_hp, pos_obj_hp), cm.HorzCat(dir_ineqs_hp, dir_obj_hp))
# Determine return values
if exit_code == 0:
is_projection_sucessfull = True
# Backtransformation and multiplication with -1 because the direction vectors are chosen opposite to the gradients such that the lengths are positive if violated
dX = cm.ScalarVectorProduct(-1, cm.TranslateToOriginalBasis(dX_o, self.ortho_basis))
norm_dX = cm.NormInf3D(dX)
else:
is_projection_sucessfull = False
dX = []
norm_dX = 1e10
self.__StoreProjectionResults(norm_dX, dX, is_projection_sucessfull, adj_len_obj, adj_len_eqs, adj_len_ineqs)
return norm_dX, is_projection_sucessfull
def __ExpressInStepLengthUnit(len_obj, len_eqs, len_ineqs, step_length):
len_bar_obj = 1/step_length * len_obj
len_bar_eqs = cm.ScalarVectorProduct(1/step_length, len_eqs)
len_bar_ineqs = cm.ScalarVectorProduct(1/step_length, len_ineqs)
return len_bar_obj, len_bar_eqs, len_bar_ineqs