Optimizer (GenOpt Code Documentation)

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

genopt.algorithm
Class Optimizer

java.lang.Object
  genopt.algorithm.Optimizer

Direct Known Subclasses:: DiscreteArmijoGradient, Mesh, ModelFiniteIntervalSearcher, ModelGPS, ModelPSO, NelderMeadONeill, Parametric

public abstract class Optimizer
extends java.lang.Object
extends java.lang.Object

Abstract Class that represents the structure of an optimization algorithm class and offers generic methods to run the optimization.
All optimization algorithms must extend this class. Note that many data fields are static. This is needed for the hybrid algorithms.

This project was carried out at:

Lawrence Berkeley National Laboratory (LBNL), Simulation Research Group,

and supported by

the U.S. Department of Energy (DOE),
the Swiss Academy of Engineering Sciences (SATW),
the Swiss National Energy Fund (NEFF), and
the Swiss National Science Foundation (SNSF)

GenOpt Copyright (c) 1998-2011, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy). All rights reserved.

Version:: GenOpt(R) 3.1.0 (December 8, 2011)
Author:: Michael Wetter

Field Summary
`private static java.io.StreamTokenizer`	`algorithm` The section `Algorithm` of the command file
`private int`	`conMode` flag for indicating how constraints are treated
`private static GenOpt`	`data` The reference to the GenOpt kernel
`private static int`	`dimCon` The number of independent, continuous variables
`private static int`	`dimDis` The number of independent, discrete variables
`private static int`	`dimF` The number of cost function values
`private static int`	`dimInpFun` The number of input functions
`private static int`	`dimX` The number of independent variables (sum of continuous and discrete)
`static java.util.concurrent.CountDownLatch`	`done` Count down latch for parallel function evaluations
`private static java.util.Map<Point,java.lang.Double[]>`	`evaPoi` The list with evaluated points and its function values.
`static int`	`EXCLUDING` constant to indicate strict inequality
`private boolean`	`firstSimulations` Flag that indicates whether the set of points that are currently evaluated are the first simulations.
`protected static java.lang.String`	`FS` System dependent file separator
`private static java.util.concurrent.atomic.AtomicBoolean`	`functionValuesParsed` Flag that indicates whether function values have been parsed at least once
`private java.util.concurrent.CountDownLatch`	`funValParLat` Count down latch, if 0, the function value pointer `funValPoi` has been set
`private static int[]`	`funValPoi` pointer that assign to each objective function value the number of the output file in which it is stored
`static int`	`INCLUDING` constant to indicate weak inequality
`protected static java.lang.String`	`LS` System dependent line separator
`static boolean`	`MAINITERATION` constant to indicate that it is a main iteration
`private static int`	`maxThrPoo` The maximum number of threads in the pool
`private static java.lang.String[]`	`nameF` The name of the function values
`private static int`	`nSimInpFil` The number of the simulation input files
`private static int`	`nSimLogFil` The number of the simulation log files
`private static int`	`nSimOutFil` The number of the simulation output files
`private static ObjectiveFunctionLocation[]`	`objFunObj` The objective function objects
`private static java.lang.String`	`optComFilNam` The name of the optimization command file
`static int`	`ORIGINAL` constant for indicating that the optimization is in the original space
`private static java.lang.String`	`separator` Separator that separate the objective function value from the values behind it.
`private static FileHandler[]`	`simInpTemFilHan` The simulation input template file handler
`private static int`	`stepNumber` The step number (for implementing variation of the weighting factors for penalty function and barrier function
`static boolean`	`SUBITERATION` constant to indicate that it is a sub iteration
`static int`	`TRANSFORMED` constant for indicating that the optimization is in the transformed space
`private static boolean`	`useSteNum` A flag to indicate whether the step number is used by the optimization algorithm.
`private static boolean`	`wriSteNum` A flag to indicate whether the step number has to be written in the simulation input file (and hence a simulation done)

Constructor Summary
	`Optimizer()` Constructor
`protected`	`Optimizer(GenOpt genOptData, int constraintMode)` Constructor

Method Summary
`private void`	`_copyRunFiles(java.lang.String[] savePath, java.lang.String[] path, java.lang.String[] name, int simNum)` Copies the files from `path` to `savePath` and adds the run number in front of the file name.
`private void`	`_deleteRunFiles(java.lang.String[] path, java.lang.String[] name)` Deletes the run files specified by path and name.
`private Point`	`_evaluateSimulation(Point x)` Evaluates the simulation writes a new input file launches the simulation checks for simulation errors returns an array with the values of the objective function
`private static double[]`	`_processResultFunction(java.lang.String[] formula, double[] objFunVal)` Process the function objects for post processing of the objective function.
`private static boolean`	`_replaceInInputFile(java.lang.String text, java.lang.String value, FileHandler[] simulationInput)` Replaces `text` with `value` in `simulationInput`.
`private Point`	`_retryEvaluateSimulation(Point x, java.lang.Throwable t)` Tries to evaluate the simulation a second time if an exception has been thrown
`private static double`	`_setToFeasibleCoordinate(double x, double l, double u)` Computes `x := 2 * l - x` if `x < l`, or `x := 2 * u - x` if `x < u`.
`private static int`	`_setToFeasibleCoordinate(int x, int l, int u)` Computes `x := 2 * l - x` if `x < l`, or `x := 2 * u - x` if `x < u`.
`private static void`	`_variableNotFound(java.lang.String variableName)` Throws a `SimulationInputException` that says that the variable could not be found.
`protected void`	`algorithmRequiresUsageOfStepNumber()` A call to this method sets `useSteNum = true`.
`void`	`appendToOutputListing(java.lang.String s)` appends a String to the output listing files
`protected boolean`	`checkMaxIteration()` Checks if the maximum number of iteration is exceeded
`void`	`checkObjectiveFunctionValue(Point x)` Checks whether the last objective function value has already been obtained previously.
`protected void`	`ensureOnlyContinuousParameters()` Checks whether all independent parameters are continuous.
`protected void`	`ensureOnlyDiscreteParameters()` Checks whether all independent parameters are discrete.
`protected double`	`getAbsAccuracyFunction()` Gets the absolute accuracy of the last two main iterations
`int`	`getDimensionContinuous()` Gets the number of independent, continuous variables
`int`	`getDimensionDiscrete()` Gets the number of independent, continuous variables
`int`	`getDimensionF()` Gets the number of function values
`int`	`getDimensionX()` Gets the number of independent variables (sum of continuous and discrete)
`double`	`getDiscreteValueDouble0(int variableNumber)` Gets the double representation of the `variableNumber`-th discrete parameter as specified in the command file If the variable represents discrete numerical values, then the double value of the currently selected value is returned.
`double`	`getDx(int i, double x)` Gets the step size `dx[i]` of the i-th continuous variable Note: `dx[i]` might be in the transformed space depending on the value of `conMode`.
`double`	`getDx0(int i)` Gets the step size `dx[i]` of the i-th continuous variable as specified in the command file.
`Point`	`getF(Point x)` Evaluates the simulation for the point x The value `conMode` determines in which mode the constraints are treated.
`Point[]`	`getF(Point[] x, boolean stopAtError)` Evaluates the simulation for the point x The value `conMode` determines in which mode the constraints are treated.
`int[]`	`getIndex0()` Gets the indices of the discrete variable `x`
`int`	`getIndex0(int i)` Gets the value (i.e., the index) of `x[i]`
`protected boolean`	`getInputValueBoolean(java.lang.String keyWord)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`protected double`	`getInputValueDouble(java.lang.String keyWord)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`protected double`	`getInputValueDouble(java.lang.String keyWord, double min, double minEqu, double max, double maxEqu)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`protected int`	`getInputValueInteger(java.lang.String keyWord)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`protected int`	`getInputValueInteger(java.lang.String keyWord, int min, int minEqu, int max, int maxEqu)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`protected java.lang.String`	`getInputValueString(java.lang.String keyWord)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`protected java.lang.String`	`getInputValueString(java.lang.String keyWord, java.lang.String[] admVal)` Gets the value of `keyWord` from the `algorithmEntry` If another String than `keyWord` is at the current position of the `algorithmEntry`, an InputFormatException is thrown
`int`	`getKindOfConstraint(int i)` Gets the kind of constraint that is imposed on the i-th continuous variable
`double`	`getL(int i)` Gets the lower bound `l[i]` of the continuous variable `x[i]`
`int`	`getLengthDiscrete(int i)` Gets the number of elements of the i-th discrete variable
`protected int`	`getMainIterationNumber()` Gets the main iteration number
`static int`	`getMaximumThreadPoolSize()` Returns the maximum size of the thread pool
`protected int`	`getMaxIterationNumber()` Gets the maximum number of allowed main iterations
`Point`	`getMinimumPoint()` Gets the minimum point.
`int`	`getMode()` Gets the mode of the optimization
`java.lang.String`	`getObjectiveFunctionName(int i)` Gets the name of the `i`-th objective function value.
`protected java.lang.String`	`getOutputPath()` Gets the output path.
`static int[]`	`getPointerToEqualPoints(Point[] x)` Gets an integer array that shows what points are equals.
`protected double`	`getRelAccuracyFunction()` Gets the relative accuracy of the last two main iterations
`protected static int`	`getSimulationNumber()` Gets the number of simulation.
`protected int`	`getStepNumber()` Gets the current step number
`double`	`getU(int i)` Gets the upper bound `u[i]` of the continuous variable `x[i]`
`java.lang.String`	`getVariableNameContinuous(int i)` Gets the name of the continuous variable `x[i]`
`java.lang.String`	`getVariableNameDiscrete(int i)` Gets the name of the discrete variable `x[i]`
`double[]`	`getX0()` Gets the values of the continuous variable `x` Note: `x` might be in the transformed space depending on the value of `conMode`
`double`	`getX0(int i)` Gets the value of `x[i]` Note: `x[i]` might be in the transformed space depending on the value of `conMode`
`void`	`goToEndOfCommandFile()` Checks whether the current section is closed and then moves to the end of the file.
`protected void`	`increaseStepNumber()` Increases the step number without a function evaluation.
`protected Point`	`increaseStepNumber(Point x)` Increases the step number.
`protected boolean`	`isFeasible(Point x)` Checks whether a point is feasible.
`boolean`	`isNextToken(java.lang.String keyWord)` Checks whether the next Token is equal to the passed String.
`protected boolean`	`maxIterationReached()` Checks if the maximum number of iteration is reached.
`boolean`	`mustStopOptimization()` Returns a flag that indicates whether GenOpt must be stopped after the current simulation (due to a user request).
`void`	`print(java.lang.String text)` Prints a message to the output device without finishing the line Note: Use this method instead of `System.out.printl(String)`, otherwise it won't be reported in the GUI
`void`	`println(java.lang.String text)` Prints a message to the output device, and then finishs the line Note: Use this method instead of `System.out.println(String)`, otherwise it won't be reported in the GUI
`protected static boolean`	`replace(java.lang.String[] strArr, java.lang.String text, java.lang.String value)` Replaces `text` with `value` in input functions.
`void`	`report(Point x, boolean MainIteration)` Reports an iterate to the output files and to the internal data structure reports the new trial reports the objective function value increases the number of the iteration Note: If a sub iteration is also a main iteration, then you have to call this function twice, first with `MainIteration = false` and then with `MainIteration = true`
`protected void`	`reportCurrentLowestPoint()` Reports the current lowest point for the case that GenOpt has to terminate.
`protected void`	`reportMinimum()` Reports the minimum point.
`protected static void`	`resetStepNumber(int sN)` Sets the step number.
`protected static Point`	`roundCoordinates(Point x)` Rounds the coordinates of the continuous parameters to float format.
`int`	`run()` Method for running the optimization algorithm until a termination criteria is satisfied.
`abstract int`	`run(Point x0)` Abstract method for running the optimization algorithm until a termination criteria is satisfied
`protected void`	`setInfo(java.lang.String s, int simNum)` Sets a message in the InformationManager The message will be displayed in the output stream (GUI in WinGenOpt, command shell otherwise) and in the log file
`private boolean[]`	`setKnownFunctionValues(Point[] x)` Sets the function values in these points that are already known.
`void`	`setMode(int constraintMode)` Sets the mode of the optimization
`protected void`	`setNumberOfMatchingResults(int maxNumberOfMatchingResults)` Sets the maximal allowed number of matching results
`static double`	`setToFeasibleCoordinate(double x, double l, double u)` Restricts the value of `x` such that `l <= x <= u`.
`static int`	`setToFeasibleCoordinate(int x, int l, int u)` Restricts the value of `x` such that `l <= x <= u`.
`protected void`	`setWarning(java.lang.String s, int simNum)` Sets a message in the WarningManager.
`void`	`simulate(Point x)` Evaluates the simulation based on the parameter set x
`protected void`	`throwInputError(java.lang.String expectedValue)` Throws an input error.
`boolean`	`useStepNumber()` Returns the flag that indicates whether the step number is used by the optimization algorithm.
`boolean`	`writeStepNumber()` Returns the flag that indicates whether the step number has to written to the simulation input file or not.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

LS

protected static final java.lang.String LS

System dependent line separator

FS

protected static final java.lang.String FS

System dependent file separator

MAINITERATION

public static final boolean MAINITERATION

constant to indicate that it is a main iteration

See Also:: Constant Field Values

SUBITERATION

public static final boolean SUBITERATION

constant to indicate that it is a sub iteration

See Also:: Constant Field Values

ORIGINAL

public static final int ORIGINAL

constant for indicating that the optimization is in the original space

See Also:: Constant Field Values

TRANSFORMED

public static final int TRANSFORMED

constant for indicating that the optimization is in the transformed space

See Also:: Constant Field Values

EXCLUDING

public static final int EXCLUDING

constant to indicate strict inequality

See Also:: Constant Field Values

INCLUDING

public static final int INCLUDING

constant to indicate weak inequality

See Also:: Constant Field Values

conMode

private int conMode

flag for indicating how constraints are treated

dimCon

private static int dimCon

The number of independent, continuous variables

dimDis

private static int dimDis

The number of independent, discrete variables

dimX

private static int dimX

The number of independent variables (sum of continuous and discrete)

dimInpFun

private static int dimInpFun

The number of input functions

dimF

private static int dimF

The number of cost function values

nameF

private static java.lang.String[] nameF

The name of the function values

done

public static java.util.concurrent.CountDownLatch done

Count down latch for parallel function evaluations

data

private static GenOpt data

The reference to the GenOpt kernel

algorithm

private static java.io.StreamTokenizer algorithm

The section Algorithm of the command file

optComFilNam

private static java.lang.String optComFilNam

The name of the optimization command file

separator

private static java.lang.String separator

Separator that separate the objective function value from the values behind it. Separators additional to whitespace characters are specified in the properties.txt file

stepNumber

private static int stepNumber

The step number (for implementing variation of the weighting factors for penalty function and barrier function

wriSteNum

private static boolean wriSteNum

A flag to indicate whether the step number has to be written in the simulation input file (and hence a simulation done)

useSteNum

private static boolean useSteNum

A flag to indicate whether the step number is used by the optimization algorithm. It is used if either wriSteNum = true or if the algorithm requires explicitly the step number to be used. This is typically the case for algorithm that construct at some point a surrogate function and then only seek to optimize the surrogate.

simInpTemFilHan

private static FileHandler[] simInpTemFilHan

The simulation input template file handler

objFunObj

private static ObjectiveFunctionLocation[] objFunObj

The objective function objects

nSimInpFil

private static int nSimInpFil

The number of the simulation input files

nSimLogFil

private static int nSimLogFil

The number of the simulation log files

nSimOutFil

private static int nSimOutFil

The number of the simulation output files

funValPoi

private static int[] funValPoi

pointer that assign to each objective function value the number of the output file in which it is stored

evaPoi

private static java.util.Map<Point,java.lang.Double[]> evaPoi

The list with evaluated points and its function values. Prior to evaluating the cost function, this list is checked whether it contains the same point, where equality is defined by the implementation of genopt.algorithm.util.math.Point.compareTo(java.lang.Object o)

maxThrPoo

private static int maxThrPoo

The maximum number of threads in the pool

functionValuesParsed

private static java.util.concurrent.atomic.AtomicBoolean functionValuesParsed

Flag that indicates whether function values have been parsed at least once

funValParLat

private java.util.concurrent.CountDownLatch funValParLat

Count down latch, if 0, the function value pointer funValPoi has been set

firstSimulations

private boolean firstSimulations

Flag that indicates whether the set of points that are currently evaluated are the first simulations. If the flag is true, then no second simulation is done in case of an error.

Constructor Detail

Optimizer

protected Optimizer(GenOpt genOptData,
                    int constraintMode)
             throws InputFormatException,
                    OptimizerException,
                    java.io.IOException,
                    java.lang.Exception

Constructor

Parameters:

genOptData - a reference to the GenOpt object.
Note: The object is used as a reference. Hence, the data of GenOpt are modified by this Class.

constraintMode - a flag indicating how constraints are treated

 0: optimization is in original space (constraints are not taken into account)
 1: optimization is in transformed space

Throws:

InputFormatException - if an error occurs while searching for Main in the Algorithm section

java.io.IOException - if an I/O exception occurs

java.lang.Exception - in an exception occurs

OptimizerException

Optimizer

public Optimizer()

Constructor

Method Detail

resetStepNumber

protected static void resetStepNumber(int sN)

Sets the step number. This method is used by multi-start algorithms. This method must not be used to decrease the step number

Parameters:: sN -

getOutputPath

protected java.lang.String getOutputPath()

Gets the output path.

Algorithms that write their own output files should write them to the directory returned by this function.

Returns:: the output path

ensureOnlyContinuousParameters

protected void ensureOnlyContinuousParameters()
                                       throws OptimizerException

Checks whether all independent parameters are continuous. If any independent parameter is not continuous, then an OptimizerException is thrown (with an descriptive information)

Throws:: OptimizerException - if some independent parameters are not continuous

ensureOnlyDiscreteParameters

protected void ensureOnlyDiscreteParameters()
                                     throws OptimizerException

Checks whether all independent parameters are discrete. If any independent parameter is not discrete, then an OptimizerException is thrown (with an descriptive information)

Throws:: OptimizerException - if some independent parameters are not discrete

_deleteRunFiles

private void _deleteRunFiles(java.lang.String[] path,
                             java.lang.String[] name)
                      throws java.lang.Exception

Deletes the run files specified by path and name. Deletes the directory if it is empty

Parameters:: path - path of the files; name - name of the files
Throws:: java.lang.Exception - if a SecurityException occured

_copyRunFiles

private void _copyRunFiles(java.lang.String[] savePath,
                           java.lang.String[] path,
                           java.lang.String[] name,
                           int simNum)
                    throws java.lang.SecurityException,
                           java.lang.Exception

Copies the files from path to savePath and adds the run number in front of the file name.

Parameters:: savePath - path where the files have to be copied to. If it does not exist, it will be created.; path - source path of the files; name - name of the files; simNum - The number of the simulation
Throws:: java.lang.SecurityException - if a SecurityException occured; java.lang.Exception - if the directory could not be made

algorithmRequiresUsageOfStepNumber

protected final void algorithmRequiresUsageOfStepNumber()

A call to this method sets useSteNum = true. This method is typically called by multiple layer algorithm that optimize different functions during the whole optimization. An example for such an algorithm is one that -- after some iterations -- constructs a surrogate function and then only attempts to optimize the surrogate, neglecting all previous results.

increaseStepNumber

protected final void increaseStepNumber()

Increases the step number without a function evaluation.
If WriteStepNumber is set to false, then the step number is not increased

See Also:: increaseStepNumber(Point)

increaseStepNumber

protected final Point increaseStepNumber(Point x)
                                  throws SimulationInputException,
                                         OptimizerException,
                                         java.lang.Exception

Increases the step number.
If the variable WriteStepNumber in the optimization command file is set to true, the function getF(Point x) is called and the new point is returned.
If WriteStepNumber is set to false, then the step number is not increased, and no simulation is done. The passed argument x is returned.
Note: You must call this function everytime when the optimization constructed a convergent sequence. This method increases a counter that can be used to implement penalty function and barrier function in the cost function.

Parameters:: x - the new point for the simulation
Returns:: the new point
Throws:: OptimizerException - if an OptimizerException occurs; SimulationInputException - if an error in writing the simulation input file occurs; java.lang.Exception - if an Exception occurs
See Also:: getF(Point)

writeStepNumber

public final boolean writeStepNumber()

Returns the flag that indicates whether the step number has to written to the simulation input file or not.
Note: If this method returns true, then after each iteration step, the method increaseStepNumber(...) has to be called in order to allow the implementation of penalty function, barrier function and slackness variables.

Returns:: true if the step number has to written, false otherwise

useStepNumber

public final boolean useStepNumber()

Returns the flag that indicates whether the step number is used by the optimization algorithm. It is used if either wriSteNum = true or if the algorithm requires explicitly the step number to be used. Note that useStepNumber() always returns true if writeStepNumber() returns true, but writeStepNumber() may return false if useStepNumber() returns true.

getStepNumber

protected int getStepNumber()

Gets the current step number

Returns:: the current step number

goToEndOfCommandFile

public void goToEndOfCommandFile()
                          throws InputFormatException,
                                 java.io.IOException

Checks whether the current section is closed and then moves to the end of the file. If either of the operation fails, an InputFormatException is thrown.
Note: This method is called from the GenOpt kernel to ensure that all the information in the command file is parsed properly

Throws:: InputFormatException - if either of the checks fails; java.io.IOException - if the optimization command file cannot be accessed

isNextToken

public final boolean isNextToken(java.lang.String keyWord)
                          throws java.io.IOException

Checks whether the next Token is equal to the passed String.

Parameters:: keyWord - the keyword that has to be searched for
Returns:: true if the next Token equals the value of keyWord, false otherwise
Throws:: java.io.IOException - if the optimization command file cannot be accessed