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 simpleConeHollow() {
  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.setAftRadius(1.0);
  45                 nc.setThickness(0.5);
  46                 nc.setType( Transition.Shape.CONICAL );
  47                 nc.setMaterial( new Material.Bulk("test",density,true));
  48
  49                 System.out.println( nc.getComponentVolume() );
  50
  51                 double volume = Math.PI / 3.0;  // outer volume
  52
  53                 // manually projected Thickness of 0.5 on to radius to determine
  54                 // the innerConeDimen.  Since the outer cone is "square" (height = radius),
  55                 // we only need to compute this one dimension in order to compute the
  56                 // volume of the inner cone.
  57                 double innerConeDimen = 1.0 - Math.sqrt(2.0) / 2.0;
  58                 double innerVolume = Math.PI / 3.0 * innerConeDimen * innerConeDimen * innerConeDimen;
  59                 volume -= innerVolume;
  60
  61                 double mass = density * volume;
  62
  63                 System.out.println( volume );
  64
  65                 assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
  66                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
  67         }
  68
  69         @Test
  70         public void simpleConeWithShoulderFilled() {
  71                 NoseCone nc = new NoseCone();
  72
  73                 final double epsilonPercent = 0.001;
  74                 final double density = 2.0;
  75
  76                 nc.setLength(1.0);
  77                 nc.setFilled(true);
  78                 nc.setType( Transition.Shape.CONICAL );
  79                 nc.setAftRadius(1.0);
  80                 nc.setAftShoulderRadius(1.0);
  81                 nc.setAftShoulderLength(1.0);
  82                 nc.setMaterial( new Material.Bulk("test",density,true));
  83
  84
  85                 System.out.println( nc.getComponentVolume() );
  86
  87                 double volume = Math.PI / 3.0;
  88                 //volume += Math.PI;
  89
  90                 double mass = density * volume;
  91
  92                 System.out.println( volume );
  93
  94                 // FIXME -
  95                 //assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
  96                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
  97         }
  98
  99         @Test
 100         public void simpleTransitionFilled() {
 101                 Transition nc = new Transition();
 102
 103                 final double epsilonPercent = 0.001;
 104                 final double density = 2.0;
 105
 106                 nc.setLength(4.0);
 107                 nc.setFilled(true);
 108                 nc.setType( Transition.Shape.CONICAL );
 109                 nc.setForeRadius(1.0);
 110                 nc.setAftRadius(2.0);
 111                 nc.setMaterial( new Material.Bulk("test",density,true));
 112
 113                 System.out.println( nc.getComponentVolume() );
 114
 115                 double volume = Math.PI / 3.0 * (2.0*2.0 + 2.0 * 1.0 + 1.0 * 1.0) * 4.0;
 116
 117                 double mass = density * volume;
 118
 119                 System.out.println( volume );
 120
 121                 assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
 122                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
 123         }
 124
 125         @Test
 126         public void simpleTransitionHollow1() {
 127                 Transition nc = new Transition();
 128
 129                 final double epsilonPercent = 0.001;
 130                 final double density = 2.0;
 131
 132                 nc.setLength(1.0);
 133                 nc.setType( Transition.Shape.CONICAL );
 134                 nc.setForeRadius(0.5);
 135                 nc.setAftRadius(1.0);
 136                 nc.setThickness(0.5);
 137                 nc.setMaterial( new Material.Bulk("test",density,true));
 138
 139                 System.out.println( nc.getComponentVolume() );
 140
 141                 // Volume of filled transition =
 142                 double filledVolume = Math.PI /3.0 * ( 1.0*1.0 + 1.0 * 0.5 + 0.5 * 0.5 ) * 1.0;
 143
 144                 // magic 2D cad drawing...
 145                 //
 146                 // Since the thickness >= fore radius, the
 147                 // hollowed out portion of the transition
 148                 // forms a cone.
 149                 // the dimensions of this cone were determined
 150                 // using a 2d cad tool.
 151
 152                 double innerConeRadius = 0.441;
 153                 double innerConeLength = 0.882;
 154                 double innerVolume = Math.PI /3.0 * innerConeLength * innerConeRadius * innerConeRadius;
 155
 156                 double volume = filledVolume - innerVolume;
 157
 158                 double mass = density * volume;
 159
 160                 System.out.println( volume );
 161
 162                 assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
 163                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
 164         }
 165
 166         @Test
 167         public void simpleTransitionHollow2() {
 168                 Transition nc = new Transition();
 169
 170                 final double epsilonPercent = 0.001;
 171                 final double density = 2.0;
 172
 173                 nc.setLength(1.0);
 174                 nc.setType( Transition.Shape.CONICAL );
 175                 nc.setForeRadius(0.5);
 176                 nc.setAftRadius(1.0);
 177                 nc.setThickness(0.25);
 178                 nc.setMaterial( new Material.Bulk("test",density,true));
 179
 180                 System.out.println( nc.getComponentVolume() );
 181
 182                 // Volume of filled transition =
 183                 double filledVolume = Math.PI /3.0 * ( 1.0*1.0 + 1.0 * 0.5 + 0.5 * 0.5 ) * 1.0;
 184
 185                 // magic 2D cad drawing...
 186                 //
 187                 // Since the thickness < fore radius, the
 188                 // hollowed out portion of the transition
 189                 // forms a transition.
 190                 // the dimensions of this transition were determined
 191                 // using a 2d cad tool.
 192
 193                 double innerTransitionAftRadius = 0.7205;
 194                 double innerTransitionForeRadius = 0.2205;
 195                 double innerVolume = Math.PI /3.0 * ( innerTransitionAftRadius * innerTransitionAftRadius + innerTransitionAftRadius * innerTransitionForeRadius + innerTransitionForeRadius * innerTransitionForeRadius);
 196
 197                 double volume = filledVolume - innerVolume;
 198
 199                 double mass = density * volume;
 200
 201                 System.out.println( volume );
 202
 203                 assertEquals( volume, nc.getComponentVolume(), epsilonPercent * volume);
 204                 assertEquals( mass, nc.getMass(), epsilonPercent * mass );
 205         }
 206
 207 }