# Multi-objective optimization¶

class rtctools.optimization.goal_programming_mixin.Goal

Bases: object

Base class for lexicographic goal programming goals.

A goal is defined by overriding the function() method, and setting at least the function_range class variable.

Variables: function_range – Range of goal function. Required. function_nominal – Nominal value of function. Used for scaling. Default is 1. target_min – Desired lower bound for goal function. Default is numpy.nan. target_max – Desired upper bound for goal function. Default is numpy.nan. priority – Integer priority of goal. Default is 1. weight – Optional weighting applied to the goal. Default is 1.0. order – Penalization order of goal violation. Default is 2. critical – If True, the algorithm will abort if this goal cannot be fully met. Default is False.

The target bounds indicate the range within the function should stay, if possible. Goals are, in that sense, soft, as opposed to standard hard constraints.

Four types of goals can be created:

1. Minimization goal if no target bounds are set:

$\min f$
2. Lower bound goal if target_min is set:

$m \leq f$
3. Upper bound goal if target_max is set:

$f \leq M$
4. Combined lower and upper bound goal if target_min and target_max are both set:

$m \leq f \leq M$

Lower priority goals take precedence over higher priority goals.

Goals with the same priority are weighted off against each other in a single objective function.

The goal violation value is taken to the order’th power in the objective function of the final optimization problem.

Example definition of the point goal $$x(t) \geq 1.1$$ for $$t=1.0$$ at priority 1:

class MyGoal(Goal):
def function(self, optimization_problem, ensemble_member):
# State 'x' at time t = 1.0
t = 1.0
return optimization_problem.state_at('x', t, ensemble_member)

function_range = (1.0, 2.0)
target_min = 1.1
priority = 1


Example definition of the path goal $$x(t) \geq 1.1$$ for all $$t$$ at priority 2:

class MyPathGoal(Goal):
def function(self, optimization_problem, ensemble_member):
# State 'x' at any point in time
return optimization_problem.state('x')

function_range = (1.0, 2.0)
target_min = 1.1
priority = 2


Note that for path goals, the ensemble member index is not passed to the call to OptimizationProblem.state(). This call returns a time-independent symbol that is also independent of the active ensemble member. Path goals are applied to all times and all ensemble members simultaneously.

function(self, optimization_problem, ensemble_member)

This method returns a CasADi MX object describing the goal function.

Returns: A CasADi MX object.
get_function_key(self, optimization_problem, ensemble_member)

Returns a key string uniquely identifying the goal function. This is used to eliminate linearly dependent constraints from the optimization problem.

has_target_bounds

True if the user goal has min/max bounds.

has_target_max

True if the user goal has max bounds.

has_target_min

True if the user goal has min bounds.

is_empty
class rtctools.optimization.goal_programming_mixin.StateGoal

Base class for lexicographic goal programming path goals that act on a single model state.

A state goal is defined by setting at least the state class variable.

Variables: state – State on which the goal acts. Required. target_min – Desired lower bound for goal function. Default is numpy.nan. target_max – Desired upper bound for goal function. Default is numpy.nan. priority – Integer priority of goal. Default is 1. weight – Optional weighting applied to the goal. Default is 1.0. order – Penalization order of goal violation. Default is 2. critical – If True, the algorithm will abort if this goal cannot be fully met. Default is False.

Example definition of the goal $$x(t) \geq 1.1$$ for all $$t$$ at priority 2:

class MyStateGoal(StateGoal):
state = 'x'
target_min = 1.1
priority = 2


Contrary to ordinary Goal objects, PathGoal objects need to be initialized with an OptimizationProblem instance to allow extraction of state metadata, such as bounds and nominal values. Consequently, state goals must be instantiated as follows:

my_state_goal = MyStateGoal(optimization_problem)


Note that StateGoal is a helper class. State goals can also be defined using Goal as direct base class, by implementing the function method and providing the function_range and function_nominal class variables manually.

__init__(self, optimization_problem)

Initialize the state goal object.

Parameters: optimization_problem – OptimizationProblem instance.
class rtctools.optimization.goal_programming_mixin.GoalProgrammingMixin

Adds lexicographic goal programming to your optimization problem.

goal_programming_options(self)

Returns a dictionary of options controlling the goal programming process.

Option Type Default value
constraint_relaxation float 0.0
violation_tolerance float inf
mu_reinit bool True
fix_minimized_values bool True
check_monotonicity bool True
equality_threshold float 1e-8

Constraints generated by the goal programming algorithm are relaxed by applying the specified relaxation. Use of this option is normally not required.

A goal is considered to be violated if the violation, scaled between 0 and 1, is greater than the specified tolerance. Violated goals are fixed. Use of this option is normally not required.

The Ipopt barrier parameter mu is normally re-initialized a every iteration of the goal programming algorithm, unless mu_reinit is set to False. Use of this option is normally not required.

If fix_minimized_values is set to True, goal functions will be set to equal their optimized values in optimization problems generated during subsequent priorities. Otherwise, only as upper bound will be set. Use of this option is normally not required.

If check_monotonicity is set to True, then it will be checked whether goals with the same function key form a monotonically decreasing sequence with regards to the target interval.

The option equality_threshold controls when a two-sided inequality constraint is folded into an equality constraint.

The option interior_distance controls the distance from the scaled target bounds, starting from which the function value is considered to lie in the interior of the target space.

Returns: A dictionary of goal programming options.
goals(self)

User problem returns list of Goal objects.

Returns: A list of goals.
path_goals(self)

User problem returns list of path Goal objects.

Returns: A list of path goals.
priority_completed(self, priority)

Called after optimization for goals of certain priority is completed.

Parameters: priority – The priority level that was completed.
priority_started(self, priority)

Called when optimization for goals of certain priority is started.

Parameters: priority – The priority level that was started.