How to use

RotationalInertiaCalculator

in

us.ihmc.robotics.geometry

public static Matrix3D getRotationalInertiaMatrixOfSolidCylinder(double mass, double radius, double height, Axis axisOfCylinder)
{
 double[] rotationalInertias = getIxxIyyIzzOfSolidCylinder(mass, radius, height, axisOfCylinder);
 Matrix3D rotationalMatrix = getRotationalInertiaFromDiagonal(rotationalInertias[0], rotationalInertias[1], rotationalInertias[2]);
 return rotationalMatrix;
}

public static Matrix3d getRotationalInertiaMatrixOfSolidEllipsoid(double mass, double xRadius, double yRadius, double zRadius)
{
 checkMassAndDimensions(mass, xRadius, yRadius, zRadius);
 double ixx = 1.0 / 5.0 * mass * (yRadius * yRadius + zRadius * zRadius);
 double iyy = 1.0 / 5.0 * mass * (zRadius * zRadius + xRadius * xRadius);
 double izz = 1.0 / 5.0 * mass * (xRadius * xRadius + yRadius * yRadius);
 Matrix3d ret = getRotationalInertiaFromDiagonal(ixx, iyy, izz);
 return ret;
}

private static RigidBodyBasics createAndAttachCylinderRB(String name, RevoluteJoint parentJoint)
{
 Matrix3D inertiaCylinder = RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidCylinder(1.0, 1.0, 1.0, Axis.Z);
 return new RigidBody(name, parentJoint, inertiaCylinder, 1.0, new Vector3D());
}

Axis axis = Axis.values()[pick];
double[] IxxIyyIzz = RotationalInertiaCalculator.getIxxIyyIzzOfSolidCylinder(mass, radius, height, axis);
double inCircleAxis0, inCircleAxis1, mainAxis;
assertEquals(0.5 * mass * radius * radius, mainAxis, DELTA);
Matrix3D rotationMatrix = RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidCylinder(mass, radius, height, axis);
assertEquals(IxxIyyIzz[0], rotationMatrix.getM00(), DELTA);
assertEquals(IxxIyyIzz[1], rotationMatrix.getM11(), DELTA);

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testBasicCylinderNegativeRadius()
{
 double mass = 1.0;
 double radius = -1.0;
 double height = 1.0;
 Axis axis = Axis.Z;
 RotationalInertiaCalculator.getIxxIyyIzzOfSolidCylinder(mass, radius, height, axis);
}

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testSolidEllipsoidNegativeYRadius()
{
  double mass = 1.0;
  double xRadius = 1.0;
  double yRadius = -1.0;
  double zRadius = 1.0;
    RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidEllipsoid(mass, xRadius, yRadius, zRadius);
}

public static Matrix3d getRotationalInertiaMatrixOfTorus(double mass, double radiusOfDonut, double radiusOfTube)
{
 double ixx = ((5.0 / 8.0 * radiusOfTube * radiusOfTube) + (1.0 / 2.0 * radiusOfDonut * radiusOfDonut)) * mass;
 double iyy = ixx;
 double izz = ((3.0 / 4.0 * radiusOfTube * radiusOfTube) + (radiusOfDonut * radiusOfDonut)) * mass;
 Matrix3d ret = getRotationalInertiaFromDiagonal(ixx, iyy, izz);
 return ret;
}

public static double[] getIxxIyyIzzOfSolidCylinder(double mass, double radius, double height, Axis axisOfCylinder)
 checkMassAndDimensions(mass, radius, radius, height);

  @ContinuousIntegrationTest(estimatedDuration = 0.0)
  @Test(timeout = 30000,expected = RuntimeException.class)
  public void testRadiiOfGyrationNegativeZRadius()
  {
    double mass = 1.0;
    double xRadius = 1.0;
    double yRadius = 1.0;
    double zRadius = -1.0;
        RotationalInertiaCalculator.getRotationalInertiaFromRadiiOfGyration(mass, xRadius, yRadius, zRadius);
  }
}

public ContactableCylinderRobot(String name, RigidBodyTransform rootJointTransform, double radius, double height, double mass, String modelName)
{
 super(name);
 rootJointTransformToWorld = rootJointTransform;
 
 afterRootJointFrame = new ReferenceFrame("rootJointFrame", worldFrame)
 {
   @Override
   protected void updateTransformToParent(RigidBodyTransform transformToParent)
   {
    floatingJoint.getTransformToWorld(transformToParent);
   }
 };
 frameCylinder = new FrameCylinder3d(afterRootJointFrame, height, radius);
 link = new Link(name + "Link");
 link.setMass(mass);
 link.setComOffset(new Vector3D(0.0, 0.0, height / 3.0));
 Matrix3D inertia = RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidCylinder(mass, radius, height, Axis.Z);
 link.setMomentOfInertia(inertia);
 linkGraphics = new Graphics3DObject();
 //linkGraphics.addCoordinateSystem(0.2);
 linkGraphics.addCylinder(frameCylinder.getHeight(), frameCylinder.getRadius(), YoAppearance.Transparent());
 if(modelName!=null)
   linkGraphics.addModelFile(modelName);
 link.setLinkGraphics(linkGraphics);
 floatingJoint = new FloatingJoint(name + "Base", name, new Vector3D(), this);
 floatingJoint.setRotationAndTranslation(rootJointTransform);
 floatingJoint.setLink(link);
 this.addRootJoint(floatingJoint);
}

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testBasicCylinderNegativeMass()
{
 double mass = -1.0;
 double radius = 1.0;
 double height = 1.0;
 Axis axis = Axis.Z;
 RotationalInertiaCalculator.getIxxIyyIzzOfSolidCylinder(mass, radius, height, axis);
}

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testSolidEllipsoidNegativeMass()
{
  double mass = -1.0;
  double xRadius = 1.0;
  double yRadius = 1.0;
  double zRadius = 1.0;
    RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidEllipsoid(mass, xRadius, yRadius, zRadius);
}

public static Matrix3D getRotationalInertiaMatrixOfTorus(double mass, double radiusOfDonut, double radiusOfTube)
{
 double ixx = ((5.0 / 8.0 * radiusOfTube * radiusOfTube) + (1.0 / 2.0 * radiusOfDonut * radiusOfDonut)) * mass;
 double iyy = ixx;
 double izz = ((3.0 / 4.0 * radiusOfTube * radiusOfTube) + (radiusOfDonut * radiusOfDonut)) * mass;
 Matrix3D ret = getRotationalInertiaFromDiagonal(ixx, iyy, izz);
 return ret;
}

public static double[] getIxxIyyIzzOfSolidCylinder(double mass, double radius, double height, Axis axisOfCylinder)
 checkMassAndDimensions(mass, radius, radius, height);

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testRadiiOfGyrationNegativeXRadius()
{
  double mass = 1.0;
  double xRadius = -1.0;
  double yRadius = 1.0;
  double zRadius = 1.0;
    RotationalInertiaCalculator.getRotationalInertiaFromRadiiOfGyration(mass, xRadius, yRadius, zRadius);
}

Matrix3D moiInCylinderFrame = RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidCylinder(mass, radius, length, Axis.Z);

public static Matrix3D getRotationalInertiaFromRadiiOfGyration(double mass, double radiusOfGyrationX, double radiusOfGyrationY, double radiusOfGyrationZ)
{
 checkMassAndDimensions(mass, radiusOfGyrationX, radiusOfGyrationY, radiusOfGyrationZ);
 double ixx = mass * (radiusOfGyrationY * radiusOfGyrationY + radiusOfGyrationZ * radiusOfGyrationZ);
 double iyy = mass * (radiusOfGyrationX * radiusOfGyrationX + radiusOfGyrationZ * radiusOfGyrationZ);
 double izz = mass * (radiusOfGyrationX * radiusOfGyrationX + radiusOfGyrationY * radiusOfGyrationY);
 Matrix3D ret = getRotationalInertiaFromDiagonal(ixx, iyy, izz);
 return ret;
}

public static Matrix3d getRotationalInertiaMatrixOfSolidCylinder(double mass, double radius, double height, Axis axisOfCylinder)
{
 double[] rotationalInertias = getIxxIyyIzzOfSolidCylinder(mass, radius, height, axisOfCylinder);
 Matrix3d rotationalMatrix = getRotationalInertiaFromDiagonal(rotationalInertias[0], rotationalInertias[1], rotationalInertias[2]);
 return rotationalMatrix;
}

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testBasicCylinderNegativeHeight()
{
 double mass = 1.0;
 double radius = 1.0;
 double height = -1.0;
 Axis axis = Axis.Z;
 RotationalInertiaCalculator.getIxxIyyIzzOfSolidCylinder(mass, radius, height, axis);
}

@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 30000,expected = RuntimeException.class)
public void testSolidEllipsoidNegativeXRadius()
{
  double mass = 1.0;
  double xRadius = -1.0;
  double yRadius = 1.0;
  double zRadius = 1.0;
    RotationalInertiaCalculator.getRotationalInertiaMatrixOfSolidEllipsoid(mass, xRadius, yRadius, zRadius);
}