git.gag.com Git - debian/openrocket/blob - src/net/sf/openrocket/gui/optimization/OptimizationTestDialog.java

   1 package net.sf.openrocket.gui.optimization;
   2
   3 import static net.sf.openrocket.util.MathUtil.pow2;
   4
   5 import java.awt.Window;
   6 import java.awt.event.ActionEvent;
   7 import java.awt.event.ActionListener;
   8
   9 import javax.swing.JButton;
  10 import javax.swing.JDialog;
  11 import javax.swing.JPanel;
  12
  13 import net.miginfocom.swing.MigLayout;
  14 import net.sf.openrocket.document.OpenRocketDocument;
  15 import net.sf.openrocket.document.Simulation;
  16 import net.sf.openrocket.optimization.general.Function;
  17 import net.sf.openrocket.optimization.general.FunctionOptimizer;
  18 import net.sf.openrocket.optimization.general.OptimizationController;
  19 import net.sf.openrocket.optimization.general.OptimizationException;
  20 import net.sf.openrocket.optimization.general.ParallelExecutorCache;
  21 import net.sf.openrocket.optimization.general.ParallelFunctionCache;
  22 import net.sf.openrocket.optimization.general.Point;
  23 import net.sf.openrocket.optimization.general.multidim.MultidirectionalSearchOptimizer;
  24 import net.sf.openrocket.optimization.rocketoptimization.RocketOptimizationFunction;
  25 import net.sf.openrocket.optimization.rocketoptimization.SimulationDomain;
  26 import net.sf.openrocket.optimization.rocketoptimization.SimulationModifier;
  27 import net.sf.openrocket.optimization.rocketoptimization.domains.StabilityDomain;
  28 import net.sf.openrocket.optimization.rocketoptimization.goals.MaximizationGoal;
  29 import net.sf.openrocket.optimization.rocketoptimization.modifiers.GenericComponentModifier;
  30 import net.sf.openrocket.optimization.rocketoptimization.parameters.MaximumAltitudeParameter;
  31 import net.sf.openrocket.rocketcomponent.BodyTube;
  32 import net.sf.openrocket.rocketcomponent.Rocket;
  33 import net.sf.openrocket.rocketcomponent.RocketComponent;
  34 import net.sf.openrocket.unit.UnitGroup;
  35 import net.sf.openrocket.util.GUIUtil;
  36
  37 public class OptimizationTestDialog extends JDialog {
  38
  39         private final OpenRocketDocument document;
  40
  41         public OptimizationTestDialog(Window parent, OpenRocketDocument document) {
  42                 super(parent, "Optimization", ModalityType.APPLICATION_MODAL);
  43
  44                 this.document = document;
  45
  46                 JPanel panel = new JPanel(new MigLayout("fill"));
  47                 this.add(panel);
  48
  49                 JButton button = new JButton("Test optimize");
  50                 button.addActionListener(new ActionListener() {
  51                         @Override
  52                         public void actionPerformed(ActionEvent e) {
  53                                 try {
  54                                         doOptimize();
  55                                 } catch (OptimizationException e1) {
  56                                         e1.printStackTrace();
  57                                 }
  58                         }
  59                 });
  60                 panel.add(button, "wrap para");
  61
  62
  63
  64                 JButton close = new JButton("Close");
  65                 close.addActionListener(new ActionListener() {
  66                         @Override
  67                         public void actionPerformed(ActionEvent e) {
  68                                 OptimizationTestDialog.this.dispose();
  69                         }
  70                 });
  71                 panel.add(close);
  72
  73
  74                 GUIUtil.setDisposableDialogOptions(this, close);
  75         }
  76
  77
  78         private void doOptimize() throws OptimizationException {
  79                 Simulation sim = document.getSimulation(0);
  80                 Rocket rocket = sim.getRocket();
  81
  82                 RocketComponent body = null;
  83
  84                 for (RocketComponent c : rocket) {
  85                         if (c instanceof BodyTube) {
  86                                 body = c;
  87                                 break;
  88                         }
  89                 }
  90
  91                 Point initial;
  92
  93                 SimulationDomain domain;
  94                 //              domain= new IdentitySimulationDomain();
  95                 domain = new StabilityDomain(2, false);
  96
  97                 SimulationModifier mod1 = new GenericComponentModifier("Test", body,
  98                                 UnitGroup.UNITS_LENGTH, 1.0, BodyTube.class, body.getID(), "Length");
  99                 mod1.setMinValue(0.1);
 100                 mod1.setMaxValue(0.7);
 101
 102                 SimulationModifier mod2 = new GenericComponentModifier("Test", body,
 103                                 UnitGroup.UNITS_LENGTH, 2.0, BodyTube.class, body.getID(), "OuterRadius");
 104                 mod2.setMinValue(0.01);
 105                 mod2.setMaxValue(0.10);
 106
 107                 OptimizationController controller = new OptimizationController() {
 108                         int step = 0;
 109
 110                         @Override
 111                         public boolean stepTaken(Point oldPoint, double oldValue, Point newPoint, double newValue, double stepSize) {
 112                                 step++;
 113                                 System.out.println("STEP " + step + " oldValue=" + oldValue + " newValue=" + newValue +
 114                                                 " oldPoint=" + oldPoint + " newPoint=" + newPoint +
 115                                                 " stepSize=" + stepSize);
 116                                 return step < 20;
 117                         }
 118                 };
 119
 120
 121                 initial = new Point(mod1.getCurrentScaledValue(sim), mod2.getCurrentScaledValue(sim));
 122
 123
 124                 Function function = new RocketOptimizationFunction(sim, new MaximumAltitudeParameter(),
 125                                 new MaximizationGoal(), domain, mod1, mod2);
 126                 /*
 127                 function = new Function() {
 128                         @Override
 129                         public double evaluate(Point point) throws InterruptedException, OptimizationException {
 130                                 // y = ax^2 + bx + c
 131                                 // y' = 2ax + b
 132                                 // 2a * pi/4 + b = 0
 133                                 // b = -a*pi/2
 134                                 // a=-1 -> b = pi/2
 135
 136
 137                                 double x = point.get(0);
 138                                 double y = -x * x + Math.PI / 2 * x;
 139                                 System.out.println("Evaluating at x=" + x + " value=" + y);
 140                                 return y;
 141                         }
 142                 };
 143                 */
 144
 145                 ParallelFunctionCache cache = new ParallelExecutorCache(1);
 146                 cache.setFunction(function);
 147
 148                 FunctionOptimizer optimizer = new MultidirectionalSearchOptimizer(cache);
 149
 150                 optimizer.optimize(initial, controller);
 151         }
 152
 153
 154         ////////////////////////////////////////////////////////////////////////////////////////////////////////
 155
 156
 157         private static int evalCount = 0;
 158
 159         public static void main(String[] args) throws OptimizationException {
 160                 Point initial;
 161
 162
 163
 164                 OptimizationController controller = new OptimizationController() {
 165                         int step = 0;
 166
 167                         @Override
 168                         public boolean stepTaken(Point oldPoint, double oldValue, Point newPoint, double newValue, double stepSize) {
 169                                 step++;
 170                                 System.out.println("STEP " + step + " oldValue=" + oldValue + " newValue=" + newValue +
 171                                                 " oldPoint=" + oldPoint + " newPoint=" + newPoint +
 172                                                 " stepSize=" + stepSize);
 173                                 return step < 20;
 174                         }
 175                 };
 176
 177
 178                 initial = new Point(0.5, 0.5);
 179
 180
 181                 Function function = new Function() {
 182                         @Override
 183                         public double evaluate(Point point) throws InterruptedException, OptimizationException {
 184                                 // y = ax^2 + bx + c
 185                                 // y' = 2ax + b
 186                                 // 2a * pi/4 + b = 0
 187                                 // b = -a*pi/2
 188                                 // a=-1 -> b = pi/2
 189
 190                                 evalCount++;
 191
 192                                 //                              double x = point.get(0);
 193                                 //                              double y = x * x - Math.PI / 2 * x;
 194                                 //                              System.out.println("Evaluating at x=" + x + " value=" + y);
 195                                 //                              return y;
 196
 197                                 double x = point.get(0);
 198                                 double y = point.get(1);
 199                                 double z = 4 * pow2((x - 0.3231)) + 2 * pow2(y - 0.8923);
 200
 201                                 System.out.println("Evaluation " + evalCount + ":  x=" + x + " y=" + y + " z=" + z);
 202
 203                                 return z;
 204                         }
 205                 };
 206
 207
 208                 ParallelFunctionCache cache = new ParallelExecutorCache();
 209                 cache.setFunction(function);
 210
 211                 FunctionOptimizer optimizer = new MultidirectionalSearchOptimizer(cache);
 212
 213                 optimizer.optimize(initial, controller);
 214
 215
 216                 System.out.println("Total evaluation count: " + evalCount);
 217         }
 218 }