E S Fraga: Jacaranda blog

Consider the following Jacaranda input file:

use jacaranda.base

define
  variable x1upper 2.5  # this will be used to set a GAMS value below
end

EGO gamsmodel
  model gams
    code test.gms       # where the base gams model code is
    command "/opt/gams/22.8/gams" # how to run gams on this system
    # use x1upper Jacaranda variable to set GAMS variable X1.UP
    in x1upper X1.UP
    # and take result from GAMS of z and place in Jacaranda's z value
    out z.l z 
    objective "solve test using nlp minimizing z"
    result z            # evaluate this expression to generate result
  end
  evaluatemodel         # do it!
  print
end

This example creates a simple object which defines the model associated with the object as being an external GAMS model. The GAMS model is in the file test.gms and includes everything but the actual solve directive. The solve directive is specified by the objective statement in Jacaranda.

The test code for this example is here:

$TITLE Test Problem 
$OFFSYMXREF 
$OFFSYMLIST 

* Example from Problem 8.26 in "Engineering Optimization" 
* by Reklaitis, Ravindran and Ragsdell (1983) 
* Code from
* http://www.che.boun.edu.tr/courses/che477/gms-mod.html#TEST.GMS
* (from a course by Ignacio Grossmann)

VARIABLES X1, X2, X3, Z ; 
POSITIVE VARIABLES X1, X2, X3 ; 

EQUATIONS CON1, CON2, CON3, OBJ ; 

CON1..  X2 - X3 =G= 0 ; 
CON2..  X1 - X3 =G= 0 ; 
CON3..  X1 - X2**2 + X1*X2 - 4 =E= 0 ; 
OBJ..   Z =E= SQR(X1) + SQR(X2) + SQR(X3) ; 

* Upper bounds 
  X1.UP = 5 ; 
  X2.UP = 3 ; 
  X3.UP = 3 ; 

* Initial point 
  X1.L = 4 ; 
  X2.L = 2 ; 
  X3.L = 2 ; 

MODEL TEST / ALL / ; 

OPTION LIMROW = 0; 
OPTION LIMCOL = 0; 

The Jacaranda input defines a new value for the upper bound on X1 and the result of evaluating the model is the value of the z variable, specifically the level of that variable, z.l. The in and out directives specify how to bring values in to the model from Jacaranda and then back out again.

The output from Jacaranda, in org-mode in Emacs, can be seen here:

where we can see that the result of solving the GAMS model is 7.25. This is actually a higher value than the optimum because we have restricted variable X1 to a smaller upper bound, to illustrate the transfer of values from Jacaranda to GAMS, and the optimum lies above this upper bound.

The result can be any expression and not just a single variable. The expression uses Jacaranda's own modelling language but has access to any variables exported from the GAMS model (z.l in this case). Any number of variables can be imported into the GAMS model and any number exported as well.

The following figure shows the three base classes which make up the genetic algorithm system. The GA class is the main controlling class. It will have a single population which must be provided during the definition of an instance of the GA object. The population will consist of a set of chromosomes, with the initialisation requiring the provision of a single chromosome to seed the population. The population may also be given diversity and selection objects which are discussed below. The chromosome is an interface; there is at least one base implementation, also described below, but it is through defining a new chromosome implementation that the method can be tailored for specific problems.

An implementation of the Chromosome interface, VariableEncodedChromosome, is available in Jacaranda, suitable for general MINLP (mixed integer nonlinear programme) problems. These problems are defined by a combination of real and integer decision or optimisation variables, one or more objective functions, possibly constraint equations, both equality and inequality, and bounds on the decision variables. This general Chromosome implementation is actually more general than this and is suitable for any object that can be encoded into and decoded from a combination of real and integer variables but whose fitness can be evaluated through an objective function object.

The mate and mutate methods use appropriate operations for MINLP problems. Specifically, the crossover operation is based on a multi-point crossover across both real and integer variables. The mutation operator selects on variable, randomly from the set of both real and integer variables, and gives it a new value randomly from the domain for that variable. These operators are actually implemented by the Encoding implementation. The default encoding used by the VariableEncodedChromosome is the GeneralEncoding class. Alternative encodings include the BoundaryMutationEncoding, which replaces the mutation operation with one which emphasises a move to the boundaries for the selected variable, and the BinaryEncoding, which encodes each real and integer value in a prespecified number of bits for each variable.

The NLP and MINLP classes implement the ObjectiveFunction interface and provide the ability to define the actual objective functions (Jacaranda support multi-objective optimisation fully), equality and inequality constraints and the lower and upper bounds on the decision variables.

1 use jacaranda.util.opt 2 3 echo "----------------------------------------------- Objective function" 4 MINLP model 5 # objective function with both real, x, and integer, y, variables 6 f "(x[0]-5)^2+(x[1]-3)^2-y*sqrt($x)" 7 # inequality contraints. 8 g "{ 2-(x[0]+x[1]), (x[0]+x[1])-10 }" 9 # lower and upper bounds 10 a "{0, 0}" "0" 11 b "{10, 10}" "1" 12 end 13 14 echo "----------------------------------------------- Chromosome" 15 VariableEncodedChromosome var 16 function model 17 end 18 19 echo "----------------------------------------------- Selection" 20 RouletteSelection roulette 21 end 22 23 echo "----------------------------------------------- Population" 24 Population pop 25 chromosome var 26 crossover 0.75 27 elite 1 28 mutation 0.02 29 n 20 30 selection roulette 31 end 32 33 echo "----------------------------------------------- GA" 34 GA ga 35 outputlevel 2 36 population pop 37 ngen 50 38 solve 39 print 40 end

An interface to Jacaranda from Octave (a tool similar to, and often very compatible with, Matlab) is potentially very useful, especially in the context of optimisation. Jacaranda provides a framework for process definitions, including simple or complex physical properties and processing units. Although Jacaranda has a number of optimisation methods included, it is not meant to be all-encompassing. As much of the optimisation research world-wide uses Octave or Matlab, an interface from Octave (due to its open source nature in preference to the proprietary and closed source Matlab) can be useful.

Previous versions of Jacaranda have included such an interface. However, the interface was based on the use of socket communication which could be slow when many objective function evaluations were required. It was also not a very portable solution which, although not often an issue (Jacaranda runs well on almost any Linux distribution), there is not reason to be limiting in portability.

Recently, a generic interface from Octave to Java has been implemented by Michael Goffioul. Jacaranda has therefore been updated to make use of this interface as it provides a much more elegant solution than what Jacaranda had before and is also more efficient.

The full Jacaranda distribution (provided to collaborators) includes an input file which demonstrates this interface. As the more general distribution does not include this particular input file, I include it here for illustration:

 1  ## Test out the Octave Java interface to Jacaranda.
 2  ## 
 3  ## Eric S Fraga
 4  function jacaranda_test
 5    persistent version;
 6    if (isempty(version))
 7      version = "2008.08.05 23:55:43";
 8      printf ("ESF %s, Octave java to Jacaranda function evaluation\n", version)
 9    endif
10    ## initialise the Jacaranda interface from Octave, using a test input
11    ## file which defines an appropriate objective function.  The
12    ## particular example, from Rathore et al (1974) is the design of a
13    ## heat integrated distillation sequence.  The input file will
14    ## generate at least one flowsheet design.  This flowsheet will define
15    ## an objective function with 8 real optimisation variables and 3
16    ## criteria for optimisation.
17    ## 
18    ## Note that the following assumes that the Jacaranda class files are
19    ## stored in the given location relative to this file and that,
20    ## therefore, Octave has been started in this directory.
21    [A B nx ny nf] = jacaranda_init ("../vle/rathore_hen.in", \ # input file
22                                     "rathore_hen-1-1", \       # objective function
23                                     "../../src/java")          # Jacaranda classpath
24    ## now evaluate the flowsheet at a number of random points
25    N = 100;
26    Y = [];
27    n_infeasible = 0;
28    for i=1:N
29      x = A + rand(1,length(A)).*(B-A);
30      try
31        y = jacaranda_evaluate (x);
32        Y = [Y; y];
33      catch
34        n_infeasible++;
35      end_try_catch
36    endfor
37    if n_infeasible > 0
38      printf ("There were %d infeasible design points (out of %d total) found.\n", n_infeasible, N);
39    endif
40    printf ("Minimum criteria values: %8.2e %8.2e %8.2e\n", min(Y));
41    printf ("Maximum criteria values: %8.2e %8.2e %8.2e\n", max(Y));
42    ## the results obtained above are plotted to give some indication of
43    ## the variation in the three criteria for random design points
44    plot (Y);
45  endfunction

I believe the comments describe clearly what is happening so I will leave it at this for now.

Although the Jacaranda system comes with a number of pre-defined process unit models (e.g. Distillation), there are many problems in conceptual design that only require simple models. These simple models may not require complex physical property values and may consist of, for instance, idealised mass and energy balances. For these cases, it may be worthwhile to define ad hoc simple models.

Jacaranda provides a generic model for such cases: units.Unit [1], intended for use with streams supporting vapour liquid equilibria properties (although methods for estimating specific VLE properties won't actually be accessible).

Defining an actual model instance using this generic model consists of a number of steps: specifying the process streams that interact with the unit, definining design variables (to allow for analysis and optimisation), defining the equations that describe the unit operation, and defining the equations that can be used for analysis or evaluation (e.g. values used by the criteria definitions). These are described in detail below through the use of a simple example.

The problem we wish to consider is the production of HF, as described in Laing & Fraga (A case study on synthesis in preliminary design, Computers & Chemical Engineering 21:S53-S58, 1997). Potential candidate designs for the process need to consider a wide range of units with varying degrees of detail. The units required include a kiln (essentially a reactor), an acid blender, an absorber, a quench unit and distillation. The distillation unit is modelled through the detailed (albeit short-cut) model available in Jacaranda (units.vle.Distillation) whereas the others can be represented using simpler models.