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