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