optimize

Optimize custom evaluation function using specified parameters

Since R2025a

Syntax

opt = optimize(obj,iterations)

Description

opt = optimize(obj,iterations) optimizes the custom evaluation function specified in the optimizer obj using the number of iterations in iterations.

Examples

Optimize Reflector Antenna for Directivity

Create a four-element linear array of dipole antennas. Use it as an exciter for a reflector antenna.

Calculate maximum directivity of this reflector antenna.

freq = 70e6;
la = linearArray(NumElements=4);
la.Tilt = 90;
referenceAnt = reflector;
referenceAnt.Exciter = la;
referenceAnt.GroundPlaneLength = 8;
referenceAnt.GroundPlaneWidth = 4;
referenceAnt.Spacing = 4;
InitialDirectivity = max(max(pattern(referenceAnt,freq)))

InitialDirectivity = 
9.9029

figure
pattern(referenceAnt,freq)

Find the lowest return loss among all ports of this antenna at 70 MHz.

sp = sparameters(referenceAnt,freq);
RetLossPort1 = 20*log10(max(abs(rfparam(sp,1,1))));
RetLossPort2 = 20*log10(max(abs(rfparam(sp,2,2))));
RetLossPort3 = 20*log10(max(abs(rfparam(sp,3,3))));
RetLossPort4 = 20*log10(max(abs(rfparam(sp,4,4))));
InitialLowestRetLossVal = max([RetLossPort1,RetLossPort2,RetLossPort3,RetLossPort4]);

Choose spacing between the dipoles of the exciter and exciter to reflector spacing as design variables. Specify the lower and upper bounds of these design variables.

Use the TR-SADEA optimizer to optimize this reflector antenna for its directivity and return loss. Specify an evaluation function for optimization using the CustomEvaluationFunction property of the OptimizerTRSADEA object. The evaluation function used in this example is defined at the end of this example.

Set the maximum number of function evaluations to 90 and initial population sample size to 10. Setting these parameters is optional. The TR-SADEA optimizer calculates best sample size automatically if you do not specify it.

Bounds = [0.1 0.1; 10 10];
s = OptimizerTRSADEA(Bounds);
s.CustomEvaluationFunction = @customEvaluationWithConstraint2;
setMaxFunctionEvaluations(s,90);
defineInitialPopulation(s,10);

Validate the optimizer setup. Run the optimization for 50 iterations and check if maximum function evaluations have been reached. Observe the convergence trends plot.

validateSetup(s)

ans = logical
   1

optimize(s,50);
flag0 = isFunctionEvaluationsExhausted(s)

flag0 = logical
   0

showConvergenceTrend(s)

View the best member data.

bestDesign = s.getBestMemberData

bestDesign = 
  bestMemberData with properties:

             member: [7.6028 5.3499]
       performances: -6.4699
            fitness: -6.4699
    bestIterationId: 47

bestDesignValues = bestDesign.member

bestDesignValues = 1×2

    7.6028    5.3499

Update the reference antenna with design values obtained from the optimization and calculate the directivity.

Observe the increase in directivity post optimization.

referenceAnt.Exciter.ElementSpacing = bestDesignValues(1);
referenceAnt.Spacing = bestDesignValues(2);
postOptimizationDirectivity = max(max(pattern(referenceAnt,freq)))

postOptimizationDirectivity = 
11.4678

figure
pattern(referenceAnt,freq)

Calculate the post optimization return loss. Use the lowest return loss value among all ports.

Observe that the value of return loss after optimization is better than its previous value.

sp = sparameters(referenceAnt,freq);
RetLossPort1 = 20*log10(max(abs(rfparam(sp,1,1))));
RetLossPort2 = 20*log10(max(abs(rfparam(sp,2,2))));
RetLossPort3 = 20*log10(max(abs(rfparam(sp,3,3))));
RetLossPort4 = 20*log10(max(abs(rfparam(sp,4,4))));
NewLowestRetLossVal = max([RetLossPort1,RetLossPort2,RetLossPort3,RetLossPort4]);

Check the exit status of the optimizer.

flag1 = isFunctionEvaluationsExhausted(s)

flag1 = logical
   0

flag2 = checkExitCondition(s)

flag2 = logical
   0

Restore the optimizer parameters to their previous successful iteration values. Use this step if the current iteration is interrupted and the iteration data is incomplete.

res = performRestore(s)

res = 
  OptimizerTRSADEA with properties:

                      Bounds: [2×2 double]
    CustomEvaluationFunction: @customEvaluationWithConstraint2
                     Weights: []
                 UseParallel: 0
        GeometricConstraints: [1×1 struct]
                   EnableLog: 0

This code defines the evaluation function used in this example.

function fitness = customEvaluationWithConstraint2(designVariables)
    
        % Create geometry
        la = linearArray(NumElements=4);
        la.Tilt = 90;
        la.ElementSpacing = designVariables(1);
        r = reflector;
        r.Exciter = la;
        r.GroundPlaneLength = 8;
        r.GroundPlaneWidth = 4;
        r.Spacing = designVariables(2);
  
        % Calculate realized gain 
        objective = max(max(pattern(r, 70e6)));
        objective = -objective; % As optimizer always minimizes objective, 
        % sign is reversed to maximize gain.
 
        % Constraints s11 < -10
        % Calculate S-parameters
        freq = 70e6;
        s = sparameters(r,freq);
        RetLossPort1 = 20*log10(max(abs(rfparam(s,1,1))));
        RetLossPort2 = 20*log10(max(abs(rfparam(s,2,2))));
        RetLossPort3 = 20*log10(max(abs(rfparam(s,3,3))));
        RetLossPort4 = 20*log10(max(abs(rfparam(s,4,4))));
        lowestRetLossVal = max([RetLossPort1,RetLossPort2,RetLossPort3,RetLossPort4]);
        expVal = -20;
       
        % As constraint is satisfied when it is less than -20 dB, better
        % values are made to be equal to -20 dB to not affect optimizer
        % direction.
        constraint = (lowestRetLossVal-expVal);
        constraint = max(constraint,0);
        
        % Handle errors during S-parameters computation.
        % High penalty value is used to handle errors.  
        fitness = objective + constraint;

end

Input Arguments

obj — Optimizer

OptimizerSADEA object | OptimizerTRSADEA object

Optimizer, specified as an OptimizerSADEA or OptimizerTRSADEA object. The function optimizes the custom evaluation function associated with the optimizer object specified in obj.

Example: OptimizerSADEA

iterations — Number of iterations for optimization

positive integer

Number of iterations for optimization, specified as a positive integer.

Example: 100

Data Types: double

Output Arguments

opt — Optimized custom evaluation function parameters

OptimizerSADEA object | OptimizerTRSADEA object

Optimized custom evaluation function parameters, returned as an OptimizerSADEA or OptimizerTRSADEA object. Use the getBestMemberData function to access the optimization results.

Version History

Introduced in R2025a