(* Content-type: application/mathematica *)

(*** Wolfram Notebook File ***)
(* http://www.wolfram.com/nb *)

(* CreatedBy='Mathematica 6.0' *)

(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[       145,          7]
NotebookDataLength[     31186,        893]
NotebookOptionsPosition[     27560,        786]
NotebookOutlinePosition[     27966,        803]
CellTagsIndexPosition[     27923,        800]
WindowFrame->Normal*)

(* Beginning of Notebook Content *)
Notebook[{

Cell[CellGroupData[{
Cell["Phys 261 Hwk #8", "Subsubtitle",
 CellChangeTimes->{{3.436179744821*^9, 3.436179758259*^9}, {
  3.4362193637917285`*^9, 3.4362193665137286`*^9}}],

Cell[CellGroupData[{

Cell["Morin 3.70", "Subsection",
 CellChangeTimes->{{3.4360043137390003`*^9, 3.436004315868*^9}, 
   3.436179723259*^9, {3.436180164182*^9, 3.436180164796*^9}}],

Cell["\<\
For any problem we start with a force diagram, so let's add the ability to \
draw vectors:\
\>", "Text",
 CellChangeTimes->{{3.436004330053*^9, 3.43600433142*^9}, {3.436004529192*^9, 
  3.436004544469*^9}, {3.436004590869*^9, 3.436004591186*^9}, {
  3.4360046840950003`*^9, 3.4360046924849997`*^9}}],

Cell[BoxData[
 RowBox[{"Needs", "[", "\"\<VectorFieldPlots`\>\"", "]"}]], "Input",
 CellChangeTimes->{{3.436004593835*^9, 3.436004604516*^9}, {3.436004665697*^9,
   3.436004669882*^9}}],

Cell["\<\
There is a tension, a weight and a normal.  We'll use a cylindrical \
coordinate system {r,\[Theta],z},
where for drawing purpose our piece of paper is the r-hat,z-hat plane:\
\>", "Text",
 CellChangeTimes->{{3.436007073561*^9, 3.436007092498*^9}, {3.43600712258*^9, 
  3.436007139269*^9}, {3.436010031914*^9, 3.4360101473050003`*^9}}],

Cell[BoxData[{
 RowBox[{"vecT", " ", "=", " ", 
  RowBox[{"T", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"-", 
      RowBox[{"Sin", "[", "\[Theta]", "]"}]}], ",", 
     RowBox[{"Cos", "[", "\[Theta]", "]"}]}], 
    "}"}]}]}], "\[IndentingNewLine]", 
 RowBox[{"vecN", " ", "=", " ", 
  RowBox[{"N0", " ", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"Cos", "[", "\[Theta]", "]"}], ",", 
     RowBox[{"Sin", "[", "\[Theta]", "]"}]}], 
    "}"}]}]}], "\[IndentingNewLine]", 
 RowBox[{"vecG", " ", "=", " ", 
  RowBox[{"m", " ", "g", " ", 
   RowBox[{"{", 
    RowBox[{"0", ",", 
     RowBox[{"-", "1"}]}], "}"}]}]}]}], "Input",
 CellChangeTimes->{{3.4360071450299997`*^9, 3.4360072528900003`*^9}, {
  3.436010782953*^9, 3.436010783105*^9}}],

Cell["Choose parameters for illustration", "Text",
 CellChangeTimes->{{3.436008729402*^9, 3.436008754359*^9}}],

Cell[BoxData[
 RowBox[{"params", " ", "=", " ", 
  RowBox[{"{", 
   RowBox[{
    RowBox[{"m", "\[Rule]", "1"}], ",", 
    RowBox[{"g", "\[Rule]", "1"}], ",", 
    RowBox[{"N0", "\[Rule]", "1"}], ",", 
    RowBox[{"T", "\[Rule]", "1"}], ",", 
    RowBox[{"\[Theta]", "\[Rule]", 
     RowBox[{"\[Pi]", "/", "6"}]}]}], "}"}]}]], "Input",
 CellChangeTimes->{{3.436007259712*^9, 3.436007274501*^9}, {3.436007376638*^9,
   3.436007382781*^9}, {3.436010770295*^9, 3.436010776514*^9}}],

Cell["\<\
And draw the diagram with all the vectors based at some common origin:\
\>", "Text",
 CellChangeTimes->{{3.436008775007*^9, 3.436008786583*^9}, {
  3.4360096515690002`*^9, 3.436009661325*^9}}],

Cell[BoxData[
 RowBox[{"pt", "=", 
  RowBox[{"{", 
   RowBox[{"0", ",", "0"}], "}"}]}]], "Input",
 CellChangeTimes->{{3.436007431719*^9, 3.43600743508*^9}}],

Cell[BoxData[
 RowBox[{"ListVectorFieldPlot", "[", 
  RowBox[{
   RowBox[{"{", 
    RowBox[{
     RowBox[{"{", 
      RowBox[{"pt", ",", "vecT"}], "}"}], ",", 
     RowBox[{"{", 
      RowBox[{"pt", ",", "vecN"}], "}"}], ",", 
     RowBox[{"{", 
      RowBox[{"pt", ",", "vecG"}], "}"}]}], "}"}], "/.", "params"}], 
  "]"}]], "Input",
 CellChangeTimes->{{3.436007031883*^9, 3.436007064781*^9}, {
  3.4360072956730003`*^9, 3.4360073110810003`*^9}, {3.4360073488719997`*^9, 
  3.4360073528780003`*^9}, {3.436007404755*^9, 3.43600749648*^9}}],

Cell["To solve just about any problem we write F=ma:", "Text",
 CellChangeTimes->{{3.436009733474*^9, 3.436009792409*^9}}],

Cell[BoxData[
 RowBox[{"FmaAssertion", " ", "=", " ", 
  RowBox[{
   RowBox[{"m", 
    RowBox[{"{", 
     RowBox[{
      RowBox[{
       RowBox[{"-", 
        RowBox[{"v", "^", "2"}]}], "/", "R"}], ",", "0"}], "}"}]}], 
   "\[Equal]", " ", 
   RowBox[{
   "vecN", " ", "+", " ", "vecG", " ", "+", " ", "vecT"}]}]}]], "Input",
 CellChangeTimes->{{3.436009793523*^9, 3.436009846301*^9}}],

Cell["Here we are solving ", "Text",
 CellChangeTimes->{{3.436010005902*^9, 3.4360100081280003`*^9}}],

Cell[BoxData[
 RowBox[{"s", "=", " ", 
  RowBox[{
   RowBox[{"(", 
    RowBox[{
     RowBox[{"Solve", "[", 
      RowBox[{"FmaAssertion", ",", 
       RowBox[{"{", 
        RowBox[{"T", ",", "N0"}], "}"}]}], "]"}], "//", "Simplify"}], ")"}], 
   "[", 
   RowBox[{"[", "1", "]"}], "]"}]}]], "Input",
 CellChangeTimes->{{3.436009941627*^9, 3.436009961962*^9}, {3.436009994157*^9,
   3.4360099963389997`*^9}, {3.436010164623*^9, 3.436010171722*^9}, {
  3.4362203250847287`*^9, 3.4362203258167286`*^9}}],

Cell["\<\
The sliding friction force is in the -\[Theta]hat direction with magnitude f=\
\[Mu]N0.  Since r[t]=R is constant, the F=ma component equation reads:\
\>", "Text",
 CellChangeTimes->{{3.4360101984849997`*^9, 3.436010222223*^9}, {
  3.436010306623*^9, 3.436010327203*^9}, {3.4361798467019997`*^9, 
  3.436179866332*^9}, {3.4362202591627283`*^9, 3.4362202854457283`*^9}}],

Cell[BoxData[
 RowBox[{"eqnv", " ", "=", " ", 
  RowBox[{
   RowBox[{"m", " ", 
    RowBox[{
     RowBox[{"v", "'"}], "[", "t", "]"}]}], " ", "\[Equal]", " ", 
   RowBox[{"(", 
    RowBox[{
     RowBox[{
      RowBox[{
       RowBox[{"-", "\[Mu]"}], " ", "N0"}], " ", "/.", " ", "s"}], " ", "/.", 
     " ", 
     RowBox[{"v", "\[Rule]", 
      RowBox[{"v", "[", "t", "]"}]}]}], ")"}]}]}]], "Input",
 CellChangeTimes->{{3.436220288173729*^9, 3.4362203402687283`*^9}}],

Cell["\<\
This is a differential equation which can be solved by separating and \
integrating, or just DSolve:\
\>", "Text",
 CellChangeTimes->{{3.4361799774890003`*^9, 3.4361800066549997`*^9}, {
  3.4362203496587286`*^9, 3.4362203642007284`*^9}, {3.436220430437729*^9, 
  3.4362204600807285`*^9}}],

Cell[BoxData[
 RowBox[{"sv", " ", "=", " ", 
  RowBox[{
   RowBox[{"DSolve", "[", 
    RowBox[{
     RowBox[{"{", 
      RowBox[{"eqnv", ",", 
       RowBox[{
        RowBox[{"v", "[", "0", "]"}], "\[Equal]", "v0"}]}], "}"}], ",", 
     RowBox[{"v", "[", "t", "]"}], ",", "t"}], "]"}], "[", 
   RowBox[{"[", "1", "]"}], "]"}]}]], "Input",
 CellChangeTimes->{{3.4362204623257284`*^9, 3.436220489227729*^9}, {
  3.436220520963729*^9, 3.4362205213547287`*^9}}],

Cell["\<\
This seems messy, but most of the mess is just the constants.  Solving for \
the time at which v(t) vanishes:\
\>", "Text",
 CellChangeTimes->{{3.4362205327647285`*^9, 3.4362206288137283`*^9}}],

Cell[BoxData[
 RowBox[{"st", " ", "=", " ", 
  RowBox[{
   RowBox[{"Solve", "[", 
    RowBox[{
     RowBox[{
      RowBox[{"(", 
       RowBox[{
        RowBox[{"v", "[", "t", "]"}], "/.", "sv"}], ")"}], "\[Equal]", "0"}], 
     ",", "t"}], "]"}], "[", 
   RowBox[{"[", "1", "]"}], "]"}]}]], "Input",
 CellChangeTimes->{{3.4362206331707287`*^9, 3.4362206542577286`*^9}}],

Cell["\<\
As Morin says, kind of messy, but it checks out. If there is no friction, for \
example, it takes forever to stop:\
\>", "Text",
 CellChangeTimes->{{3.43618001198*^9, 3.4361801039820004`*^9}, {
  3.4362206611347284`*^9, 3.4362207248307285`*^9}}],

Cell[BoxData[
 RowBox[{"Limit", "[", 
  RowBox[{
   RowBox[{"(", 
    RowBox[{"t", "/.", "st"}], ")"}], ",", 
   RowBox[{"\[Mu]", "\[Rule]", "0"}]}], "]"}]], "Input",
 CellChangeTimes->{{3.4362206778807287`*^9, 3.4362206888607283`*^9}}],

Cell["\<\
Or if the \"cone\" is in fact a flat table (\[Theta]=\[Pi]/2) when the normal \
force is just the good old mg independent of velocity,
so we constantly decelerate at \[Mu]g, so the time to go from v0 to 0 is:\
\>", "Text",
 CellChangeTimes->{{3.4362207269197283`*^9, 3.4362207855207286`*^9}}],

Cell[BoxData[
 RowBox[{"Limit", "[", 
  RowBox[{
   RowBox[{"(", 
    RowBox[{"t", "/.", "st"}], ")"}], ",", 
   RowBox[{"\[Theta]", "\[Rule]", 
    RowBox[{"\[Pi]", "/", "2"}]}]}], "]"}]], "Input",
 CellChangeTimes->{{3.4362207869937286`*^9, 3.4362208010237284`*^9}}]
}, Open  ]],

Cell[CellGroupData[{

Cell["Morin 5.56", "Subsection",
 CellChangeTimes->{{3.4360043137390003`*^9, 3.436004315868*^9}, 
   3.436179723259*^9, {3.436180164182*^9, 3.436180164796*^9}, {
   3.4361802044379997`*^9, 3.436180208902*^9}, {3.436180886426*^9, 
   3.43618092334*^9}, {3.4362208472527285`*^9, 3.436220848253729*^9}}],

Cell["\<\
This one sort of belongs with the \"Speedy Travel\" from last week.  A planet \
of mass density \[Rho] spins at \[Omega].  How fast can it spin before
material flies off, e.g. at the equator?  That is, for what \[Omega] is the \
gravity force just large enough to keep material in orbit at R?
If m is a small piece of material at the equator, then we want that:\
\>", "Text",
 CellChangeTimes->{{3.4362208501707287`*^9, 3.4362208810477285`*^9}, {
  3.436220918687729*^9, 3.4362210410417285`*^9}}],

Cell[BoxData[
 RowBox[{"s", "=", 
  RowBox[{"Solve", "[", " ", 
   RowBox[{
    RowBox[{
     RowBox[{
      RowBox[{"-", " ", "m"}], " ", 
      RowBox[{"\[Omega]", "^", "2"}], " ", "R"}], " ", "\[Equal]", " ", 
     RowBox[{
      RowBox[{"-", "G"}], " ", "M", " ", 
      RowBox[{"m", " ", "/", " ", 
       RowBox[{"R", "^", "2"}]}]}]}], ",", "\[Omega]"}], "]"}]}]], "Input",
 CellChangeTimes->{{3.4362210179477286`*^9, 3.4362210759997287`*^9}}],

Cell["\<\
Phrasing the answer in terms of \[Rho] the period is then:\
\>", "Text",
 CellChangeTimes->{{3.4362210791717286`*^9, 3.4362210901777287`*^9}, {
  3.4362211480317287`*^9, 3.4362211512257285`*^9}}],

Cell[BoxData[
 RowBox[{"T", " ", "=", " ", 
  RowBox[{
   RowBox[{
    RowBox[{"2", " ", 
     RowBox[{"\[Pi]", "/", "\[Omega]"}]}], " ", "/.", " ", 
    RowBox[{"s", "[", 
     RowBox[{"[", "2", "]"}], "]"}]}], " ", "/.", " ", 
   RowBox[{"M", "\[Rule]", " ", 
    RowBox[{
     RowBox[{"(", 
      RowBox[{"4", "/", "3"}], ")"}], " ", "\[Pi]", " ", 
     RowBox[{"R", "^", "3"}], " ", "\[Rho]", " "}]}]}]}]], "Input",
 CellChangeTimes->{{3.436221095015729*^9, 3.4362211572307286`*^9}}],

Cell[BoxData[
 RowBox[{"T0", "=", 
  RowBox[{"Simplify", "[", 
   RowBox[{"T", ",", 
    RowBox[{"Assumptions", "\[Rule]", 
     RowBox[{"R", ">", "0"}]}]}], "]"}]}]], "Input",
 CellChangeTimes->{{3.4362211704547286`*^9, 3.4362211931277285`*^9}, {
  3.436221480628729*^9, 3.436221481432729*^9}}],

Cell["Numerically, let's load up the constants we need:", "Text",
 CellChangeTimes->{{3.4362212164207287`*^9, 3.436221224142729*^9}, {
  3.4362213493557286`*^9, 3.4362213652007284`*^9}}],

Cell[BoxData[
 RowBox[{"Needs", "[", "\"\<PhysicalConstants`\>\"", "]"}]], "Input",
 CellChangeTimes->{{3.435622893804*^9, 3.435622913704*^9}}],

Cell[BoxData[
 RowBox[{
  RowBox[{"T0", "/.", " ", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"G", "\[Rule]", "GravitationalConstant"}], ",", 
     RowBox[{"\[Rho]", "\[Rule]", 
      RowBox[{"EarthMass", "/", 
       RowBox[{"(", 
        RowBox[{
         RowBox[{"(", 
          RowBox[{"4", "/", "3"}], ")"}], "\[Pi]", " ", 
         RowBox[{"EarthRadius", "^", "3"}]}], ")"}]}]}]}], "}"}]}], "/.", " ", 
  RowBox[{"{", 
   RowBox[{"Newton", "\[Rule]", 
    RowBox[{"Kilogram", " ", 
     RowBox[{"Meter", " ", "/", 
      RowBox[{"Second", "^", "2"}]}]}]}], "}"}]}]], "Input",
 CellChangeTimes->{{3.436221366930729*^9, 3.4362214460347285`*^9}, {
  3.4362214854177284`*^9, 3.436221489899729*^9}}],

Cell[BoxData[
 RowBox[{"Convert", "[", 
  RowBox[{
   RowBox[{"5068.49", " ", "Second"}], ",", " ", "Hour"}], "]"}]], "Input",
 CellChangeTimes->{{3.436221501956729*^9, 3.4362215169367285`*^9}}],

Cell["\<\
And oh yeah, this is exactly the time for speedy travel through the rabbit \
hole.\
\>", "Text",
 CellChangeTimes->{{3.4362215197827287`*^9, 3.4362215433377285`*^9}}]
}, Open  ]],

Cell[CellGroupData[{

Cell["Morin 5.83", "Subsection",
 CellChangeTimes->{{3.4360043137390003`*^9, 3.436004315868*^9}, 
   3.436179723259*^9, {3.436180164182*^9, 3.436180164796*^9}, {
   3.4361802044379997`*^9, 3.436180208902*^9}, {3.436180886426*^9, 
   3.43618092334*^9}}],

Cell["\<\
Consider a standard 2D elastic collision: initially particle one (M) is \
moving at v0 toward particle 2 (m at rest).
After a collision, particle 2 heads off at an angle \[Theta] while m1 goes at \
\[Phi].
We are asked to find \[Theta] when the vertical component of particle 2's \
final state velocity is as large as it can be.\
\>", "Text",
 CellChangeTimes->{{3.436180956528*^9, 3.436181015651*^9}, {
  3.4361810520550003`*^9, 3.436181183084*^9}, {3.4362216073547287`*^9, 
  3.436221718845729*^9}, {3.4362218091297283`*^9, 3.4362218413397284`*^9}, {
  3.436295377951*^9, 3.43629542444*^9}}],

Cell["\<\
Thinking about it in the center of mass frame makes the problem easy.  First, \
observe that the CM is moving
purely in the x-direction, so the lab and CM frame agree on the y-direction \
velocities of a given object,
and in particular maximizing v2y in one frame will maximize in the other.  So \
how do we maximize v2y in the
CM frame?  By having the particles fly off  purely in the y-direction \
obviously.  So in the CM description, 
particle 2 comes in with velocity (-Vcm) in the x-direction, then scatters at \
the same speed (Vcm) in the y-direction.
In the lab frame then, the resulting velocity vector is (Vcm,Vcm), i.e. at \
angle \[Pi]/4 relative to the x-axis.\
\>", "Text",
 CellChangeTimes->{{3.436295465727*^9, 3.436295776028*^9}}],

Cell["\<\
Now let's solve this problem purely in the lab frame.  The conservation \
equations are:\
\>", "Text",
 CellChangeTimes->{{3.436295796453*^9, 3.43629579796*^9}}],

Cell[BoxData[
 RowBox[{"eqnpx", " ", "=", " ", 
  RowBox[{
   RowBox[{"M", " ", "v0"}], " ", "\[Equal]", " ", 
   RowBox[{
    RowBox[{"M", " ", "v1", " ", 
     RowBox[{"Cos", "[", "\[Phi]", "]"}]}], " ", "+", " ", 
    RowBox[{"m", " ", "v2", " ", 
     RowBox[{"Cos", "[", "\[Theta]", "]"}]}]}]}]}]], "Input",
 CellChangeTimes->{{3.436181184146*^9, 3.436181235847*^9}, {
  3.436221844404729*^9, 3.4362218486157284`*^9}}],

Cell[BoxData[
 RowBox[{"eqnpy", " ", "=", " ", 
  RowBox[{"0", " ", "\[Equal]", " ", 
   RowBox[{
    RowBox[{"M", " ", "v1", " ", 
     RowBox[{"Sin", "[", "\[Phi]", "]"}]}], " ", "-", " ", 
    RowBox[{"m", " ", "v2", " ", 
     RowBox[{"Sin", "[", "\[Theta]", "]"}]}]}]}]}]], "Input",
 CellChangeTimes->{{3.4361812381029997`*^9, 3.436181254165*^9}, {
  3.436190708058522*^9, 3.4361907088085175`*^9}, {3.4362218513257284`*^9, 
  3.436221854371729*^9}}],

Cell[BoxData[
 RowBox[{"eqnK", " ", "=", " ", 
  RowBox[{
   RowBox[{"M", " ", 
    RowBox[{"v0", "^", "2"}]}], " ", "\[Equal]", " ", 
   RowBox[{
    RowBox[{"M", " ", 
     RowBox[{"v1", "^", "2"}]}], " ", "+", " ", 
    RowBox[{"m", " ", 
     RowBox[{"v2", "^", "2"}]}]}]}]}]], "Input",
 CellChangeTimes->{{3.436181256453*^9, 3.4361812704230003`*^9}, {
  3.436221857057729*^9, 3.4362218621017284`*^9}}],

Cell["Solving ...", "Text",
 CellChangeTimes->{{3.436181276073*^9, 3.4361812973*^9}, {
  3.4362218713437285`*^9, 3.4362218757217283`*^9}}],

Cell[BoxData[
 RowBox[{"s", "=", " ", 
  RowBox[{"FullSimplify", "[", 
   RowBox[{"Solve", "[", 
    RowBox[{
     RowBox[{"{", 
      RowBox[{"eqnpx", ",", "eqnpy", ",", "eqnK"}], "}"}], ",", 
     RowBox[{"{", 
      RowBox[{"v1", ",", "v2", ",", "\[Phi]"}], "}"}]}], "]"}], 
   "]"}]}]], "Input",
 CellChangeTimes->{{3.4362218792997284`*^9, 3.4362219113547287`*^9}}],

Cell["\<\
which is messy enough, but taking out the solution we seek we define\
\>", "Text",
 CellChangeTimes->{{3.436221926555729*^9, 3.4362219548627286`*^9}}],

Cell[BoxData[
 RowBox[{
  RowBox[{"v2y", "[", "\[Theta]_", "]"}], " ", "=", " ", 
  RowBox[{
   RowBox[{"(", 
    RowBox[{"v2", "/.", 
     RowBox[{"s", "[", 
      RowBox[{"[", "7", "]"}], "]"}]}], ")"}], " ", 
   RowBox[{"Sin", "[", "\[Theta]", "]"}]}]}]], "Input",
 CellChangeTimes->{{3.4362219561317286`*^9, 3.4362219770647287`*^9}}],

Cell["\<\
For what value of \[Theta] is this maximized?\
\>", "Text",
 CellChangeTimes->{{3.4362219824867287`*^9, 3.4362219924657288`*^9}}],

Cell[BoxData[
 RowBox[{"Solve", "[", 
  RowBox[{
   RowBox[{
    RowBox[{
     RowBox[{"v2y", "'"}], "[", "\[Theta]", "]"}], "\[Equal]", "0"}], ",", 
   "\[Theta]"}], "]"}]], "Input",
 CellChangeTimes->{{3.4362219978157287`*^9, 3.436222007114729*^9}}],

Cell["\<\
Oh yeah, that becomes obvious e.g. when one remembers trig ID's such as\
\>", "Text",
 CellChangeTimes->{{3.436222010220729*^9, 3.4362220296907287`*^9}}],

Cell[BoxData[
 RowBox[{"TrigExpand", "[", 
  RowBox[{"Sin", "[", 
   RowBox[{"2", " ", "\[Theta]"}], "]"}], "]"}]], "Input",
 CellChangeTimes->{{3.4362220310217285`*^9, 3.436222036812729*^9}}],

Cell["\<\
and then notes that Sin[2 \[Theta]] is maximized when 2\[Theta] = \[Pi]/2.  \
Note that maximal v2y is then:\
\>", "Text",
 CellChangeTimes->{{3.4362221205637283`*^9, 3.4362221575717287`*^9}}],

Cell[BoxData[
 RowBox[{"v2y", "[", 
  RowBox[{"\[Pi]", "/", "4"}], "]"}]], "Input",
 CellChangeTimes->{{3.4362221586857285`*^9, 3.4362221626977286`*^9}}],

Cell["which just happens to be the center of mass velocity.", "Text",
 CellChangeTimes->{{3.4362221691987286`*^9, 3.436222179246729*^9}}]
}, Open  ]],

Cell[CellGroupData[{

Cell["Morin 5.89", "Subsection",
 CellChangeTimes->{{3.4360043137390003`*^9, 3.436004315868*^9}, 
   3.436179723259*^9, {3.436180164182*^9, 3.436180164796*^9}, {
   3.4361802044379997`*^9, 3.436180208902*^9}, {3.436180886426*^9, 
   3.43618092334*^9}, {3.4362222518037286`*^9, 3.4362222527197285`*^9}}],

Cell["\<\
A plate of mass M moves at v.  A mass m is dropped on the plate and skids to \
rest relative to the plate.
How much energy must be pumped in to the system to make the plate (together \
with mass m) move again at v?\
\>", "Text",
 CellChangeTimes->{{3.4362222599977283`*^9, 3.4362223607577286`*^9}, {
  3.4675489677788*^9, 3.467548967966*^9}}],

Cell["\<\
Well, there are no external forces (frictionless table) so momentum is \
conserved in the plate/pea collision, and the
new speed is given by:\
\>", "Text",
 CellChangeTimes->{{3.4362223643847284`*^9, 3.4362224332117286`*^9}}],

Cell[BoxData[
 RowBox[{"s", "=", 
  RowBox[{"Solve", "[", 
   RowBox[{
    RowBox[{
     RowBox[{"M", " ", "v"}], " ", "\[Equal]", " ", 
     RowBox[{
      RowBox[{"(", 
       RowBox[{"M", "+", "m"}], ")"}], " ", "vnew"}]}], ",", "vnew"}], 
   "]"}]}]], "Input",
 CellChangeTimes->{{3.4362224353307285`*^9, 3.4362224562667284`*^9}}],

Cell["That means that we have kinetic energy", "Text",
 CellChangeTimes->{{3.4362224617157288`*^9, 3.436222470536729*^9}}],

Cell[BoxData[
 RowBox[{"Knew", " ", "=", " ", 
  RowBox[{
   RowBox[{
    RowBox[{"(", 
     RowBox[{"1", "/", "2"}], ")"}], " ", 
    RowBox[{"(", 
     RowBox[{"M", "+", "m"}], ")"}], " ", 
    RowBox[{
     RowBox[{"(", "vnew", ")"}], "^", "2"}]}], " ", "/.", " ", 
   RowBox[{"s", "[", 
    RowBox[{"[", "1", "]"}], "]"}]}]}]], "Input",
 CellChangeTimes->{{3.4362224737957287`*^9, 3.4362224874747286`*^9}, {
  3.436222570536729*^9, 3.4362225712627287`*^9}, {3.4362226239577284`*^9, 
  3.4362226310457287`*^9}}],

Cell["\<\
And if we want to end up in a state with both M and m moving at the original \
v we must supply an energy\
\>", "Text",
 CellChangeTimes->{{3.4362226428157287`*^9, 3.436222672173729*^9}}],

Cell[BoxData[
 RowBox[{"\[CapitalDelta]K", " ", "=", " ", 
  RowBox[{
   RowBox[{
    RowBox[{
     RowBox[{"(", 
      RowBox[{"1", "/", "2"}], ")"}], " ", 
     RowBox[{"(", 
      RowBox[{"M", "+", "m"}], ")"}], " ", 
     RowBox[{"v", "^", "2"}]}], " ", "-", " ", "Knew"}], " ", "//", 
   "Simplify"}]}]], "Input",
 CellChangeTimes->{{3.4362226754827285`*^9, 3.4362227041007285`*^9}}],

Cell["Notice that when M is large this becomes:", "Text",
 CellChangeTimes->{{3.4362227157907286`*^9, 3.4362227277287283`*^9}}],

Cell[BoxData[
 RowBox[{"Limit", "[", 
  RowBox[{"\[CapitalDelta]K", ",", 
   RowBox[{"M", "\[Rule]", "Infinity"}]}], "]"}]], "Input",
 CellChangeTimes->{{3.4362227288797283`*^9, 3.4362227371037283`*^9}}],

Cell["\<\
The \"intuitive\" explanation is that from beginning to end the plate is in \
the same state, but we have added the energy 
necessary to bring mass m from speed 0 up to v (i.e (1/2) m v^2), AND we've \
replaced the energy lost to heat in
the scraping, sliding, stopping process as the little mass interacts with the \
plate.  In the limit that M is large, let's view
that process in the CM frame (i.e. the plate frame).  In that frame, the \
little m lands with relative velocity v, then
skids to a stop, losing *all* of its kinetic energy.  Thus (1/2) m v^2 is \
lost to heat, and altogether our energy bill is mv^2.
\
\>", "Text",
 CellChangeTimes->{{3.4362227444177284`*^9, 3.4362227592247286`*^9}, {
  3.4362229238117285`*^9, 3.4362231231847286`*^9}}]
}, Open  ]],

Cell[CellGroupData[{

Cell["Morin 5.94", "Subsection",
 CellChangeTimes->{{3.4360043137390003`*^9, 3.436004315868*^9}, 
   3.436179723259*^9, {3.436180164182*^9, 3.436180164796*^9}, {
   3.4361802044379997`*^9, 3.436180208902*^9}, {3.436180886426*^9, 
   3.43618092334*^9}, {3.4362222518037286`*^9, 3.4362222527197285`*^9}, {
   3.4362231444127283`*^9, 3.4362231469287286`*^9}}],

Cell["\<\
An essentially massless dustpan starts from rest at the top of a incline \
(parameterized by the angle \[Theta]).
Along the ramp there is a layer of dust with density \[Sigma] kg/meter.  The \
dustpan slides (frictionlessly) down
the hill, sweeping up the dust along the way.  We see the motion x(t) where x \
is the distance from the start.\
\>", "Text",
 CellChangeTimes->{{3.4362231483867283`*^9, 3.4362231695387287`*^9}, {
  3.436295827025*^9, 3.4362959424309998`*^9}}],

Cell["\<\
We derive the differential equation in the usual \[CapitalDelta]t way:  at \
time t we have a dustpan of mass m(t) = \[Sigma] x(t)
(that being the amount of dust which has been swept up so far) colliding with \
an amount \[CapitalDelta]m of dust at rest.
If we are moving at v(t) = x'(t), the amount of dust we are about to pick up \
in \[CapitalDelta]t is \[Sigma] \[CapitalDelta]x = \[Sigma] v \[CapitalDelta]t.
After the collision, both dustpan and dust continue on at v+\[CapitalDelta]v. \
 Thus the change in momentum is:\
\>", "Text",
 CellChangeTimes->{{3.436295937676*^9, 3.4362961189119997`*^9}}],

Cell[BoxData[
 RowBox[{"\[CapitalDelta]p", " ", "=", " ", 
  RowBox[{
   RowBox[{
    RowBox[{"(", 
     RowBox[{"m", " ", "+", " ", "\[CapitalDelta]m"}], ")"}], 
    RowBox[{"(", 
     RowBox[{"v", "+", "\[CapitalDelta]v"}], ")"}]}], " ", "-", " ", 
   RowBox[{"m", " ", "v"}]}]}]], "Input",
 CellChangeTimes->{{3.436296122541*^9, 3.4362961707019997`*^9}}],

Cell["Dividing by \[CapitalDelta]t we get ", "Text",
 CellChangeTimes->{{3.436296309774*^9, 3.436296320358*^9}, {3.436296350942*^9,
   3.436296351682*^9}}],

Cell[BoxData[
 RowBox[{
  RowBox[{
   RowBox[{"(", 
    RowBox[{"\[CapitalDelta]p", "/", "\[CapitalDelta]t"}], ")"}], " ", "/.", 
   " ", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"m", "\[Rule]", 
      RowBox[{"\[Sigma]", " ", 
       RowBox[{"x", "[", "t", "]"}]}]}], ",", " ", 
     RowBox[{"\[CapitalDelta]m", " ", "\[Rule]", " ", 
      RowBox[{"\[Sigma]", " ", 
       RowBox[{
        RowBox[{"x", "'"}], "[", "t", "]"}], " ", "\[CapitalDelta]t"}]}], ",",
      " ", 
     RowBox[{"v", "\[Rule]", 
      RowBox[{
       RowBox[{"x", "'"}], "[", "t", "]"}]}], ",", " ", 
     RowBox[{"\[CapitalDelta]v", "\[Rule]", 
      RowBox[{
       RowBox[{
        RowBox[{"x", "''"}], "[", "t", "]"}], "\[CapitalDelta]t"}]}]}], 
    "}"}]}], "//", "Simplify"}]], "Input",
 CellChangeTimes->{{3.4362962015810003`*^9, 3.436296293302*^9}}],

Cell[BoxData[
 RowBox[{"Limit", "[", 
  RowBox[{"%", ",", 
   RowBox[{"\[CapitalDelta]t", "\[Rule]", "0"}]}], "]"}]], "Input",
 CellChangeTimes->{{3.436296357417*^9, 3.436296363226*^9}}],

Cell["\<\
Equating with the external force (which is m g Sin[\[Theta]], or m g\[Theta] \
for short) the \[Sigma]'s cancel and we get our equation of motion:\
\>", "Text",
 CellChangeTimes->{{3.436296370723*^9, 3.436296418233*^9}}],

Cell[BoxData[
 RowBox[{"eqn", " ", "=", " ", 
  RowBox[{
   RowBox[{
    RowBox[{"x", "''"}], "[", "t", "]"}], "  ", "\[Equal]", " ", 
   RowBox[{"g\[Theta]", " ", "-", 
    RowBox[{
     RowBox[{
      RowBox[{"(", 
       RowBox[{
        RowBox[{"x", "'"}], "[", "t", "]"}], ")"}], "^", "2"}], "/", 
     RowBox[{"x", "[", "t", "]"}]}]}]}]}]], "Input",
 CellChangeTimes->{{3.4362231705857286`*^9, 3.4362232463627286`*^9}, {
  3.530995096796852*^9, 3.5309951374439983`*^9}, {3.530995200657754*^9, 
  3.530995205966617*^9}}],

Cell["With fingers crossed we ask for:", "Text",
 CellChangeTimes->{{3.436223222491729*^9, 3.4362232597267284`*^9}, {
  3.436296438861*^9, 3.436296441053*^9}}],

Cell[BoxData[
 RowBox[{"s", " ", "=", 
  RowBox[{"DSolve", "[", 
   RowBox[{"eqn", ",", 
    RowBox[{"x", "[", "t", "]"}], ",", "t"}], "]"}]}]], "Input",
 CellChangeTimes->{{3.4362232605947285`*^9, 3.4362232877367287`*^9}, {
  3.436223509897729*^9, 3.436223522069729*^9}, {3.4362964435959997`*^9, 
  3.436296445116*^9}}],

Cell["\<\
Obviously we got both more and less than we bargained for.
How do we solve this one \"by hand\"?!
The argument runs backward from the answer: we ask \"what could x(t) look \
like\"?
We have the following building blocks from which to build an expression for \
x(t):  t, g, \[Theta], \[Sigma].
Given the physical dimensions, we observe that the answer for x(t) cannot \
involve \[Sigma], 
since it is the only parameter which has kilograms in its units, and there is \
nothing to cancel
those in an expression which must end up with dimensions of meters.  This \
\"explains\" why
the \[Sigma]'s cancelled out of our differential equation.  Then from the \
rest the only expression with
units of distance is: g t^2.  Thus x(t) = f(\[Theta]) g t^2 where all that \
remains is to find the dimensionless constant.
So we try the ansatz x(t) = (1/2) a t^2:\
\>", "Text",
 CellChangeTimes->{{3.436296503623*^9, 3.436296538546*^9}, {3.436296608157*^9,
   3.436296914429*^9}}],

Cell[BoxData[
 RowBox[{"eqn", " ", "/.", " ", 
  RowBox[{"{", 
   RowBox[{"x", "\[Rule]", 
    RowBox[{"Function", "[", 
     RowBox[{
      RowBox[{"{", "t", "}"}], ",", 
      RowBox[{
       RowBox[{"(", 
        RowBox[{"1", "/", "2"}], ")"}], " ", "a", " ", 
       RowBox[{"t", "^", "2"}]}]}], "]"}]}], "}"}]}]], "Input",
 CellChangeTimes->{{3.436223299746729*^9, 3.4362233099627285`*^9}, {
  3.4362233449087286`*^9, 3.4362234042597284`*^9}}],

Cell[BoxData[
 RowBox[{"Solve", "[", 
  RowBox[{"%", ",", "a"}], "]"}]], "Input",
 CellChangeTimes->{{3.436296923863*^9, 3.436296927924*^9}}],

Cell["\<\
In other words, the acceleration is constant and equal to (1/3) g \
Sin[\[Theta]].
As a last check:\
\>", "Text",
 CellChangeTimes->{{3.436296970942*^9, 3.436296995767*^9}}],

Cell[BoxData[
 RowBox[{"eqn", " ", "/.", " ", 
  RowBox[{"{", 
   RowBox[{"x", "\[Rule]", 
    RowBox[{"Function", "[", 
     RowBox[{
      RowBox[{"{", "t", "}"}], ",", 
      RowBox[{
       RowBox[{"(", 
        RowBox[{"1", "/", "6"}], ")"}], " ", "g\[Theta]", " ", 
       RowBox[{"t", "^", "2"}]}]}], "]"}]}], "}"}]}]], "Input",
 CellChangeTimes->{{3.436297004604*^9, 3.436297028487*^9}}]
}, Open  ]]
}, Open  ]]
},
ScreenStyleEnvironment->"Presentation",
WindowSize->{1008, 647},
WindowMargins->{{8, Automatic}, {Automatic, -4}},
ShowSelection->True,
FrontEndVersion->"8.0 for Microsoft Windows (32-bit) (February 23, 2011)",
StyleDefinitions->"Default.nb"
]
(* End of Notebook Content *)

(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{}
*)
(*CellTagsIndex
CellTagsIndex->{}
*)
(*NotebookFileOutline
Notebook[{
Cell[CellGroupData[{
Cell[567, 22, 151, 2, 51, "Subsubtitle"],
Cell[CellGroupData[{
Cell[743, 28, 160, 2, 63, "Subsection"],
Cell[906, 32, 309, 6, 47, "Text"],
Cell[1218, 40, 185, 3, 50, "Input"],
Cell[1406, 45, 345, 6, 111, "Text"],
Cell[1754, 53, 738, 22, 119, "Input"],
Cell[2495, 77, 110, 1, 47, "Text"],
Cell[2608, 80, 477, 11, 50, "Input"],
Cell[3088, 93, 202, 4, 47, "Text"],
Cell[3293, 99, 156, 4, 50, "Input"],
Cell[3452, 105, 539, 14, 85, "Input"],
Cell[3994, 121, 122, 1, 47, "Text"],
Cell[4119, 124, 385, 12, 50, "Input"],
Cell[4507, 138, 101, 1, 47, "Text"],
Cell[4611, 141, 499, 13, 50, "Input"],
Cell[5113, 156, 379, 6, 79, "Text"],
Cell[5495, 164, 467, 14, 50, "Input"],
Cell[5965, 180, 298, 6, 79, "Text"],
Cell[6266, 188, 457, 12, 50, "Input"],
Cell[6726, 202, 203, 4, 79, "Text"],
Cell[6932, 208, 370, 11, 50, "Input"],
Cell[7305, 221, 255, 5, 79, "Text"],
Cell[7563, 228, 236, 6, 50, "Input"],
Cell[7802, 236, 302, 5, 111, "Text"],
Cell[8107, 243, 268, 7, 50, "Input"]
}, Open  ]],
Cell[CellGroupData[{
Cell[8412, 255, 300, 4, 63, "Subsection"],
Cell[8715, 261, 506, 8, 175, "Text"],
Cell[9224, 271, 449, 12, 50, "Input"],
Cell[9676, 285, 205, 4, 47, "Text"],
Cell[9884, 291, 487, 13, 50, "Input"],
Cell[10374, 306, 295, 7, 50, "Input"],
Cell[10672, 315, 186, 2, 47, "Text"],
Cell[10861, 319, 143, 2, 50, "Input"],
Cell[11007, 323, 701, 19, 119, "Input"],
Cell[11711, 344, 194, 4, 50, "Input"],
Cell[11908, 350, 176, 4, 47, "Text"]
}, Open  ]],
Cell[CellGroupData[{
Cell[12121, 359, 252, 4, 63, "Subsection"],
Cell[12376, 365, 603, 11, 175, "Text"],
Cell[12982, 378, 758, 14, 399, "Text"],
Cell[13743, 394, 171, 4, 47, "Text"],
Cell[13917, 400, 423, 10, 50, "Input"],
Cell[14343, 412, 454, 10, 50, "Input"],
Cell[14800, 424, 406, 11, 50, "Input"],
Cell[15209, 437, 138, 2, 47, "Text"],
Cell[15350, 441, 369, 10, 50, "Input"],
Cell[15722, 453, 160, 3, 47, "Text"],
Cell[15885, 458, 337, 9, 50, "Input"],
Cell[16225, 469, 139, 3, 47, "Text"],
Cell[16367, 474, 251, 7, 50, "Input"],
Cell[16621, 483, 163, 3, 47, "Text"],
Cell[16787, 488, 192, 4, 50, "Input"],
Cell[16982, 494, 202, 4, 47, "Text"],
Cell[17187, 500, 153, 3, 50, "Input"],
Cell[17343, 505, 137, 1, 47, "Text"]
}, Open  ]],
Cell[CellGroupData[{
Cell[17517, 511, 302, 4, 63, "Subsection"],
Cell[17822, 517, 352, 7, 143, "Text"],
Cell[18177, 526, 235, 5, 111, "Text"],
Cell[18415, 533, 334, 10, 50, "Input"],
Cell[18752, 545, 122, 1, 47, "Text"],
Cell[18877, 548, 514, 14, 50, "Input"],
Cell[19394, 564, 197, 4, 79, "Text"],
Cell[19594, 570, 388, 11, 50, "Input"],
Cell[19985, 583, 127, 1, 47, "Text"],
Cell[20115, 586, 203, 4, 50, "Input"],
Cell[20321, 592, 765, 14, 367, "Text"]
}, Open  ]],
Cell[CellGroupData[{
Cell[21123, 611, 356, 5, 63, "Subsection"],
Cell[21482, 618, 483, 9, 207, "Text"],
Cell[21968, 629, 615, 10, 271, "Text"],
Cell[22586, 641, 357, 9, 50, "Input"],
Cell[22946, 652, 155, 2, 47, "Text"],
Cell[23104, 656, 835, 24, 85, "Input"],
Cell[23942, 682, 186, 4, 50, "Input"],
Cell[24131, 688, 230, 4, 79, "Text"],
Cell[24364, 694, 525, 14, 50, "Input"],
Cell[24892, 710, 159, 2, 47, "Text"],
Cell[25054, 714, 320, 7, 50, "Input"],
Cell[25377, 723, 976, 20, 495, "Text"],
Cell[26356, 745, 448, 12, 50, "Input"],
Cell[26807, 759, 141, 3, 50, "Input"],
Cell[26951, 764, 183, 5, 79, "Text"],
Cell[27137, 771, 395, 11, 50, "Input"]
}, Open  ]]
}, Open  ]]
}
]
*)

(* End of internal cache information *)