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.newUserMaterial(Material.Type.BULK,"test",density));
  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.newUserMaterial(Material.Type.BULK,"test",density));
  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.newUserMaterial(Material.Type.BULK,"test",density));
  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.newUserMaterial(Material.Type.BULK,"test",density));
 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.newUserMaterial(Material.Type.BULK,"test",density));
 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.newUserMaterial(Material.Type.BULK,"test",density));
 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.newUserMaterial(Material.Type.BULK,"test",density));
 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.newUserMaterial(Material.Type.BULK,"test",density));
 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.newUserMaterial(Material.Type.BULK,"test",density));
 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 * ( innerTransitionAftRadius * innerTransitionAftRadius + innerTransitionAftRadius * innerTransitionForeRadius + innerTransitionForeRadius * innerTransitionForeRadius);
 374
 375                 double volume = filledVolume - innerVolume;
 376
 377                 double mass = density * volume;
 378
 379                 System.out.println( volume );
 380
 381                 assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
 382                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
 383
 384                 assertEquals( 0.56827, cg.x, epsilonPercent * 0.56827 );
 385                 assertEquals( mass, cg.weight, epsilonPercent * mass);
 386         }
 387
 388         @Test
 389         public void simpleTransitionWithShouldersHollow2() {
 390                 Transition nc = new Transition();
 391
 392                 final double epsilonPercent = 0.001;
 393                 final double density = 2.0;
 394
 395                 nc.setLength(1.0);
 396                 nc.setType( Transition.Shape.CONICAL );
 397                 nc.setForeRadius(0.5);
 398                 nc.setAftRadius(1.0);
 399                 nc.setThickness(0.25);
 400                 nc.setAftShoulderLength(1.0);
 401                 nc.setAftShoulderRadius(1.0);
 402                 nc.setAftShoulderThickness(0.25);
 403                 nc.setForeShoulderLength(1.0);
 404                 nc.setForeShoulderRadius(0.5);
 405                 nc.setForeShoulderThickness(0.25);
 406
 407                 nc.setMaterial( Material.newUserMaterial(Material.Type.BULK,"test",density));
 408
 409                 Coordinate cg = nc.getCG();
 410
 411                 System.out.println( nc.getComponentVolume() + "\t" + nc.getMass());
 412                 System.out.println( cg );
 413
 414                 // Volume of filled transition =
 415                 double filledVolume = Math.PI /3.0 * ( 1.0*1.0 + 1.0 * 0.5 + 0.5 * 0.5 ) * 1.0;
 416
 417                 // magic 2D cad drawing...
 418                 //
 419                 // Since the thickness < fore radius, the
 420                 // hollowed out portion of the transition
 421                 // forms a transition.
 422                 // the dimensions of this transition were determined
 423                 // using a 2d cad tool.
 424
 425                 double innerTransitionAftRadius = 0.7205;
 426                 double innerTransitionForeRadius = 0.2205;
 427                 double innerVolume = Math.PI /3.0 * ( innerTransitionAftRadius * innerTransitionAftRadius + innerTransitionAftRadius * innerTransitionForeRadius + innerTransitionForeRadius * innerTransitionForeRadius);
 428
 429                 double volume = filledVolume - innerVolume;
 430
 431                 // now add aft shoulder
 432                 volume += Math.PI * 1.0 * 1.0 * 1.0 - Math.PI * 1.0 * 0.75 * 0.75;
 433                 // now add fore shoulder
 434                 volume += Math.PI * 1.0 * 0.5 * 0.5 - Math.PI * 1.0 * 0.25 * 0.25;
 435
 436
 437                 double mass = density * volume;
 438
 439                 System.out.println( volume );
 440
 441                 assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
 442                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
 443
 444                 assertEquals( 0.7829, cg.x, epsilonPercent * 0.7829 );
 445                 assertEquals( mass, cg.weight, epsilonPercent * mass);
 446         }
 447
 448 }