git.gag.com Git - debian/openrocket/blob - core/src/net/sf/openrocket/unit/UnitGroup.java

   1 package net.sf.openrocket.unit;
   2
   3 import static net.sf.openrocket.util.Chars.*;
   4 import static net.sf.openrocket.util.MathUtil.pow2;
   5
   6 import java.util.ArrayList;
   7 import java.util.Collections;
   8 import java.util.HashMap;
   9 import java.util.Map;
  10 import java.util.regex.Matcher;
  11 import java.util.regex.Pattern;
  12
  13 import net.sf.openrocket.rocketcomponent.Configuration;
  14 import net.sf.openrocket.rocketcomponent.Rocket;
  15
  16
  17 /**
  18  * A group of units (eg. length, mass etc.).  Contains a list of different units of a same
  19  * quantity.
  20  *
  21  * @author Sampo Niskanen <sampo.niskanen@iki.fi>
  22  */
  23
  24 public class UnitGroup {
  25
  26         public static final UnitGroup UNITS_NONE;
  27
  28         public static final UnitGroup UNITS_MOTOR_DIMENSIONS;
  29         public static final UnitGroup UNITS_LENGTH;
  30         public static final UnitGroup UNITS_DISTANCE;
  31
  32         public static final UnitGroup UNITS_AREA;
  33         public static final UnitGroup UNITS_STABILITY;
  34         /**
  35          * This unit group contains only the caliber unit that never scales the originating "SI" value.
  36          * It can be used in cases where the originating value is already in calibers to obtains the correct unit.
  37          */
  38         public static final UnitGroup UNITS_STABILITY_CALIBERS;
  39         public static final UnitGroup UNITS_VELOCITY;
  40         public static final UnitGroup UNITS_ACCELERATION;
  41         public static final UnitGroup UNITS_MASS;
  42         public static final UnitGroup UNITS_INERTIA;
  43         public static final UnitGroup UNITS_ANGLE;
  44         public static final UnitGroup UNITS_DENSITY_BULK;
  45         public static final UnitGroup UNITS_DENSITY_SURFACE;
  46         public static final UnitGroup UNITS_DENSITY_LINE;
  47         public static final UnitGroup UNITS_FORCE;
  48         public static final UnitGroup UNITS_IMPULSE;
  49
  50         /** Time in the order of less than a second (time step etc). */
  51         public static final UnitGroup UNITS_TIME_STEP;
  52
  53         /** Time in the order of seconds (motor delay etc). */
  54         public static final UnitGroup UNITS_SHORT_TIME;
  55
  56         /** Time in the order of the flight time of a rocket. */
  57         public static final UnitGroup UNITS_FLIGHT_TIME;
  58         public static final UnitGroup UNITS_ROLL;
  59         public static final UnitGroup UNITS_TEMPERATURE;
  60         public static final UnitGroup UNITS_PRESSURE;
  61         public static final UnitGroup UNITS_RELATIVE;
  62         public static final UnitGroup UNITS_ROUGHNESS;
  63
  64         public static final UnitGroup UNITS_COEFFICIENT;
  65
  66         //      public static final UnitGroup UNITS_FREQUENCY;
  67
  68
  69         public static final Map<String, UnitGroup> UNITS;
  70
  71
  72         /*
  73          * Note:  Units may not use HTML tags.
  74          *
  75          * The scaling value "X" is obtained by "one of this unit is X of SI units"
  76          * Type into Google for example:  "1 in^2 in m^2"
  77          */
  78         static {
  79                 UNITS_NONE = new UnitGroup();
  80                 UNITS_NONE.addUnit(Unit.NOUNIT2);
  81
  82                 UNITS_LENGTH = new UnitGroup();
  83                 UNITS_LENGTH.addUnit(new GeneralUnit(0.001, "mm"));
  84                 UNITS_LENGTH.addUnit(new GeneralUnit(0.01, "cm"));
  85                 UNITS_LENGTH.addUnit(new GeneralUnit(1, "m"));
  86                 UNITS_LENGTH.addUnit(new GeneralUnit(0.0254, "in"));
  87                 UNITS_LENGTH.addUnit(new FractionalUnit(0.0254, "in/64", "in", 64, 1d/16d));
  88                 UNITS_LENGTH.addUnit(new GeneralUnit(0.3048, "ft"));
  89                 UNITS_LENGTH.setDefaultUnit(1);
  90
  91                 UNITS_MOTOR_DIMENSIONS = new UnitGroup();
  92                 UNITS_MOTOR_DIMENSIONS.addUnit(new GeneralUnit(0.001, "mm"));
  93                 UNITS_MOTOR_DIMENSIONS.addUnit(new GeneralUnit(0.01, "cm"));
  94                 UNITS_MOTOR_DIMENSIONS.addUnit(new GeneralUnit(0.0254, "in"));
  95                 UNITS_MOTOR_DIMENSIONS.setDefaultUnit(0);
  96
  97                 UNITS_DISTANCE = new UnitGroup();
  98                 UNITS_DISTANCE.addUnit(new GeneralUnit(1, "m"));
  99                 UNITS_DISTANCE.addUnit(new GeneralUnit(1000, "km"));
 100                 UNITS_DISTANCE.addUnit(new GeneralUnit(0.3048, "ft"));
 101                 UNITS_DISTANCE.addUnit(new GeneralUnit(0.9144, "yd"));
 102                 UNITS_DISTANCE.addUnit(new GeneralUnit(1609.344, "mi"));
 103                 UNITS_DISTANCE.addUnit(new GeneralUnit(1852, "nmi"));
 104
 105                 UNITS_AREA = new UnitGroup();
 106                 UNITS_AREA.addUnit(new GeneralUnit(pow2(0.001), "mm" + SQUARED));
 107                 UNITS_AREA.addUnit(new GeneralUnit(pow2(0.01), "cm" + SQUARED));
 108                 UNITS_AREA.addUnit(new GeneralUnit(1, "m" + SQUARED));
 109                 UNITS_AREA.addUnit(new GeneralUnit(pow2(0.0254), "in" + SQUARED));
 110                 UNITS_AREA.addUnit(new GeneralUnit(pow2(0.3048), "ft" + SQUARED));
 111                 UNITS_AREA.setDefaultUnit(1);
 112
 113
 114                 UNITS_STABILITY = new UnitGroup();
 115                 UNITS_STABILITY.addUnit(new GeneralUnit(0.001, "mm"));
 116                 UNITS_STABILITY.addUnit(new GeneralUnit(0.01, "cm"));
 117                 UNITS_STABILITY.addUnit(new GeneralUnit(0.0254, "in"));
 118                 UNITS_STABILITY.addUnit(new CaliberUnit((Rocket) null));
 119                 UNITS_STABILITY.setDefaultUnit(3);
 120
 121                 UNITS_STABILITY_CALIBERS = new UnitGroup();
 122                 UNITS_STABILITY_CALIBERS.addUnit(new GeneralUnit(1, "cal"));
 123
 124
 125                 UNITS_VELOCITY = new UnitGroup();
 126                 UNITS_VELOCITY.addUnit(new GeneralUnit(1, "m/s"));
 127                 UNITS_VELOCITY.addUnit(new GeneralUnit(1 / 3.6, "km/h"));
 128                 UNITS_VELOCITY.addUnit(new GeneralUnit(0.3048, "ft/s"));
 129                 UNITS_VELOCITY.addUnit(new GeneralUnit(0.44704, "mph"));
 130
 131                 UNITS_ACCELERATION = new UnitGroup();
 132                 UNITS_ACCELERATION.addUnit(new GeneralUnit(1, "m/s" + SQUARED));
 133                 UNITS_ACCELERATION.addUnit(new GeneralUnit(0.3048, "ft/s" + SQUARED));
 134                 UNITS_ACCELERATION.addUnit(new GeneralUnit(9.80665, "G"));
 135
 136                 UNITS_MASS = new UnitGroup();
 137                 UNITS_MASS.addUnit(new GeneralUnit(0.001, "g"));
 138                 UNITS_MASS.addUnit(new GeneralUnit(1, "kg"));
 139                 UNITS_MASS.addUnit(new GeneralUnit(0.0283495231, "oz"));
 140                 UNITS_MASS.addUnit(new GeneralUnit(0.45359237, "lb"));
 141
 142                 UNITS_INERTIA = new UnitGroup();
 143                 UNITS_INERTIA.addUnit(new GeneralUnit(0.0001, "kg" + DOT + "cm" + SQUARED));
 144                 UNITS_INERTIA.addUnit(new GeneralUnit(1, "kg" + DOT + "m" + SQUARED));
 145                 UNITS_INERTIA.addUnit(new GeneralUnit(1.82899783e-5, "oz" + DOT + "in" + SQUARED));
 146                 UNITS_INERTIA.addUnit(new GeneralUnit(0.000292639653, "lb" + DOT + "in" + SQUARED));
 147                 UNITS_INERTIA.addUnit(new GeneralUnit(0.0421401101, "lb" + DOT + "ft" + SQUARED));
 148                 UNITS_INERTIA.addUnit(new GeneralUnit(1.35581795, "lbf" + DOT + "ft" + DOT + "s" + SQUARED));
 149                 UNITS_INERTIA.setDefaultUnit(1);
 150
 151                 UNITS_ANGLE = new UnitGroup();
 152                 UNITS_ANGLE.addUnit(new DegreeUnit());
 153                 UNITS_ANGLE.addUnit(new FixedPrecisionUnit("rad", 0.01));
 154                 UNITS_ANGLE.addUnit(new GeneralUnit(1.0 / 3437.74677078, "arcmin"));
 155
 156                 UNITS_DENSITY_BULK = new UnitGroup();
 157                 UNITS_DENSITY_BULK.addUnit(new GeneralUnit(1000, "g/cm" + CUBED));
 158                 UNITS_DENSITY_BULK.addUnit(new GeneralUnit(1, "kg/m" + CUBED));
 159                 UNITS_DENSITY_BULK.addUnit(new GeneralUnit(1729.99404, "oz/in" + CUBED));
 160                 UNITS_DENSITY_BULK.addUnit(new GeneralUnit(16.0184634, "lb/ft" + CUBED));
 161
 162                 UNITS_DENSITY_SURFACE = new UnitGroup();
 163                 UNITS_DENSITY_SURFACE.addUnit(new GeneralUnit(10, "g/cm" + SQUARED));
 164                 UNITS_DENSITY_SURFACE.addUnit(new GeneralUnit(0.001, "g/m" + SQUARED));
 165                 UNITS_DENSITY_SURFACE.addUnit(new GeneralUnit(1, "kg/m" + SQUARED));
 166                 UNITS_DENSITY_SURFACE.addUnit(new GeneralUnit(43.9418487, "oz/in" + SQUARED));
 167                 UNITS_DENSITY_SURFACE.addUnit(new GeneralUnit(0.305151727, "oz/ft" + SQUARED));
 168                 UNITS_DENSITY_SURFACE.addUnit(new GeneralUnit(4.88242764, "lb/ft" + SQUARED));
 169                 UNITS_DENSITY_SURFACE.setDefaultUnit(1);
 170
 171                 UNITS_DENSITY_LINE = new UnitGroup();
 172                 UNITS_DENSITY_LINE.addUnit(new GeneralUnit(0.001, "g/m"));
 173                 UNITS_DENSITY_LINE.addUnit(new GeneralUnit(1, "kg/m"));
 174                 UNITS_DENSITY_LINE.addUnit(new GeneralUnit(0.0930102465, "oz/ft"));
 175
 176                 UNITS_FORCE = new UnitGroup();
 177                 UNITS_FORCE.addUnit(new GeneralUnit(1, "N"));
 178                 UNITS_FORCE.addUnit(new GeneralUnit(4.44822162, "lbf"));
 179                 UNITS_FORCE.addUnit(new GeneralUnit(9.80665, "kgf"));
 180
 181                 UNITS_IMPULSE = new UnitGroup();
 182                 UNITS_IMPULSE.addUnit(new GeneralUnit(1, "Ns"));
 183                 UNITS_IMPULSE.addUnit(new GeneralUnit(4.44822162, "lbf" + DOT + "s"));
 184
 185                 UNITS_TIME_STEP = new UnitGroup();
 186                 UNITS_TIME_STEP.addUnit(new FixedPrecisionUnit("ms", 1, 0.001));
 187                 UNITS_TIME_STEP.addUnit(new FixedPrecisionUnit("s", 0.01));
 188                 UNITS_TIME_STEP.setDefaultUnit(1);
 189
 190                 UNITS_SHORT_TIME = new UnitGroup();
 191                 UNITS_SHORT_TIME.addUnit(new GeneralUnit(1, "s"));
 192
 193                 UNITS_FLIGHT_TIME = new UnitGroup();
 194                 UNITS_FLIGHT_TIME.addUnit(new GeneralUnit(1, "s"));
 195                 UNITS_FLIGHT_TIME.addUnit(new GeneralUnit(60, "min"));
 196
 197                 UNITS_ROLL = new UnitGroup();
 198                 UNITS_ROLL.addUnit(new GeneralUnit(1, "rad/s"));
 199                 UNITS_ROLL.addUnit(new GeneralUnit(2 * Math.PI, "r/s"));
 200                 UNITS_ROLL.addUnit(new GeneralUnit(2 * Math.PI / 60, "rpm"));
 201                 UNITS_ROLL.setDefaultUnit(1);
 202
 203                 UNITS_TEMPERATURE = new UnitGroup();
 204                 UNITS_TEMPERATURE.addUnit(new FixedPrecisionUnit("K", 1));
 205                 UNITS_TEMPERATURE.addUnit(new TemperatureUnit(1, 273.15, DEGREE + "C"));
 206                 UNITS_TEMPERATURE.addUnit(new TemperatureUnit(5.0 / 9.0, 459.67, DEGREE + "F"));
 207                 UNITS_TEMPERATURE.setDefaultUnit(1);
 208
 209                 UNITS_PRESSURE = new UnitGroup();
 210                 UNITS_PRESSURE.addUnit(new FixedPrecisionUnit("mbar", 1, 1.0e2));
 211                 UNITS_PRESSURE.addUnit(new FixedPrecisionUnit("bar", 0.001, 1.0e5));
 212                 UNITS_PRESSURE.addUnit(new FixedPrecisionUnit("atm", 0.001, 1.01325e5));
 213                 UNITS_PRESSURE.addUnit(new GeneralUnit(101325.0 / 760.0, "mmHg"));
 214                 UNITS_PRESSURE.addUnit(new GeneralUnit(3386.389, "inHg"));
 215                 UNITS_PRESSURE.addUnit(new GeneralUnit(6894.75729, "psi"));
 216                 UNITS_PRESSURE.addUnit(new GeneralUnit(1, "Pa"));
 217
 218                 UNITS_RELATIVE = new UnitGroup();
 219                 UNITS_RELATIVE.addUnit(new FixedPrecisionUnit("" + ZWSP, 0.01, 1.0));
 220                 UNITS_RELATIVE.addUnit(new GeneralUnit(0.01, "%"));
 221                 UNITS_RELATIVE.addUnit(new FixedPrecisionUnit("" + PERMILLE, 1, 0.001));
 222                 //              UNITS_RELATIVE.addUnit(new FixedPrecisionUnit("" + ZWSP, 0.01, 1.0));
 223                 //              UNITS_RELATIVE.addUnit(new FixedPrecisionUnit("%", 1, 0.01));
 224                 //              UNITS_RELATIVE.addUnit(new FixedPrecisionUnit("" + PERMILLE, 1, 0.001));
 225                 UNITS_RELATIVE.setDefaultUnit(1);
 226
 227
 228                 UNITS_ROUGHNESS = new UnitGroup();
 229                 UNITS_ROUGHNESS.addUnit(new GeneralUnit(0.000001, MICRO + "m"));
 230                 UNITS_ROUGHNESS.addUnit(new GeneralUnit(0.0000254, "mil"));
 231
 232
 233                 UNITS_COEFFICIENT = new UnitGroup();
 234                 UNITS_COEFFICIENT.addUnit(new FixedPrecisionUnit("" + ZWSP, 0.01)); // zero-width space
 235
 236
 237                 // This is not used by OpenRocket, and not extensively tested:
 238                 //              UNITS_FREQUENCY = new UnitGroup();
 239                 //              UNITS_FREQUENCY.addUnit(new GeneralUnit(1, "s"));
 240                 //              UNITS_FREQUENCY.addUnit(new GeneralUnit(0.001, "ms"));
 241                 //              UNITS_FREQUENCY.addUnit(new GeneralUnit(0.000001, MICRO + "s"));
 242                 //              UNITS_FREQUENCY.addUnit(new FrequencyUnit(1, "Hz"));
 243                 //              UNITS_FREQUENCY.addUnit(new FrequencyUnit(1000, "kHz"));
 244                 //              UNITS_FREQUENCY.setDefaultUnit(3);
 245
 246
 247                 HashMap<String, UnitGroup> map = new HashMap<String, UnitGroup>();
 248                 map.put("NONE", UNITS_NONE);
 249                 map.put("LENGTH", UNITS_LENGTH);
 250                 map.put("MOTOR_DIMENSIONS", UNITS_MOTOR_DIMENSIONS);
 251                 map.put("DISTANCE", UNITS_DISTANCE);
 252                 map.put("VELOCITY", UNITS_VELOCITY);
 253                 map.put("ACCELERATION", UNITS_ACCELERATION);
 254                 map.put("AREA", UNITS_AREA);
 255                 map.put("STABILITY", UNITS_STABILITY);
 256                 map.put("MASS", UNITS_MASS);
 257                 map.put("INERTIA", UNITS_INERTIA);
 258                 map.put("ANGLE", UNITS_ANGLE);
 259                 map.put("DENSITY_BULK", UNITS_DENSITY_BULK);
 260                 map.put("DENSITY_SURFACE", UNITS_DENSITY_SURFACE);
 261                 map.put("DENSITY_LINE", UNITS_DENSITY_LINE);
 262                 map.put("FORCE", UNITS_FORCE);
 263                 map.put("IMPULSE", UNITS_IMPULSE);
 264                 map.put("TIME_STEP", UNITS_TIME_STEP);
 265                 map.put("SHORT_TIME", UNITS_SHORT_TIME);
 266                 map.put("FLIGHT_TIME", UNITS_FLIGHT_TIME);
 267                 map.put("ROLL", UNITS_ROLL);
 268                 map.put("TEMPERATURE", UNITS_TEMPERATURE);
 269                 map.put("PRESSURE", UNITS_PRESSURE);
 270                 map.put("RELATIVE", UNITS_RELATIVE);
 271                 map.put("ROUGHNESS", UNITS_ROUGHNESS);
 272                 map.put("COEFFICIENT", UNITS_COEFFICIENT);
 273
 274                 UNITS = Collections.unmodifiableMap(map);
 275         }
 276
 277         public static void setDefaultMetricUnits() {
 278                 UNITS_LENGTH.setDefaultUnit("cm");
 279                 UNITS_MOTOR_DIMENSIONS.setDefaultUnit("mm");
 280                 UNITS_DISTANCE.setDefaultUnit("m");
 281                 UNITS_AREA.setDefaultUnit("cm" + SQUARED);
 282                 UNITS_STABILITY.setDefaultUnit("cal");
 283                 UNITS_VELOCITY.setDefaultUnit("m/s");
 284                 UNITS_ACCELERATION.setDefaultUnit("m/s" + SQUARED);
 285                 UNITS_MASS.setDefaultUnit("g");
 286                 UNITS_INERTIA.setDefaultUnit("kg" + DOT + "m" + SQUARED);
 287                 UNITS_ANGLE.setDefaultUnit("" + DEGREE);
 288                 UNITS_DENSITY_BULK.setDefaultUnit("g/cm" + CUBED);
 289                 UNITS_DENSITY_SURFACE.setDefaultUnit("g/m" + SQUARED);
 290                 UNITS_DENSITY_LINE.setDefaultUnit("g/m");
 291                 UNITS_FORCE.setDefaultUnit("N");
 292                 UNITS_IMPULSE.setDefaultUnit("Ns");
 293                 UNITS_TIME_STEP.setDefaultUnit("s");
 294                 UNITS_FLIGHT_TIME.setDefaultUnit("s");
 295                 UNITS_ROLL.setDefaultUnit("r/s");
 296                 UNITS_TEMPERATURE.setDefaultUnit(DEGREE + "C");
 297                 UNITS_PRESSURE.setDefaultUnit("mbar");
 298                 UNITS_RELATIVE.setDefaultUnit("%");
 299                 UNITS_ROUGHNESS.setDefaultUnit(MICRO + "m");
 300         }
 301
 302         public static void setDefaultImperialUnits() {
 303                 UNITS_LENGTH.setDefaultUnit("in");
 304                 UNITS_MOTOR_DIMENSIONS.setDefaultUnit("in");
 305                 UNITS_DISTANCE.setDefaultUnit("ft");
 306                 UNITS_AREA.setDefaultUnit("in" + SQUARED);
 307                 UNITS_STABILITY.setDefaultUnit("cal");
 308                 UNITS_VELOCITY.setDefaultUnit("ft/s");
 309                 UNITS_ACCELERATION.setDefaultUnit("ft/s" + SQUARED);
 310                 UNITS_MASS.setDefaultUnit("oz");
 311                 UNITS_INERTIA.setDefaultUnit("lb" + DOT + "ft" + SQUARED);
 312                 UNITS_ANGLE.setDefaultUnit("" + DEGREE);
 313                 UNITS_DENSITY_BULK.setDefaultUnit("oz/in" + CUBED);
 314                 UNITS_DENSITY_SURFACE.setDefaultUnit("oz/ft" + SQUARED);
 315                 UNITS_DENSITY_LINE.setDefaultUnit("oz/ft");
 316                 UNITS_FORCE.setDefaultUnit("N");
 317                 UNITS_IMPULSE.setDefaultUnit("Ns");
 318                 UNITS_TIME_STEP.setDefaultUnit("s");
 319                 UNITS_FLIGHT_TIME.setDefaultUnit("s");
 320                 UNITS_ROLL.setDefaultUnit("r/s");
 321                 UNITS_TEMPERATURE.setDefaultUnit(DEGREE + "F");
 322                 UNITS_PRESSURE.setDefaultUnit("mbar");
 323                 UNITS_RELATIVE.setDefaultUnit("%");
 324                 UNITS_ROUGHNESS.setDefaultUnit("mil");
 325         }
 326
 327
 328         /**
 329          * Return a UnitGroup for stability units based on the rocket.
 330          *
 331          * @param rocket        the rocket from which to calculate the caliber
 332          * @return                      the unit group
 333          */
 334         public static UnitGroup stabilityUnits(Rocket rocket) {
 335                 return new StabilityUnitGroup(rocket);
 336         }
 337
 338
 339         /**
 340          * Return a UnitGroup for stability units based on the rocket configuration.
 341          *
 342          * @param config        the rocket configuration from which to calculate the caliber
 343          * @return                      the unit group
 344          */
 345         public static UnitGroup stabilityUnits(Configuration config) {
 346                 return new StabilityUnitGroup(config);
 347         }
 348
 349
 350         /**
 351          * Return a UnitGroup for stability units based on a constant caliber.
 352          *
 353          * @param reference     the constant reference length
 354          * @return                      the unit group
 355          */
 356         public static UnitGroup stabilityUnits(double reference) {
 357                 return new StabilityUnitGroup(reference);
 358         }
 359
 360
 361         //////////////////////////////////////////////////////
 362
 363
 364         protected ArrayList<Unit> units = new ArrayList<Unit>();
 365         protected int defaultUnit = 0;
 366
 367         public int getUnitCount() {
 368                 return units.size();
 369         }
 370
 371         public Unit getDefaultUnit() {
 372                 return units.get(defaultUnit);
 373         }
 374
 375         public int getDefaultUnitIndex() {
 376                 return defaultUnit;
 377         }
 378
 379         public void setDefaultUnit(int n) {
 380                 if (n < 0 || n >= units.size()) {
 381                         throw new IllegalArgumentException("index out of range: " + n);
 382                 }
 383                 defaultUnit = n;
 384         }
 385
 386
 387
 388         /**
 389          * Find a unit by approximate unit name.  Only letters and (ordinary) numbers are
 390          * considered in the matching.  This method is mainly means for testing, allowing
 391          * a simple means to obtain a particular unit.
 392          *
 393          * @param str   the unit name.
 394          * @return              the corresponding unit, or <code>null</code> if not found.
 395          */
 396         public Unit findApproximate(String str) {
 397                 str = str.replaceAll("\\W", "").trim();
 398                 for (Unit u : units) {
 399                         String name = u.getUnit().replaceAll("\\W", "").trim();
 400                         if (str.equalsIgnoreCase(name))
 401                                 return u;
 402                 }
 403                 return null;
 404         }
 405
 406         /**
 407          * Set the default unit based on the unit name.  Throws an exception if a
 408          * unit with the provided name is not available.
 409          *
 410          * @param   name        the unit name.
 411          * @throws  IllegalArgumentException    if the corresponding unit is not found in the group.
 412          */
 413         public void setDefaultUnit(String name) throws IllegalArgumentException {
 414                 for (int i = 0; i < units.size(); i++) {
 415                         if (units.get(i).getUnit().equals(name)) {
 416                                 setDefaultUnit(i);
 417                                 return;
 418                         }
 419                 }
 420                 throw new IllegalArgumentException("name=" + name);
 421         }
 422
 423         public Unit getUnit( String name ) throws IllegalArgumentException {
 424                 for (int i = 0; i < units.size(); i++) {
 425                         if (units.get(i).getUnit().equals(name)) {
 426                                 return units.get(i);
 427                         }
 428                 }
 429                 throw new IllegalArgumentException("name=" + name);
 430         }
 431
 432         public Unit getUnit(int n) {
 433                 return units.get(n);
 434         }
 435
 436         public int getUnitIndex(Unit u) {
 437                 return units.indexOf(u);
 438         }
 439
 440         public void addUnit(Unit u) {
 441                 units.add(u);
 442         }
 443
 444         public boolean contains(Unit u) {
 445                 return units.contains(u);
 446         }
 447
 448         public Unit[] getUnits() {
 449                 return units.toArray(new Unit[0]);
 450         }
 451
 452
 453         /**
 454          * Return the value formatted by the default unit of this group.
 455          * It is the same as calling <code>getDefaultUnit().toString(value)</code>.
 456          *
 457          * @param value         the SI value to format.
 458          * @return                      the formatted string.
 459          * @see                         Unit#toString(double)
 460          */
 461         public String toString(double value) {
 462                 return this.getDefaultUnit().toString(value);
 463         }
 464
 465
 466         /**
 467          * Return the value formatted by the default unit of this group including the unit.
 468          * It is the same as calling <code>getDefaultUnit().toStringUnit(value)</code>.
 469          *
 470          * @param value         the SI value to format.
 471          * @return                      the formatted string.
 472          * @see                         Unit#toStringUnit(double)
 473          */
 474         public String toStringUnit(double value) {
 475                 return this.getDefaultUnit().toStringUnit(value);
 476         }
 477
 478
 479
 480
 481
 482         /**
 483          * Creates a new Value object with the specified value and the default unit of this group.
 484          *
 485          * @param value the value to set.
 486          * @return              a new Value object.
 487          */
 488         public Value toValue(double value) {
 489                 return this.getDefaultUnit().toValue(value);
 490         }
 491
 492
 493
 494
 495         private static final Pattern STRING_PATTERN = Pattern.compile("^\\s*([0-9.,-]+)(.*?)$");
 496
 497         /**
 498          * Converts a string into an SI value.  If the string has one of the units in this
 499          * group appended to it, that unit will be used in conversion.  Otherwise the default
 500          * unit will be used.  If an unknown unit is specified or the value does not parse
 501          * with <code>Double.parseDouble</code> then a <code>NumberFormatException</code>
 502          * is thrown.
 503          * <p>
 504          * This method is applicable only for simple units without e.g. powers.
 505          *
 506          * @param str   the string to parse.
 507          * @return              the SI value.
 508          * @throws NumberFormatException   if the string cannot be parsed.
 509          */
 510         public double fromString(String str) {
 511                 Matcher matcher = STRING_PATTERN.matcher(str);
 512
 513                 if (!matcher.matches()) {
 514                         throw new NumberFormatException("string did not match required pattern");
 515                 }
 516
 517                 double value = Double.parseDouble(matcher.group(1));
 518                 String unit = matcher.group(2).trim();
 519
 520                 if (unit.equals("")) {
 521                         value = this.getDefaultUnit().fromUnit(value);
 522                 } else {
 523                         int i;
 524                         for (i = 0; i < units.size(); i++) {
 525                                 Unit u = units.get(i);
 526                                 if (unit.equalsIgnoreCase(u.getUnit())) {
 527                                         value = u.fromUnit(value);
 528                                         break;
 529                                 }
 530                         }
 531                         if (i >= units.size()) {
 532                                 throw new NumberFormatException("unknown unit " + unit);
 533                         }
 534                 }
 535
 536                 return value;
 537         }
 538
 539
 540         ///////////////////////////
 541
 542
 543         /**
 544          * A private class that switches the CaliberUnit to a rocket-specific CaliberUnit.
 545          * All other methods are passed through to UNITS_STABILITY.
 546          */
 547         private static class StabilityUnitGroup extends UnitGroup {
 548
 549                 public StabilityUnitGroup(double ref) {
 550                         this(new CaliberUnit(ref));
 551                 }
 552
 553                 public StabilityUnitGroup(Rocket rocket) {
 554                         this(new CaliberUnit(rocket));
 555                 }
 556
 557                 public StabilityUnitGroup(Configuration config) {
 558                         this(new CaliberUnit(config));
 559                 }
 560
 561                 private StabilityUnitGroup(CaliberUnit caliberUnit) {
 562                         this.units.addAll(UnitGroup.UNITS_STABILITY.units);
 563                         this.defaultUnit = UnitGroup.UNITS_STABILITY.defaultUnit;
 564                         for (int i = 0; i < units.size(); i++) {
 565                                 if (units.get(i) instanceof CaliberUnit) {
 566                                         units.set(i, caliberUnit);
 567                                 }
 568                         }
 569                 }
 570
 571
 572                 @Override
 573                 public void setDefaultUnit(int n) {
 574                         super.setDefaultUnit(n);
 575                         UNITS_STABILITY.setDefaultUnit(n);
 576                 }
 577         }
 578 }