git.gag.com Git - debian/openrocket/blob - core/test/net/sf/openrocket/rocketcomponent/SymmetricComponentVolumeTest.java

   1 package net.sf.openrocket.rocketcomponent;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import net.sf.openrocket.material.Material;
   5 import net.sf.openrocket.util.Coordinate;
   6 import net.sf.openrocket.util.BaseTestCase.BaseTestCase;
   7
   8 import org.junit.Test;
   9
  10 public class SymmetricComponentVolumeTest extends BaseTestCase {
  11
  12         @Test
  13         public void simpleConeFilled() {
  14                 NoseCone nc = new NoseCone();
  15
  16                 final double epsilonPercent = 0.001;
  17                 final double density = 2.0;
  18
  19                 nc.setLength(1.0);
  20                 nc.setFilled(true);
  21                 nc.setType(Transition.Shape.CONICAL);
  22                 nc.setAftRadius(1.0);
  23                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
  24
  25                 Coordinate cg = nc.getCG();
  26
  27                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
  28                 System.out.println(cg);
  29
  30                 double volume = Math.PI / 3.0;
  31
  32                 double mass = density * volume;
  33
  34                 System.out.println(volume);
  35
  36                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
  37                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
  38
  39                 assertEquals(0.75, cg.x, epsilonPercent * 0.75);
  40                 assertEquals(mass, cg.weight, epsilonPercent * mass);
  41         }
  42
  43         @Test
  44         public void simpleConeWithShoulderFilled() {
  45                 NoseCone nc = new NoseCone();
  46
  47                 final double epsilonPercent = 0.001;
  48                 final double density = 2.0;
  49
  50                 nc.setLength(1.0);
  51                 nc.setFilled(true);
  52                 nc.setType(Transition.Shape.CONICAL);
  53                 nc.setAftRadius(1.0);
  54                 nc.setAftShoulderRadius(1.0);
  55                 nc.setAftShoulderLength(1.0);
  56                 nc.setAftShoulderThickness(1.0);
  57                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
  58
  59                 Coordinate cg = nc.getCG();
  60
  61                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
  62                 System.out.println(cg);
  63
  64                 double volume = Math.PI / 3.0;
  65                 volume += Math.PI;
  66
  67                 double mass = density * volume;
  68
  69                 System.out.println(volume + "\t" + mass);
  70
  71                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
  72                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
  73
  74                 assertEquals(1.312, cg.x, epsilonPercent * 1.071);
  75                 assertEquals(mass, cg.weight, epsilonPercent * mass);
  76         }
  77
  78         @Test
  79         public void simpleConeHollow() {
  80                 NoseCone nc = new NoseCone();
  81
  82                 final double epsilonPercent = 0.001;
  83                 final double density = 2.0;
  84
  85                 nc.setLength(1.0);
  86                 nc.setAftRadius(1.0);
  87                 nc.setThickness(0.5);
  88                 nc.setType(Transition.Shape.CONICAL);
  89                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
  90
  91                 Coordinate cg = nc.getCG();
  92
  93                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
  94                 System.out.println(cg);
  95
  96                 double volume = Math.PI / 3.0; // outer volume
  97
  98                 // manually projected Thickness of 0.5 on to radius to determine
  99                 // the innerConeDimen.  Since the outer cone is "square" (height = radius),
 100                 // we only need to compute this one dimension in order to compute the
 101                 // volume of the inner cone.
 102                 double innerConeDimen = 1.0 - Math.sqrt(2.0) / 2.0;
 103                 double innerVolume = Math.PI / 3.0 * innerConeDimen * innerConeDimen * innerConeDimen;
 104                 volume -= innerVolume;
 105
 106                 double mass = density * volume;
 107
 108                 System.out.println(volume);
 109
 110                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 111                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 112
 113                 assertEquals(0.7454, cg.x, epsilonPercent * 0.7454);
 114                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 115         }
 116
 117         @Test
 118         public void simpleConeWithShoulderHollow() {
 119                 NoseCone nc = new NoseCone();
 120
 121                 final double epsilonPercent = 0.001;
 122                 final double density = 2.0;
 123
 124                 nc.setLength(1.0);
 125                 nc.setType(Transition.Shape.CONICAL);
 126                 nc.setAftRadius(1.0);
 127                 nc.setThickness(0.5);
 128                 nc.setAftShoulderRadius(1.0);
 129                 nc.setAftShoulderLength(1.0);
 130                 nc.setAftShoulderThickness(0.5);
 131                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 132
 133                 Coordinate cg = nc.getCG();
 134
 135                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 136                 System.out.println(cg);
 137
 138                 double volume = Math.PI / 3.0; // outer volume
 139
 140                 // manually projected Thickness of 0.5 on to radius to determine
 141                 // the innerConeDimen.  Since the outer cone is "square" (height = radius),
 142                 // we only need to compute this one dimension in order to compute the
 143                 // volume of the inner cone.
 144                 double innerConeDimen = 1.0 - Math.sqrt(2.0) / 2.0;
 145                 double innerVolume = Math.PI / 3.0 * innerConeDimen * innerConeDimen * innerConeDimen;
 146                 volume -= innerVolume;
 147
 148                 volume += Math.PI - Math.PI * 0.5 * 0.5;
 149
 150
 151                 double mass = density * volume;
 152
 153                 System.out.println(volume);
 154
 155                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 156                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 157
 158                 assertEquals(1.2719, cg.x, epsilonPercent * 1.2719);
 159                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 160         }
 161
 162         @Test
 163         public void simpleTransitionFilled() {
 164                 Transition nc = new Transition();
 165
 166                 final double epsilonPercent = 0.001;
 167                 final double density = 2.0;
 168
 169                 nc.setLength(4.0);
 170                 nc.setFilled(true);
 171                 nc.setType(Transition.Shape.CONICAL);
 172                 nc.setForeRadius(1.0);
 173                 nc.setAftRadius(2.0);
 174                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 175
 176                 Coordinate cg = nc.getCG();
 177
 178                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 179                 System.out.println(cg);
 180
 181                 double volume = Math.PI / 3.0 * (2.0 * 2.0 + 2.0 * 1.0 + 1.0 * 1.0) * 4.0;
 182
 183                 double mass = density * volume;
 184
 185                 System.out.println(volume);
 186
 187                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 188                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 189
 190                 assertEquals(2.4285, cg.x, epsilonPercent * 2.4285);
 191                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 192         }
 193
 194         @Test
 195         public void simpleTransitionWithShouldersFilled() {
 196                 Transition nc = new Transition();
 197
 198                 final double epsilonPercent = 0.001;
 199                 final double density = 2.0;
 200
 201                 nc.setLength(4.0);
 202                 nc.setFilled(true);
 203                 nc.setType(Transition.Shape.CONICAL);
 204                 nc.setForeRadius(1.0);
 205                 nc.setAftRadius(2.0);
 206                 nc.setAftShoulderLength(1.0);
 207                 nc.setAftShoulderRadius(2.0);
 208                 nc.setAftShoulderThickness(2.0);
 209                 nc.setForeShoulderLength(1.0);
 210                 nc.setForeShoulderRadius(1.0);
 211                 nc.setForeShoulderThickness(1.0);
 212                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 213
 214                 Coordinate cg = nc.getCG();
 215
 216                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 217                 System.out.println(cg);
 218
 219                 double volume = Math.PI / 3.0 * (2.0 * 2.0 + 2.0 * 1.0 + 1.0 * 1.0) * 4.0;
 220                 // plus aft shoulder:
 221                 volume += Math.PI * 1.0 * 2.0 * 2.0;
 222                 // plus fore shoulder:
 223                 volume += Math.PI * 1.0 * 1.0 * 1.0;
 224
 225                 double mass = density * volume;
 226
 227                 System.out.println(volume);
 228
 229                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 230                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 231
 232                 assertEquals(2.8023, cg.x, epsilonPercent * 2.8023);
 233                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 234         }
 235
 236         @Test
 237         public void simpleTransitionHollow1() {
 238                 Transition nc = new Transition();
 239
 240                 final double epsilonPercent = 0.001;
 241                 final double density = 2.0;
 242
 243                 nc.setLength(1.0);
 244                 nc.setType(Transition.Shape.CONICAL);
 245                 nc.setForeRadius(0.5);
 246                 nc.setAftRadius(1.0);
 247                 nc.setThickness(0.5);
 248                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 249
 250                 Coordinate cg = nc.getCG();
 251
 252                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 253                 System.out.println(cg);
 254
 255                 // Volume of filled transition =
 256                 double filledVolume = Math.PI / 3.0 * (1.0 * 1.0 + 1.0 * 0.5 + 0.5 * 0.5) * 1.0;
 257
 258                 // magic 2D cad drawing...
 259                 //
 260                 // Since the thickness >= fore radius, the
 261                 // hollowed out portion of the transition
 262                 // forms a cone.
 263                 // the dimensions of this cone were determined
 264                 // using a 2d cad tool.
 265
 266                 double innerConeRadius = 0.441;
 267                 double innerConeLength = 0.882;
 268                 double innerVolume = Math.PI / 3.0 * innerConeLength * innerConeRadius * innerConeRadius;
 269
 270                 double volume = filledVolume - innerVolume;
 271
 272                 double mass = density * volume;
 273
 274                 System.out.println(volume);
 275
 276                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 277                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 278
 279                 assertEquals(0.5884, cg.x, epsilonPercent * 0.5884);
 280                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 281         }
 282
 283         @Test
 284         public void simpleTransitionWithShouldersHollow1() {
 285                 Transition nc = new Transition();
 286
 287                 final double epsilonPercent = 0.001;
 288                 final double density = 2.0;
 289
 290                 nc.setLength(1.0);
 291                 nc.setType(Transition.Shape.CONICAL);
 292                 nc.setForeRadius(0.5);
 293                 nc.setAftRadius(1.0);
 294                 nc.setThickness(0.5);
 295                 nc.setAftShoulderLength(1.0);
 296                 nc.setAftShoulderRadius(1.0);
 297                 nc.setAftShoulderThickness(0.5);
 298                 nc.setForeShoulderLength(1.0);
 299                 nc.setForeShoulderRadius(0.5);
 300                 nc.setForeShoulderThickness(0.5); // note this means fore shoulder is filled.
 301                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 302
 303                 Coordinate cg = nc.getCG();
 304
 305                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 306                 System.out.println(cg);
 307
 308                 // Volume of filled transition =
 309                 double filledVolume = Math.PI / 3.0 * (1.0 * 1.0 + 1.0 * 0.5 + 0.5 * 0.5) * 1.0;
 310
 311                 // magic 2D cad drawing...
 312                 //
 313                 // Since the thickness >= fore radius, the
 314                 // hollowed out portion of the transition
 315                 // forms a cone.
 316                 // the dimensions of this cone were determined
 317                 // using a 2d cad tool.
 318
 319                 double innerConeRadius = 0.441;
 320                 double innerConeLength = 0.882;
 321                 double innerVolume = Math.PI / 3.0 * innerConeLength * innerConeRadius * innerConeRadius;
 322
 323                 double volume = filledVolume - innerVolume;
 324
 325                 // Now add aft shoulder
 326                 volume += Math.PI * 1.0 * 1.0 * 1.0 - Math.PI * 1.0 * 0.5 * 0.5;
 327                 // Now add fore shoulder
 328                 volume += Math.PI * 1.0 * 0.5 * 0.5;
 329
 330                 double mass = density * volume;
 331
 332                 System.out.println(volume);
 333
 334                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 335                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 336
 337                 assertEquals(0.8581, cg.x, epsilonPercent * 0.8581);
 338                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 339         }
 340
 341         @Test
 342         public void simpleTransitionHollow2() {
 343                 Transition nc = new Transition();
 344
 345                 final double epsilonPercent = 0.001;
 346                 final double density = 2.0;
 347
 348                 nc.setLength(1.0);
 349                 nc.setType(Transition.Shape.CONICAL);
 350                 nc.setForeRadius(0.5);
 351                 nc.setAftRadius(1.0);
 352                 nc.setThickness(0.25);
 353                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 354
 355                 Coordinate cg = nc.getCG();
 356
 357                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 358                 System.out.println(cg);
 359
 360                 // Volume of filled transition =
 361                 double filledVolume = Math.PI / 3.0 * (1.0 * 1.0 + 1.0 * 0.5 + 0.5 * 0.5) * 1.0;
 362
 363                 // magic 2D cad drawing...
 364                 //
 365                 // Since the thickness < fore radius, the
 366                 // hollowed out portion of the transition
 367                 // forms a transition.
 368                 // the dimensions of this transition were determined
 369                 // using a 2d cad tool.
 370
 371                 double innerTransitionAftRadius = 0.7205;
 372                 double innerTransitionForeRadius = 0.2205;
 373                 double innerVolume = Math.PI / 3.0
 374                                 * (innerTransitionAftRadius * innerTransitionAftRadius + innerTransitionAftRadius * innerTransitionForeRadius + innerTransitionForeRadius * innerTransitionForeRadius);
 375
 376                 double volume = filledVolume - innerVolume;
 377
 378                 double mass = density * volume;
 379
 380                 System.out.println(volume);
 381
 382                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 383                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 384
 385                 assertEquals(0.56827, cg.x, epsilonPercent * 0.56827);
 386                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 387         }
 388
 389         @Test
 390         public void simpleTransitionWithShouldersHollow2() {
 391                 Transition nc = new Transition();
 392
 393                 final double epsilonPercent = 0.001;
 394                 final double density = 2.0;
 395
 396                 nc.setLength(1.0);
 397                 nc.setType(Transition.Shape.CONICAL);
 398                 nc.setForeRadius(0.5);
 399                 nc.setAftRadius(1.0);
 400                 nc.setThickness(0.25);
 401                 nc.setAftShoulderLength(1.0);
 402                 nc.setAftShoulderRadius(1.0);
 403                 nc.setAftShoulderThickness(0.25);
 404                 nc.setForeShoulderLength(1.0);
 405                 nc.setForeShoulderRadius(0.5);
 406                 nc.setForeShoulderThickness(0.25);
 407
 408                 nc.setMaterial(Material.newMaterial(Material.Type.BULK, "test", density, true));
 409
 410                 Coordinate cg = nc.getCG();
 411
 412                 System.out.println(nc.getComponentVolume() + "\t" + nc.getMass());
 413                 System.out.println(cg);
 414
 415                 // Volume of filled transition =
 416                 double filledVolume = Math.PI / 3.0 * (1.0 * 1.0 + 1.0 * 0.5 + 0.5 * 0.5) * 1.0;
 417
 418                 // magic 2D cad drawing...
 419                 //
 420                 // Since the thickness < fore radius, the
 421                 // hollowed out portion of the transition
 422                 // forms a transition.
 423                 // the dimensions of this transition were determined
 424                 // using a 2d cad tool.
 425
 426                 double innerTransitionAftRadius = 0.7205;
 427                 double innerTransitionForeRadius = 0.2205;
 428                 double innerVolume = Math.PI / 3.0
 429                                 * (innerTransitionAftRadius * innerTransitionAftRadius + innerTransitionAftRadius * innerTransitionForeRadius + innerTransitionForeRadius * innerTransitionForeRadius);
 430
 431                 double volume = filledVolume - innerVolume;
 432
 433                 // now add aft shoulder
 434                 volume += Math.PI * 1.0 * 1.0 * 1.0 - Math.PI * 1.0 * 0.75 * 0.75;
 435                 // now add fore shoulder
 436                 volume += Math.PI * 1.0 * 0.5 * 0.5 - Math.PI * 1.0 * 0.25 * 0.25;
 437
 438
 439                 double mass = density * volume;
 440
 441                 System.out.println(volume);
 442
 443                 assertEquals(volume, nc.getComponentVolume(), epsilonPercent * volume);
 444                 assertEquals(mass, nc.getMass(), epsilonPercent * mass);
 445
 446                 assertEquals(0.7829, cg.x, epsilonPercent * 0.7829);
 447                 assertEquals(mass, cg.weight, epsilonPercent * mass);
 448         }
 449
 450 }