Пример #1
0
    def RunOptimizationLoop(self):
        timer = Timer()
        timer.StartTimer()

        for self.optimization_iteration in range(1,self.max_iterations):
            print("\n>===================================================================")
            print("> ",timer.GetTimeStamp(),": Starting optimization iteration ", self.optimization_iteration)
            print(">===================================================================\n")

            timer.StartNewLap()

            self.__initializeNewShape()

            self.__analyzeShape()

            self.__computeShapeUpdate()

            self.__logCurrentOptimizationStep()

            print("\n> Time needed for current optimization step = ", timer.GetLapTime(), "s")
            print("> Time needed for total optimization so far = ", timer.GetTotalTime(), "s")

            if self.__isAlgorithmConverged():
                break
            else:
                self.__determineAbsoluteChanges()
    def RunOptimizationLoop(self):
        timer = Timer()
        timer.StartTimer()

        for self.opt_iteration in range(
                1, self.algorithm_settings["max_iterations"].GetInt() + 1):
            print(
                "\n>==================================================================="
            )
            print("> ", timer.GetTimeStamp(),
                  ": Starting optimization iteration ", self.opt_iteration)
            print(
                ">===================================================================\n"
            )

            timer.StartNewLap()

            self.__InitializeNewShape()

            self.__AnalyzeShape()

            self.__PostProcessGradientsObtainedFromAnalysis()

            len_obj, dir_obj, len_eqs, dir_eqs, len_ineqs, dir_ineqs = self.__ConvertAnalysisResultsToLengthDirectionFormat(
            )

            step_length = self.__DetermineMaxStepLength()

            len_bar_obj, len_bar_eqs, len_bar_ineqs = self.__ExpressInStepLengthUnit(
                len_obj, len_eqs, len_ineqs, step_length)

            dX_bar, process_details = self.__DetermineStep(
                len_bar_obj, dir_obj, len_bar_eqs, dir_eqs, len_bar_ineqs,
                dir_ineqs)

            dX = self.__ComputeShapeUpdate(dX_bar, step_length)

            values_to_be_logged = {}
            values_to_be_logged["len_bar_obj"] = len_bar_obj
            values_to_be_logged[
                "len_bar_cons"] = self.__CombineConstraintDataToOrderedList(
                    len_bar_eqs, len_bar_ineqs)
            values_to_be_logged["step_length"] = step_length
            values_to_be_logged["test_norm_dX_bar"] = process_details[
                "test_norm_dX"]
            values_to_be_logged["bi_itrs"] = process_details["bi_itrs"]
            values_to_be_logged["bi_err"] = process_details["bi_err"]
            values_to_be_logged["adj_len_bar_obj"] = process_details[
                "adj_len_obj"]
            values_to_be_logged[
                "adj_len_bar_cons"] = self.__CombineConstraintDataToOrderedList(
                    process_details["adj_len_eqs"],
                    process_details["adj_len_ineqs"])
            values_to_be_logged["norm_dX"] = NormInf3D(dX)

            self.__LogCurrentOptimizationStep(values_to_be_logged)

            print("\n> Time needed for current optimization step = ",
                  timer.GetLapTime(), "s")
            print("> Time needed for total optimization so far = ",
                  timer.GetTotalTime(), "s")
Пример #3
0
    def RunOptimizationLoop(self):
        timer = Timer()
        timer.StartTimer()

        current_lambda = self.lambda0
        penalty_scaling = self.penalty_scaling_0
        penalty_factor = self.penalty_factor_0

        total_iteration = 0
        is_design_converged = False
        is_max_total_iterations_reached = False
        previos_L = None

        for outer_iteration in range(1, self.max_outer_iterations + 1):
            for inner_iteration in range(1, self.max_inner_iterations + 1):

                total_iteration += 1
                timer.StartNewLap()

                print(
                    "\n>======================================================================================="
                )
                print("> ", timer.GetTimeStamp(), ": Starting iteration ",
                      outer_iteration, ".", inner_iteration, ".",
                      total_iteration, "(outer . inner . total)")
                print(
                    ">=======================================================================================\n"
                )

                # Initialize new shape
                self.model_part_controller.UpdateTimeStep(total_iteration)

                for node in self.design_surface.Nodes:
                    new_shape_change = node.GetSolutionStepValue(
                        ALPHA_MAPPED) * node.GetValue(
                            BEAD_DIRECTION) * self.bead_height
                    node.SetSolutionStepValue(SHAPE_CHANGE, new_shape_change)

                self.model_part_controller.DampNodalVariableIfSpecified(
                    SHAPE_CHANGE)

                for node in self.design_surface.Nodes:
                    shape_update = node.GetSolutionStepValue(
                        SHAPE_CHANGE, 0) - node.GetSolutionStepValue(
                            SHAPE_CHANGE, 1)
                    node.SetSolutionStepValue(SHAPE_UPDATE, shape_update)

                self.model_part_controller.UpdateMeshAccordingInputVariable(
                    SHAPE_UPDATE)
                self.model_part_controller.SetReferenceMeshToMesh()

                # Analyze shape
                self.communicator.initializeCommunication()
                self.communicator.requestValueOf(
                    self.objectives[0]["identifier"].GetString())
                self.communicator.requestGradientOf(
                    self.objectives[0]["identifier"].GetString())

                self.analyzer.AnalyzeDesignAndReportToCommunicator(
                    self.design_surface, total_iteration, self.communicator)

                objective_value = self.communicator.getStandardizedValue(
                    self.objectives[0]["identifier"].GetString())
                objGradientDict = self.communicator.getStandardizedGradient(
                    self.objectives[0]["identifier"].GetString())
                WriteDictionaryDataOnNodalVariable(
                    objGradientDict, self.optimization_model_part, DF1DX)

                self.model_part_controller.DampNodalVariableIfSpecified(DF1DX)

                # Compute sensitivities w.r.t. scalar design variable alpha
                for node in self.design_surface.Nodes:
                    raw_gradient = node.GetSolutionStepValue(DF1DX)
                    bead_dir = node.GetValue(BEAD_DIRECTION)

                    dF1dalpha_i = self.bead_height * (
                        raw_gradient[0] * bead_dir[0] + raw_gradient[1] *
                        bead_dir[1] + raw_gradient[2] * bead_dir[2])
                    node.SetSolutionStepValue(DF1DALPHA, dF1dalpha_i)

                # Map gradient of objective
                self.mapper.InverseMap(DF1DALPHA, DF1DALPHA_MAPPED)

                # Compute scaling
                max_norm_objective_gradient = self.optimization_utilities.ComputeMaxNormOfNodalVariable(
                    DF1DALPHA_MAPPED)

                if outer_iteration == 1 and inner_iteration == min(
                        3, self.max_inner_iterations):
                    if self.bead_side == "positive" or self.bead_side == "negative":
                        max_norm_penalty_gradient = 1.0
                    elif self.bead_side == "both":
                        max_norm_penalty_gradient = 2.0

                    penalty_scaling = max_norm_objective_gradient / max_norm_penalty_gradient

                # Compute penalization term
                penalty_value = 0.0
                if self.bead_side == "positive":
                    for node in self.design_surface.Nodes:
                        if not node.Is(BOUNDARY):
                            alpha_i = node.GetSolutionStepValue(ALPHA)
                            penalty_value += penalty_scaling * (alpha_i -
                                                                alpha_i**2)

                            penalty_gradient_i = penalty_scaling * (
                                1 - 2 * alpha_i)
                            node.SetSolutionStepValue(DPDALPHA,
                                                      penalty_gradient_i)

                elif self.bead_side == "negative":
                    for node in self.design_surface.Nodes:
                        if not node.Is(BOUNDARY):
                            alpha_i = node.GetSolutionStepValue(ALPHA)
                            penalty_value += penalty_scaling * (-alpha_i -
                                                                alpha_i**2)

                            penalty_gradient_i = penalty_scaling * (
                                -1 - 2 * alpha_i)
                            node.SetSolutionStepValue(DPDALPHA,
                                                      penalty_gradient_i)

                elif self.bead_side == "both":
                    for node in self.design_surface.Nodes:
                        if not node.Is(BOUNDARY):
                            alpha_i = node.GetSolutionStepValue(ALPHA)
                            penalty_value += penalty_scaling * (-alpha_i**2 +
                                                                1)

                            penalty_gradient_i = penalty_scaling * (-2 *
                                                                    alpha_i)
                            node.SetSolutionStepValue(DPDALPHA,
                                                      penalty_gradient_i)

                # Filter penalty term if specified
                if self.filter_penalty_term:
                    self.mapper.InverseMap(DPDALPHA, DPDALPHA_MAPPED)

                # Compute value of Lagrange function
                L = objective_value + current_lambda * penalty_value + 0.5 * penalty_factor * penalty_value**2
                if inner_iteration == 1:
                    dL_relative = 0.0
                else:
                    dL_relative = 100 * (L / previos_L - 1)

                # Compute gradient of Lagrange function
                if self.filter_penalty_term:
                    penalty_gradient_variable = DPDALPHA_MAPPED
                else:
                    penalty_gradient_variable = DPDALPHA
                for node in self.design_surface.Nodes:
                    dLdalpha_i = node.GetSolutionStepValue(
                        DF1DALPHA_MAPPED
                    ) + current_lambda * node.GetSolutionStepValue(
                        penalty_gradient_variable)
                    node.SetSolutionStepValue(DLDALPHA, dLdalpha_i)

                # Normalization using infinity norm
                dLdalpha_for_normalization = {}
                for node in self.design_surface.Nodes:
                    nodal_alpha = node.GetSolutionStepValue(ALPHA)
                    if nodal_alpha == self.lower_bound or nodal_alpha == self.upper_bound or node.Is(
                            BOUNDARY):
                        dLdalpha_for_normalization[node.Id] = 0.0
                    else:
                        dLdalpha_for_normalization[
                            node.Id] = node.GetSolutionStepValue(DLDALPHA)**2

                max_value = math.sqrt(max(dLdalpha_for_normalization.values()))
                if max_value == 0.0:
                    max_value = 1.0

                # Compute updated design variable
                for node in self.design_surface.Nodes:
                    dalpha = -self.step_size * node.GetSolutionStepValue(
                        DLDALPHA) / max_value
                    alpha_new = node.GetSolutionStepValue(ALPHA) + dalpha

                    # Enforce bounds
                    alpha_new = max(alpha_new, self.lower_bound)
                    alpha_new = min(alpha_new, self.upper_bound)

                    # Enforce constraints
                    if node.Is(BOUNDARY):
                        alpha_new = 0.0

                    node.SetSolutionStepValue(ALPHA, alpha_new)

                    alpha_new_vectorized = alpha_new * node.GetValue(
                        BEAD_DIRECTION)
                    node.SetSolutionStepValue(CONTROL_POINT_CHANGE,
                                              alpha_new_vectorized)

                # Map design variables
                self.mapper.Map(ALPHA, ALPHA_MAPPED)

                # Log current optimization step and store values for next iteration
                additional_values_to_log = {}
                additional_values_to_log[
                    "step_size"] = self.algorithm_settings["line_search"][
                        "step_size"].GetDouble()
                additional_values_to_log["outer_iteration"] = outer_iteration
                additional_values_to_log["inner_iteration"] = inner_iteration
                additional_values_to_log["lagrange_value"] = L
                additional_values_to_log[
                    "lagrange_value_relative_change"] = dL_relative
                additional_values_to_log["penalty_value"] = penalty_value
                additional_values_to_log["penalty_lambda"] = current_lambda
                additional_values_to_log["penalty_scaling"] = penalty_scaling
                additional_values_to_log["penalty_factor"] = penalty_factor
                additional_values_to_log[
                    "max_norm_objective_gradient"] = max_norm_objective_gradient

                self.data_logger.LogCurrentValues(total_iteration,
                                                  additional_values_to_log)
                self.data_logger.LogCurrentDesign(total_iteration)

                previos_L = L

                # Convergence check of inner loop
                if total_iteration == self.max_total_iterations:
                    is_max_total_iterations_reached = True
                    break

                if inner_iteration >= self.min_inner_iterations and inner_iteration > 1:
                    # In the first outer iteration, the constraint is not yet active and properly scaled. Therefore, the objective is used to check the relative improvement
                    if outer_iteration == 1:
                        if abs(
                                self.data_logger.GetValue(
                                    "rel_change_obj", total_iteration)
                        ) < self.inner_iteration_tolerance:
                            break
                    else:
                        if abs(dL_relative) < self.inner_iteration_tolerance:
                            break

                if penalty_value == 0.0:
                    is_design_converged = True
                    break

                print("\n> Time needed for current optimization step = ",
                      timer.GetLapTime(), "s")
                print("> Time needed for total optimization so far = ",
                      timer.GetTotalTime(), "s")

            # Compute penalty factor such that estimated Lagrange multiplier is obtained
            if outer_iteration == 1:
                penalty_factor = self.estimated_lagrange_multiplier / penalty_value

            # Update lambda
            current_lambda = current_lambda + penalty_factor * penalty_value

            print("\n> Time needed for current optimization step = ",
                  timer.GetLapTime(), "s")
            print("> Time needed for total optimization so far = ",
                  timer.GetTotalTime(), "s")

            # Check convergence of outer loop
            if outer_iteration == self.max_outer_iterations:
                print(
                    "\n> Maximal outer iterations of optimization problem reached!"
                )
                break

            if is_max_total_iterations_reached:
                print(
                    "\n> Maximal total iterations of optimization problem reached!"
                )
                break

            if is_design_converged:
                print(
                    "\n> Update of design variables is zero. Optimization converged!"
                )
                break
    def __DetermineStep(self, len_obj, dir_obj, len_eqs, dir_eqs, len_ineqs,
                        dir_ineqs):
        print("\n> Starting determination of step...")

        timer = Timer()
        timer.StartTimer()

        # Create projector object wich can do the projection in the orthogonalized subspace
        projector = Projector(len_obj, dir_obj, len_eqs, dir_eqs, len_ineqs,
                              dir_ineqs, self.algorithm_settings)

        # 1. Test projection if there is room for objective improvement
        # I.e., the actual step length to become feasible for an inactive threshold is smaller than 1 and hence a part of the step can be dedicated to objective improvement
        len_obj_test = 0.01
        inactive_threshold = 100
        test_norm_dX, is_projection_sucessfull = projector.RunProjection(
            len_obj_test, inactive_threshold)

        print("> Time needed for one projection step = ", timer.GetTotalTime(),
              "s")

        # 2. Determine step following two different modes depending on the previos found step length to the feasible domain
        if is_projection_sucessfull:
            if test_norm_dX < 1:  # Minimizing mode
                print("\n> Computing projection case 1...")

                func = lambda len_obj: projector.RunProjection(
                    len_obj, inactive_threshold)

                len_obj_min = len_obj_test
                len_obj_max = 1.3
                bi_target = 1
                bi_tolerance = self.algorithm_settings[
                    "bisectioning_tolerance"].GetDouble()
                bi_max_itr = self.algorithm_settings[
                    "bisectioning_max_itr"].GetInt()
                len_obj_result, bi_itrs, bi_err = PerformBisectioning(
                    func, len_obj_min, len_obj_max, bi_target, bi_tolerance,
                    bi_max_itr)

                projection_results = projector.GetDetailedResultsOfLatestProjection(
                )

            else:  # Correction mode
                print("\n> Computing projection case 2...")

                len_obj = self.algorithm_settings[
                    "obj_share_during_correction"].GetDouble()
                func = lambda threshold: projector.RunProjection(
                    len_obj, threshold)

                threshold_min = 0
                threshold_max = 1.3
                bi_target = 1
                bi_tolerance = self.algorithm_settings[
                    "bisectioning_tolerance"].GetDouble()
                bi_max_itr = self.algorithm_settings[
                    "bisectioning_max_itr"].GetInt()
                l_threshold_result, bi_itrs, bi_err = PerformBisectioning(
                    func, threshold_min, threshold_max, bi_target,
                    bi_tolerance, bi_max_itr)

                projection_results = projector.GetDetailedResultsOfLatestProjection(
                )
        else:
            raise RuntimeError(
                "Case of not converged test projection not yet implemented yet!"
            )

        print("\n> Time needed for determining step = ", timer.GetTotalTime(),
              "s")

        process_details = {
            "test_norm_dX": test_norm_dX,
            "bi_itrs": bi_itrs,
            "bi_err": bi_err,
            "adj_len_obj": projection_results["adj_len_obj"],
            "adj_len_eqs": projection_results["adj_len_eqs"],
            "adj_len_ineqs": projection_results["adj_len_ineqs"]
        }

        return projection_results["dX"], process_details