code: def test_rolling_disc():
      # Rolling Disc Example
      # Here the rolling disc is formed from the contact point up, removing the
      # need to introduce generalized speeds. Only 3 configuration and 3
      # speed variables are need to describe this system, along with the
      # disc's mass and radius, and the local gravity.
      q1, q2, q3 = dynamicsymbols("q1 q2 q3")
      q1d, q2d, q3d = dynamicsymbols("q1 q2 q3", 1)
      r, m, g = symbols("r m g")
  
      # The kinematics are formed by a series of simple rotations. Each simple
      # rotation creates a new frame, and the next rotation is defined by the new
      # frame's basis vectors. This example uses a 3-1-2 series of rotations, or
      # Z, X, Y series of rotations. Angular velocity for this is defined using
      # the second frame's basis (the lean frame).
      N = ReferenceFrame("N")
      Y = N.orientnew("Y", "Axis", [q1, N.z])
      L = Y.orientnew("L", "Axis", [q2, Y.x])
      R = L.orientnew("R", "Axis", [q3, L.y])
  
      # This is the translational kinematics. We create a point with no velocity
      # in N; this is the contact point between the disc and ground. Next we form
      # the position vector from the contact point to the disc's center of mass.
      # Finally we form the velocity and acceleration of the disc.
      C = Point("C")
      C.set_vel(N, 0)
      Dmc = C.locatenew("Dmc", r * L.z)
      Dmc.v2pt_theory(C, N, R)
  
      # Forming the inertia dyadic.
      I = inertia(L, m / 4 * r**2, m / 2 * r**2, m / 4 * r**2)
      BodyD = RigidBody("BodyD", Dmc, R, m, (I, Dmc))
  
      # Finally we form the equations of motion, using the same steps we did
      # before. Supply the Lagrangian, the generalized speeds.
      BodyD.potential_energy = -m * g * r * cos(q2)
      Lag = Lagrangian(N, BodyD)
      q = [q1, q2, q3]
      q1 = Function("q1")
      q2 = Function("q2")
      q3 = Function("q3")
      l = LagrangesMethod(Lag, q)
      l.form_lagranges_equations()
      RHS = l.rhs()
      RHS.simplify()
      t = symbols("t")
  
      assert l.mass_matrix[3:6] == [0, 5 * m * r**2 / 4, 0]
      assert RHS[4].simplify() == (
          (
              -8 * g * sin(q2(t))
              + r
              * (
                  5 * sin(2 * q2(t)) * Derivative(q1(t), t)
                  + 12 * cos(q2(t)) * Derivative(q3(t), t)
              )
              * Derivative(q1(t), t)
          )
          / (10 * r)
      )
      assert RHS[5] == (
          -5 * cos(q2(t)) * Derivative(q1(t), t)
          + 6 * tan(q2(t)) * Derivative(q3(t), t)
          + 4 * Derivative(q1(t), t) / cos(q2(t))
      ) * Derivative(q2(t), t)
  
file_path: sympy/sympy/physics/mechanics/tests/test_lagrange.py
imports: from sympy.physics.mechanics import dynamicsymbols, ReferenceFrame, Point, RigidBody, LagrangesMethod, Particle, inertia, Lagrangian
  from sympy.core.function import Derivative, Function
  from sympy.core.numbers import pi
  from sympy.core.symbol import symbols
  from sympy.functions.elementary.trigonometric import cos, sin, tan
  from sympy.matrices.dense import Matrix
  from sympy.simplify.simplify import simplify
  from sympy.testing.pytest import raises
label_desc: Use image node_id 6 for calling a global function with example usage: test_rolling_disc() without return types