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

   1 package net.sf.openrocket.gui.dialogs.optimization;
   2
   3 import java.awt.Component;
   4 import java.awt.Window;
   5 import java.awt.event.ActionEvent;
   6 import java.awt.event.ActionListener;
   7 import java.awt.event.MouseAdapter;
   8 import java.awt.event.MouseEvent;
   9 import java.io.BufferedWriter;
  10 import java.io.File;
  11 import java.io.FileWriter;
  12 import java.io.IOException;
  13 import java.io.Writer;
  14 import java.text.Collator;
  15 import java.util.ArrayList;
  16 import java.util.Collections;
  17 import java.util.Comparator;
  18 import java.util.HashMap;
  19 import java.util.LinkedHashMap;
  20 import java.util.LinkedList;
  21 import java.util.List;
  22 import java.util.Map;
  23
  24 import javax.swing.BorderFactory;
  25 import javax.swing.DefaultComboBoxModel;
  26 import javax.swing.JButton;
  27 import javax.swing.JCheckBox;
  28 import javax.swing.JComboBox;
  29 import javax.swing.JComponent;
  30 import javax.swing.JDialog;
  31 import javax.swing.JFileChooser;
  32 import javax.swing.JLabel;
  33 import javax.swing.JOptionPane;
  34 import javax.swing.JPanel;
  35 import javax.swing.JScrollPane;
  36 import javax.swing.JSpinner;
  37 import javax.swing.JTable;
  38 import javax.swing.JToggleButton;
  39 import javax.swing.ListSelectionModel;
  40 import javax.swing.Timer;
  41 import javax.swing.border.TitledBorder;
  42 import javax.swing.event.ChangeEvent;
  43 import javax.swing.event.ChangeListener;
  44 import javax.swing.event.ListSelectionEvent;
  45 import javax.swing.event.ListSelectionListener;
  46 import javax.swing.event.TreeSelectionEvent;
  47 import javax.swing.event.TreeSelectionListener;
  48 import javax.swing.table.AbstractTableModel;
  49 import javax.swing.table.DefaultTableCellRenderer;
  50 import javax.swing.table.TableColumnModel;
  51 import javax.swing.tree.DefaultMutableTreeNode;
  52 import javax.swing.tree.TreePath;
  53
  54 import net.miginfocom.swing.MigLayout;
  55 import net.sf.openrocket.document.OpenRocketDocument;
  56 import net.sf.openrocket.document.Simulation;
  57 import net.sf.openrocket.gui.SpinnerEditor;
  58 import net.sf.openrocket.gui.adaptors.DoubleModel;
  59 import net.sf.openrocket.gui.components.CsvOptionPanel;
  60 import net.sf.openrocket.gui.components.DescriptionArea;
  61 import net.sf.openrocket.gui.components.DoubleCellEditor;
  62 import net.sf.openrocket.gui.components.StyledLabel;
  63 import net.sf.openrocket.gui.components.StyledLabel.Style;
  64 import net.sf.openrocket.gui.components.UnitCellEditor;
  65 import net.sf.openrocket.gui.components.UnitSelector;
  66 import net.sf.openrocket.gui.scalefigure.RocketFigure;
  67 import net.sf.openrocket.gui.scalefigure.ScaleScrollPane;
  68 import net.sf.openrocket.l10n.Translator;
  69 import net.sf.openrocket.logging.LogHelper;
  70 import net.sf.openrocket.optimization.general.OptimizationException;
  71 import net.sf.openrocket.optimization.general.Point;
  72 import net.sf.openrocket.optimization.rocketoptimization.OptimizableParameter;
  73 import net.sf.openrocket.optimization.rocketoptimization.OptimizationGoal;
  74 import net.sf.openrocket.optimization.rocketoptimization.SimulationDomain;
  75 import net.sf.openrocket.optimization.rocketoptimization.SimulationModifier;
  76 import net.sf.openrocket.optimization.rocketoptimization.domains.IdentitySimulationDomain;
  77 import net.sf.openrocket.optimization.rocketoptimization.domains.StabilityDomain;
  78 import net.sf.openrocket.optimization.rocketoptimization.goals.MaximizationGoal;
  79 import net.sf.openrocket.optimization.rocketoptimization.goals.MinimizationGoal;
  80 import net.sf.openrocket.optimization.rocketoptimization.goals.ValueSeekGoal;
  81 import net.sf.openrocket.optimization.services.OptimizationServiceHelper;
  82 import net.sf.openrocket.rocketcomponent.Rocket;
  83 import net.sf.openrocket.rocketcomponent.RocketComponent;
  84 import net.sf.openrocket.startup.Application;
  85 import net.sf.openrocket.unit.CaliberUnit;
  86 import net.sf.openrocket.unit.Unit;
  87 import net.sf.openrocket.unit.UnitGroup;
  88 import net.sf.openrocket.unit.Value;
  89 import net.sf.openrocket.util.BugException;
  90 import net.sf.openrocket.util.Chars;
  91 import net.sf.openrocket.util.FileHelper;
  92 import net.sf.openrocket.util.GUIUtil;
  93 import net.sf.openrocket.util.Named;
  94 import net.sf.openrocket.util.Prefs;
  95 import net.sf.openrocket.util.TextUtil;
  96
  97 import com.itextpdf.text.Font;
  98
  99
 100 /**
 101  * General rocket optimization dialog.
 102  *
 103  * @author Sampo Niskanen <sampo.niskanen@iki.fi>
 104  */
 105 public class GeneralOptimizationDialog extends JDialog {
 106         private static final LogHelper log = Application.getLogger();
 107         private static final Translator trans = Application.getTranslator();
 108
 109         private static final Collator collator = Collator.getInstance();
 110
 111
 112         private static final String GOAL_MAXIMIZE = trans.get("goal.maximize");
 113         private static final String GOAL_MINIMIZE = trans.get("goal.minimize");
 114         private static final String GOAL_SEEK = trans.get("goal.seek");
 115
 116         private static final String START_TEXT = trans.get("btn.start");
 117         private static final String STOP_TEXT = trans.get("btn.stop");
 118
 119
 120
 121         private final List<OptimizableParameter> optimizationParameters = new ArrayList<OptimizableParameter>();
 122         private final Map<Object, List<SimulationModifier>> simulationModifiers =
 123                         new HashMap<Object, List<SimulationModifier>>();
 124
 125
 126         private final OpenRocketDocument baseDocument;
 127         private OpenRocketDocument documentCopy;
 128
 129
 130         private final JButton addButton;
 131         private final JButton removeButton;
 132         private final JButton removeAllButton;
 133
 134         private final ParameterSelectionTableModel selectedModifierTableModel;
 135         private final JTable selectedModifierTable;
 136         private final DescriptionArea selectedModifierDescription;
 137         private final SimulationModifierTree availableModifierTree;
 138
 139         private final JComboBox simulationSelectionCombo;
 140         private final JComboBox optimizationParameterCombo;
 141
 142         private final JComboBox optimizationGoalCombo;
 143         private final JSpinner optimizationGoalSpinner;
 144         private final UnitSelector optimizationGoalUnitSelector;
 145         private final DoubleModel optimizationSeekValue;
 146
 147         private DoubleModel minimumStability;
 148         private DoubleModel maximumStability;
 149         private final JCheckBox minimumStabilitySelected;
 150         private final JSpinner minimumStabilitySpinner;
 151         private final UnitSelector minimumStabilityUnitSelector;
 152         private final JCheckBox maximumStabilitySelected;
 153         private final JSpinner maximumStabilitySpinner;
 154         private final UnitSelector maximumStabilityUnitSelector;
 155
 156         private final JLabel bestValueLabel;
 157         private final JLabel stepCountLabel;
 158         private final JLabel evaluationCountLabel;
 159         private final JLabel stepSizeLabel;
 160
 161         private final RocketFigure figure;
 162         private final JToggleButton startButton;
 163         private final JButton plotButton;
 164         private final JButton saveButton;
 165
 166         private final JButton applyButton;
 167         private final JButton resetButton;
 168         private final JButton closeButton;
 169
 170         private final List<SimulationModifier> selectedModifiers = new ArrayList<SimulationModifier>();
 171
 172         /** List of components to disable while optimization is running */
 173         private final List<JComponent> disableComponents = new ArrayList<JComponent>();
 174
 175         /** Whether optimization is currently running or not */
 176         private boolean running = false;
 177         /** The optimization worker that is running */
 178         private OptimizationWorker worker = null;
 179
 180
 181         private double bestValue = Double.NaN;
 182         private Unit bestValueUnit = Unit.NOUNIT2;
 183         private int stepCount = 0;
 184         private int evaluationCount = 0;
 185         private double stepSize = 0;
 186
 187         private final Map<Point, FunctionEvaluationData> evaluationHistory = new LinkedHashMap<Point, FunctionEvaluationData>();
 188         private final List<Point> optimizationPath = new LinkedList<Point>();
 189
 190
 191         private boolean updating = false;
 192
 193
 194         /**
 195          * Sole constructor.
 196          *
 197          * @param document      the document
 198          * @param parent        the parent window
 199          */
 200         public GeneralOptimizationDialog(OpenRocketDocument document, Window parent) {
 201                 super(parent, trans.get("title"));
 202
 203                 this.baseDocument = document;
 204                 this.documentCopy = document.copy();
 205
 206                 loadOptimizationParameters();
 207                 loadSimulationModifiers();
 208
 209                 JPanel sub;
 210                 JLabel label;
 211                 JScrollPane scroll;
 212                 String tip;
 213
 214                 JPanel panel = new JPanel(new MigLayout("fill"));
 215
 216
 217                 ChangeListener clearHistoryChangeListener = new ChangeListener() {
 218                         @Override
 219                         public void stateChanged(ChangeEvent e) {
 220                                 clearHistory();
 221                         }
 222                 };
 223                 ActionListener clearHistoryActionListener = new ActionListener() {
 224                         @Override
 225                         public void actionPerformed(ActionEvent e) {
 226                                 clearHistory();
 227                         }
 228                 };
 229
 230
 231
 232                 //// Selected modifiers table
 233
 234                 selectedModifierTableModel = new ParameterSelectionTableModel();
 235                 selectedModifierTable = new JTable(selectedModifierTableModel);
 236                 selectedModifierTable.setDefaultRenderer(Double.class, new DoubleCellRenderer());
 237                 selectedModifierTable.setRowSelectionAllowed(true);
 238                 selectedModifierTable.setColumnSelectionAllowed(false);
 239                 selectedModifierTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 240
 241                 // Make sure spinner editor fits into the cell height
 242                 selectedModifierTable.setRowHeight(new JSpinner().getPreferredSize().height - 4);
 243
 244                 selectedModifierTable.setDefaultEditor(Double.class, new DoubleCellEditor());
 245                 selectedModifierTable.setDefaultEditor(Unit.class, new UnitCellEditor() {
 246                         @Override
 247                         protected UnitGroup getUnitGroup(Unit value, int row, int column) {
 248                                 return selectedModifiers.get(row).getUnitGroup();
 249                         }
 250                 });
 251
 252                 disableComponents.add(selectedModifierTable);
 253
 254                 selectedModifierTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
 255                         @Override
 256                         public void valueChanged(ListSelectionEvent e) {
 257                                 updateComponents();
 258                         }
 259                 });
 260
 261                 // Set column widths
 262                 TableColumnModel columnModel = selectedModifierTable.getColumnModel();
 263                 columnModel.getColumn(0).setPreferredWidth(150);
 264                 columnModel.getColumn(1).setPreferredWidth(40);
 265                 columnModel.getColumn(2).setPreferredWidth(40);
 266                 columnModel.getColumn(3).setPreferredWidth(40);
 267
 268                 scroll = new JScrollPane(selectedModifierTable);
 269
 270                 label = new StyledLabel(trans.get("lbl.paramsToOptimize"), Style.BOLD);
 271                 disableComponents.add(label);
 272                 panel.add(label, "split 3, flowy");
 273                 panel.add(scroll, "wmin 300lp, height 200lp, grow");
 274                 selectedModifierDescription = new DescriptionArea(2, -3);
 275                 disableComponents.add(selectedModifierDescription);
 276                 panel.add(selectedModifierDescription, "growx");
 277
 278
 279
 280                 //// Add/remove buttons
 281                 sub = new JPanel(new MigLayout("fill"));
 282
 283                 addButton = new JButton(Chars.LEFT_ARROW + " " + trans.get("btn.add") + "   ");
 284                 addButton.setToolTipText(trans.get("btn.add.ttip"));
 285                 addButton.addActionListener(new ActionListener() {
 286                         @Override
 287                         public void actionPerformed(ActionEvent e) {
 288                                 SimulationModifier mod = getSelectedAvailableModifier();
 289                                 if (mod != null) {
 290                                         addModifier(mod);
 291                                         clearHistory();
 292                                 } else {
 293                                         log.error("Attempting to add simulation modifier when none is selected");
 294                                 }
 295                         }
 296                 });
 297                 disableComponents.add(addButton);
 298                 sub.add(addButton, "wrap para, sg button");
 299
 300                 removeButton = new JButton("   " + trans.get("btn.remove") + " " + Chars.RIGHT_ARROW);
 301                 removeButton.setToolTipText(trans.get("btn.remove.ttip"));
 302                 removeButton.addActionListener(new ActionListener() {
 303                         @Override
 304                         public void actionPerformed(ActionEvent e) {
 305                                 SimulationModifier mod = getSelectedModifier();
 306                                 if (mod == null) {
 307                                         log.error("Attempting to remove simulation modifier when none is selected");
 308                                         return;
 309                                 }
 310                                 removeModifier(mod);
 311                                 clearHistory();
 312                         }
 313                 });
 314                 disableComponents.add(removeButton);
 315                 sub.add(removeButton, "wrap para*2, sg button");
 316
 317                 removeAllButton = new JButton(trans.get("btn.removeAll"));
 318                 removeAllButton.setToolTipText(trans.get("btn.removeAll.ttip"));
 319                 removeAllButton.addActionListener(new ActionListener() {
 320                         @Override
 321                         public void actionPerformed(ActionEvent e) {
 322                                 log.user("Removing all selected modifiers");
 323                                 selectedModifiers.clear();
 324                                 selectedModifierTableModel.fireTableDataChanged();
 325                                 availableModifierTree.repaint();
 326                                 clearHistory();
 327                         }
 328                 });
 329                 disableComponents.add(removeAllButton);
 330                 sub.add(removeAllButton, "wrap para, sg button");
 331
 332                 panel.add(sub);
 333
 334
 335
 336                 //// Available modifier tree
 337                 availableModifierTree = new SimulationModifierTree(documentCopy.getRocket(), simulationModifiers, selectedModifiers);
 338                 availableModifierTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {
 339                         @Override
 340                         public void valueChanged(TreeSelectionEvent e) {
 341                                 updateComponents();
 342                         }
 343                 });
 344
 345                 // Handle double-click
 346                 availableModifierTree.addMouseListener(new MouseAdapter() {
 347                         @Override
 348                         public void mousePressed(MouseEvent e) {
 349                                 if (e.getClickCount() == 2) {
 350                                         SimulationModifier mod = getSelectedAvailableModifier();
 351                                         if (mod != null) {
 352                                                 addModifier(mod);
 353                                                 clearHistory();
 354                                         } else {
 355                                                 log.user("Double-clicked non-available option");
 356                                         }
 357                                 }
 358                         }
 359                 });
 360
 361                 disableComponents.add(availableModifierTree);
 362                 scroll = new JScrollPane(availableModifierTree);
 363                 label = new StyledLabel(trans.get("lbl.availableParams"), Style.BOLD);
 364                 disableComponents.add(label);
 365                 panel.add(label, "split 2, flowy");
 366                 panel.add(scroll, "width 300lp, height 200lp, grow, wrap para*2");
 367
 368
 369
 370
 371                 ////  Optimization options sub-panel
 372
 373                 sub = new JPanel(new MigLayout("fill"));
 374                 TitledBorder border = BorderFactory.createTitledBorder(trans.get("lbl.optimizationOpts"));
 375                 GUIUtil.changeFontStyle(border, Font.BOLD);
 376                 sub.setBorder(border);
 377                 disableComponents.add(sub);
 378
 379
 380                 //// Simulation to optimize
 381
 382                 label = new JLabel(trans.get("lbl.optimizeSim"));
 383                 tip = trans.get("lbl.optimizeSim.ttip");
 384                 label.setToolTipText(tip);
 385                 disableComponents.add(label);
 386                 sub.add(label, "");
 387
 388                 simulationSelectionCombo = new JComboBox();
 389                 simulationSelectionCombo.setToolTipText(tip);
 390                 populateSimulations();
 391                 simulationSelectionCombo.addActionListener(clearHistoryActionListener);
 392                 disableComponents.add(simulationSelectionCombo);
 393                 sub.add(simulationSelectionCombo, "growx, wrap unrel");
 394
 395
 396
 397                 //// Value to optimize
 398                 label = new JLabel(trans.get("lbl.optimizeValue"));
 399                 tip = trans.get("lbl.optimizeValue.ttip");
 400                 label.setToolTipText(tip);
 401                 disableComponents.add(label);
 402                 sub.add(label, "");
 403
 404                 optimizationParameterCombo = new JComboBox();
 405                 optimizationParameterCombo.setToolTipText(tip);
 406                 populateParameters();
 407                 optimizationParameterCombo.addActionListener(clearHistoryActionListener);
 408                 disableComponents.add(optimizationParameterCombo);
 409                 sub.add(optimizationParameterCombo, "growx, wrap unrel");
 410
 411
 412
 413                 //// Optimization goal
 414                 label = new JLabel(trans.get("lbl.optimizeGoal"));
 415                 tip = trans.get("lbl.optimizeGoal");
 416                 label.setToolTipText(tip);
 417                 disableComponents.add(label);
 418                 sub.add(label, "");
 419
 420                 optimizationGoalCombo = new JComboBox(new String[] { GOAL_MAXIMIZE, GOAL_MINIMIZE, GOAL_SEEK });
 421                 optimizationGoalCombo.setToolTipText(tip);
 422                 optimizationGoalCombo.setEditable(false);
 423                 optimizationGoalCombo.addActionListener(clearHistoryActionListener);
 424                 disableComponents.add(optimizationGoalCombo);
 425                 sub.add(optimizationGoalCombo, "growx");
 426
 427
 428                 //// Optimization custom value
 429                 optimizationSeekValue = new DoubleModel(0, UnitGroup.UNITS_NONE);
 430                 optimizationSeekValue.addChangeListener(clearHistoryChangeListener);
 431
 432                 optimizationGoalSpinner = new JSpinner(optimizationSeekValue.getSpinnerModel());
 433                 tip = trans.get("lbl.optimizeGoalValue.ttip");
 434                 optimizationGoalSpinner.setToolTipText(tip);
 435                 optimizationGoalSpinner.setEditor(new SpinnerEditor(optimizationGoalSpinner));
 436                 disableComponents.add(optimizationGoalSpinner);
 437                 sub.add(optimizationGoalSpinner, "width 30lp");
 438
 439                 optimizationGoalUnitSelector = new UnitSelector(optimizationSeekValue);
 440                 optimizationGoalUnitSelector.setToolTipText(tip);
 441                 disableComponents.add(optimizationGoalUnitSelector);
 442                 sub.add(optimizationGoalUnitSelector, "width 20lp, wrap unrel");
 443
 444
 445                 panel.add(sub, "grow");
 446
 447
 448
 449                 ////  Required stability sub-panel
 450
 451                 sub = new JPanel(new MigLayout("fill"));
 452                 border = BorderFactory.createTitledBorder(trans.get("lbl.requireStability"));
 453                 GUIUtil.changeFontStyle(border, Font.BOLD);
 454                 sub.setBorder(border);
 455                 disableComponents.add(sub);
 456
 457
 458
 459                 double ref = CaliberUnit.calculateCaliber(baseDocument.getRocket());
 460                 minimumStability = new DoubleModel(ref, UnitGroup.stabilityUnits(ref));
 461                 maximumStability = new DoubleModel(5 * ref, UnitGroup.stabilityUnits(ref));
 462                 minimumStability.addChangeListener(clearHistoryChangeListener);
 463                 maximumStability.addChangeListener(clearHistoryChangeListener);
 464
 465
 466                 //// Minimum stability
 467                 tip = trans.get("lbl.requireMinStability.ttip");
 468                 minimumStabilitySelected = new JCheckBox(trans.get("lbl.requireMinStability"));
 469                 minimumStabilitySelected.setSelected(true);
 470                 minimumStabilitySelected.setToolTipText(tip);
 471                 minimumStabilitySelected.addActionListener(new ActionListener() {
 472                         @Override
 473                         public void actionPerformed(ActionEvent e) {
 474                                 updateComponents();
 475                         }
 476                 });
 477                 disableComponents.add(minimumStabilitySelected);
 478                 sub.add(minimumStabilitySelected);
 479
 480                 minimumStabilitySpinner = new JSpinner(minimumStability.getSpinnerModel());
 481                 minimumStabilitySpinner.setToolTipText(tip);
 482                 minimumStabilitySpinner.setEditor(new SpinnerEditor(minimumStabilitySpinner));
 483                 disableComponents.add(minimumStabilitySpinner);
 484                 sub.add(minimumStabilitySpinner, "growx");
 485
 486                 minimumStabilityUnitSelector = new UnitSelector(minimumStability);
 487                 minimumStabilityUnitSelector.setToolTipText(tip);
 488                 disableComponents.add(minimumStabilityUnitSelector);
 489                 sub.add(minimumStabilityUnitSelector, "growx, wrap unrel");
 490
 491
 492                 //// Maximum stability
 493                 tip = trans.get("lbl.requireMaxStability.ttip");
 494                 maximumStabilitySelected = new JCheckBox(trans.get("lbl.requireMaxStability"));
 495                 maximumStabilitySelected.setToolTipText(tip);
 496                 maximumStabilitySelected.addActionListener(new ActionListener() {
 497                         @Override
 498                         public void actionPerformed(ActionEvent e) {
 499                                 updateComponents();
 500                         }
 501                 });
 502                 disableComponents.add(maximumStabilitySelected);
 503                 sub.add(maximumStabilitySelected);
 504
 505                 maximumStabilitySpinner = new JSpinner(maximumStability.getSpinnerModel());
 506                 maximumStabilitySpinner.setToolTipText(tip);
 507                 maximumStabilitySpinner.setEditor(new SpinnerEditor(maximumStabilitySpinner));
 508                 disableComponents.add(maximumStabilitySpinner);
 509                 sub.add(maximumStabilitySpinner, "growx");
 510
 511                 maximumStabilityUnitSelector = new UnitSelector(maximumStability);
 512                 maximumStabilityUnitSelector.setToolTipText(tip);
 513                 disableComponents.add(maximumStabilityUnitSelector);
 514                 sub.add(maximumStabilityUnitSelector, "growx, wrap para");
 515
 516
 517
 518                 //              DescriptionArea desc = new DescriptionArea("Stability requirements are verified during each time step of the simulation.",
 519                 //                              2, -2, false);
 520                 //              desc.setViewportBorder(null);
 521                 //              disableComponents.add(desc);
 522                 //              sub.add(desc, "span, growx");
 523
 524
 525                 panel.add(sub, "span 2, grow, wrap para*2");
 526
 527
 528
 529
 530                 ////  Rocket figure
 531                 figure = new RocketFigure(getSelectedSimulation().getConfiguration());
 532                 figure.setBorderPixels(1, 1);
 533                 ScaleScrollPane figureScrollPane = new ScaleScrollPane(figure);
 534                 figureScrollPane.setFitting(true);
 535                 panel.add(figureScrollPane, "span, split, height 200lp, grow");
 536
 537
 538                 sub = new JPanel(new MigLayout("fill"));
 539
 540
 541                 label = new JLabel(trans.get("status.bestValue"));
 542                 tip = trans.get("status.bestValue.ttip");
 543                 label.setToolTipText(tip);
 544                 sub.add(label, "gapright unrel");
 545
 546                 bestValueLabel = new JLabel();
 547                 bestValueLabel.setToolTipText(tip);
 548                 sub.add(bestValueLabel, "wmin 60lp, wrap rel");
 549
 550
 551                 label = new JLabel(trans.get("status.stepCount"));
 552                 tip = trans.get("status.stepCount.ttip");
 553                 label.setToolTipText(tip);
 554                 sub.add(label, "gapright unrel");
 555
 556                 stepCountLabel = new JLabel();
 557                 stepCountLabel.setToolTipText(tip);
 558                 sub.add(stepCountLabel, "wrap rel");
 559
 560
 561                 label = new JLabel(trans.get("status.evalCount"));
 562                 tip = trans.get("status.evalCount.ttip");
 563                 label.setToolTipText(tip);
 564                 sub.add(label, "gapright unrel");
 565
 566                 evaluationCountLabel = new JLabel();
 567                 evaluationCountLabel.setToolTipText(tip);
 568                 sub.add(evaluationCountLabel, "wrap rel");
 569
 570
 571                 label = new JLabel(trans.get("status.stepSize"));
 572                 tip = trans.get("status.stepSize.ttip");
 573                 label.setToolTipText(tip);
 574                 sub.add(label, "gapright unrel");
 575
 576                 stepSizeLabel = new JLabel();
 577                 stepSizeLabel.setToolTipText(tip);
 578                 sub.add(stepSizeLabel, "wrap para");
 579
 580
 581                 //// Start/Stop button
 582
 583                 startButton = new JToggleButton(START_TEXT);
 584                 startButton.addActionListener(new ActionListener() {
 585                         @Override
 586                         public void actionPerformed(ActionEvent e) {
 587                                 if (updating) {
 588                                         log.debug("Updating, ignoring event");
 589                                         return;
 590                                 }
 591                                 if (running) {
 592                                         log.user("Stopping optimization");
 593                                         stopOptimization();
 594                                 } else {
 595                                         log.user("Starting optimization");
 596                                         startOptimization();
 597                                 }
 598                         }
 599                 });
 600                 sub.add(startButton, "span, growx, wrap para*2");
 601
 602
 603                 plotButton = new JButton(trans.get("btn.plotPath"));
 604                 plotButton.setToolTipText(trans.get("btn.plotPath.ttip"));
 605                 plotButton.addActionListener(new ActionListener() {
 606                         @Override
 607                         public void actionPerformed(ActionEvent e) {
 608                                 log.user("Plotting optimization path, dimensionality=" + selectedModifiers.size());
 609                                 OptimizationPlotDialog dialog = new OptimizationPlotDialog(optimizationPath, evaluationHistory,
 610                                                 selectedModifiers, getSelectedParameter(),
 611                                                 UnitGroup.stabilityUnits(getSelectedSimulation().getRocket()),
 612                                                 GeneralOptimizationDialog.this);
 613                                 dialog.setVisible(true);
 614                         }
 615                 });
 616                 disableComponents.add(plotButton);
 617                 sub.add(plotButton, "span, growx, wrap");
 618
 619
 620                 saveButton = new JButton(trans.get("btn.save"));
 621                 saveButton.setToolTipText(trans.get("btn.save.ttip"));
 622                 saveButton.addActionListener(new ActionListener() {
 623                         @Override
 624                         public void actionPerformed(ActionEvent e) {
 625                                 log.user("User selected save path");
 626                                 savePath();
 627                         }
 628                 });
 629                 disableComponents.add(saveButton);
 630                 sub.add(saveButton, "span, growx");
 631
 632
 633
 634                 panel.add(sub, "wrap para*2");
 635
 636
 637
 638
 639                 ////  Bottom buttons
 640
 641                 applyButton = new JButton(trans.get("btn.apply"));
 642                 applyButton.setToolTipText(trans.get("btn.apply.ttip"));
 643                 applyButton.addActionListener(new ActionListener() {
 644                         @Override
 645                         public void actionPerformed(ActionEvent e) {
 646                                 log.user("Applying optimization changes");
 647                                 applyDesign();
 648                         }
 649                 });
 650                 disableComponents.add(applyButton);
 651                 panel.add(applyButton, "span, split, gapright para, right");
 652
 653                 resetButton = new JButton(trans.get("btn.reset"));
 654                 resetButton.setToolTipText(trans.get("btn.reset.ttip"));
 655                 resetButton.addActionListener(new ActionListener() {
 656                         @Override
 657                         public void actionPerformed(ActionEvent e) {
 658                                 log.user("Resetting optimization design");
 659                                 resetDesign();
 660                         }
 661                 });
 662                 disableComponents.add(resetButton);
 663                 panel.add(resetButton, "gapright para, right");
 664
 665                 closeButton = new JButton(trans.get("btn.close"));
 666                 closeButton.setToolTipText(trans.get("btn.close.ttip"));
 667                 closeButton.addActionListener(new ActionListener() {
 668                         @Override
 669                         public void actionPerformed(ActionEvent e) {
 670                                 log.user("Closing optimization dialog");
 671                                 stopOptimization();
 672                                 GeneralOptimizationDialog.this.dispose();
 673                         }
 674                 });
 675                 panel.add(closeButton, "right");
 676
 677
 678                 this.add(panel);
 679                 clearHistory();
 680                 updateComponents();
 681                 GUIUtil.setDisposableDialogOptions(this, null);
 682         }
 683
 684
 685         private void startOptimization() {
 686                 if (running) {
 687                         log.info("Optimization already running");
 688                         return;
 689                 }
 690
 691
 692                 if (selectedModifiers.isEmpty()) {
 693                         JOptionPane.showMessageDialog(this, trans.get("error.selectParams.text"),
 694                                         trans.get("error.selectParams.title"), JOptionPane.ERROR_MESSAGE);
 695                         updating = true;
 696                         startButton.setSelected(false);
 697                         startButton.setText(START_TEXT);
 698                         updating = false;
 699                         return;
 700                 }
 701
 702
 703                 running = true;
 704
 705                 // Update the button status
 706                 updating = true;
 707                 startButton.setSelected(true);
 708                 startButton.setText(STOP_TEXT);
 709                 updating = false;
 710
 711
 712                 // Create a copy of the simulation (we're going to modify the original in the current thread)
 713                 Simulation simulation = getSelectedSimulation();
 714                 Rocket rocketCopy = simulation.getRocket().copyWithOriginalID();
 715                 simulation = simulation.duplicateSimulation(rocketCopy);
 716
 717                 OptimizableParameter parameter = getSelectedParameter();
 718
 719                 OptimizationGoal goal;
 720                 String value = (String) optimizationGoalCombo.getSelectedItem();
 721                 if (GOAL_MAXIMIZE.equals(value)) {
 722                         goal = new MaximizationGoal();
 723                 } else if (GOAL_MINIMIZE.equals(value)) {
 724                         goal = new MinimizationGoal();
 725                 } else if (GOAL_SEEK.equals(value)) {
 726                         goal = new ValueSeekGoal(optimizationSeekValue.getValue());
 727                 } else {
 728                         throw new BugException("optimizationGoalCombo had invalid value: " + value);
 729                 }
 730
 731                 SimulationDomain domain;
 732                 if (minimumStabilitySelected.isSelected() || maximumStabilitySelected.isSelected()) {
 733                         double min, max;
 734                         boolean minAbsolute, maxAbsolute;
 735
 736                         /*
 737                          * Make minAbsolute/maxAbsolute consistent with each other to produce reasonable
 738                          * result in plot tool tips.  Yes, this is a bit ugly.
 739                          */
 740
 741                         // Min stability
 742                         Unit unit = minimumStability.getCurrentUnit();
 743                         if (unit instanceof CaliberUnit) {
 744                                 min = unit.toUnit(minimumStability.getValue());
 745                                 minAbsolute = false;
 746                         } else {
 747                                 min = minimumStability.getValue();
 748                                 minAbsolute = true;
 749                         }
 750
 751                         // Max stability
 752                         unit = maximumStability.getCurrentUnit();
 753                         if (unit instanceof CaliberUnit) {
 754                                 max = unit.toUnit(maximumStability.getValue());
 755                                 maxAbsolute = false;
 756                         } else {
 757                                 max = maximumStability.getValue();
 758                                 maxAbsolute = true;
 759                         }
 760
 761
 762                         if (!minimumStabilitySelected.isSelected()) {
 763                                 min = Double.NaN;
 764                                 minAbsolute = maxAbsolute;
 765                         }
 766                         if (!maximumStabilitySelected.isSelected()) {
 767                                 max = Double.NaN;
 768                                 maxAbsolute = minAbsolute;
 769                         }
 770
 771                         domain = new StabilityDomain(min, minAbsolute, max, maxAbsolute);
 772                 } else {
 773                         domain = new IdentitySimulationDomain();
 774                 }
 775
 776                 SimulationModifier[] modifiers = selectedModifiers.toArray(new SimulationModifier[0]);
 777
 778                 // Create and start the background worker
 779                 worker = new OptimizationWorker(simulation, parameter, goal, domain, modifiers) {
 780                         @Override
 781                         protected void done(OptimizationException exception) {
 782                                 log.info("Optimization finished, exception=" + exception, exception);
 783
 784                                 if (exception != null) {
 785                                         JOptionPane.showMessageDialog(GeneralOptimizationDialog.this,
 786                                                         new Object[] {
 787                                                                         trans.get("error.optimizationFailure.text"),
 788                                                                         exception.getLocalizedMessage()
 789                                         }, trans.get("error.optimizationFailure.title"), JOptionPane.ERROR_MESSAGE);
 790                                 }
 791
 792                                 worker = null;
 793                                 stopOptimization();
 794
 795                                 // Disable the start/stop button for a short while after ending the simulation
 796                                 // to prevent accidentally starting a new optimization when trying to stop it
 797                                 startButton.setEnabled(false);
 798                                 Timer timer = new Timer(750, new ActionListener() {
 799                                         @Override
 800                                         public void actionPerformed(ActionEvent e) {
 801                                                 startButton.setEnabled(true);
 802                                         }
 803                                 });
 804                                 timer.setRepeats(false);
 805                                 timer.start();
 806                         }
 807
 808                         @Override
 809                         protected void functionEvaluated(List<FunctionEvaluationData> data) {
 810                                 for (FunctionEvaluationData d : data) {
 811                                         evaluationHistory.put(d.getPoint(), d);
 812                                         evaluationCount++;
 813                                 }
 814                                 updateCounters();
 815                         }
 816
 817                         @Override
 818                         protected void optimizationStepTaken(List<OptimizationStepData> data) {
 819
 820                                 // Add starting point to the path
 821                                 if (optimizationPath.isEmpty()) {
 822                                         optimizationPath.add(data.get(0).getOldPoint());
 823                                 }
 824
 825                                 // Add other points to the path
 826                                 for (OptimizationStepData d : data) {
 827                                         optimizationPath.add(d.getNewPoint());
 828                                 }
 829
 830                                 // Get function value from the latest point
 831                                 OptimizationStepData latest = data.get(data.size() - 1);
 832                                 Point newPoint = latest.getNewPoint();
 833
 834                                 FunctionEvaluationData pointValue = evaluationHistory.get(newPoint);
 835                                 if (pointValue != null && pointValue.getParameterValue() != null) {
 836                                         bestValue = pointValue.getParameterValue().getValue();
 837                                 } else {
 838                                         bestValue = Double.NaN;
 839                                 }
 840
 841                                 // Update the simulation
 842                                 Simulation sim = getSelectedSimulation();
 843                                 for (int i = 0; i < newPoint.dim(); i++) {
 844                                         try {
 845                                                 selectedModifiers.get(i).modify(sim, newPoint.get(i));
 846                                         } catch (OptimizationException e) {
 847                                                 throw new BugException("Simulation modifier failed to modify the base simulation " +
 848                                                                 "modifier=" + selectedModifiers.get(i), e);
 849                                         }
 850                                 }
 851                                 figure.updateFigure();
 852
 853                                 // Update other counter data
 854                                 stepCount += data.size();
 855                                 stepSize = latest.getStepSize();
 856                                 updateCounters();
 857                         }
 858                 };
 859                 worker.start();
 860
 861
 862                 clearHistory();
 863
 864                 updateComponents();
 865         }
 866
 867         private void stopOptimization() {
 868                 if (!running) {
 869                         log.info("Optimization not running");
 870                         return;
 871                 }
 872
 873                 if (worker != null && worker.isAlive()) {
 874                         log.info("Worker still running, interrupting it and setting to null");
 875                         worker.interrupt();
 876                         worker = null;
 877                         return;
 878                 }
 879
 880                 running = false;
 881
 882                 // Update the button status
 883                 updating = true;
 884                 startButton.setSelected(false);
 885                 startButton.setText(START_TEXT);
 886                 updating = false;
 887
 888
 889                 updateComponents();
 890         }
 891
 892
 893
 894
 895         /**
 896          * Reset the current optimization history and values.  This does not reset the design.
 897          */
 898         private void clearHistory() {
 899                 evaluationHistory.clear();
 900                 optimizationPath.clear();
 901                 bestValue = Double.NaN;
 902                 bestValueUnit = getSelectedParameter().getUnitGroup().getDefaultUnit();
 903                 stepCount = 0;
 904                 evaluationCount = 0;
 905                 stepSize = 0.5;
 906                 updateCounters();
 907                 updateComponents();
 908         }
 909
 910
 911         private void applyDesign() {
 912                 // TODO: MEDIUM: Apply also potential changes to simulations
 913                 Rocket src = getSelectedSimulation().getRocket().copyWithOriginalID();
 914                 Rocket dest = baseDocument.getRocket();
 915                 try {
 916                         baseDocument.startUndo(trans.get("undoText"));
 917                         dest.freeze();
 918
 919                         // Remove all children
 920                         while (dest.getChildCount() > 0) {
 921                                 dest.removeChild(0);
 922                         }
 923
 924                         // Move all children to the destination rocket
 925                         while (src.getChildCount() > 0) {
 926                                 RocketComponent c = src.getChild(0);
 927                                 src.removeChild(0);
 928                                 dest.addChild(c);
 929                         }
 930
 931                 } finally {
 932                         dest.thaw();
 933                         baseDocument.stopUndo();
 934                 }
 935         }
 936
 937
 938         private void resetDesign() {
 939                 clearHistory();
 940
 941                 documentCopy = baseDocument.copy();
 942
 943                 loadOptimizationParameters();
 944                 loadSimulationModifiers();
 945
 946                 // Replace selected modifiers with corresponding new modifiers
 947                 List<SimulationModifier> newSelected = new ArrayList<SimulationModifier>();
 948                 for (SimulationModifier original : selectedModifiers) {
 949                         List<SimulationModifier> newModifiers = simulationModifiers.get(original.getRelatedObject());
 950                         if (newModifiers != null) {
 951                                 int index = newModifiers.indexOf(original);
 952                                 if (index >= 0) {
 953                                         SimulationModifier updated = newModifiers.get(index);
 954                                         updated.setMinValue(original.getMinValue());
 955                                         updated.setMaxValue(original.getMaxValue());
 956                                         newSelected.add(updated);
 957                                 }
 958                         }
 959                 }
 960                 selectedModifiers.clear();
 961                 selectedModifiers.addAll(newSelected);
 962                 selectedModifierTableModel.fireTableDataChanged();
 963
 964                 // Update the available modifier tree
 965                 availableModifierTree.populateTree(documentCopy.getRocket(), simulationModifiers);
 966                 availableModifierTree.expandComponents();
 967
 968
 969                 // Update selectable simulations
 970                 populateSimulations();
 971
 972                 // Update selectable parameters
 973                 populateParameters();
 974
 975         }
 976
 977
 978         private void populateSimulations() {
 979                 String current = null;
 980                 Object selection = simulationSelectionCombo.getSelectedItem();
 981                 if (selection != null) {
 982                         current = selection.toString();
 983                 }
 984
 985
 986                 List<Named<Simulation>> simulations = new ArrayList<Named<Simulation>>();
 987                 Rocket rocket = documentCopy.getRocket();
 988
 989                 for (Simulation s : documentCopy.getSimulations()) {
 990                         String id = s.getConfiguration().getMotorConfigurationID();
 991                         String name = createSimulationName(s.getName(), rocket.getMotorConfigurationNameOrDescription(id));
 992                         simulations.add(new Named<Simulation>(s, name));
 993                 }
 994
 995                 for (String id : rocket.getMotorConfigurationIDs()) {
 996                         if (id == null) {
 997                                 continue;
 998                         }
 999                         Simulation sim = new Simulation(rocket);
1000                         sim.getConfiguration().setMotorConfigurationID(id);
1001                         String name = createSimulationName(trans.get("basicSimulationName"), rocket.getMotorConfigurationNameOrDescription(id));
1002                         simulations.add(new Named<Simulation>(sim, name));
1003                 }
1004
1005
1006                 Simulation sim = new Simulation(rocket);
1007                 sim.getConfiguration().setMotorConfigurationID(null);
1008                 String name = createSimulationName(trans.get("noSimulationName"), rocket.getMotorConfigurationNameOrDescription(null));
1009                 simulations.add(new Named<Simulation>(sim, name));
1010
1011
1012                 simulationSelectionCombo.setModel(new DefaultComboBoxModel(simulations.toArray()));
1013
1014                 if (current != null) {
1015                         for (int i = 0; i < simulations.size(); i++) {
1016                                 if (simulations.get(i).toString().equals(current)) {
1017                                         simulationSelectionCombo.setSelectedIndex(i);
1018                                         break;
1019                                 }
1020                         }
1021                 }
1022         }
1023
1024
1025         private void populateParameters() {
1026                 String current = null;
1027                 Object selection = optimizationParameterCombo.getSelectedItem();
1028                 if (selection != null) {
1029                         current = selection.toString();
1030                 } else {
1031                         // Default to apogee altitude event if it is not the first one in the list
1032                         current = trans.get("MaximumAltitudeParameter.name");
1033                 }
1034
1035                 List<Named<OptimizableParameter>> parameters = new ArrayList<Named<OptimizableParameter>>();
1036                 for (OptimizableParameter p : optimizationParameters) {
1037                         parameters.add(new Named<OptimizableParameter>(p, p.getName()));
1038                 }
1039
1040                 optimizationParameterCombo.setModel(new DefaultComboBoxModel(parameters.toArray()));
1041
1042                 for (int i = 0; i < parameters.size(); i++) {
1043                         if (parameters.get(i).toString().equals(current)) {
1044                                 optimizationParameterCombo.setSelectedIndex(i);
1045                                 break;
1046                         }
1047                 }
1048         }
1049
1050         private void updateCounters() {
1051                 bestValueLabel.setText(bestValueUnit.toStringUnit(bestValue));
1052                 stepCountLabel.setText("" + stepCount);
1053                 evaluationCountLabel.setText("" + evaluationCount);
1054                 stepSizeLabel.setText(UnitGroup.UNITS_RELATIVE.toStringUnit(stepSize));
1055         }
1056
1057
1058         private void loadOptimizationParameters() {
1059                 optimizationParameters.clear();
1060                 optimizationParameters.addAll(OptimizationServiceHelper.getOptimizableParameters(documentCopy));
1061
1062                 if (optimizationParameters.isEmpty()) {
1063                         throw new BugException("No rocket optimization parameters found, distribution built wrong.");
1064                 }
1065
1066                 Collections.sort(optimizationParameters, new Comparator<OptimizableParameter>() {
1067                         @Override
1068                         public int compare(OptimizableParameter o1, OptimizableParameter o2) {
1069                                 return o1.getName().compareTo(o2.getName());
1070                         }
1071                 });
1072         }
1073
1074
1075         private void loadSimulationModifiers() {
1076                 simulationModifiers.clear();
1077
1078                 for (SimulationModifier m : OptimizationServiceHelper.getSimulationModifiers(documentCopy)) {
1079                         Object key = m.getRelatedObject();
1080                         List<SimulationModifier> list = simulationModifiers.get(key);
1081                         if (list == null) {
1082                                 list = new ArrayList<SimulationModifier>();
1083                                 simulationModifiers.put(key, list);
1084                         }
1085                         list.add(m);
1086                 }
1087
1088                 for (Object key : simulationModifiers.keySet()) {
1089                         List<SimulationModifier> list = simulationModifiers.get(key);
1090                         Collections.sort(list, new Comparator<SimulationModifier>() {
1091                                 @Override
1092                                 public int compare(SimulationModifier o1, SimulationModifier o2) {
1093                                         return o1.getName().compareTo(o2.getName());
1094                                 }
1095                         });
1096                 }
1097
1098         }
1099
1100
1101
1102         private void addModifier(SimulationModifier mod) {
1103                 if (!selectedModifiers.contains(mod)) {
1104                         log.user(1, "Adding simulation modifier " + mod);
1105                         selectedModifiers.add(mod);
1106                         Collections.sort(selectedModifiers, new SimulationModifierComparator());
1107                         selectedModifierTableModel.fireTableDataChanged();
1108                         availableModifierTree.repaint();
1109                 } else {
1110                         log.user(1, "Attempting to add an already existing simulation modifier " + mod);
1111                 }
1112         }
1113
1114
1115         private void removeModifier(SimulationModifier mod) {
1116                 log.user(1, "Removing simulation modifier " + mod);
1117                 selectedModifiers.remove(mod);
1118                 selectedModifierTableModel.fireTableDataChanged();
1119                 availableModifierTree.repaint();
1120         }
1121
1122
1123
1124         /**
1125          * Update the enabled status of all components in the dialog.
1126          */
1127         private void updateComponents() {
1128
1129                 if (updating) {
1130                         return;
1131                 }
1132
1133                 updating = true;
1134
1135
1136                 // First enable all components if optimization not running
1137                 if (!running) {
1138                         for (JComponent c : disableComponents) {
1139                                 c.setEnabled(true);
1140                         }
1141                 }
1142
1143
1144                 // "Add" button
1145                 SimulationModifier mod = getSelectedAvailableModifier();
1146                 if (mod != null && !selectedModifiers.contains(mod)) {
1147                         addButton.setEnabled(true);
1148                 } else {
1149                         addButton.setEnabled(false);
1150                 }
1151
1152                 // "Remove" button
1153                 removeButton.setEnabled(selectedModifierTable.getSelectedRow() >= 0);
1154
1155                 // "Remove all" button
1156                 removeAllButton.setEnabled(!selectedModifiers.isEmpty());
1157
1158
1159                 // Optimization goal
1160                 String selected = (String) optimizationGoalCombo.getSelectedItem();
1161                 if (GOAL_SEEK.equals(selected)) {
1162                         optimizationGoalSpinner.setVisible(true);
1163                         optimizationGoalUnitSelector.setVisible(true);
1164                 } else {
1165                         optimizationGoalSpinner.setVisible(false);
1166                         optimizationGoalUnitSelector.setVisible(false);
1167                 }
1168
1169
1170                 // Minimum/maximum stability options
1171                 minimumStabilitySpinner.setEnabled(minimumStabilitySelected.isSelected());
1172                 minimumStabilityUnitSelector.setEnabled(minimumStabilitySelected.isSelected());
1173                 maximumStabilitySpinner.setEnabled(maximumStabilitySelected.isSelected());
1174                 maximumStabilityUnitSelector.setEnabled(maximumStabilitySelected.isSelected());
1175
1176
1177                 // Plot button (enabled if path exists and dimensionality is 1 or 2)
1178                 plotButton.setEnabled(!optimizationPath.isEmpty() && (selectedModifiers.size() == 1 || selectedModifiers.size() == 2));
1179
1180                 // Save button (enabled if path exists)
1181                 saveButton.setEnabled(!optimizationPath.isEmpty());
1182
1183
1184                 // Last disable all components if optimization is running
1185                 if (running) {
1186                         for (JComponent c : disableComponents) {
1187                                 c.setEnabled(false);
1188                         }
1189                 }
1190
1191
1192                 // Update description text
1193                 mod = getSelectedModifier();
1194                 if (mod != null) {
1195                         selectedModifierDescription.setText(mod.getDescription());
1196                 } else {
1197                         selectedModifierDescription.setText("");
1198                 }
1199
1200
1201                 // Update the figure
1202                 figure.setConfiguration(getSelectedSimulation().getConfiguration());
1203
1204                 updating = false;
1205         }
1206
1207
1208         private void savePath() {
1209
1210                 if (evaluationHistory.isEmpty()) {
1211                         throw new BugException("evaluation history is empty");
1212                 }
1213
1214                 CsvOptionPanel csvOptions = new CsvOptionPanel(GeneralOptimizationDialog.class,
1215                                 trans.get("export.header"), trans.get("export.header.ttip"));
1216
1217
1218                 JFileChooser chooser = new JFileChooser();
1219                 chooser.setFileFilter(FileHelper.CSV_FILE_FILTER);
1220                 chooser.setCurrentDirectory(Prefs.getDefaultDirectory());
1221                 chooser.setAccessory(csvOptions);
1222
1223                 if (chooser.showSaveDialog(this) != JFileChooser.APPROVE_OPTION)
1224                         return;
1225
1226                 File file = chooser.getSelectedFile();
1227                 if (file == null)
1228                         return;
1229
1230                 file = FileHelper.ensureExtension(file, "csv");
1231                 if (!FileHelper.confirmWrite(file, this)) {
1232                         return;
1233                 }
1234
1235                 String fieldSeparator = csvOptions.getFieldSeparator();
1236                 String commentCharacter = csvOptions.getCommentCharacter();
1237                 boolean includeHeader = csvOptions.getSelectionOption(0);
1238                 csvOptions.storePreferences();
1239
1240                 log.info("Saving optimization path to " + file + ", fieldSeparator=" + fieldSeparator +
1241                                 ", commentCharacter=" + commentCharacter + ", includeHeader=" + includeHeader);
1242
1243                 try {
1244                         Writer writer = new BufferedWriter(new FileWriter(file));
1245
1246                         // Write header
1247                         if (includeHeader) {
1248                                 FunctionEvaluationData data = evaluationHistory.values().iterator().next();
1249
1250                                 writer.write(commentCharacter);
1251                                 for (SimulationModifier mod : selectedModifiers) {
1252                                         writer.write(mod.getRelatedObject().toString() + ": " + mod.getName() + " / " +
1253                                                         mod.getUnitGroup().getDefaultUnit().getUnit());
1254                                         writer.write(fieldSeparator);
1255                                 }
1256                                 if (minimumStabilitySelected.isSelected() || maximumStabilitySelected.isSelected()) {
1257                                         writer.write(trans.get("export.stability") + " / " + data.getDomainReference().getUnit().getUnit());
1258                                         writer.write(fieldSeparator);
1259                                 }
1260                                 writer.write(getSelectedParameter().getName() + " / " +
1261                                                 getSelectedParameter().getUnitGroup().getDefaultUnit().getUnit());
1262
1263                                 writer.write("\n");
1264                         }
1265
1266
1267                         for (FunctionEvaluationData data : evaluationHistory.values()) {
1268                                 Value[] state = data.getState();
1269
1270                                 for (int i = 0; i < state.length; i++) {
1271                                         writer.write(TextUtil.doubleToString(state[i].getUnitValue()));
1272                                         writer.write(fieldSeparator);
1273                                 }
1274
1275                                 if (minimumStabilitySelected.isSelected() || maximumStabilitySelected.isSelected()) {
1276                                         writer.write(TextUtil.doubleToString(data.getDomainReference().getUnitValue()));
1277                                         writer.write(fieldSeparator);
1278                                 }
1279
1280                                 if (data.getParameterValue() != null) {
1281                                         writer.write(TextUtil.doubleToString(data.getParameterValue().getUnitValue()));
1282                                 } else {
1283                                         writer.write("N/A");
1284                                 }
1285                                 writer.write("\n");
1286                         }
1287
1288                         writer.close();
1289                         log.info("File successfully saved");
1290
1291                 } catch (IOException e) {
1292                         FileHelper.errorWriting(e, this);
1293                 }
1294
1295         }
1296
1297         /**
1298          * Return the currently selected available simulation modifier from the modifier tree,
1299          * or <code>null</code> if none selected.
1300          */
1301         private SimulationModifier getSelectedAvailableModifier() {
1302                 TreePath treepath = availableModifierTree.getSelectionPath();
1303                 if (treepath != null) {
1304                         Object o = ((DefaultMutableTreeNode) treepath.getLastPathComponent()).getUserObject();
1305                         if (o instanceof SimulationModifier) {
1306                                 return (SimulationModifier) o;
1307                         }
1308                 }
1309                 return null;
1310         }
1311
1312         /**
1313          * Return the currently selected simulation.
1314          * @return      the selected simulation.
1315          */
1316         @SuppressWarnings("unchecked")
1317         private Simulation getSelectedSimulation() {
1318                 return ((Named<Simulation>) simulationSelectionCombo.getSelectedItem()).get();
1319         }
1320
1321
1322         /**
1323          * Return the currently selected simulation modifier from the table,
1324          * or <code>null</code> if none selected.
1325          * @return      the selected modifier or <code>null</code>.
1326          */
1327         private SimulationModifier getSelectedModifier() {
1328                 int row = selectedModifierTable.getSelectedRow();
1329                 if (row < 0) {
1330                         return null;
1331                 }
1332                 row = selectedModifierTable.convertRowIndexToModel(row);
1333                 return selectedModifiers.get(row);
1334         }
1335
1336
1337         /**
1338          * Return the currently selected optimization parameter.
1339          * @return      the selected optimization parameter.
1340          */
1341         @SuppressWarnings("unchecked")
1342         private OptimizableParameter getSelectedParameter() {
1343                 return ((Named<OptimizableParameter>) optimizationParameterCombo.getSelectedItem()).get();
1344         }
1345
1346
1347         private Unit getModifierUnit(int index) {
1348                 return selectedModifiers.get(index).getUnitGroup().getDefaultUnit();
1349         }
1350
1351         private String createSimulationName(String simulationName, String motorConfiguration) {
1352                 String name;
1353                 boolean hasParenthesis = motorConfiguration.matches("^[\\[\\(].*[\\]\\)]$");
1354                 name = simulationName + " ";
1355                 if (!hasParenthesis) {
1356                         name += "(";
1357                 }
1358                 name += motorConfiguration;
1359                 if (!hasParenthesis) {
1360                         name += ")";
1361                 }
1362                 return name;
1363         }
1364
1365         /**
1366          * The table model for the parameter selection.
1367          *
1368          * [Body tube: Length]  [min]  [max]  [unit]
1369          */
1370         private class ParameterSelectionTableModel extends AbstractTableModel {
1371
1372                 private static final int PARAMETER = 0;
1373                 private static final int CURRENT = 1;
1374                 private static final int MIN = 2;
1375                 private static final int MAX = 3;
1376                 private static final int COUNT = 4;
1377
1378                 @Override
1379                 public int getColumnCount() {
1380                         return COUNT;
1381                 }
1382
1383                 @Override
1384                 public int getRowCount() {
1385                         return selectedModifiers.size();
1386                 }
1387
1388                 @Override
1389                 public String getColumnName(int column) {
1390                         switch (column) {
1391                         case PARAMETER:
1392                                 return trans.get("table.col.parameter");
1393                         case CURRENT:
1394                                 return trans.get("table.col.current");
1395                         case MIN:
1396                                 return trans.get("table.col.min");
1397                         case MAX:
1398                                 return trans.get("table.col.max");
1399                         default:
1400                                 throw new IndexOutOfBoundsException("column=" + column);
1401                         }
1402
1403                 }
1404
1405                 @Override
1406                 public Class<?> getColumnClass(int column) {
1407                         switch (column) {
1408                         case PARAMETER:
1409                                 return String.class;
1410                         case CURRENT:
1411                                 return Double.class;
1412                         case MIN:
1413                                 return Double.class;
1414                         case MAX:
1415                                 return Double.class;
1416                         default:
1417                                 throw new IndexOutOfBoundsException("column=" + column);
1418                         }
1419                 }
1420
1421                 @Override
1422                 public Object getValueAt(int row, int column) {
1423
1424                         SimulationModifier modifier = selectedModifiers.get(row);
1425
1426                         switch (column) {
1427                         case PARAMETER:
1428                                 return modifier.getRelatedObject().toString() + ": " + modifier.getName();
1429                         case CURRENT:
1430                                 try {
1431                                         return getModifierUnit(row).toUnit(modifier.getCurrentSIValue(getSelectedSimulation()));
1432                                 } catch (OptimizationException e) {
1433                                         throw new BugException("Could not read current SI value from modifier " + modifier, e);
1434                                 }
1435                         case MIN:
1436                                 return getModifierUnit(row).toUnit(modifier.getMinValue());
1437                         case MAX:
1438                                 return getModifierUnit(row).toUnit(modifier.getMaxValue());
1439                         default:
1440                                 throw new IndexOutOfBoundsException("column=" + column);
1441                         }
1442
1443                 }
1444
1445                 @Override
1446                 public void setValueAt(Object value, int row, int column) {
1447
1448                         switch (column) {
1449                         case PARAMETER:
1450                                 break;
1451
1452                         case MIN:
1453                                 double min = (Double) value;
1454                                 min = getModifierUnit(row).fromUnit(min);
1455                                 selectedModifiers.get(row).setMinValue(min);
1456                                 break;
1457
1458                         case CURRENT:
1459                                 break;
1460
1461                         case MAX:
1462                                 double max = (Double) value;
1463                                 max = getModifierUnit(row).fromUnit(max);
1464                                 selectedModifiers.get(row).setMaxValue(max);
1465                                 break;
1466
1467                         default:
1468                                 throw new IndexOutOfBoundsException("column=" + column);
1469                         }
1470                         this.fireTableRowsUpdated(row, row);
1471
1472                 }
1473
1474                 @Override
1475                 public boolean isCellEditable(int row, int column) {
1476                         switch (column) {
1477                         case PARAMETER:
1478                                 return false;
1479                         case CURRENT:
1480                                 return false;
1481                         case MIN:
1482                                 return true;
1483                         case MAX:
1484                                 return true;
1485                         default:
1486                                 throw new IndexOutOfBoundsException("column=" + column);
1487                         }
1488                 }
1489
1490         }
1491
1492
1493         private class DoubleCellRenderer extends DefaultTableCellRenderer {
1494                 @Override
1495                 public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
1496                                 boolean hasFocus, int row, int column) {
1497
1498                         super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
1499
1500                         double val = (Double) value;
1501                         Unit unit = getModifierUnit(row);
1502
1503                         val = unit.fromUnit(val);
1504                         this.setText(unit.toStringUnit(val));
1505
1506                         return this;
1507                 }
1508         }
1509
1510
1511         private static class SimulationModifierComparator implements Comparator<SimulationModifier> {
1512
1513                 @Override
1514                 public int compare(SimulationModifier mod1, SimulationModifier mod2) {
1515                         Object rel1 = mod1.getRelatedObject();
1516                         Object rel2 = mod2.getRelatedObject();
1517
1518                         /*
1519                          * Primarily order by related object:
1520                          *
1521                          * - RocketComponents first
1522                          * - Two RocketComponents are ordered based on their position in the rocket
1523                          */
1524                         if (!rel1.equals(rel2)) {
1525
1526                                 if (rel1 instanceof RocketComponent) {
1527                                         if (rel2 instanceof RocketComponent) {
1528
1529                                                 RocketComponent root = ((RocketComponent) rel1).getRoot();
1530                                                 for (RocketComponent c : root) {
1531                                                         if (c.equals(rel1)) {
1532                                                                 return -1;
1533                                                         }
1534                                                         if (c.equals(rel2)) {
1535                                                                 return 1;
1536                                                         }
1537                                                 }
1538
1539                                                 throw new BugException("Error sorting modifiers, mod1=" + mod1 + " rel1=" + rel1 +
1540                                                                 " mod2=" + mod2 + " rel2=" + rel2);
1541
1542                                         } else {
1543                                                 return -1;
1544                                         }
1545                                 } else {
1546                                         if (rel2 instanceof RocketComponent) {
1547                                                 return 1;
1548                                         }
1549                                 }
1550
1551                         }
1552
1553                         // Secondarily sort by name
1554                         return collator.compare(mod1.getName(), mod2.getName());
1555                 }
1556         }
1557
1558
1559
1560 }