Create the 12 homeworks

[moorepants]

Homework design

• Each week an average student should spend about 4-6 hours on completing the homework
• One jupyter notebook per lecture video would be a nice alignment (so multiple notebooks per week), these can be different "parts" in Vocareum
• Homeworks are designed to be autograded by nbgrader (https://nbgrader.readthedocs.io)
  • I think we should make all of the assertion tests hidden, except maybe one for each problem that shows what the input/output format should be.
• Ideally each question stands on its own, so correct prior questions aren't needed to succeed at the new question. Or at least keep the build up on prior answers at a minimum.
• Use of templates and initialization code should be used so that the student is focusing on learning the new content for that particular lesson (e.g. if they are forming final EoMs, then give them the kinematics and forces).
• The homeworks should be developed in a private github repository.

Homework inspiration sources

• SymPy solved Kane 1985 chapter exercises:
  • Chapter 2: https://pydy.readthedocs.io/en/latest/examples/kane-levinson-1985-chapter-02.html
  • Chapter 3: https://pydy.readthedocs.io/en/latest/examples/kane-levinson-1985-chapter-03.html
  • Chapters 2-6: https://github.com/pydy/pydy/tree/master/examples/Kane1985
• Select solved homework problems from Kane 1985:
  • https://nbviewer.org/github/moorepants/mae223/tree/master/content/homework-notebooks/
• Problem sets from Kane 1983: https://ecommons.cornell.edu/handle/1813/637
• PyDy examples: https://github.com/pydy/pydy/tree/master/examples
• PyDy documentation examples: https://pydy.readthedocs.io/en/latest/index.html
• SymPy Mechanics examples: https://docs.sympy.org/latest/modules/physics/mechanics/examples.html
• resonance notebooks: https://moorepants.github.io/resonance/
• resonance homeworks: https://gitlab.com/mechmotum/resonance-homework
• Angadh Nanjangud's draft textbook: https://angadhn.github.io/ComputationalDynamics

Tips

To check whether symbolic equations are correct, it's best to evaluate them with some specific or random numerical inputs. The basic form of the asserions should look like:

expr = a + b*sm.cos(theta)  # student's answer

# assertions
eval_students_expr = sm.lambdify((a, b, theta), expr)
np.testing.assert_allclose(12.0 - 0.45*np.cos(23994.0),
                           eval_students_expr(12.0, -0.45, 23994.0))

This will check floating point evaluations of the symbolic expressions. Do it for several unique sets of numerical inputs to check the a realistic range of values. This will avoid the long duration required to simplify symbolics and avoid the problem that comparing two symbolic expressions directly will generally fail.

Symbolic calculations can often take a long time to compute especially for naive choices in how the code is written. We'll probably need a way to have nbgrader time out on the autograding and give up. We should warn students that correct solutions should take only a second or so to run (and design our problems so that is true).

Homework suggestions

• [ ] HW01: Jupyter, NBGrader, Python, SymPy introduction
  • Part 1 (30 points): Jupyter + Python basics
  • Make 6 problems worth 5 points each
  • Start with this notebook: https://gitlab.com/mechmotum/resonance-homework/-/blob/master/source/hw01.ipynb and remove any plotting, numpy, and the resonance system stuff, only test pure Python code and concepts.
  • You can also base additional problems on the materials here: https://moorepants.github.io/learn-multibody-dynamics/jupyter-python.html (I'm still working on that page).
  • NumPy, SciPy, and Matplotlib will be introduced at the beginning of Q4, so only use base Python in this notebook.
  • Part 2 (30 points): SymPy
  • Make 6 problems worth 5 points each
  • The questions should test aspects of this material: https://moorepants.github.io/learn-multibody-dynamics/sympy.html
  • Problem example: have them create two nonlinear symbolic expressions with functions of time, differentiate with respect to time, this results in equations linear in the df/dt terms, then solve the system of equations for the df/dt terms.
  • A problem where they try evaluating a matrix of non-trivial expressions using evalf, lambdify, xreplace so they can learn the differences.
  • Pick some reasonalby difficult linear algegra problem that lets them explore some other things, like determinants or even eigenvalues (of small matrices). Have them solve the linear algebra problem with sympy
  • A problem that introduces the solve() function where they have to solve a non-linear trigometric function (for example the constraint equation from a 4 bar linkage is solvable example), let them see the multiple solutions and how to extract them from sympy's output.
  • You could give them a very long complicated symbolic expression (like 1000s of operations) and then have them lambify it and evaluate it. Have them time the execution with timeit. Then have them cse the expression to see how it simplifies and then introduce the cse=Trye flag for lambdify which does cse internally. Have them evalute and time the new function. There should be a reduction in execution speed. They could use count_ops to show the operation count for the original expression and the set of cse expressions. Note that cse=True is new in sympy 1.9.
  • Part 3 (40 points): Reference Frames, Orientation, Direction Cosine Matrices, Euler Angles
  • Make 4 problems worth 10 points each
  • Material will be like the reference frame section here: https://nbviewer.org/github/pydy/pydy-tutorial-human-standing/blob/master/notebooks/n01_dynamics_overview.ipynb#Rotation-matrices-(direction-cosine-matrices)
  • Pick some problems from Kane's two books as inspiration.
    • SD: 1.1, but change the numbers and the vector lambda
    • Make a multibox problem like this https://docs.sympy.org/latest/_images/kin_angvel2.svg The idea is to stack some boxes, attach triads to each box, and then rotate the boxes one-by-one about the x, y, or z axes for successive simple rotations, the rotation matrix from the first to last box should be computed. The question should be designed such that they do the matrix forumlations manually (not using ReferenceFrame.orient_axis(). Or ask them to do both ways and show their manual formulation is the same as what successive ReferenceFrame.ortient_axis() would do. If you want to sketch a "cans" drawing of this too, that could help connect to Heike's class (if she shows the cans).
    • SD: 1.8 (redraw the figure so we don't violate copyright and then change the numbers and the vector)
    • SD 1.12
• [ ] HW02:
• [ ] HW03:
• [ ] HW04:
• [ ] HW05:
• [ ] HW06:
• [ ] HW07:
• [ ] HW08:
• [ ] HW09:
• [ ] HW10:
• [ ] HW11:
• [ ] HW12:

[moorepants]

I've moved this information to the new private homework repository. See https://github.com/moorepants/me41055-homework/issues/1