GPU-Agnostic Programming using CubeCL

2025-12-29T01:23:21+00:00

CubeCL</a> is a Rust crate that is used for writing GPU programs in pure Rust, which is compatible with a wide range of GPU platforms. It is the underlying library powering the “Burn</a>” machine learning framework.</p>

This article will look at some of the basics of how to use CubeCL and some of its quirks. You can find the example code in this repository: thomasantony/cubecl-recipes</a>.</p>

CubeCL Topology</h2>

Before diving into the code, it helps to understand CubeCL’s execution model and terminology. If you’re familiar with CUDA or other GPU programming frameworks, CubeCL uses different names for similar concepts:</p>

CubeCL Term</th> CUDA Equivalent</th> Description</th></tr></thead>

Unit</td> Thread</td> A single execution unit running your kernel code</td></tr>

Cube</td> Block</td> A group of units that can share memory and synchronize</td></tr>

Hyper-Cube</td> Grid</td> The entire collection of cubes dispatched for a kernel</td></tr>

Plane</td>

Warp/Subgroup</td>

A subset of units in a cube that execute in lockstep</td></tr> </tbody></table>

The following diagram illustrates the relationship between Units, Cubes, and Hyper-Cubes:</p>

</p>

A cube is composed of units, so a 3x3x3 cube has 27 units that can be accessed by their positions along the x, y, and z axes. Similarly, a hyper-cube is composed of cubes, just as a cube is composed of units. Each cube in the hyper-cube can be accessed by its position relative to the hyper-cube along the x, y, and z axes. Hence, a hyper-cube of 3x3x3 will have 27 cubes. In this example, the total number of working units would be 27 x 27 = 729.</p>

— CubeCL Book</a></p> </blockquote>

The following table (also from the CubeCL Book</a>) shows how CubeCL’s topology constants map to CUDA and WebGPU equivalents:</p>

CubeCL</th>	CUDA</th>	WebGPU</th></tr></thead>
`CUBE_COUNT_X</code></td>`	`gridDim.x</code></td>`	`num_workgroups.x</code></td></tr>`
`CUBE_COUNT_Y</code></td>`	`gridDim.y</code></td>`	`num_workgroups.y</code></td></tr>`
`CUBE_COUNT_Z</code></td>`	`gridDim.z</code></td>`	`num_workgroups.z</code></td></tr>`
`CUBE_POS_X</code></td>`	`blockIdx.x</code></td>`	`workgroup_id.x</code></td></tr>`
`CUBE_POS_Y</code></td>`	`blockIdx.y</code></td>`	`workgroup_id.y</code></td></tr>`
`CUBE_POS_Z</code></td>`	`blockIdx.z</code></td>`	`workgroup_id.z</code></td></tr>`
`CUBE_DIM_X</code></td>`	`blockDim.x</code></td>`	`workgroup_size.x</code></td></tr>`
`CUBE_DIM_Y</code></td>`	`blockDim.y</code></td>`	`workgroup_size.y</code></td></tr>`
`CUBE_DIM_Z</code></td>`	`blockDim.z</code></td>`	`workgroup_size.z</code></td></tr>`
`UNIT_POS</code></td>`	N/A</td>	`local_invocation_index</code></td></tr>`
`UNIT_POS_X</code></td>`	`threadIdx.x</code></td>`	`local_invocation_id.x</code></td></tr>`
`UNIT_POS_Y</code></td>`	`threadIdx.y</code></td>`	`local_invocation_id.y</code></td></tr>`
`UNIT_POS_Z</code></td>`	`threadIdx.z</code></td>`	`local_invocation_id.z</code></td></tr>`
`PLANE_DIM</code></td>`	`warpSize</code></td>`	`subgroup_size</code></td></tr>`
`ABSOLUTE_POS_X</code></td>`	N/A</td>	`global_id.x</code></td></tr>`
`ABSOLUTE_POS_Y</code></td>`	N/A</td>	`global_id.y</code></td></tr>`
`ABSOLUTE_POS_Z</code></td>`	N/A</td>	global_id.z</code></td></tr> </tbody></table> Throughout this article, I may use CUDA terminology (thread, block) interchangeably with CubeCL terminology (unit, cube) since many readers will be more familiar with the CUDA terms.</p> Hello, World</h2> We will start with a very simple parallel program - one that takes an array of numbers and doubles each element. Roughly the same as the following python function, except that it will be using the GPU and executing in parallel</p> def </span>double_array</span>(</span>numbers</span>): </span> output = [] </span> </span>for </span>i </span>in </span>range</span>(</span>len</span>(numbers)): </span> output[i] = numbers[i] * </span>2.0 </span> </span>return </span>output </span></code></pre> Yes, I am aware that this could have been simplified using numpy or a list comprehension. But the point of the above code was to give a direct correlation to the GPU code that we will be writing.</p> We start off by creating a new Rust project using cargo</code>:</p> cargo</span> new first-gpu-program </span>cd</span> first-gpu-program </span></code></pre> Now we need to add the dependencies - in this case, just cubecl</code> with the wgpu</code> feature enabled. The WGPU backend allows running your code on a wide range of GPUs. Add the following under [dependencies]</code> in Cargo.toml</code></p> cubecl </span>= { </span>version </span>= "</span>0.8.1</span>", </span>features </span>= ["</span>wgpu</span>"] } </span></code></pre> Build and run the program using cargo run</code> and the program should build and print out “Hello, world!”.</p> Just like on other GPU programming platforms, the basic unit of a parallel program in CubeCL is a “kernel”. This is a function that gets dispatched to execute on the GPU. See the CubeCL book</a> for more details. Kernels do not have a return value and will be returning data instead by writing to mutable array references that are passed into it.</p> Here is the CubeCL version of the Python program given above:</p> use </span>cubecl::prelude::; </span> </span>#[</span>cube</span>(launch)] </span>fn </span>kernel_double_numbers</span>(</span>input_data</span>: &Array<</span>u32</span>>, </span>output_data</span>: &</span>mut </span>Array<</span>u32</span>>) { </span> </span>// ABSOLUTE_POS is equivalent to CUBE_POS CUBE_DIM + UNIT_POS </span> </span>let</span> index = </span>ABSOLUTE_POS</span>; </span> output_data[index] = input_data[index] * </span>2</span>; </span>} </span> </span>fn </span>main</span>() { </span> </span>let</span> device = Default::default(); </span> </span>let</span> client = cubecl::wgpu::WgpuRuntime::client(&device); </span> </span> </span>let</span> input_data = (</span>1</span>..</span>11</span>).collect::<Vec<</span>u32</span>>>(); </span> println!("</span>Input: </span>{:?}</span>", &input_data); </span> </span>let</span> num_elements = input_data.</span>len</span>(); </span> </span>let</span> zeros = vec![</span>0</span>u32</span>; num_elements]; </span> </span>let</span> input_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&input_data)); </span> </span>let</span> output_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&zeros)); </span> </span> </span>unsafe </span>{ </span> kernel_double_numbers::launch::<cubecl::wgpu::WgpuRuntime>( </span> &client, </span> CubeCount::Static(</span>1</span>, </span>1</span>, </span>1</span>), </span> CubeDim::new(num_elements as </span>u32</span>, </span>1</span>, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&input_data_gpu, num_elements, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&output_data_gpu, num_elements, </span>1</span>), </span> ) </span> } </span> </span> </span>let</span> result = client.</span>read_one</span>(output_data_gpu.</span>clone</span>()); </span> </span>let</span> output = </span>u32</span>::from_bytes(&result).</span>to_vec</span>(); </span> println!("</span>Output: </span>{:?}</span>", output); </span>} </span></code></pre> Compile and run the program and you should see the following:</p> Input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] </span>Output: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] </span></code></pre> Let’s look at the code in more detail:</p> Defining the Kernel</h3> #[</span>cube</span>(launch)] </span></code></pre> This is a Rust macro that converts a Rust function into a GPU kernel that can be dispatched. It generates the ::launch</code> method that is used to dispatch the kernel to the GPU. Within the kernel, you write the code for one</em> of the threads. You identify the element of the array that you are supposed to operate on using the intrinsic values CUBE_POS</code>, UNIT_POS</code> etc. (see CubeCL Topology</a> above for details on these constants).</p> In the example code, we assume that the array is to be accessed in the following manner:</p> [x x x x x x x x \| x x x x x x x x] </span> ^.............^ ^.............^ </span> Block 0 Block 1 </span></code></pre> This is accomplished by using ABSOLUTE_POS</code>:</p> </span>// ABSOLUTE_POS is equivalent to CUBE_POS * CUBE_DIM + UNIT_POS </span> </span>let</span> index = </span>ABSOLUTE_POS</span>; </span></code></pre> Initializing the CubeCL Device and Runtime</h3> Going to the main()</code> function, the first step is initializing the GPU and the CubeCL runtime:</p> </span>let</span> device = Default::default(); </span> </span>let</span> client = cubecl::wgpu::WgpuRuntime::client(&device); </span></code></pre> If you were using a different runtime (say CUDA), you would initialize that here instead of WGPU.</p> Initializing GPU buffers and copying input data</h3> The next step is to take the input data and copy it into GPU buffers. GPU buffers need to be defined for the output buffer as well:</p> </span>let</span> input_data = (</span>1</span>..</span>11</span>).collect::<Vec<</span>u32</span>>>(); </span> println!("</span>Input: </span>{:?}</span>", &input_data); </span> </span>let</span> num_elements = input_data.</span>len</span>(); </span> </span> </span>let</span> zeros = vec![</span>0</span>u32</span>; num_elements]; </span> </span>let</span> input_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&input_data)); </span> </span>let</span> output_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&zeros)); </span></code></pre> Note here that the zeros</code> variable (and any other CPU-side buffer) can be reused if multiple buffers need to be created. The values are copied to the GPU buffer in each case.</p> Launching the kernel</h3> </span>unsafe </span>{ </span> kernel_double_numbers::launch::<cubecl::wgpu::WgpuRuntime>( </span> &client, </span> CubeCount::Static(</span>1</span>, </span>1</span>, </span>1</span>), </span> CubeDim::new(num_elements as </span>u32</span>, </span>1</span>, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&input_data_gpu, num_elements, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&output_data_gpu, num_elements, </span>1</span>), </span> ) </span> } </span></code></pre> This section actually launches the kernel, and dispatches it to the GPU for execution. The first argument is the client object that was initialized earlier.</p> The second and third arguments specify the “shape” and size of the “cubes” to be scheduled on the GPU. The kernel is executed on a “HyperCube” (called a Grid in CUDA) of cubes, and each cube consists of multiple units (threads). CubeCount</code> specifies the size of the hypercube along X, Y, and Z dimensions (only X is used in this example), and CubeDim</code> specifies the number of units/threads in each cube.</p> The ArrayArg</code> objects take in the GPU buffer handles created before using client.create()</code> and pass them as arguments to the kernel. These values map on to the &Array<u32></code> and &mut Array<u32></code> parameters in the kernel.</p> Extracting the output values</h3> Once the computation is complete, the values need to be copied back to the RAM so that we can use them elsewhere.</p> </span>let</span> result = client.</span>read_one</span>(output_data_gpu.</span>clone</span>()); </span> </span>let</span> output = </span>u32</span>::from_bytes(&result).</span>to_vec</span>(); </span> println!("</span>Output: </span>{:?}</span>", output); </span></code></pre> The output_data_gpu</code> handle is cloned here in case it needs to be used again elsewhere (maybe for launching another kernel).</p> Scalar Arguments</h2> You are also able to pass scalar values to the kernel - lets say, an integer that will be used in place of 2</code> for scaling the arrays. This is done by passing in an instance of ScalarArg</code>. Modify the kernel as follows:</p> #[</span>cube</span>(launch)] </span>fn </span>kernel_scale_numbers</span>(</span>input_data</span>: &Array<</span>u32</span>>, </span>scale</span>: </span>u32</span>, </span>output_data</span>: &</span>mut </span>Array<</span>u32</span>>) { </span> </span>// ABSOLUTE_POS is equivalent to CUBE_POS * CUBE_DIM + UNIT_POS </span> </span>let</span> index = </span>ABSOLUTE_POS</span>; </span> output_data[index] = input_data[index] * scale; </span> </span>// ^ used instead of 2 </span>} </span></code></pre> The kernel is then launched as:</p> </span>unsafe </span>{ </span> kernel_scale_numbers::launch::<cubecl::wgpu::WgpuRuntime>( </span> &client, </span> CubeCount::Static(</span>1</span>, </span>1</span>, </span>1</span>), </span> CubeDim::new(num_elements as </span>u32</span>, </span>1</span>, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&input_data_gpu, num_elements, </span>1</span>), </span> ScalarArg::new(</span>3</span>), </span>// <-- scalar argument </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&output_data_gpu, num_elements, </span>1</span>), </span> ) </span> } </span></code></pre> Running the program should now give the output:</p> Input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] </span>Output: [3, 6, 9, 12, 15, 18, 21, 24, 27, 30] </span></code></pre> Backend-Agnostic Code</h2> The examples above hardcoded the WGPU runtime as the CubeCL backend to use for running the code. This is not ideal if the code is to be distributed as a crate/library. CubeCL offers a generics-based pattern for making your code agnostic to the GPU platform. The kernel itself remains identical as it does not have any platform-specific references. However, the launching of the kernel needs to be extracted out into a separate function.</p> fn </span>launch_scale_numbers_kernel</span><R: Runtime>( </span> </span>client</span>: &ComputeClient<</span>R::</span>Server>, </span> </span>input</span>: &Handle, </span> </span>scale</span>: </span>u32</span>, </span> </span>output</span>: &Handle, </span> </span>num_elements</span>: </span>usize</span>, </span>) { </span> </span>unsafe </span>{ </span> kernel_scale_numbers::launch::<R>( </span> &client, </span> CubeCount::Static(</span>1</span>, </span>1</span>, </span>1</span>), </span> CubeDim::new(num_elements as </span>u32</span>, </span>1</span>, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(input, num_elements, </span>1</span>), </span> ScalarArg::new(scale), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(output, num_elements, </span>1</span>), </span> ) </span> } </span>} </span></code></pre> The function is then called as:</p> launch_scale_numbers_kernel::<cubecl::wgpu::WgpuRuntime>( </span> &client, </span> &input_data_gpu, </span> </span>3</span>, </span> &output_data_gpu, </span> num_elements, </span> ); </span></code></pre> The launch_scale_numbers_kernel</code> could be in a separate crate and is completely agnostic to the specific GPU platform that it will be deployed to. The platform is only specified when the function is called.</p> Cube functions</h2> You may want to split out small chunks of your kernel code so that it can be reused in multiple kernels. This is done using by defining functions that use the #[cube]</code> macro and comes with a few caveats. The arguments to such functions can either be scalar values (u32</code>, f32</code> etc.), or a type like Array</code>.</p> Example:</p> #[</span>cube</span>] </span>fn </span>do_scale</span>(</span>input</span>: &Array<</span>u32</span>>, </span>scale</span>: </span>u32</span>) -> </span>u32 </span>{ </span> </span>// ABSOLUTE_POS is equivalent to CUBE_POS * CUBE_DIM + UNIT_POS </span> </span>let</span> index = </span>ABSOLUTE_POS</span>; </span> input[index] * scale </span>} </span> </span>#[</span>cube</span>(launch)] </span>fn </span>kernel_scale_numbers</span>(</span>input_data</span>: &Array<</span>u32</span>>, </span>scale</span>: </span>u32</span>, </span>output_data</span>: &</span>mut </span>Array<</span>u32</span>>) { </span> </span>// ABSOLUTE_POS is equivalent to CUBE_POS * CUBE_DIM + UNIT_POS </span> </span>let</span> index = </span>ABSOLUTE_POS</span>; </span> output_data[index] = </span>do_scale</span>(input_data, scale); </span>} </span></code></pre> Shared Memory</h2> Shared Memory is allocated in kernels and used for sharing information between threads in the same “cube” (aka block). Since this is implemented as on-chip SRAM, it is significantly faster than the “global” GPU memory. It is allocated in a kernel using the SharedMemory</code> type:</p> let</span> smem_histogram = SharedMemory::<</span>u32</span>>::new(</span>SIZE</span>); </span></code></pre> In the above example, SIZE</code> must be a constant known at compile-time. This can be limiting when you want to write flexible kernels where the shared memory size depends on launch parameters. CubeCL’s #[comptime]</code> feature (described in the next section) provides a solution to this constraint.</p> Shared memory can be used like any other array, except that the data in it is only shared across the threads in the same cube.</p> Comptime Parameters</h2> CubeCL provides a #[comptime]</code> attribute for kernel parameters that need to be known at kernel compile time, but can vary between different kernel invocations. This is particularly useful for SharedMemory</code> sizes that depend on launch configuration.</p> When you mark a parameter with #[comptime]</code>, the value is baked into the kernel during JIT compilation. CubeCL will compile a specialized version of the kernel for each unique combination of comptime values you use.</p> #[</span>cube</span>(launch)] </span>fn </span>kernel_with_comptime</span>( </span> </span>data</span>: &</span>mut </span>Array<</span>u32</span>>, </span> #[comptime] </span>buffer_size</span>: </span>u32</span>, </span>) { </span> </span>// buffer_size is known at kernel compile time </span> </span>let</span> shared_buffer = SharedMemory::<</span>u32</span>>::new(buffer_size); </span> </span>// ... use shared_buffer </span>} </span></code></pre> The kernel is launched by passing the comptime value as a regular argument:</p> unsafe </span>{ </span> kernel_with_comptime::launch::<R>( </span> &client, </span> cube_count, </span> cube_dim, </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&data_gpu, num_elements, </span>1</span>), </span> buffer_size, </span>// comptime parameter - no wrapper needed </span> ) </span>} </span></code></pre> A practical example of this pattern is shown in the Block Exclusive Sum</a> section below, where #[comptime]</code> is used to configure the number of planes for shared memory allocation.</p> Atomic Variables</h2> The Atomic</code> type allows definition of variables that are used for atomic read/write operations. Such operations are useful for avoiding race conditions. For Shared Memory, this is defined as:</p> let</span> smem_histogram = SharedMemory::<Atomic<</span>u32</span>>>::new(</span>SIZE</span>); </span></code></pre> For global memory, in CubeCL, it is not necessary to allocate the memory as Atomic. Instead, it is enough to change the type of the parameter to the kernel to say &Array<Atomic<u32>></code> instead of &Array<u32></code>.</p> Read operations are performed as:</p> let</span> val = Atomic::load(&smem_histogram[i]); </span></code></pre> Write operations can be done as:</p> Atomic::store(&smem_histogram[i], val); </span></code></pre> See all the valid atomic operations on this page</a></p> Plane Intrinsics</h2> In CubeCL, there is a concept of something called a “plane”. This is a sub-set of the threads in a block. This has to do with how the threads are actually scheduled on the GPU for execution. On NVIDIA GPUs, threads are scheduled for execution as sets of 32 threads called “warps”. These are guaranteed to be running simultaneously on a GPU. If you schedule blocks that are larger than the warp-size on the GPU, the block gets split up into warps (aka planes in CubeCL), and gets swapped in and out.</p> CubeCL offers some GPU primitives that operate at the level of all threads on the plane. These are not very well documented at the time of writing unless you wade through some of the unit tests.</p> Plane Exclusive Sum</h3> Here is an example where we use plane intrinsics to compute an “exclusive sum</a>”. The algorithm will take an array like [1, 1, 1, 1]</code> and return [0, 1, 2, 3]</code>. It uses the plane_exclusive_sum</a> function.</p> #[</span>cube</span>(launch)] </span>fn </span>kernel_plane_exclusive_sum</span>(</span>input_data</span>: &Array<</span>u32</span>>, </span>output_data</span>: &</span>mut </span>Array<</span>u32</span>>) { </span> </span>// ABSOLUTE_POS is equivalent to CUBE_POS * CUBE_DIM + UNIT_POS </span> </span>let</span> index = </span>ABSOLUTE_POS</span>; </span> </span> </span>let</span> local_data = input_data[index]; </span> </span>let</span> local_sum = </span>plane_exclusive_sum</span>(local_data); </span> </span> output_data[index] = local_sum; </span>} </span> </span>fn </span>main</span>() </span>{ </span> </span>let</span> device = Default::default(); </span> </span>let</span> client = cubecl::wgpu::WgpuRuntime::client(&device); </span> </span> </span>type </span>R = cubecl::wgpu::WgpuRuntime; </span> </span> </span>let</span> input_data = vec![</span>1</span>u32</span>; </span>16</span>]; </span> println!("</span>Input: </span>{:?}</span>", &input_data); </span> </span>let</span> num_elements = input_data.</span>len</span>(); </span> </span>let</span> zeros = vec![</span>0</span>u32</span>; num_elements]; </span> </span>let</span> input_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&input_data)); </span> </span>let</span> output_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&zeros)); </span> </span> </span>const </span>SMALL_BLOCK_SIZE</span>: </span>usize </span>= </span>8</span>; </span> </span>let</span> num_blocks = num_elements / </span>SMALL_BLOCK_SIZE</span>; </span> </span>unsafe </span>{ </span> kernel_plane_exclusive_sum::launch::<R>( </span> &client, </span> CubeCount::Static(num_blocks as </span>u32</span>, </span>1</span>, </span>1</span>), </span> CubeDim::new(</span>SMALL_BLOCK_SIZE </span>as </span>u32</span>, </span>1</span>, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&input_data_gpu, num_elements, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&output_data_gpu, num_elements, </span>1</span>), </span> ) </span> } </span> </span>let</span> result = client.</span>read_one</span>(output_data_gpu.</span>clone</span>()); </span> </span>let</span> output = </span>u32</span>::from_bytes(&result).</span>to_vec</span>(); </span> println!("</span>Plane Exclusive Sum: </span>{:?}</span>\n</span>", output); </span>} </span></code></pre> The magic happens in these lines:</p> </span>let</span> local_data = input_data[index]; </span> </span>let</span> local_sum = </span>plane_exclusive_sum</span>(local_data); </span> </span> output_data[index] = local_sum; </span></code></pre> The plane_exclusive_sum</code> takes the value of local_data</code> from every other unit/thread in the current plane/warp and computes an exclusive sum, and returns the value that should be returned by the current thread.</p> One caveat here is that this is limited to the plane (usually a maximum of 32-64 threads depending on the GPU platform). In the above example, we use an array with 16 elements and enforce a block-size (and hence plane size) of 8. This will give us the following result:</p> Input: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] </span>Plane Exclusive Sum: [0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7] </span></code></pre> If you want to perform an exclusive scan over the entire block (possibly multiple planes), we need to use a more complicated algorithm where shared memory is used to accumulate results between planes.</p> Block Exclusive Sum</h3> This example demonstrates the #[comptime]</code> pattern described earlier. Instead of hardcoding the shared memory size, we pass num_planes</code> as a comptime parameter, making the kernel flexible for different block sizes.</p> /// Performs exclusive sum over all elements in a block, using plane primitives </span>#[</span>cube</span>(launch)] </span>fn </span>kernel_block_exclusive_sum</span>( </span> </span>input_data</span>: &Array<</span>u32</span>>, </span> </span>output_data</span>: &</span>mut </span>Array<</span>u32</span>>, </span> #[comptime] </span>num_planes</span>: </span>u32</span>, </span>) { </span> </span>let</span> thread_id = </span>UNIT_POS</span>; </span> </span>let</span> plane_thread_idx = </span>UNIT_POS_PLANE</span>; </span> </span>let</span> plane_idx = thread_id / </span>PLANE_DIM</span>; </span> </span> </span>// ABSOLUTE_POS is equivalent to CUBE_POS * CUBE_DIM + UNIT_POS </span> </span>let</span> thread_idx = </span>ABSOLUTE_POS</span>; </span> </span> </span>// Select plane size as the smaller of the current block size or the max plane size </span> </span>// So if block size is 8, plane size will be 8 </span> </span>// If block size is 64, plane size will be 32 (if that is the maximum) </span> </span>let</span> plane_size = </span>if </span>CUBE_DIM </span>< </span>PLANE_DIM </span>{ </span> </span>CUBE_DIM </span> } </span>else </span>{ </span> </span>PLANE_DIM </span> }; </span> </span> </span>// Define shared memory for inter-plane communication </span> </span>// Size is determined at kernel compile time via comptime parameter </span> </span>let mut</span> shared_totals = SharedMemory::<</span>u32</span>>::new(num_planes); </span> </span> </span>// 1. local scan </span> </span>let</span> original = input_data[thread_idx]; </span> </span>let</span> local_scan = </span>plane_exclusive_sum</span>(original); </span> </span> </span>// 2. plane totals → shared mem </span> </span>let</span> plane_total = </span> </span>plane_shuffle</span>(local_scan, plane_size - </span>1</span>) + </span>plane_shuffle</span>(original, plane_size - </span>1</span>); </span> </span>if</span> plane_thread_idx == </span>0 </span>{ </span> shared_totals[plane_idx] = plane_total; </span> } </span> </span>sync_cube</span>(); </span> </span> </span>// 3. scan totals (single plane or serial) </span> </span>if</span> plane_idx == </span>0 </span>&& plane_thread_idx < num_planes { </span> </span>let</span> offset = </span>plane_exclusive_sum</span>(shared_totals[plane_thread_idx]); </span> </span>// reuse shared_totals for storing offsets </span> shared_totals[plane_thread_idx] = offset; </span> } </span> </span>sync_cube</span>(); </span> </span> </span>// 4. apply offset </span> </span>let</span> result = local_scan + shared_totals[plane_idx]; </span> </span> output_data[thread_idx] = result; </span>} </span> </span>fn </span>main</span>() </span>{ </span> </span>let</span> device = Default::default(); </span> </span>let</span> client = cubecl::wgpu::WgpuRuntime::client(&device); </span> </span> </span>type </span>R = cubecl::wgpu::WgpuRuntime; </span> </span> </span>let</span> input_data = vec![</span>1</span>u32</span>; </span>64</span>]; </span> println!("</span>Input: </span>{:?}</span>", &input_data); </span> </span>let</span> num_elements = input_data.</span>len</span>(); </span> </span>let</span> input_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&input_data)); </span> </span>let</span> zeros = vec![</span>0</span>u32</span>; num_elements]; </span> </span>let</span> output_data_gpu = client.</span>create</span>(</span>u32</span>::as_bytes(&zeros)); </span> </span> </span>const </span>BLOCK_SIZE</span>: </span>usize </span>= </span>64</span>; </span> </span>const </span>NUM_PLANES</span>: </span>u32 </span>= (</span>BLOCK_SIZE </span>/ </span>PLANE_DIM </span>as </span>usize</span>) as </span>u32</span>; </span> </span>let</span> num_blocks = num_elements / </span>BLOCK_SIZE</span>; </span> </span> </span>unsafe </span>{ </span> kernel_block_exclusive_sum::launch::<R>( </span> &client, </span> CubeCount::Static(num_blocks as </span>u32</span>, </span>1</span>, </span>1</span>), </span> CubeDim::new(</span>BLOCK_SIZE </span>as </span>u32</span>, </span>1</span>, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&input_data_gpu, num_elements, </span>1</span>), </span> ArrayArg::from_raw_parts::<</span>u32</span>>(&output_data_gpu, num_elements, </span>1</span>), </span> </span>NUM_PLANES</span>, </span>// comptime parameter for shared memory size </span> ) </span> } </span> </span>let</span> result = client.</span>read_one</span>(output_data_gpu.</span>clone</span>()); </span> </span>let</span> output = </span>u32</span>::from_bytes(&result).</span>to_vec</span>(); </span> println!("</span>Block Exclusive Sum: </span>{:?}</span>\n</span>", output); </span>} </span></code></pre> Here, we use a larger array with 64 elements to make sure that the block size exceeds the plane size (on WGPU) of 32. The NUM_PLANES</code> constant is computed from BLOCK_SIZE / PLANE_DIM</code> and passed to the kernel, where it determines the shared memory allocation size.</p> The algorithm works as follows:</p> The local scan takes the 64-long array [1, 1, ... 1]</code> and converts it into [0, 1, ... 31, 0, 1, ... 31]</code>.</p> </li> The next step is to compute the “shared totals”. This is the total sum from each plane accumulated into a shared memory array. In this case, it would be [32, 32]</code>. This is done by adding the last value of the local scan in the current plane, with the last value of the input array processed by the current plane.</p> </li> </ol> To compute this, we use another plane-intrinsic function called plane_shuffle</a>.</p> plane_shuffle</span>(local_scan, plane_size - </span>1</span>) </span></code></pre> The above function call returns the value of local_scan</code> from the thread index plane_size - 1</code> (aka the final thread in the plane). So the shared total is computed as:</p> </span>let</span> plane_total = </span> </span>plane_shuffle</span>(local_scan, plane_size - </span>1</span>) + </span>plane_shuffle</span>(original, plane_size - </span>1</span>); </span> </span>if</span> plane_thread_idx == </span>0 </span>{ </span> shared_totals[plane_idx] = plane_total; </span> } </span></code></pre> The value is then stored into the shared memory by a single thread (gated by the if</code> condition). There is no point in all of the threads trying to write the exact same value to the shared array.</p> Compute the offsets from the shared totals using another exclusive scan, i.e. [32, 32]</code> becomes [0, 32]</code>. These are the values to be added to each plane’s local scan results. So we add 0</code> to the local scan results from plane 0, 32</code> to the local scan results from plane 1, etc.</li> </ol> This exclusive scan can also be performed using the plane_exclusive_sum</code> function - except that we make sure to not use more threads than are required.</p> </span>let</span> offset = </span>plane_exclusive_sum</span>(shared_totals[plane_thread_idx]); </span> </span>// reuse shared_totals for storing offsets </span> shared_totals[plane_thread_idx] = offset; </span></code></pre> Now applying the offset is as simple as taking the current thread’s local scan result (local_scan</code>) and adding the appropriate offset to it.</li> </ol> Note</em>: sync_cube()</code> is used to synchronize processing between all the threads/units in a block. All the threads will wait at these points until every other thread in the block has reached the same point.</p> This should now give the result:</p> Input: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] </span>Block Exclusive Sum: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] </span></code></pre> Gotchas</h2> CubeCL does not like mutable unused variables without a type definition.</li> </ul> If you add the following to a kernel or a #[cube] function :</p> let mut</span> mynumber = </span>0</span>; </span></code></pre> If you do not use this value anywhere in a way that lets the compiler infer its type, you will get an error message like:</p> error[E0283]: type annotations needed </span> --> src/main.rs:88:1 </span> \| </span>88 \| #[cube(launch)] </span> \| ^^^^^^^^^^^^^^^ cannot infer type for struct `ExpandElementTyped<_>` </span> \| </span> = note: multiple `impl`s satisfying `ExpandElementTyped<_>: IntoMut` found in the `cubecl_core` crate: </span> - impl<T> IntoMut for ExpandElementTyped<T> </span> where T: ExpandElementIntoMut; </span> - impl<T> IntoMut for ExpandElementTyped<cubecl::frontend::SharedMemory<T>> </span> where T: CubePrimitive; </span> = note: this error originates in the attribute macro `cube` (in Nightly builds, run with -Z macro-backtrace for more info) </span></code></pre> It doesn’t say which line of the code causes the error, so it can be confusing if you did not know what to look for.</p> Conclusion</h2> CubeCL provides a compelling approach to GPU programming in Rust, offering the ability to write portable GPU code that can target multiple backends (WGPU, CUDA, etc.) from a single codebase. While the documentation is still maturing, the core concepts map well to existing GPU programming paradigms, making it accessible to developers familiar with CUDA or other GPU frameworks.</p> Inner Product of Functions 2025-11-23T20:06:28.023+00:00 The inner/dot product for Euclidean vectors is defined as:</p> $$ \langle u, v \rangle = \sum_{i} u_i v_i $$ </div> Following on from how we defined a norm</a> for square integrable functions</a>, we can similarly define an inner product for such functions in $\mathbb{L}^2$:</p> $$ \langle f, g \rangle = \int_{-\infty}^{\infty} f(x) g(x) dx $$ </div> This inner product can now be used to define a norm</a>/length for our space:</p> $$ \|\| f \|\| = \sqrt{ \langle f, f \rangle } = \sqrt{\int_{-\infty}^{\infty} \|f(x)\|^2 dx} $$ </div> Norm of a Function or Square integrable functions 2025-11-23T19:56:54.213+00:00 We know that functions can be treated as infinite dimensional vectors</a>. A vector has a norm or length defined for it. How do we do that for a function?</p> Square integrable functions</h2> Assume that we have a function: $f: \mathbb{R} \to \mathbb{C}$. It is said to be square integrable</em> if it satisfies the following condition:</p> $$ \int_{-\infty}^{\infty} \|f(x)\|^2 dx < \infty $$ </div> This is similar to the squared sum of all elements in a vector and can be considered equivalent to a squared Euclidean norm ($\sum_i v_i$). This is a measure of length</em> and the condition above is asserting that this “length” is finite for the given function (vector). For functions, this quantity is typically called energy</em>.</p> The set of such functions are commonly denoted as $\mathbb{L}^2$ and is a subset of the vector space of all functions</a>.</p> Functions form a Vector Space 2025-11-23T19:54:51.959+00:00 Functions can be treated as infinite dimensional vectors. For example, typically a vector is interpreted as an ordered list of numbers. This could also be interpreted as a function mapping the indices to the values. E.g. a vector in $\mathbb{R}^3$ can be considered to be a function mapping the domain $1, 2, 3$ to the codomain $\mathbb{R}$ (since the values in the vector are real numbers).</p> $$ v: \{1, 2, 3\} \to \mathbb{R} $$ </div> If our vector was $N$ dimensional, then this would become: $v: {1, 2, …, N} \to \mathbb{R}$. This could even be defined for infinite $N$ in which case the function becomes a mapping from the natural numbers $\mathbb{N}$ to the real numbers: $v: \mathbb{N} \to \mathbb{R}$.</p> What if we allowed the “index” to be any real (or complex) number: $v: \mathbb{R} \to \mathbb{R}? This “vector” is just a function from reals to reals. It can be proven1</a></sup> that functions, together with the standard addition and scalar multiplication operations form a vector space.</p> References</h2> ^1</sup>Hilbert space: treating functions as vectors - Appendix A</a></p> </div> Inner Product Space 2025-11-23T19:39:29.694+00:00 An inner product space1</a></sup> is a real or complex vector space that has an operation called an “inner product” defined for it. The inner product of two vectors is a scalar, and is typically denoted by angle brackets like $\langle a, b\rangle$.</p> This is a generalization of the dot product that is defined in Euclidean vector spaces ($a \cdot b = \sum a_i b_i $). The existence of an inner product also allows generalized definition of other concepts such as angles, lengths and orthogonality (zero inner product) between the vectors in the vector space.</p> References</h2> ^1</sup>Inner Product Space</a></p> </div> Hilbert Spaces 2025-11-23T19:37:16.546+00:00 A Hilbert space is an inner product space</a> that is also “complete” w.r.t the inner product - i.e. no sequence of elements in the set converges to an element outside the set. This is a generalization of the Euclidean vector space to infinite dimensions.</p> The key intuition behind this is to treat functions as infinite dimensional vectors</a>, which have inner products</a> and norms</a> just like Euclidean vectors. This allows us to generalize many concepts from vectors to apply to functions.</p> Generalized Fourier Series</h2> A fourier series1</a></sup> is a way of expressing a perioding function as a weighted sum of sines and cosines of different frequencies.</p> For functions in $\mathbb{L}^2$, the inner product allows us to define the concepts of orthogonality</em> and basis vectors</em>. This in turn lets us express these functions as a weighted sum of of a series of orthogonal basis functions</em> that span the space. This allows us to apply concepts from Linear Algebra such as the Gram-Schmidt process2</a></sup> to the space of functions. This is how we get orthogonal basis functions such as Chebyshev polynomials 3</a></sup> and Legendre polynomials4</a></sup>.</p> References</h2> ^5</sup>Hilbert space: treating functions as vectors</a></p> </div> ^1</sup>Fourier Series</a></p> </div> ^2</sup>Gram-Schmidt process</a></p> </div> ^3</sup>Chebyshev Polynomials</a></p> </div> ^4</sup>Legendre Polynomials</a></p> </div> Volumetric Scene Representations 2025-11-11T19:19:52.957+00:00 A volumetric scene represenation is a data structure or algorithmic representation of a scene - typically associated with computer vision. It can be either “implicit” or “explicit”. Some examples of scene representations are:</p> Point Clouds</li> Depth Maps</li> Meshes</li> Voxel Grids</li> Octrees</li> Signed Distance Functions</li> Neural Fields NeRF - Neural Radiance Fields</li> </ul> </li> 3D Gaussian Splats</li> </ul> Volume Rendering 2025-11-06T05:38:34.009+00:00 Volumetric rendering is an algorithm used for rendering radiance fields such as [[NeRFs]] and [[3D Gaussian Splats]]1</a></sup>2</a></sup>.</p> You start with some implicit or explicit scene representation</a> that can be sampled at 3D positions along a ray in a scene, to return a color, $c$, and an opacity $\alpha$.</p> $$ C = \sum_{i=1}^{N} T_i \alpha_i c_i ~\text{ where } T_i = \prod_{j=1}^{i-1} (1 - \alpha_i) $$ </div> The “output” of this gives the color $C$ of a single pixel by sampling a ray at multiple discrete points in the scene. Depending on the underlying representation (NeRF, 3DGS etc.), the opacity $\alpha_i$ and the color $c_i$ are computed in different ways. $T_i$ is the cumulative “transmittance” of all the pixels so far in the ray. This essentially zeros out all the pixels “behind” an opaque surface. Once the ray reaches an opaque surface (i.e. $\alpha_i \approx 1$), $T_i$ for all subsequent values of $i$ will be multiplied by $(1- \alpha_i) = 0$.</p> This allows a continuous, differentiable function for the color which also “switches off” once an opaque function is encountered.</p> References</h2> ^1</sup>3D Gaussian Splatting for Real-Time Radiance Field Rendering</a></p> </div> ^2</sup>3D Gaussian Splatting for Real-Time Radiance Field Rendering - YouTube</a></p> </div> Git Worktrees 2025-10-12T19:03:44.388+00:00 Git worktrees allow you to check out multiple branches simultaneously without re-cloning the repository multiple times 1</a></sup>. This is an alternative to using “stash” to save uncommited changes and switching branches.</p> For example, if we are currently on branch feature/ticket-number-xxxx</code> and want to go work on bugfix/ticket-yyyy</code>, we can run the command</p> git</span> worktree add ../proj-ticket-yyyy bugfix/ticket-yyyy </span></code></pre> The command is to be run from the root directory of your repo, but the worktree itself will be created in the parent directory (or elsewhere). There is no .git</code> folder in the new folder that gets created, but instead it has a .git</code> file. It is recommended to do it this way to avoid confusion from nesting folders in the same repo.</p> You can run git commands such as commit, push, pull, rebase etc. in the separate worktree folder even while another branch is checked out in your original folder.</p> Once you are done with the branch, you can run git worktree remove .</code> to remove the folder with the worktree.</p> A worktree is also useful when doing code reviews if you want to check out an existing branch without moving away from whatever branch you were working on. This is especially useful on projects with long compile times when switching between branches.</p> Worktrees are also very useful when working with agentic coding tools like Claude Code. You can have multiple parallel instances of the AI working on different branches of the code simultaneously 2</a></sup>.</p> References</h2> ^1</sup>Git Worktrees - An Alternative to Git Stash</a></p> </div> ^2</sup>How I am using Coding Agents in September 2025</a></p> </div> Sandwich Bread v0.1 (Sep 2025) - 129 cal per 60g slice 2025-09-25T03:24:50.136+00:00 Ingredients</h2> Water - 131ml</li> 2% Ultra-Filtered Milk - 93ml</li> All Purpose Flour - 320g</li> Red Star Instant Yeast - 8 g</li> Diamond Crystal salt - 6g</li> Granulated Sugar - 15g</li> Vital Wheat Gluten (Anthony’s) - 1.0 tbsp</li> Kerrygold Unsalted Butter - 30g</li> Diastatic malt (Hoosier Farms) - 10g</li> Ascorbic acid powder - 1/8 tsp (very helpful for making the dough stronger)</li> </ul> Equipment</h2> Stand Mixer (you could make this with a no-knead process similar to what is described by Chain Baker, but I did not do that here)</li> Scale</li> Thermometer</li> Cutting board/flat surface</li> Rolling pin</li> Loaf pan</li> Parchment paper</li> </ul> Method</h2> Mix the water and milk. Microwave for ~10 seconds at a time until the temperature is around ~90F.</li> Add a small amount of sugar to the liquid and then add the yeast. Set aside for ~10 minutes for the yeast to “bloom”</li> Mix all the other dry ingredients (i.e. all except the butter</strong>) throughly (use a whisk or a sieve). You can also add it to the stand mixer and run with dough hook for a minute or so to mix it.</li> Add the yeast mixture with the stand mixer on its slowest setting until fully incorporated. Wait for the dough to form. If there are some dry bits at the bottom, add a bit more water about 1/4 tsp at a time until a smooth dough ball forms.</li> Increase the speed of the mixer a couple of notches and run it for ~3 minutes. The dough should have developed a bit now and shouldn’t tear easily if pulled</li> Turn down the mixer’s speed and add the butter about one teaspoon at a time. Once all the butter is added, turn up the speed again. Run it for ~2-3 minutes, or until the dough is a smooth ball again. Adding in the butter will disrupt the gluten in the original dough ball so it might become a shaggy mess at first.</li> Once the dough is a smooth ball again and passes the window-pane test^{1</a></sup>, cover the bowl with a towel and place in a warm area. One easy method is to run the oven (gas-fired) for 1 minute at whatever temperature and shut it off. It should then be approximately 90-100F. Let the dough rise for 1.5-2 hours.</li>} The dough should now have doubled in size (or more). De-gas the dough by “punching it down”. Roll it out into a sheet about 1/2 inch thick and about the same width as the loaf pan.</li> Spray the loaf pan with some oil, add a piece of parchment paper to cover the interior and place the dough into the loaf pan</li> Let the loaf pan sit in the same warm area as before, for another hour or so. The dough should now puff up again.</li> Pre-heat the oven to 350F (without the loaf-pan/dough in it of course). Brush the outside of the bread with some milk for some extra browning. Bake the dough for ~25-30 minutes. When the bread is done, the interior temperature will be around 190F.</li> As prepared by me, this resulted in a loaf of approximately 700g. Sliced into 12 pieces, thats around 60 grams per slice.</li> </ul> Nutrition Facts</h2> Assuming each slice is ~60g (about 0.25 inches), the macros are the following (for the particular brand of ingredients that I used):</p> Calories: 129</li> Carbohydrates: 22.5g Fiber: 0.8g</li> Sugar: 1.8g</li> </ul> </li> Fat: 2.5g Saturated Fat: 1.4g</li> </ul> </li> Protein: 3.8g</li> Cholesterol: 6.2mg</li> Sodium: 212mg</li> </ul> Remarks</h2> I adapted this from Joshua Weissman’s bread recipe^{2</a></sup>. My inital attempts at increasing fiber/protein failed miserably, and so I switched to the original reference recipe. I scaled it down to 75% to cut the calories, added the vitamin C3</a></sup> (ascorbic acid), hoping it would make the dough stronger and possibly bigger. And it seems to work! The dough, even if it is scaled down, completely filled and puffed up out of my loaf pan.</p>} In the next version, I will try scaling it down further and adding a little bit more gluten and maybe some oat fiber.</p> ^2</sup>Joshua Weissman’s Sandwich Bread Recipe</a></p> </div> ^1</sup>What is the Windowpane Test for Bread Dough? - King Arthur Baking</a></p> </div> ^3</sup>This is How Vitamin C (Ascorbic Acid) Affects Bread Dough - ChainBaker</a></p> </div> IFR Alternate Requirements 2025-05-26T18:00:35.953+00:00 The 1-2-3 Rule</h2> For an IFR flight, you do not</strong> have to file an alternative if the following conditions are forecast at ETA +/- 1</strong> hour:</p> At least 2</strong>000 ft ceiling</li> At least 3</strong> SM visibility</li> </ul> Alternate Minimums</h2> In order to qualify as an alternate, an airport must be forecast to have at least:</p> 600 ft ceiling and 2 SM visibility for precision approaches</li> 800 ft ceiling and 2 SM visibility for non-precision approaches</li> </ul> If the airport has non-standard alternate minimums defined for it (identified by an “A” icon in the notes section of their FAA approach plates)), those values apply instead. These non-standard minima are published in the U.S. Terminal Procedures Publication (TPP).</p> Engine start procedure for Cirrus SR22T-G6 2025-05-24T19:45:38.319+00:00 Cold Start (First start of the day or Oil temp < 100F)</h2> Mixture: Full Rich</li> Power Lever: Full Forward</li> Fuel Pump - PRIME (2-3 seconds), then BOOST</li> Power Lever: Open 1/4 inch</li> Start</li> Oil pressure check, Amp check</li> Lean for Max RPM</li> </ul> Hot Start (Oil temp > 100F)</h2> If the engine is warm, no priming is required. Remaining procedure is the same.</p> Hot Start (Oil temp is nw/ 150F and 200F)</h2> Alternate technique:</p> No priming</li> Mixture at cutoff, power at half (“W”)</li> Fuel pump to BOOST right as you turn ignition to START</li> Bring mixture to full rich over three seconds while cranking</li> Bring power back once engine starts</li> </ul> Flooded Engine</h2> Weak intermittent firing followed by puffs of black smoke from the exhaust stack indicates over-priming or flooding.</p> Turn fuel pump off</li> Allow fuel to drain from intake tubes</li> Set mixture to full lean, and power lever to full forward</li> Crank the engine through several turns</li> When engine starts, release ignition switch, retard power and add mixture to full rich</li> </ul> Note</strong> Limit cranking to intervals of 10 seconds with a 20-second cooling period between cranks.</p> References</h2> [1] Cirrus IFOM - Chapter 2, Section 5 [2] Cirrus SR22T-G6 POH - Section 4-11 [3] https://www.youtube.com/watch?v=eFAb9JK–HM</p> Cirrus SR22T: Abnormal Procedures for the Turbocharger 2025-05-18T19:40:25.631+00:00 In the event of an unexplained loss of manifold pressure in an SR22T, the engine reverts to operating like a naturally aspirated engine. However, depending on the cause of the anomaly, this could be anything from a benign to a serious event. However, since it is not possible to accurately determine the exact cause, any such event should require an immediate diversion.</p> Induction leak</li> </ol> This is on the “cold side” of the turbo (i.e with fresh air), and the intake air is leaking out before/after it is pressurized. This is typically not a significant hazard and the only consequence is that the engine reverts to performance of a naturally aspirated engine. Adjust flight profile as necessary and land as soon as possible. However, the next three possibilities on the “hot side” could pose more significant hazards.</p> Exhaust leak</li> </ol> An exhaust leak prior to the turbocharger could result in an engine fire if the high-velocity and hot exhaust gases interacts with combustible components at any point.</p> Wastegate failure</li> </ol> Wastegate is held closed by oil pressure. Loss of oil pressure would cause it to open, resulting in a loss of turbo performance. This could be a significant problem as the engine could get starved of oil. Monitor oil pressure.</p> Turbocharger failure</li> </ol> The turbo is lubricated with oil, and so a failure here could also cause a loss of oil.</p> References</h2> https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=1072487639</li> </ul> What Is A Schmitt Trigger? 2025-03-25T04:55:30.123+00:00 A Schmitt trigger is a Comparator</a> with hysteris. A typical comparator returns HIGH when the input exceeds a threshold and LOW once it is below. This can cause oscillations/noise at borderline values. A Schmitt trigger instead has two thresholds. Between the two thresholds, the output does not change. The output goes LOW only once the input goes below the lower threshold and HIGH when it goes above the upper threshold. An inverting Schmitt trigger has basically the opposite output as the Schmitt trigger (put a NOT in front of it).</p> One simple application of this is for debouncing a button input.</p> References</h2> [1] https://www.youtube.com/watch?v=woTiKij76cA</p> SINDy: Sparse Identification of Nonlinear Dynamics 2024-08-05T20:18:21.325+00:00 SINDy1</a></sup> is an algorithm for identifying a nonlinear dynamic model from data. The algorithm fits a dynamic model, $\dot{x} = f(\mathbf{x}(t))$, for a state vector $\mathbf{x}$. Steps:</p> Sample $\mathbf{x}$ and $\mathbf{\dot{x}}$ at $m$ points in time into matrices $\mathbf{X}$ and $\mathbf{\dot{X}}$ . The derivative may also be approximated here using numerical methods.</p> </li> Compute a “library” matrix $\Theta(\mathbf{X})$ where each column is a candidate nonlinear function like $1$, $X$, $X^2$, $\sin{X}$ etc. This is completely arbitrary and is chosen based on intuition or prior knowledge about the system.</p> </li> A vector of coefficients $\Xi = {\xi_1, \xi_2, … }$ are fit such that $\mathbf{\dot{X}} = \Phi(\mathbf{X}) \Xi$. The fitting is done while encouraging sparsity in $\Xi$ in order to have the fewest number of terms in the final dynamic equations.</p> </li> </ol> Libraries like PySINDy2</a></sup> implements this algorithm.</p> ^1</sup>Sparse Identification of Nonlinear Dynamics (SINDy): Sparse Machine Learning Models 5 Years Later</a></p> </div> ^2</sup>PySINDy Examples</a></p> </div> Fragment Shaders 2023-11-16T02:42:56.608+00:00 A fragment shader is a program that is part of a rendering pipeline1</a></sup> which takes as input a fragment (generated by rasterizing the outputs of a vertex shader</a>) and outputs a pixel color value and depth.</p> ^1</sup>Fragment - OpenGL Wiki</a></p> </div> ^2</sup>Fragment Shader - OpenGL Wiki</a></p> </div> ^3</sup>Rendering Pipeline Overview - OpenGL Wiki</a></p> </div> Vertex Shaders 2023-11-16T02:36:56.132+00:00 A vertex shader is a program that runs on the GPU that is one of the stages in a “rendering pipeline” (e.g. the OpenGL rendering pipelline1</a></sup>). It is typically written ina special programming language such as GLSL2</a></sup> or WGSL3</a></sup>. The job of a vertex shader is to take a single vertex as input and output a single vertex (usually in 4D homogenous coordinates), in “clip-space”, after doing some user-defined transformation on it. It may also generate other user-defined outputs.</p> The rendering pipeline takes these outputs and the output vertex and then interpolates them to generate values for points between two vertices (e.g. on a triangle formed by three vertices). These are called “Fragments”. The pipeline then eventually calls the fragment shader</a> to generate pixels (of some color) corresponding to these fragments.</p> ^4</sup>Vertex Shader - OpenGL Wiki</a></p> </div> ^1</sup>Rendering Pipeline Overview - OpenGL Wiki</a></p> </div> ^2</sup>GLSL</a></p> </div> ^3</sup>WebGPU Shading Language</a></p> </div> Understanding 3D Gaussian Splats by writing a software renderer 2023-11-13T19:10:35-08:00 If you want to skip to the code, you can find it here</a>.</p> 3D gaussian splats</a> have been all the rage since they were published. They may end up revolutionizing how we model realistic 3D worlds and seems to be the successor to NeRFs</a>.</p> Most of the articles that I have seen about them addresses the training-side of it (which is arguably more important). Hardly any addresses the nitty-gritty details on how to parse a pre-trained model and view it. While differentiable rendering is a key part of what makes this technology possible, the differentiable part is not really necessary if all you are interested in is viewing a pre-trained model.</p> There are a few indepndantly written renderers on github - most of them using OpenGL, and some using WebGPU or WebGL. Some of the Python versions require CUDA (and are hence tied to NVIDIA systems). There is also a Rust version</a> that is pretty platform-agnostic.</p> However, even the simplest</a> of these use shaders - pieces of code written a special languages that run on the GPU. The particular example I linked also depends on OpenGL 4.3 and hence does not run on macOS.</p> My goal with this project was to write a renderer in plain Rust, doing all the rendering math on the CPU. And after spinning my wheels for a bit, I realized that I need to start even simpler - with a version written in pure Python in a [Jupyter notebook].</p> What are 3D gaussian splats?</h2> 3D Gaussian Splats are a method of encoding information from a scene such that we can synthesize “novel views”, that were not in the original set of photos used to generate it. There are some very neat examples on the official site</a> for the paper. There have been also been a few web-based viwers (https://gsplat.tech/</a>, https://poly.cam/gaussian-splatting</a> ) that show off some really good examples.</p> Results</h2> As of the time of writing, I have a working CPU-based Gaussian splat renderer prototype written in Python and a faster one written in Rust. On my M1 Max Macbook Pro, the Python version takes about 2-3 minutes to render a 2560x1440 image for the “push sledge</a>” model (download here</a>) with about ~284000 gaussians in it. The Rust version renders the same model pretty much instantly.</p> How it works</h2> Python version</h3> While the CPU-based renderer does not use any OpenGL or WebGPU shaders, it still follows mostly the same logic. For the Python version, I had to add in some (not-so-efficient) versions of things that are typically handled by the graphics rendering pipeline on a GPU. Here is the overall workflow for the renderer in the Jupyter notebook</a>:</p> Load the gaussians from the .ply file. I used the ply-rs</a> crate in the Rust version and the load_plyfile</code> functions from util_gau.py</a>.</p> </span>from </span>tqdm </span>import </span>tqdm </span> model = </span>load_ply</span>('</span>point_cloud.ply</span>') </span> </span> </span> </span>print</span>('</span>Loading gaussians ...</span>') </span> gaussian_objects = [] </span> </span>for </span>(pos, scale, rot, opacity, sh) </span>in </span>tqdm</span>(</span>zip</span>(model.xyz, model.scale, model.rot, model.opacity, model.sh)): </span> gaussian_objects.</span>append</span>(</span>Gaussian</span>(pos, scale, rot, opacity, sh)) </span></code></pre> </li> Initialize a Camera model with a certain dimensions and position. I used one based off of the version at https://github.com/limacv/GaussianSplattingViewer/ .</p> (h, w) = (</span>720</span>, </span>1280</span>) </span> camera = </span>Camera</span>(h, w, </span>position</span>=(-</span>0.57651054</span>, </span>2.99040512</span>, -</span>0.03924271</span>), </span>target</span>=(-</span>0.0</span>, </span>0.0</span>, </span>0.0</span>)) </span></code></pre> </li> Sort the gaussians by depth from the camera model (this may need to be repeated if the camera can be moved).</p> </span>print</span>('</span>Sorting the gaussians by depth</span>') </span> indices = np.</span>argsort</span>([gau.</span>get_depth</span>(camera) </span>for </span>gau </span>in </span>gaussian_objects]) </span></code></pre> </li> Project the 3D gaussians</a> on to the camera plane to form ellipses. Compute the parameters of this ellipse (which represents a 2D gaussian and is represted by a variable called conic</code>). See the get_cov2d()</code> and the get_conic_and_bb()</code> methods in the Jupyter notebook</a></p> </li> This step is a quirk of how graphics rendering pipelines work. We start with a list of four 3D vertices (called a “quad”). In a typical 3D rendering pipeline, these may be actual vertices from a 3D model. In our case, we make the quad cover the entire screen. This is represented by the vertices [-1, 1], [1, 1], [1, -1] and [-1, -1]. This is essentially a square centered at the origin. These are in something called “Normalized Device Coordinates” which is agnostic to the actual resolution of the camera model or the screen.</p> vertices = np.</span>array</span>([[-</span>1</span>, </span>1</span>], [</span>1</span>, </span>1</span>], [</span>1</span>, -</span>1</span>], [-</span>1</span>, -</span>1</span>]]) </span> </span># Four values (bounds of the values used to evaluate gaussian) </span> bboxsize_cam = np.</span>multiply</span>(vertices, bboxsize_cam) </span> </span> view_matrix = camera.</span>get_view_matrix</span>() </span> projection_matrix = camera.</span>get_projection_matrix</span>() </span> </span> position4 = np.</span>append</span>(</span>self</span>.pos, </span>1.0</span>) </span> g_pos_view = view_matrix @ position4 </span> g_pos_screen = projection_matrix @ g_pos_view </span> g_pos_screen = g_pos_screen / g_pos_screen[</span>3</span>] </span> </span> </span># Bounds of gaussian in Normalized Device Coordinates (-1 to 1) </span> bbox_ndc = np.</span>multiply</span>(vertices, bboxsize_ndc) + g_pos_screen[:</span>2</span>] </span> bbox_ndc = np.</span>hstack</span>((bbox_ndc, np.</span>zeros</span>((vertices.shape[</span>0</span>],</span>2</span>)))) </span> bbox_ndc[:,</span>2</span>:</span>4</span>] = g_pos_screen[</span>2</span>:</span>4</span>] </span></code></pre> </li> Since the final rendered view consists of a combination of all the gaussians, we add identical full-screen quads for each gaussian and procees them one by one. For each one, we generate the 2D gaussian parameters, as well as the bounding box of the gaussian in screen-coordinates.</p> </li> In an actual graphics pipeline, this bounding box is then used to determine what pixels to draw on the screen. Since we are doing everything manually in the Python version, I scale the 2D gaussian bounding box by the screen size and iterate over each pixel within it, one by one. See the plot_opacity()</code> function in the notebook for details.</p> </li> For each pixel, sample the gaussian to obtain the opacity (alpha) value. Use the spherical harmonics coefficients</a> to determine the RGB color of the pixel for the particular viewing direction from the camera to the gaussian. This pixel value is then added to the output image.</p> </li> </ol> Rust version</h3> The Rust version uses the euc</a> software rendering crate. I define a rendering pipeline with a “vertex” and “fragment” shader. It works very similar to how OpenGL or other graphics library does things. So I did not have to iterate over individual pixels like I did in the Python version.</p> Repository layout</h3> Github: https://github.com/thomasantony/splat/</a></p> . </span>├── Cargo.lock </span>├── Cargo.toml </span>├── LICENSE </span>├── README.md </span>├── notes </span>│ ├── 00_Gaussian_Projection.ipynb <--- Python prototype </span>│ ├── requirements.txt <--- install before running notebook </span>│ ├── util.py </span>│ └── util_gau.py </span>├── notes.md </span>├── src </span>│ ├── bin </span>│ │ ├── 00_ply_load.rs <-- PLY file loading in Rust </span>│ │ ├── 01_naive_gaussian.rs <-- Rendering some hard-coded gaussians </span>│ │ ├── 02_ply_demo.rs <-- First version the worked </span>│ │ └── attempt03.rs <-- incomplete attempt at a different approach </span>│ ├── camera.rs </span>│ ├── gaussians.rs </span>│ ├── lib.rs </span>│ ├── main.rs <-- Current version </span>│ └── pipelines.rs </span></code></pre> Lessons Learned</h2> When working on a new project, it is always better if you have a working example, or at least some kind of data or reference that you can use to figure out if you are going in the right direction. In this case, the “naive gaussians” example from https://github.com/limacv/GaussianSplattingViewer</a>, as well as viewing the GPU buffers for that code using RenderDoc</a> was extremely helpful</p> </li> Unless you are familiar with the field, it is really easy to mess up simple things like loading data from a data file. For example, the PLY model files used for storing the gaussian splats all contain fields called opacity</code> and scale</code>, the former being the visual opacity of the gaussian and the latter being a 3-vector describing the spread of the gaussian. It is easy to assume that opacity</code> is a value between [0,1]</code> and scale</code> can be used directly to scale the gaussians. It turned out that the opacity was actually log(opacity)</code> and had to be exponentiated before use. Similarly, the scale</code> parameter had to be passed through a sigmoid function before use. For someone not too familar with this field, it seems entirely arbitrary (though it makes sense later once you read about it). I would have been stuck with this for a lot longer if I had not seen the existing examples.</p> ... </span> ("</span>scale_0</span>", Property::Float(v)) => </span>self</span>.scale[</span>0</span>] = v.</span>exp</span>(), </span> ("</span>scale_1</span>", Property::Float(v)) => </span>self</span>.scale[</span>1</span>] = v.</span>exp</span>(), </span> ("</span>scale_2</span>", Property::Float(v)) => </span>self</span>.scale[</span>2</span>] = v.</span>exp</span>(), </span> ("</span>opacity</span>", Property::Float(v)) => </span>self</span>.opacity = </span>1.0 </span>/ (</span>1.0 </span>+ (-v).</span>exp</span>()), </span> ... </span></code></pre> </li> The nalgebra</a> crate, while being a great library for numerical manipulation, has some quirks that can trip you up. For example, if you print a matrix using the debug formatter ({:?}</code>), it will print the transpose of the matrix for some reason. This led to me wasting a couple of hours trying to figure out why matrix multiplication no longer worked how I thought it did.</p> </li> -a.max(b)</code> is not the same as (-a).max(b)</code> in Rust</p> </li> RenderDoc</a> does not seem to be able to capture frames from OpenGL programs run in WSL2</p> </li> </ul> What’s Next</h2> While the Python version is far from being real-time, it seems like the rust version is performant enough to run in real-time. Some possible improvements:</p> Use “structure-of-arrays” layout to hold the data. This may make a few operations such as sorting the gaussians significantly faster. I opted for array-of-structures in the current version due to how the ply-rs</a> file parses data from the point cloud (PLY) files.</li> Use a “geometry shader</a>” to generate the vertices for each gaussian.</li> Add camera controls using egui</a> or imgui</a></li> </ul> Acknowledgements</h2> The following articles/code bases were extremely helpful in teaching me about how 3D Gaussian Splats work</p> numbyNum :: 3D Gaussian Splatting for Real-Time Radiance Field Rendering (Reviewed) \| Medium</a></li> 3D Gaussian Splatting - A beginner friendly introduction to 3D Gaussian Splats and tutorial on how to train them.</a></li> limacv/GaussianSplattingViewer</a> - most of my code is based on the vertex and fragment shader code in this repository. Also RenderDoc</a> for digging into this program further.</li> [Concept summary] 3D Gaussian and 2D projection</a></li> </ul> Understanding 3D Gaussian Splats by writing a software renderer 2023-11-13T19:10:35-08:00 If you want to skip to the code, you can find it here</a>.</p> 3D gaussian splats</a> have been all the rage since they were published. They may end up revolutionizing how we model realistic 3D worlds and seems to be the successor to NeRFs</a>.</p> Most of the articles that I have seen about them addresses the training-side of it (which is arguably more important). Hardly any addresses the nitty-gritty details on how to parse a pre-trained model and view it. While differentiable rendering is a key part of what makes this technology possible, the differentiable part is not really necessary if all you are interested in is viewing a pre-trained model.</p> There are a few indepndantly written renderers on github - most of them using OpenGL, and some using WebGPU or WebGL. Some of the Python versions require CUDA (and are hence tied to NVIDIA systems). There is also a Rust version</a> that is pretty platform-agnostic.</p> However, even the simplest</a> of these use shaders - pieces of code written a special languages that run on the GPU. The particular example I linked also depends on OpenGL 4.3 and hence does not run on macOS.</p> My goal with this project was to write a renderer in plain Rust, doing all the rendering math on the CPU. And after spinning my wheels for a bit, I realized that I need to start even simpler - with a version written in pure Python in a [Jupyter notebook].</p> What are 3D gaussian splats?</h2> 3D Gaussian Splats are a method of encoding information from a scene such that we can synthesize “novel views”, that were not in the original set of photos used to generate it. There are some very neat examples on the official site</a> for the paper. There have been also been a few web-based viwers (https://gsplat.tech/</a>, https://poly.cam/gaussian-splatting</a> ) that show off some really good examples.</p> Results</h2> As of the time of writing, I have a working CPU-based Gaussian splat renderer prototype written in Python and a faster one written in Rust. On my M1 Max Macbook Pro, the Python version takes about 2-3 minutes to render a 2560x1440 image for the “push sledge</a>” model (download here</a>) with about ~284000 gaussians in it. The Rust version renders the same model pretty much instantly.</p> How it works</h2> Python version</h3> While the CPU-based renderer does not use any OpenGL or WebGPU shaders, it still follows mostly the same logic. For the Python version, I had to add in some (not-so-efficient) versions of things that are typically handled by the graphics rendering pipeline on a GPU. Here is the overall workflow for the renderer in the Jupyter notebook</a>:</p> Load the gaussians from the .ply file. I used the ply-rs</a> crate in the Rust version and the load_plyfile</code> functions from util_gau.py</a>.</p> </span>from </span>tqdm </span>import </span>tqdm </span> model = </span>load_ply</span>('</span>point_cloud.ply</span>') </span> </span> </span> </span>print</span>('</span>Loading gaussians ...</span>') </span> gaussian_objects = [] </span> </span>for </span>(pos, scale, rot, opacity, sh) </span>in </span>tqdm</span>(</span>zip</span>(model.xyz, model.scale, model.rot, model.opacity, model.sh)): </span> gaussian_objects.</span>append</span>(</span>Gaussian</span>(pos, scale, rot, opacity, sh)) </span></code></pre> </li> Initialize a Camera model with a certain dimensions and position. I used one based off of the version at https://github.com/limacv/GaussianSplattingViewer/ .</p> (h, w) = (</span>720</span>, </span>1280</span>) </span> camera = </span>Camera</span>(h, w, </span>position</span>=(-</span>0.57651054</span>, </span>2.99040512</span>, -</span>0.03924271</span>), </span>target</span>=(-</span>0.0</span>, </span>0.0</span>, </span>0.0</span>)) </span></code></pre> </li> Sort the gaussians by depth from the camera model (this may need to be repeated if the camera can be moved).</p> </span>print</span>('</span>Sorting the gaussians by depth</span>') </span> indices = np.</span>argsort</span>([gau.</span>get_depth</span>(camera) </span>for </span>gau </span>in </span>gaussian_objects]) </span></code></pre> </li> Project the 3D gaussians</a> on to the camera plane to form ellipses. Compute the parameters of this ellipse (which represents a 2D gaussian and is represted by a variable called conic</code>). See the get_cov2d()</code> and the get_conic_and_bb()</code> methods in the Jupyter notebook</a></p> </li> This step is a quirk of how graphics rendering pipelines work. We start with a list of four 3D vertices (called a “quad”). In a typical 3D rendering pipeline, these may be actual vertices from a 3D model. In our case, we make the quad cover the entire screen. This is represented by the vertices [-1, 1], [1, 1], [1, -1] and [-1, -1]. This is essentially a square centered at the origin. These are in something called “Normalized Device Coordinates” which is agnostic to the actual resolution of the camera model or the screen.</p> vertices = np.</span>array</span>([[-</span>1</span>, </span>1</span>], [</span>1</span>, </span>1</span>], [</span>1</span>, -</span>1</span>], [-</span>1</span>, -</span>1</span>]]) </span> </span># Four values (bounds of the values used to evaluate gaussian) </span> bboxsize_cam = np.</span>multiply</span>(vertices, bboxsize_cam) </span> </span> view_matrix = camera.</span>get_view_matrix</span>() </span> projection_matrix = camera.</span>get_projection_matrix</span>() </span> </span> position4 = np.</span>append</span>(</span>self</span>.pos, </span>1.0</span>) </span> g_pos_view = view_matrix @ position4 </span> g_pos_screen = projection_matrix @ g_pos_view </span> g_pos_screen = g_pos_screen / g_pos_screen[</span>3</span>] </span> </span> </span># Bounds of gaussian in Normalized Device Coordinates (-1 to 1) </span> bbox_ndc = np.</span>multiply</span>(vertices, bboxsize_ndc) + g_pos_screen[:</span>2</span>] </span> bbox_ndc = np.</span>hstack</span>((bbox_ndc, np.</span>zeros</span>((vertices.shape[</span>0</span>],</span>2</span>)))) </span> bbox_ndc[:,</span>2</span>:</span>4</span>] = g_pos_screen[</span>2</span>:</span>4</span>] </span></code></pre> </li> Since the final rendered view consists of a combination of all the gaussians, we add identical full-screen quads for each gaussian and procees them one by one. For each one, we generate the 2D gaussian parameters, as well as the bounding box of the gaussian in screen-coordinates.</p> </li> In an actual graphics pipeline, this bounding box is then used to determine what pixels to draw on the screen. Since we are doing everything manually in the Python version, I scale the 2D gaussian bounding box by the screen size and iterate over each pixel within it, one by one. See the plot_opacity()</code> function in the notebook for details.</p> </li> For each pixel, sample the gaussian to obtain the opacity (alpha) value. Use the spherical harmonics coefficients</a> to determine the RGB color of the pixel for the particular viewing direction from the camera to the gaussian. This pixel value is then added to the output image.</p> </li> </ol> Rust version</h3> The Rust version uses the euc</a> software rendering crate. I define a rendering pipeline with a “vertex” and “fragment” shader. It works very similar to how OpenGL or other graphics library does things. So I did not have to iterate over individual pixels like I did in the Python version.</p> Repository layout</h3> Github: https://github.com/thomasantony/splat/</a></p> . </span>├── Cargo.lock </span>├── Cargo.toml </span>├── LICENSE </span>├── README.md </span>├── notes </span>│ ├── 00_Gaussian_Projection.ipynb <--- Python prototype </span>│ ├── requirements.txt <--- install before running notebook </span>│ ├── util.py </span>│ └── util_gau.py </span>├── notes.md </span>├── src </span>│ ├── bin </span>│ │ ├── 00_ply_load.rs <-- PLY file loading in Rust </span>│ │ ├── 01_naive_gaussian.rs <-- Rendering some hard-coded gaussians </span>│ │ ├── 02_ply_demo.rs <-- First version the worked </span>│ │ └── attempt03.rs <-- incomplete attempt at a different approach </span>│ ├── camera.rs </span>│ ├── gaussians.rs </span>│ ├── lib.rs </span>│ ├── main.rs <-- Current version </span>│ └── pipelines.rs </span></code></pre> Lessons Learned</h2> When working on a new project, it is always better if you have a working example, or at least some kind of data or reference that you can use to figure out if you are going in the right direction. In this case, the “naive gaussians” example from https://github.com/limacv/GaussianSplattingViewer</a>, as well as viewing the GPU buffers for that code using RenderDoc</a> was extremely helpful</p> </li> Unless you are familiar with the field, it is really easy to mess up simple things like loading data from a data file. For example, the PLY model files used for storing the gaussian splats all contain fields called opacity</code> and scale</code>, the former being the visual opacity of the gaussian and the latter being a 3-vector describing the spread of the gaussian. It is easy to assume that opacity</code> is a value between [0,1]</code> and scale</code> can be used directly to scale the gaussians. It turned out that the opacity was actually log(opacity)</code> and had to be exponentiated before use. Similarly, the scale</code> parameter had to be passed through a sigmoid function before use. For someone not too familar with this field, it seems entirely arbitrary (though it makes sense later once you read about it). I would have been stuck with this for a lot longer if I had not seen the existing examples.</p> ... </span> ("</span>scale_0</span>", Property::Float(v)) => </span>self</span>.scale[</span>0</span>] = v.</span>exp</span>(), </span> ("</span>scale_1</span>", Property::Float(v)) => </span>self</span>.scale[</span>1</span>] = v.</span>exp</span>(), </span> ("</span>scale_2</span>", Property::Float(v)) => </span>self</span>.scale[</span>2</span>] = v.</span>exp</span>(), </span> ("</span>opacity</span>", Property::Float(v)) => </span>self</span>.opacity = </span>1.0 </span>/ (</span>1.0 </span>+ (-v).</span>exp</span>()), </span> ... </span></code></pre> </li> The nalgebra</a> crate, while being a great library for numerical manipulation, has some quirks that can trip you up. For example, if you print a matrix using the debug formatter ({:?}</code>), it will print the transpose of the matrix for some reason. This led to me wasting a couple of hours trying to figure out why matrix multiplication no longer worked how I thought it did.</p> </li> -a.max(b)</code> is not the same as (-a).max(b)</code> in Rust</p> </li> RenderDoc</a> does not seem to be able to capture frames from OpenGL programs run in WSL2</p> </li> </ul> What’s Next</h2> While the Python version is far from being real-time, it seems like the rust version is performant enough to run in real-time. Some possible improvements:</p> Use “structure-of-arrays” layout to hold the data. This may make a few operations such as sorting the gaussians significantly faster. I opted for array-of-structures in the current version due to how the ply-rs</a> file parses data from the point cloud (PLY) files.</li> Use a “geometry shader</a>” to generate the vertices for each gaussian.</li> Add camera controls using egui</a> or imgui</a></li> </ul> Acknowledgements</h2> The following articles/code bases were extremely helpful in teaching me about how 3D Gaussian Splats work</p> numbyNum :: 3D Gaussian Splatting for Real-Time Radiance Field Rendering (Reviewed) \| Medium</a></li> 3D Gaussian Splatting - A beginner friendly introduction to 3D Gaussian Splats and tutorial on how to train them.</a></li> limacv/GaussianSplattingViewer</a> - most of my code is based on the vertex and fragment shader code in this repository. Also RenderDoc</a> for digging into this program further.</li> [Concept summary] 3D Gaussian and 2D projection</a></li> </ul> Hyena Hierarchy: Towards Larger Convolutional Language Models 2023-04-23T04:10:30.070+00:00 Here are some rough notes on the “Hyena Hierarchy” architecture described in the paper 1</a></sup>.</p> This is a new way of getting sub-quadratic scaling for attention</p> </li> it uses convolution filter</p> typical convolution filters are in the form of an array of values which are learned and applied like an Finite-Impulse-Response discrete filter (FIR)2</a></sup></li> this doesn’t scale well</li> instead the filter parameters are represented as a function of “t” where “t” represents the index or “time-step” in the filter. This means you can get a filter of any length from a limited number of parameters</li> furthermore, this function is chosen to be the output of a state-space model of the type from control theory (Ax+Bu, Cx+Du etc.)</li> If x0 = 0, then you can get an expression for the output “y” (aka the filter), in terms of matrices A, B, C and D (which can be learned during training)</li> dimensions of the state-space model and structore of the matrices represent the degrees of freedom available</li> </ul> </li> FFT can be used to implement convolutions</p> </li> Typical attention involves three linear projections passed through a softmax function - called query, key and value</p> </li> “Hyena” uses N+1 linear projections (not necessarily equal to three). One of these projections take the role of the “value”.</p> </li> So y = H(u)v</code></p> H(u) is defined by “interleaving implicit long convolutions and element-wise multiplication” with one projection at a time</li> It somehow retains the sublinear scaling by not “materializing” H(u)</li> The element-wise product in time domain corresponds to convolution in frequency domain</li> </ul> </li> more details to come as I understand the paper further</p> </li> </ul> ^1</sup>Hyena Hierarchy: Towards Larger Convolutional Language Models</a>, Poli et.al</p> </div> ^2</sup>Finite Impulse Response</a></p> </div> Generalization through memorization: Nearest neighbor language models 2023-04-13T02:25:07.127+00:00 This paper1</a></sup> describes a method for augmenting an existing language model with external memory to improve its performance without requiring any extra training. The datastore is initialized for a given dataset and used during inference time. The authors demonstrate performance improvements (measured in perplexity over a given dataset) even when operating on data-stores for datasets the model was not trained on.</p> How it works</h2> The method essentially involves “memorizing” the training set and using it to directly augment the model at inference time. This can also be used for memorizing data other than the training set</em> and give similar improvements.</p> Indexing or “Memorizing”</h3> The data-store is a “key-value” database, similar to faiss</a> or pinecone</a> with vectors (of floating point numbers) that form keys and some arbitrary data as value. To “memorize” a data set, the existing LLM is evaluated on the data split into some chunk size, and the outputs of the network right before the final “softmax” layer is used as the “key” for the database, while the subsequent token in the dataset (which the model is supposed to predict) is stored as the value.</p> Assume that $x_0$, $x_1$ … $x_{n-1}$, are the different tokens in a chunk of text from the dataset. Let f</code> be a function that converts this token sequence into the “key” vector. In the paper, they examined different layer outputs for this and showed that the output of the final layer, right before the soft-max activation, is a good candidate for this. So for a given token-sequence, the key and value are given by</p> $$ k = f([x_0, x_1, ... , x_{n-1}])\\ v = x_n $$ </div> For a chunk of n-tokens, we may have up to n-1 different data-points stored in the database, i.e. $f([x_0]) \rightarrow x_1$, $f([x_0, x_1]) \rightarrow x_2$ and so on.</p> Inference</h3> At inference time, the input token-sequence is run through the LM to get the probability distribution for the next token. The activations of the final layer prior to the soft-max is then used to perform a k-nearest-neighbors search in the vector datastore created in the last step (the authors used Euclidean distance and k=1000 for this search). The vectors are then converted into a probability distribution of its own using the distances as follows:</p> $$ P_{kNN}(y\|x) = \sum_{(k_i, v_i \in N)} \mathbb{1}_{y=v_i} \exp\left(\ -d(k_i, f(x_i)) \right) $$ </div> where $\mathbb{1}_{y=v_i}$ is the one-hot encoded vector for token $v_i$, $d(k_i, f(x_i))$ is the distance for the search result from the search-key.</p> $P_{LM}(y\|x)$ are the logits from the original model. The final probability distribution is then computed by linearly interpolating between the two distributions:</p> $$ P(y\|x) = \lambda P_{kNN}(y\|x) + (1 - \lambda) P_{LM}(y\|x) $$ </div> where $\lambda$ is a fixed coefficient. Reference 2</a></sup> talks about selecting $\lambda$ based on “semantic similarity” (the cosine distance?) between the closest key from the search results and the search query. They trained a model to predict what the coefficient-profile should be for a given dataset (i.e how to map semantic similarity to the interpolation coefficient $\lambda$).</p> ^1</sup>Generalization through memorization: Nearest neighbor language models</a>, Khandelwal, U., Levy, O., Jurafsky, D., Zettlemoyer, L., & Lewis, M. (2019)</p> </div> ^2</sup>You can’t pick your neighbors, or can you? When and how to rely on retrieval in the kNN-LM</a>, Drozdov, A., Wang, S., Rahimi, R., McCallum, A., Zamani, H., & Iyyer, M. (2022)</p> </div> How to send UDP packets from command line 2023-04-07T04:47:57.397+00:00 The following command sends the 4-byte packet ‘\x01\x02\x03\x04’ to 127.0.0.1 on port 2222</p> echo -n -e '\x01\x02\x03\x04' > /dev/udp/127.0.0.1/2222 </span></code></pre> Python extension debugging in Vscode 2023-03-27T15:14:29.276+00:00 Troubleshooting</h2> If you get EXC_BAD_INSTRUCTION on M1 Mac, downgrade openssl from 3.1.0 to 3.0.7 (and Python to 3.10.9)</li> </ul> How was ChatGPT trained? 2023-03-15T06:19:22.987+00:00 Train a GPT-like model to “understand langauge”. This could be based on a data-set of prompts and expected responses.</p> </li> Sample several outputs from the model for a given prompt. Have human labeler rank the outputs. Train yet another</em> transformer based model (the “reward model”) that can predict this rank/“goodness” of the answer based on the human labeled answers.</p> </li> Stack the reward model (RM) at the end of GPT and use it to generate the loss function. This is then used to fine-tune the GPT while keeping the RM frozen. And thus you get ChatGPT.</p> </li> </ol> References</h2> [1] https://www.youtube.com/watch?v=_MPJ3CyDokU</p> [2] “Learning to summarize from human feedback” https://arxiv.org/pdf/2009.01325.pdf</p> Plasma 2023-01-01T06:02:10.759+00:00 Plasma, also called the “fourth state of matter”, consists of a collection of ions and electrons that is quasi-neutral</em> and exhibits collective behavior.</p> This behavior is primarily caused due to the electromagnetic interactions between the particles. The degree of interactions will depend on the average density of charged particles to neutral particles.</p> Generating music using ChatGPT 2022-12-04T13:00:42-08:00 I have been experimenting with OpenAI’s ChatGPT</a> since it came out a couple of days ago. You can see the transcripts of some of my conversations with it here</a>. Today I tried to get it to generate audio, specifically music.</p> TLDR: It can generate some notes. But maybe it can do more with careful prompting.</p> Anyway, my musical background extends as far as trying to teach myself to play the piano and the violin using Youtube tutorials and I didn’t really get too far. With that in mind, I wanted to see if ChatGPT could generate anything resembling music using its text-based interface.</p> In my first conversation</a>, I asked it for a suitable format and it informed me about the existence of MusicXML</a>. I also had it write a parser/player for it in Python. I should confess that it took a few attempts to get a working player out of it but in the end it was successful. I discovered the library music21</code> with my initial prompts and then found that pygame</code> can playback MIDI files. I used this information to tweak my prompt until I got the code that I wanted.</p> Here is the final code it generated for playing MusicXML files:</p> import </span>sys </span>import </span>music21 </span>import </span>pygame </span>from </span>pygame.locals </span>import </span>* </span> </span># Get the MusicXML file from the command line argument </span>if </span>len</span>(sys.argv) != </span>2</span>: </span> </span>print</span>('</span>Please provide a MusicXML file as a command line argument</span>') </span> sys.</span>exit</span>(</span>1</span>) </span> </span>music_xml_file = sys.argv[</span>1</span>] </span> </span># Convert the MusicXML file to a MIDI file using music21 </span>midi_file = music21.converter.</span>parse</span>(music_xml_file).</span>write</span>('</span>midi</span>') </span> </span># Initialize pygame </span>pygame.</span>init</span>() </span>pygame.mixer.</span>init</span>() </span> </span># Load the MIDI file and play it </span>pygame.mixer.music.</span>load</span>(midi_file) </span>pygame.mixer.music.</span>play</span>() </span> </span># Wait for the playback to finish before exiting </span>clock = pygame.time.</span>Clock</span>() </span>while </span>pygame.mixer.music.</span>get_busy</span>(): </span> clock.</span>tick</span>(</span>30</span>) </span></code></pre> Armed with the file, I then asked it to generate a sample MusicXML file and it actually made something that could be played back! So then I went further</a> and wanted to see if it could generate specific tunes. While I wasn’t quite as successful here, it still generated valid MusicXML files that could be played back.</p> I decided to go a step further and tried it make it generate Base64 encoded MIDI files. It didn’t make valid MIDI files, but I had some interesting results regardless. It generated this base64 string</p> VGhlIHN5bmNocm9uaXplciBjYW4ndCBjcmVhdGUgYSBNSURJIGZpbGUgYmVjYXVzZSBpdCBvbmx5IGdlbmVyYXRlcyBNdXNp </span>Y1hNTCBvdXRwdXQuIFRvIGNyZWF0ZSBhIE1JREkgZmlsZSBmcm9tIE11c2ljWE1MLCB5b3UgbmVlZCB0byB1c2UgYSBz </span>dXBwb3J0ZWQgbWlkaSBwcm9jZXNzZXIuIERvIHlvdSB3YW50IG1lIHRvIHN1cHBvcnQgbWlkaSBwcm9jZXNzaW5nIGlu </span>IHRoZSBmdXR1cmU/VG8gY3JlYXRlIGEgTUlESSBmaWxlIGZyb20gTXVzaWNYTUwsIGZpcnN0IGxvYWQgdGhlIE11c2ljWE1MIGludG8gdGhl </span>IG1pZGkgcHJvY2Vzc2VyLiBUaGVuIHVzZSB0aGUgcHJvY2Vzc2VyJ3MgZnVuY3Rpb25hbGl0eSB0byBjb252ZXJ0IHRo </span>ZSBNdXNpY1hNTCBpbnRvIGEgTUlESSBmaWxlLiBUaGUgTUlESSBmaWxlIGNhbiB0aGVuIGJlIHVzZWQgaW4gbXVsdGlw </span>bGUgbWlkaSBhcHBsaWNhdGlvbnMuIElmIHlvdSB3YW50IHRvIHJlYWQgbW9yZSBhYm91dCBjb252ZXJ0aW5nIE11c2lj </span>WE1MIGludG8gTUlESSwgeW91IGNhbiBzZWUgdGhlIE1JREkgZG9jc3MgZm9yIG1vcmUgaW5mb3JtYXRpb24u </span>VG8gc3BlY2lmeSB0aGUgQy1tYWpvciBzY2FsZSBpbiBNdXNpY1hNTCwgeW91IGNhbiB1c2UgdGhlIGZvbGxvd2luZyBj </span>b2RlOlxuPGNvZGU+XG48c2NvcGUtcGFydHdpc2UgdmVyc2lvbj0iMy4xIj5cbiAgPHBhcnQtbGlzdD5cbiAgICA8c2Nv </span>cmUtcGFydCBpZD0iUDIiPlxuICAgICAgPHBhcnQtbmFtZT5QYWlubyBQYXJ0PC9wYXJ0LW5hbWU+XG4gICAgPC9zY29y </span>ZS1wYXJ0PlxuICA8L3BhcnQtbGlzdD5cbiAgPHBhcnQgaWQ9IlAyIj5cbiAgICA8bWVhc3VyZSBudW1iZXI9IjEiPlxuICAg </span>ICAgPGF0dHJpYnV0ZXM+XG4gICAgICAgIDxkaXZpc2lvbnM+MTwvZGl2aXNpb25zPlxuICAgICAgICA8a2V5PlxuICAg </span>ICAgICAgIDxmaWZ0aGhzPjA8L2ZpZnRoaHM+XG4gICAgICAgIDwva2V5PlxuICAgICAgICA8dGltZT5cbiAgICAgICAg </span>ICA8YmVhdHM+MzwvYmVhdHM+XG4gICAgICAgICAgPGJlYXQtdHlwZT4zPC9iZWF0LXR5cGU+XG4gICAgICAgIDwvdGlt </span>ZT5cbiAgICAgICAgPGNsZWY+XG4gICAgICAgICAgPHNpZ24+Rzwvc2lnbj5cbiAgICAgICAgICA8bGluZT4yPC9saW5l </span>PlxuICAgICAgICA8L2NsZWY+XG4gICAgICA8L2F0dHJpYnV0ZXM+XG4gICAgICA8bm90ZT5cbiAgICAgICAgPHA+XG4gICAg </span>ICAgICAgPHN0ZXA+Qzwvc3RlcD5cbiAgICAgICAgICA8b2N0YXZlPjQ8L29jdGF2ZT5cbiAgICAgICAgPC9wPlxuICAgICAg </span>ICA8ZHVyYXRpb24+MTwvZHVyYXRpb24+XG4gICAgICAgIDx0eXBlPnF1YXJ0ZXI8L3R5cGU+XG4gICAgICA8L25vdGU+XG4g </span>ICAgICA8bm90ZT5cbiAgICAgICAgPHA+XG4gICAgICAgICAgPHN0ZXA+RC1hbHRlcjwvc3RlcD5cbiAgICAgICAgICA8b2N0YXZl </span>PjQ8L29jdGF2ZT5cbiAgICAgICAgPC9wPlxuICAgICAgICA8ZHVyYXRpb24+MTwvZHVyYXRpb24+XG4gICAgICAgIDx0eXBl </span>PnF1YXJ0ZXI8L3R5cGU+XG4gICAgICA8L25vdGU+XG4gICAgICA8bm90ZT5cbiAgICAgICAgPHA+XG4gICAgICAgICAgPHN0 </span>ZXA+RTwvc3RlcD5cbiAgICAgICAgICA8b2N0YXZlPjQ8L29jdGF2ZT5cbiAgICAgICAgPC9wPlxuICAgICAgICA8ZHVyYXRp </span>b24+MTwvZHVyYXRpb24+XG4gICAgICAgIDx0eXBlPnF1YXJ0ZXI8L3R5cGU+XG4gICAgICA8L25vdGU+XG4gICAgICA8bm90 </span>ZT5cbiAgICAgICAgPHA+XG4gICAgICAgICAgPHN0ZXA+RiZhbXA7PC9zdGVwPlxuICAgICAgICAgIDxvY3RhdmU+NDwv </span>b2N0YXZlPlxuICAgICAgICA8L3A+XG4gICAgICAgIDxkdXJhdGlvbj4xPC9kdXJhdGlvbj5cbiAgICAgICAgPHR5cGU+cXVh </span>cnRlcjwvdHlwZT5cbiAgICAgIDwvbm90ZT5cbiAgICAgIDxub3RlPlxuICAgICAgICA8cD5cbiAgICAgICAgICA8c3RlcD5G </span>JmFtcDsrMTwvc3RlcD5cbiAgICAgICAgICA8b2N0YXZlPjQ8L29jdGF2ZT5cbiAgICAgICAgPC9wPlxuICAgICAgICA8ZHVy </span>YXRpb24+MTwvZHVyYXRpb24+XG4gICAgICAgIDx0eXBlPnF1YXJ0ZXI8L3R5cGU+XG4gICAgICA8L25vdGU+XG4gICAgICA8 </span>bm90ZT5cbiAgICAgICAgPHA+XG4gICAgICAgICAgPHN0ZXA+Rzwvc3RlcD5cbiAgICAgICAgICA8b2N0YXZlPjQ8L29jdG </span>F2ZT5cbiAgICAgICAgPC9wPlICAgICAgICA8ZHVyYXRpb24+MTwvZHVyYXRpb24+XG4gICAgICAgIDx0eXBlPnF1YXJ0ZXI8L3R5cGU+XG4gICAgICA8L25v </span>dGU+XG4gICAgPC9tZWFzdXJlPlxuICA8L3BhcnQ+XG48L3Njb3BlLXBhcnR3aXNlPlxuPC9jb2RlPlxuVGhpcyBjb2RlIGNy </span>ZWF0ZXMgYSBzaW5nbGUgbWVhc3VyZSB3aXRoIGEgcGFpbm8gcGFydCB0aGF0IHBsYXlzIHRoZSBDLW1ham9yIHNjYWxl </span>LiBZb3UgY2FuIGV4cGFuZCBvciBtb2RpZnkgdGhpcyBjb2RlIGFjY29yZGluZyB0byB5b3VyIG5lZWRzLiBJZiB5b3Ug </span>d2lzaCB0byB1cGRhdGUgdGhlIHRlbXBvLCB5b3UgY2FuIGFkZCBhIHRlbXBvIHRhZyB3aXRoaW4gdGhlIGF0dHJpYnV0 </span>ZXMgdGFnIGxpa2Ugc286XG48Y29kZT5cbiAgPGF0dHJpYnV0ZXM+XG4gICAgPHRlbXBvPlxuICAgICAgPGJlYXQtdW5p </span>dD5zZWNvbmQ8L2JlYXQtdW5pdD5cbiAgICAgIDxwZXItbWludXRlPjEyMDwvcGVyLW1pbnV0ZT5cbiAgICA8L3RlbXBvPlxu </span>ICA8L2F0dHJpYnV0ZXM+XG48L2NvZGU+XG5UaGlzIGNvZGUgc2V0cyB0aGUgdGVtcG8gdG8gMTIwIGJlaGF2cyBwZXIg </span>c2Vjb25kLiBZb3UgY2FuIG1vZGlmeSB0aGlzIHRvIGFjaGlldmUgdGhlIHRlbXBvIHlvdSB3YW50Lg== </span></code></pre> When I ran it through a decoder, I got the following output:</p> The synchronizer can't create a MIDI file because it only generates MusicXML output. To create a MIDI file from MusicXML, you need to use a supported midi processer. Do you want me to support midi processing in the future?To create a MIDI file from MusicXML, first load the MusicXML into the midi processer. Then use the processer's functionality to convert the MusicXML into a MIDI file. The MIDI file can then be used in multiple midi applications. If you want to read more about converting MusicXML into MIDI, you can see the MIDI docss for more information.To specify the C-major scale in MusicXML, you can use the following code:\n<code>\n<scope-partwise version="3.1">\n <part-list>\n <score-part id="P2">\n <part-name>Paino Part</part-name>\n </score-part>\n </part-list>\n <part id="P2">\n <measure number="1">\n <attributes>\n <divisions>1</divisions>\n <key>\n <fifthhs>0</fifthhs>\n </key>\n <time>\n <beats>3</beats>\n <beat-type>3</beat-type>\n </time>\n <clef>\n <sign>G</sign>\n <line>2</line>\n </clef>\n </attributes>\n <note>\n <p>\n <step>C</step>\n <octave>4</octave>\n </p>\n <duration>1</duration>\n <type>quarter</type>\n </note>\n <note>\n <p>\n <step>D-alter</step>\n <octave>4</octave>\n </p>\n <duration>1</duration>\n <type>quarter</type>\n </note>\n <note>\n <p>\n <step>E</step>\n <octave>4</octave>\n </p>\n <duration>1</duration>\n <type>quarter</type>\n </note>\n <note>\n <p>\n <step>F&</step>\n <octave>4</octave>\n </p>\n <duration>1</duration>\n <type>quarter</type>\n </note>\n <note>\n <p>\n <step>F&+1</step>\n <octave>4</octave>\n </p>\n <duration>1</duration>\n <type>quarter</type>\n </note>\n <note>\n <p>\n <step>G</step>\n <octave>4</octave>\n </p></p> </blockquote> This was followed by some binary data that trashed the blog post formatting so I have removed it here.</p> This is quite strange. I am not entirely sure what it is doing here. It almost looks like it tried to use a program to generate the data … but it doesn’t really have programs that it can run. So it seems like hallucinated the whole process. The MusicXML that is in the decoded data has some typos. But once it is cleaned up, it looks like this:</p> <</span>score-partwise </span>version</span>="</span>3.1</span>"> </span> <</span>part-list</span>> </span> <</span>score-part </span>id</span>="</span>P2</span>"> </span> <</span>part-name</span>>Paino Part</</span>part-name</span>> </span> </</span>score-part</span>> </span> </</span>part-list</span>> </span> <</span>part </span>id</span>="</span>P2</span>"> </span> <</span>measure </span>number</span>="</span>1</span>"> </span> <</span>attributes</span>> </span> <</span>divisions</span>>1</</span>divisions</span>> </span> <</span>key</span>> </span> <</span>fifths</span>>0</</span>fifths</span>> </span> </</span>key</span>> </span> <</span>time</span>> </span> <</span>beats</span>>3</</span>beats</span>> </span> <</span>beat-type</span>>3</</span>beat-type</span>> </span> </</span>time</span>> </span> <</span>clef</span>> </span> <</span>sign</span>>G</</span>sign</span>> </span> <</span>line</span>>2</</span>line</span>> </span> </</span>clef</span>> </span> <</span>tempo</span>> </span> <</span>beat-unit</span>>eighth</</span>beat-unit</span>> </span> <</span>per-minute</span>>120</</span>per-minute</span>> </span> </</span>tempo</span>> </span> </</span>attributes</span>> </span> <</span>note</span>> </span> <</span>p</span>> </span> <</span>step</span>>C</</span>step</span>> </span> <</span>octave</span>>4</</span>octave</span>> </span> </</span>p</span>> </span> <</span>duration</span>>1</</span>duration</span>> </span> <</span>type</span>>quarter</</span>type</span>> </span> </</span>note</span>> </span> <</span>note</span>> </span> <</span>p</span>> </span> <</span>step</span>>D-alter</</span>step</span>> </span> <</span>octave</span>>4</</span>octave</span>> </span> </</span>p</span>> </span> <</span>duration</span>>1</</span>duration</span>> </span> <</span>type</span>>quarter</</span>type</span>> </span> </</span>note</span>> </span> <</span>note</span>> </span> <</span>p</span>> </span> <</span>step</span>>E</</span>step</span>> </span> <</span>octave</span>>4</</span>octave</span>> </span> </</span>p</span>> </span> <</span>duration</span>>1</</span>duration</span>> </span> <</span>type</span>>quarter</</span>type</span>> </span> </</span>note</span>> </span> <</span>note</span>> </span> <</span>p</span>> </span> <</span>step</span>>F</span>&</span>amp;</span></</span>step</span>> </span> <</span>octave</span>>4</</span>octave</span>> </span> </</span>p</span>> </span> <</span>duration</span>>1</</span>duration</span>> </span> <</span>type</span>>quarter</</span>type</span>> </span> </</span>note</span>> </span> <</span>note</span>> </span> <</span>p</span>> </span> <</span>step</span>>F</span>&</span>amp;</span>+1</</span>step</span>> </span> <</span>octave</span>>4</</span>octave</span>> </span> </</span>p</span>> </span> <</span>duration</span>>1</</span>duration</span>> </span> <</span>type</span>>quarter</</span>type</span>> </span> </</span>note</span>> </span> </</span>measure</span>> </span> </</span>part</span>> </span></</span>score-partwise</span>> </span></code></pre> My prior prompts about MusicXML may also have pointed it to go down that path instead of generating MIDI directly. These are interesting results regardless!</p> I didn’t try GPT3 when it first came out and I didn’t really get the hype. But now, … now I see it. This year we have already had tremendous leaps forward - DALL-E, MidJourney, Stable Diffusion, and now ChatGPT. It seems like we have hit the vertical part of the exponential curve.</p> ===</p> On further probing, it came up with a script where the musical notes were directly stored in a list in Python. This led me to asking it to use that to store music as CSV files. The conversation in question can be found here</a>. Interestingly, when I asked it to generate a CSV file containing the first few bars of “Ode to Joy”, I got something that sounded like “Twinkle Twinkle Little Star”. Try out the following code and input file:</p> import </span>csv </span>import </span>sys </span>from </span>midiutil.MidiFile </span>import </span>MIDIFile </span>from </span>pygame </span>import </span>mixer </span> </span># Parse command line argument </span>try</span>: </span> csv_filename = sys.argv[</span>1</span>] </span>except </span>IndexError: </span> </span>print</span>("</span>Please provide the CSV file as a command line argument.</span>") </span> sys.</span>exit</span>(</span>1</span>) </span> </span># Parse CSV file </span>pitches = [] </span>durations = [] </span>times = [] </span>with </span>open</span>(csv_filename) </span>as </span>csvfile: </span> reader = csv.</span>reader</span>(csvfile) </span> </span>for </span>row </span>in </span>reader: </span> pitches.</span>append</span>(</span>int</span>(row[</span>0</span>])) </span> durations.</span>append</span>(</span>int</span>(row[</span>1</span>])) </span> times.</span>append</span>(</span>float</span>(row[</span>2</span>])) </span> </span># Create MIDI file </span>midi_file = </span>MIDIFile</span>(</span>1</span>) </span># One track </span>track = </span>0 </span>time = </span>0 </span>midi_file.</span>addTrackName</span>(track, time, "</span>Temporary MIDI Track</span>") </span>midi_file.</span>addTempo</span>(track, time, </span>120</span>) </span> </span># Add notes to the MIDI file </span>for </span>pitch, duration, time_offset </span>in </span>zip</span>(pitches, durations, times): </span> midi_file.</span>addNote</span>(track, </span>0</span>, pitch, time + time_offset, duration, </span>100</span>) </span> </span># Write the MIDI file to disk </span>with </span>open</span>("</span>temp.mid</span>", "</span>wb</span>") </span>as </span>output_file: </span> midi_file.</span>writeFile</span>(output_file) </span> </span># Play back the MIDI file using pygame.mixer </span>mixer.</span>init</span>() </span>mixer.music.</span>load</span>("</span>temp.mid</span>") </span>mixer.music.</span>play</span>() </span> </span># Wait until MIDI file is done playing before exiting </span>while </span>mixer.music.</span>get_busy</span>(): </span> </span>continue </span></code></pre> And here is the “music”:</p> 60</span>,</span>2</span>,</span>0 </span>60</span>,</span>2</span>,</span>0.5 </span>67</span>,</span>2</span>,</span>1 </span>67</span>,</span>2</span>,</span>1.5 </span>69</span>,</span>2</span>,</span>2 </span>69</span>,</span>2</span>,</span>2.5 </span>67</span>,</span>4</span>,</span>3 </span>65</span>,</span>2</span>,</span>4 </span>65</span>,</span>2</span>,</span>4.5 </span>64</span>,</span>2</span>,</span>5 </span>64</span>,</span>2</span>,</span>5.5 </span>62</span>,</span>2</span>,</span>6 </span>62</span>,</span>2</span>,</span>6.5 </span>60</span>,</span>2</span>,</span>7 </span>60</span>,</span>2</span>,</span>7.5 </span>67</span>,</span>2</span>,</span>8 </span>67</span>,</span>2</span>,</span>8.5 </span>69</span>,</span>2</span>,</span>9 </span>69</span>,</span>2</span>,</span>9.5 </span>67</span>,</span>4</span>,</span>10 </span>65</span>,</span>2</span>,</span>11 </span>65</span>,</span>2</span>,</span>11.5 </span>64</span>,</span>2</span>,</span>12 </span>64</span>,</span>2</span>,</span>12.5 </span>62</span>,</span>2</span>,</span>13 </span>62</span>,</span>2</span>,</span>13.5 </span></code></pre> Section 3.1 : Hamilton's Equations 2022-11-30T07:18:48+00:00 3 Hamiltonian Mechanics</h1> Numerical experiments are just what their name implies: experiments. In describing and evaluating them, one should enter the state of mind of the experimental physicist, rather than that of the mathematician. Numerical experiments cannot be used to prove theorems; but, from the physicist’s point of view, they do often provide convincing evidence for the existence of a phenomenon. We will therefore follow an informal, descriptive and non-rigorous approach. Briefly stated, our aim will be to understand the fundamental properties of dynamical systems rather than to prove them. ~ Michel Hénon, “Numerical Exploration of Hamiltonian Systems,” in Chaotic Behavior of Deterministic Systems [21], p. 57.</p> </blockquote> The formulation of mechanics with generalized coordinates and momenta as the dynamic state variables is called the Hamiltonian formulation. This is equivalent to the Lagrangian formulation, but present a differnet point of view. It is especially useful for understanding the evolution of a system, especially when there are symmetries and conserved quantities</p> </li> In systems with symmetries, the conjugate momenta of “cyclic coordinates” (which do not appear in the Lagrangian) are conserved. This insight can be used to simplify and solve many problems in dynamics (e.g. spinning top). The Hamiltonian formulation is motivated by the desire to focus attention on the momenta.</p> </li> In the Lagrangian formulation, the momenta are “secondary” quantities – they are functions of state variables and the evolution of these state variables only depend on the state variables themselves and not the momenta. Since the momenta can be inferred form velocities, it is possible to represent the dynamics in terms of coordinates and momenta. In such a formulation, if a momentum is conserved, it is immediately apparent from its dynamic equation.</p> </li> Mechanical systems can exhibit simple or complex behavior - periodic motion, chaotic motion etc. Sometimes the periodicity may be driven by an external force. The Hamiltonian formulation of dynamics provides a convenient framework in which the possible motions may be placed and understood. We will be able to see the range of stable resonance motions and the range of states reached by chaotic trajectories, and discover other unsuspected possible motions.</strong></p> </li> </ul> 3.1 Hamilton’s Equations</h2> $\require{cancel}$</p> Restricting our attention to Lagrangians that only depend onf time, coordinates and velocities, the momenta in a system can be represented as functions of coordinates, velocities and time. It is possible to invert these functions to get a local representation of velocity in terms of time, coordinates and momenta. The equations of motion when recast in terms of coordinates and momenta are called Hamilton’s canonical equations</strong>. We will look at three derivations of these equations:</p> The first strategy is an expansion of the one described in the above paragraph - starting with inverting the momentum state function.</p> </li> The second derivation in Section 3.1.1 first abstracts a key part of the first derivation and then applies the more abstract machinery to derive Hamilton’s equations. The third (section 3.1.2) uses the action principle.</p> </li> </ul> The equations for the time derivative of a momentum can be found from Lagrange’s equations as:</p> $$ D{p}(t) = \partial_1 L(t, q(t),D{q}(t))\tag{3.1} $$ </div> where (by definition of generalized momenta),</p> $$ p(t) = \partial_2 L(t, q(t), Dq(t))\tag{3.2} $$ </div> To eliminate $Dq(t)$ from Eq. 3.1, we need to invert Eq.3.2. To avoid confusion, we will do this by assigning simple variable names to the function arguments and its output. If Eq.3.1 is restated as:</p> $$ a = \partial_2 L (b, c, d)\tag{3.3} $$ </div> Then the equation can be inverted in terms of the third argument to get the new function $\mathscr{V}$ so that:</p> $$ d = \mathscr{V}(b, c, a)\tag{3.4} $$ </div> Substituting $a$ from Eq. 3.3 in 3.4 (and $d$ in Eq. 3.3),</p> $$ \begin{align} d = \mathscr{V}(b, c, \partial_2 L(b, c, d))\tag{3.5}\\ a = \partial_2 L(b, c, \mathscr{V}(b, c, a))\tag{3.6}\\ \end{align} $$ </div> THis pattern can be applied to Eq. 3.1 to get:</p> $$ Dp(t) = \partial_1 L (t, q(t), \mathscr{V}(t, q(t), p(t)))\tag{3.7} $$ </div> Similarly, Eq. 3.2 can be inverted to get:</p> $$ Dq(t) = \mathscr{V}(t, q(t), \partial_1 L(t, q(t), Dq(t))\tag{3.8} $$ </div> Equations 3.7 and 3.8 give dynamic equations for $q$ and $p$ as functions of time, coordinates and momenta. To represent this better, we can define a new Lagrangian as a function of time, coordinates and momenta.</p> $$ \widetilde{L}(t, q, p) = L(t, q, \mathscr{V}(t, q, p)) $$ </div> Here we are using mnemonic names t, q, p for formal parameters of the function being defined. We could have used names like a, b, c as above, but this would have made the argument harder to read.</p> </blockquote> To get the equations of motion, we need to compute $\partial_1 L$ (applying the chain rule, assuming that $L$ is not an explicit function of time):</p> $$ \begin{align} \partial_1 \widetilde{L}(t, q, \mathscr{V}(t, q, p)) &= \partial_1 L (t, q, \mathscr{V}(t, q, p)) + \overbrace{\partial_2 L (t, q, \mathscr{V}(t, q, p))}^{=p~\text{from Eq 3.2}}\partial_1 \mathscr{V}(t, q, p)\\ &= \partial_1 L (t, q, \mathscr{V}(t, q, p)) + p \partial_1 \mathscr{V}(t, q, p)\tag{3.10} \end{align} $$ </div> We introduce the “momentum selector” function here, $P(t,q,p) = p$ such that $\partial_1 P = 0$ to get,</p> $$ \begin{align} \partial_1 L (t, q, \mathscr{V}(t, q, p)) &= \partial_1 \widetilde{L}(t, q, p) - p \partial_1 \mathscr{V}(t, q, p)\\ &= \partial_1 \widetilde{L}(t, q, p) - P(t, q, p)\partial_1 \mathscr{V}(t, q, p)\\ &= -\partial_1 H(t, q, p)\tag{3.11} \end{align} $$ </div> In Eq. 3.11, $H$ is the Hamiltonian</em> defined as:</p> $$ H = P\mathscr{V} - \widetilde{L}\tag{3.12} $$ </div> Substituing Eq. 3.11 in 3.7, we get the dynamic equation for momentum as:</p> $$ Dp(t) = -\partial_1 H(t, q(t), p(t))\tag{3.11} $$ </div> The equation for $Dq(t)$ can also be written in terms of the Hamiltonian as shown below:</p> $$ \begin{align} \partial_2 H (t, q, p) &= \partial_2 (P\mathscr{V} - \widetilde{L})(t, q, p)\\ &= \overbrace{\partial_2 P(t, q, p)}^{=1} \mathscr{V}(t, q, p) + \overbrace{P(t, q, p)}^{=p} \partial_2 \mathscr{V}(t, q, p) - \partial_2 \widetilde{L}(t, q, p)\\ &= \mathscr{V}(t, q, p) + p\partial_2 \mathscr{V}(t, q, p) - \partial_2 \widetilde{L}(t, q, p)\tag{3.14} \end{align} $$ </div> $\partial_2 \widetilde{L}$ can be computed using the chain rule as:</p> $$ \begin{align} \partial_2 \widetilde{L}(t, q, p) &= \partial_2 \left(L(t, q, \mathscr{V}(t, q, p))\right)\\ &= \partial_2 L(t, q, \mathscr{V}(t, q, p)) \partial_2 \mathscr{V}(t, q, p)\\ &= p \partial_2\mathscr{V}(t, q, p)\tag{3.15} \end{align} $$ </div> Eq. 3.14 now reduces to: $\partial_2 H (t, q, \mathscr{V}(t, q, p)) = \mathscr{V}(t, q, p) + \cancel{p\partial_2 \mathscr{V}(t, q, p)} - \cancel{p\partial_2 \mathscr{V}(t, q, p)} = \mathscr{V}(t, q, p)$. This can be substituted in Eq. 3.8 to get:</p> $$ Dq(t) = \partial_2 H (t, q, \mathscr{V}(t, q, p))\tag{3.17} $$ </div> Equations 3.13 and 3.17 are called Hamilton’s equations</em>.</p> $$ \begin{align} Dq(t) &= \partial_2 H (t, q, \mathscr{V}(t, q, p))\\ Dp(t) &= -\partial_1 H(t, q(t), p(t))\tag{3.18}\\ \end{align} $$ </div> The first equation in 3.18 is restating the relation between velocity and momenta in terms of the Hamiltonian and applies for all paths regardless of whether they are realizable. The second equation only applies for realizable paths. The Hamiltonian has the same value as the energy function $\mathscr{E}$ from Chapter 1. The only difference is that that the velocities are expressed in terms of time, coordinates, and momenta using $\mathscr{V}$:</p> $$ H(t, q, p) = \mathscr{E}(t, q, \mathscr{V}(t,q,p))\tag{3.20} $$ </div> Illustration using free particle</h3> The Lagrangian for the motion of a free-particle of mass $m$ is:</p> $$ L(t; x,y; v_x,v_y) = \frac{1}{2} m (v_x^2 + v_y^2) - V(x, y) $$ </div> To compute the Hamiltonian, we first ocmpute the momenta as $p = \partial_2 L; p_x = mv_x; p_y = mv_y$. Solving for velocities, we get, $v_x = p_x/m, v_y = p_y/m$ (This is the definition of $\mathscr{V}$). The Hamiltonian is $H = pv - L(t,q,v)$ with $v$ expressed in terms of $(t, q, p)$.</p> $$ \begin{align} H &= p_x\frac{p_x}{m} + p_y\frac{p_y}{m} - L = \frac{p_x^2 + p_y^2}{m} - \frac{1}{2}\frac{p_x^2 + p_y^2}{m} + V(x,y)\\ &= \frac{p_x^2 + p_y^2}{2m} + V(x, y) \end{align} $$ </div> This is the total energy $T + V$ expressed in terms of the momenta. Hamilton’s equations for $Dq(t)$ are:</p> $$ D_x(t) = p_x(t)/m \quad D_y(t) = p_y(t)/m\\ $$ </div> The Hamilton’s equations for the momenta are:</p> $$ \begin{align} Dp_x(t) &= -\partial_{p_x} H = -\partial_0 V(x(t), y(t))\\ Dp_y(t) &= -\partial_{p_y} H = -\partial_1 V(x(t), y(t)) \end{align} $$ </div> Hamiltonian State</h3> Given a coordinate path $q$ and a Lagrangian $L$, the corresponding momentum path $p$ is given by Eq. 3.2. This can also be represented in terms of the Hamiltonian as was shown in the section above. The expression for momntum is valid whether or not the path is realizable, i.e., $p = \partial_2 L(t, q, v)$. In the Lagrangian formulation, $(t, q, v)$ represents the state of the path at a given moment and Lagrange’s equations describe a unique path emnating from this state. Similarly, $(t, q, p)$ represents the starte of a path in the Hamiltonian formulation and Hamilton’s equations describe a path emnating from this state. The two formulations are equivalent and creates the same path for the a given initial state.</p> When converting Lagrange equations into first order ODEs (prior to integration), we need to invert $ \partial_2 \partial_2 L$. While Hamilton’s equations are already first order ODEs, their construction involves an inversion in the form of the function $\mathscr{V}$. A system that is non-invertible in the Lagrangian formulation remains so in the Hamiltonian formulation as well.</p> For any given path, $q$, the Lagrangian and Hamiltonian state paths can be deduced from it. For the Lagrangian formulation, the state path is given by:</p> $$ \Gamma[q](t) = (t, q(t), Dq(t)) $$ </div> The construction of the Hamiltonian path requires the definition of a Lagrangian. The Hamiltonian path is given by:</p> $$ \Pi_L[q](t) = (t, q(t), \partial_2 L(t, q(t), Dq(t))) = (t, q(t), p(t)) $$ </div> The Hamiltonian state path is not unique for a given path as it is dependent on the Lagrangian that we choose when formulating it. There is no unique choice for the Lagrangian and hence there is no unique Hamiltonian state path for a given path.</p> The $2n$-dimensional space whose elements are labeled by the n generalized coordinates $q^i$ and the $n$ generalized momenta $p_i$ is called the phase space</em>. The components of the generalized coordinates and momenta are collectively called the phase-space components</em>. The dynamical state of the system is completely specified by the phase-space state tuple $(t, q, p)$, given a Lagrangian or Hamiltonian to provide the map between velocities and momenta.</p> </blockquote> Computing Hamilton’s Equations</h3> ;; Implementation of Hamilton's Equations </span>(</span>defn </span>qp->H-state-path </span>[q p] </span> (</span>fn </span>[t] </span> (</span>up</span> t (</span>q</span> t) (</span>p</span> t)))) </span> </span>(</span>defn </span>my-Hamiltonian->state-derivative </span>[Hamiltonian] </span> (</span>fn </span>[H-state] </span> (</span>up </span>1 </span> (((</span>partial </span>2</span>) Hamiltonian) H-state) </span> (</span>- </span>(((</span>partial </span>1</span>) Hamiltonian) H-state))))) </span> </span>(</span>defn </span>my-Hamilton-equations </span>[Hamiltonian] </span> (</span>fn </span>[q p] </span> (</span>let </span>[state-path (</span>qp->H-state-path</span> q p)] </span> (</span>- </span>(</span>D</span> state-path) </span> (</span>compose </span>(</span>my-Hamiltonian->state-derivative</span> Hamiltonian) </span> state-path))))) </span></code></pre> #'user/my-Hamilton-equations </span></code></pre> ;; Free particle Hamtiltonian </span>(</span>defn </span>H-rectangular </span>[m V] </span> (</span>fn </span>[state] </span> (</span>let </span>[q (</span>coordinate</span> state) </span> p (</span>momentum</span> state)] </span> (</span>+ </span>(</span>/ </span>(</span>square</span> p) (</span>* </span>2</span> m)) </span> (</span>V </span>(</span>ref</span> q </span>0</span>) (</span>ref</span> q </span>1</span>)))))) </span> </span>(</span>rendermd </span>(</span>let </span>[V (</span>literal-function </span>'V (</span>-> </span>(</span>X</span> Real Real) Real)) </span> q (</span>up </span>(</span>literal-function </span>'x) </span> (</span>literal-function </span>'y)) </span> p (</span>down </span>(</span>literal-function </span>'p_x) </span> (</span>literal-function </span>'p_y))] </span> (((</span>Hamilton-equations </span>(</span>H-rectangular </span>'m V)) q p) 't))) </span></code></pre> $$ \begin{pmatrix}\displaystyle{0} \cr \cr \displaystyle{\begin{pmatrix}\displaystyle{\frac{m\,Dx\left(t\right) - p_x\left(t\right)}{m}} \cr \cr \displaystyle{\frac{m\,Dy\left(t\right) - p_y\left(t\right)}{m}}\end{pmatrix}} \cr \cr \displaystyle{\begin{bmatrix}\displaystyle{Dp_x\left(t\right) + \partial_0V\left(x\left(t\right), y\left(t\right)\right)} \cr \cr \displaystyle{Dp_y\left(t\right) + \partial_1V\left(x\left(t\right), y\left(t\right)\right)}\end{bmatrix}}\end{pmatrix} $$ </div> The zero in the first element of the structure of Hamilton’s equation residuals is just the tautology that time advances uniformly: the time function is just the identity, so its derivative is one and the residual is zero. The equations in the second element of the structure relate the coordinate paths and the momentum paths. The equations in the third element give the rate of change of the momenta in terms of the applied forces.</p> </blockquote> Section 2.12: Nonsingular Coordinates and Quaternions 2022-11-16T05:29:39+00:00 2.12 Nonsingular Coordinates and Quaternions</h3> The Euler angles provide a convenient way to parameterize the orientation of a rigid body. However, the equations of motion derived for them have singularities. Though we can avoid the singularities by using other Euler-like combinations with different singularities, this kludge is not very satisfying.</p> </blockquote> We know from Euler’s theorem that any orientation can be reached with a single rotation. Specifying this rotation requires specifying its axis and the angle of rotation.</p> </li> One possibility: Use latitude and longitude to define the axis. But this becomes undefined in the case of zero rotation</p> </li> Another possibility: Use a vector whose direction is that of the axis vector and whose length defines the amount of rotation. In this case, rotation by $2\pi$ is equal to no rotation at all. Every rotation can be represented by a countably infinite number of vectors, each with a length of $\theta + 2M\pi$ for an integer $M$. This makes it problematic to invert the mapping from other representations of rotation.</p> </li> A fix for the above point is to scale the vector by sine of half of the rotation angle. With this choice a rotation by zero angle will have the same orientation vector as a rotation by $2\pi$. But there is still another problem: rotations by $\theta$ and $2\pi - \theta$ are not distinguished. That is, a vector may represent both the “short-rotation” and the “long rotation” for the same orientation.</p> </li> We can solve this by keeping track of the cosine of half the angle of rotation (though in reality we just need the sign of the cosine). Wrapping this all up into 4-tuples gives us Hamilton’s quaternions</em>.</p> </li> </ul> For a rotation by angle $\theta$ about axis $\hat{n}$, the components of a quaternion defining the rotation are:</p> $$ (\cos(\theta/2),~\sin(\theta/2)\hat{n}_x,~\sin(\theta/2)\hat{n}_y,~\sin(\theta/2)\hat{n}_z) $$ </div> This is a unit quaternion as the sum of squares of its components is equal to one. The first element is called the “real part”, $r$, and the other three elements can form a tuple $v$ called the “imaginary part”. The angle of rotation can be obtained by computing $\theta = \arctan(\|v\|, r)$, and the axis direction is $v/\|v\|$.</p> The rotation represented by a quaternion is not changed by reversing the sign of all its components. This is because changing the sign of v reverses the axis but does not change the angle and changing the sign of the first component changes the angle $\theta$ to $2\pi − \theta$, so the actual rotation is unchanged.</li> </ul> DCM from Quaternion</h3> Given the four elements of a quaternion, we can do compute the corresponding rotation matrix. First we get the angle $\theta$ and axis, $\hat{n}$ when given a quaternion. We rotate by angle $\theta$ about the $z$ axis and then transform this rotation by a rotation to the axis specified by the colatitude ($\varphi$) and longitude ($\lambda$) of the axis $\hat{n}$:</p> $$ \mathbf{R}(\theta, \hat{n}) = \mathbf{R}_z(\lambda)\mathbf{R}_y(\varphi)~\mathbf{R}_z(\theta)~\mathbf{R}_y(\varphi)^\mathscr{T}\mathbf{R}_z(\lambda)^\mathscr{T} $$ </div> where $\varphi = \arccos(\hat{n_z})$ and $\lambda = \arctan(\hat{n}_y, \hat{n}_x)$.</p> (</span>defn </span>my-angle-axis->rotation-matrix </span>[theta n] </span> (</span>let </span>[nx (</span>ref</span> n </span>0</span>) </span> ny (</span>ref</span> n </span>1</span>) </span> nz (</span>ref</span> n </span>2</span>) </span> colatitude (</span>acos</span> nz) </span> longitude (</span>atan</span> ny nx)] </span> (</span>* </span>(</span>rotate-z-matrix</span> longitude) </span> (</span>rotate-y-matrix</span> colatitude) </span> (</span>rotate-z-matrix</span> theta) </span> (</span>transpose </span>(</span>rotate-y-matrix</span> colatitude)) </span> (</span>transpose </span>(</span>rotate-z-matrix</span> longitude))))) </span> </span>(</span>rendermd </span>(</span>my-angle-axis->rotation-matrix </span>(</span>/</span> pi </span>4</span>) (</span>up </span>0 0 1</span>))) </span></code></pre> $$ \mathsf{matrix-by-rows}\left(\begin{pmatrix}\displaystyle{0.7071067811865476} \cr \cr \displaystyle{-0.7071067811865475} \cr \cr \displaystyle{0}\end{pmatrix}, \begin{pmatrix}\displaystyle{0.7071067811865475} \cr \cr \displaystyle{0.7071067811865476} \cr \cr \displaystyle{0}\end{pmatrix}, \begin{pmatrix}\displaystyle{0.0} \cr \cr \displaystyle{0.0} \cr \cr \displaystyle{1}\end{pmatrix}\right) $$ </div> (</span>defn </span>quaternion->angle-axis </span>[q] </span> (</span>let </span>[v (</span>quat/three-vector</span> q) </span> sintheta (</span>sqrt </span>(</span>dot-product</span> v v)) </span> theta (</span>* </span>2 </span>(</span>atan</span> sintheta (</span>quat/real-part</span> q))) </span> axis (</span>/</span> v sintheta)] </span> (</span>up</span> theta axis))) </span> </span>;; Quaternion to DCM </span>(</span>defn </span>quaternion->DCM </span>[q] </span> (</span>let </span>[aa (</span>quaternion->angle-axis</span> q) </span> theta (</span>ref</span> aa </span>0</span>) </span> n (</span>ref</span> aa </span>1</span>)] </span> (</span>angle-axis->rotation-matrix</span> theta n))) </span> </span>;; 30 degrees about z axis </span>(</span>render </span>(</span>quaternion->DCM </span>(</span>quat/make </span>(</span>cos </span>(</span>/ </span>(</span>/</span> pi </span>6</span>) </span>2</span>)) </span>0 0 </span>(</span>sin </span>(</span>/ </span>(</span>/</span> pi </span>6</span>) </span>2</span>))))) </span></code></pre> matrix-by-rows(up(0.8660254037844387, -0.49999999999999994, 0), up(0.49999999999999994, 0.8660254037844387, 0), up(0.0, 0.0, 1)) </div> The matrix terms here are all divided by the magnitude of $q$ which can be ignored since we use unit quaternions. Once this is removed, we get the following form for the rotation matrix from a quaternion $(q_0, q_1, q_2, q_3)$:</p> $$ \begin{pmatrix}q_0^2 + q_1^2 - q_2^2 -q_3^2 & -2q_0q_3 + 2q_1q_2 & 2q_0q_2 + 2q_1q_3 \\ 2q_0q_3 + 2q_1q_2 & q_0^2 - q_1^2 + q_2^2 - q_3^2 & -2q_0q_1 + 2q_2q_3\\ -2q_0q_2 + 2q_1q_3 & 2q_0q_1 + 2q_2q_3 & q_0^2 - q_1^2 - q_2^2 + q_3^2\\ \end{pmatrix} $$ </div> (</span>defn </span>quaternion->rotation-matrix </span>[q] </span> (</span>let </span>[q-vec (</span>quat/->vector</span> q) </span> q0 (</span>ref</span> q-vec </span>0</span>) </span> q1 (</span>ref</span> q-vec </span>1</span>) </span> q2 (</span>ref</span> q-vec </span>2</span>) </span> q3 (</span>ref</span> q-vec </span>3</span>) </span> m-2 </span> (</span>+ </span>(</span>expt</span> q0 </span>2</span>) (</span>expt</span> q1 </span>2</span>) </span> (</span>expt</span> q2 </span>2</span>) (</span>expt</span> q3 </span>2</span>))] </span> (</span>/ </span>(</span>matrix-by-rows </span> (</span>list </span>(</span>- </span>(</span>+ </span>(</span>expt</span> q0 </span>2</span>) (</span>expt</span> q1 </span>2</span>)) </span> (</span>+ </span>(</span>expt</span> q2 </span>2</span>) (</span>expt</span> q3 </span>2</span>))) </span> (</span>* </span>2 </span>(</span>- </span>(</span></span> q1 q2) (</span></span> q0 q3))) </span> (</span>* </span>2 </span>(</span>+ </span>(</span></span> q1 q3) (</span></span> q0 q2)))) </span> (</span>list </span>(</span>* </span>2 </span>(</span>+ </span>(</span></span> q1 q2) (</span></span> q0 q3))) </span> (</span>- </span>(</span>+ </span>(</span>expt</span> q0 </span>2</span>) (</span>expt</span> q2 </span>2</span>)) </span> (</span>+ </span>(</span>expt</span> q1 </span>2</span>) (</span>expt</span> q3 </span>2</span>))) </span> (</span>* </span>2 </span>(</span>- </span>(</span></span> q2 q3) (</span></span> q0 q1)))) </span> (</span>list </span>(</span>* </span>2 </span>(</span>- </span>(</span></span> q1 q3) (</span></span> q0 q2))) </span> (</span>* </span>2 </span>(</span>+ </span>(</span></span> q2 q3) (</span></span> q0 q1))) </span> (</span>- </span>(</span>+ </span>(</span>expt</span> q0 </span>2</span>) (</span>expt</span> q3 </span>2</span>)) </span> (</span>+ </span>(</span>expt</span> q1 </span>2</span>) (</span>expt</span> q2 </span>2</span>))))) </span> m-2))) </span> </span>;; This function can be further used to compute the components of angular velocity using M->omega-body </span> </span>(</span>rendermat </span> ((</span>rigid/M->omega-body </span> (</span>compose</span> quaternion->rotation-matrix quat/make)) </span> (</span>up </span>'t </span> (</span>up </span>'q_0 'q_1 'q_2 'q_3) </span> (</span>up </span>'qdot_0 'qdot_1 'qdot_2 'qdot_3)))) </span></code></pre> $$ \begin{bmatrix}\displaystyle{\begin{pmatrix}\displaystyle{\frac{2\,q_0\,{\dot q}_1 -2\,q_1\,{\dot q}_0 -2\,q_2\,{\dot q}_3 + 2\,q_3\,{\dot q}_2}{{q_0}^{2} + {q_1}^{2} + {q_2}^{2} + {q_3}^{2}}} \cr \cr \displaystyle{\frac{2\,q_0\,{\dot q}_2 + 2\,q_1\,{\dot q}_3 -2\,q_2\,{\dot q}_0 -2\,q_3\,{\dot q}_1}{{q_0}^{2} + {q_1}^{2} + {q_2}^{2} + {q_3}^{2}}} \cr \cr \displaystyle{\frac{2\,q_0\,{\dot q}_3 -2\,q_1\,{\dot q}_2 + 2\,q_2\,{\dot q}_1 -2\,q_3\,{\dot q}_0}{{q_0}^{2} + {q_1}^{2} + {q_2}^{2} + {q_3}^{2}}}\end{pmatrix}}\end{bmatrix} $$ </div> Ignoring the denominator, the quaternion is independent of the scale of the quaternion. And since it is a fucntion of time, the rates of $q$ are also independent of scale. This can be further simplified by representing the products in the numerator as a matrix product. Define the following matrices:</p> $$ \begin{align} \mathbf{i} &= \begin{pmatrix}0 & +1 & 0 & 0\\ -1 & 0 & 0 & 0\\ 0 & 0 & 0 & -1\\ 0 & 0 & +1 & 0\\\end{pmatrix}\\ \mathbf{j} &= \begin{pmatrix}0 & 0 & +1 & 0\\ 0 & 0 & 0 & +1\\ -1 & 0 & 0 & 0\\ 0 & -1 & 0 & 0\\\end{pmatrix}\\ \mathbf{k} &= \begin{pmatrix}0 & 0 & 0 & +1\\ 0 & 0 & -1 & 0\\ 0 & +1 & 0 & 0\\ -1 & 0 & 0 & 0\\\end{pmatrix}\tag{2.125} \end{align} $$ </div> The angular velocity components can now be written as :</p> $$ \begin{align} \omega^a &= 2\mathscr{q}^\mathscr{T}\mathbf{i}\dot{\mathscr{q}}~/~\\|\mathscr{q}\\|^2\\ \omega^b &= 2\mathscr{q}^\mathscr{T}\mathbf{j}\dot{\mathscr{q}}~/~\\|\mathscr{q}\\|^2\\ \omega^c &= 2\mathscr{q}^\mathscr{T}\mathbf{k}\dot{\mathscr{q}}~/~\\|\mathscr{q}\\|^2\\ \end{align} $$ </div> where $\mathscr{q}$ is a column vector of the components of $q$. The anti-symmetric matrices $\mathbf{i}$, $\mathbf{j}$ and $\mathbf{k}$ have the interesting properties that make it the basis vectors for the quaternions:</p> $$ \mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -\mathbf{1} $$ </div> where $\mathbf{1}$ is the identity matrix.</p> Composition of rotations</h3> An easy way to compose ttwo rotations would be to convert ehm to DCMs and multiply them. However this results in a very messy results where each component is scaled by a factor of $\|q\|\|p\|$ (which is equal to $1$ for unit quaternions). Eliminating this scale factor, we get the following form for composition of quaternions</p> $$ \begin{pmatrix} p_0q_0-p_1q_1-p_2q_2-p_3q_3\\ p_0q_1+p_1q_0-p_2q_3+p_3q_2\\ p_0q_2+p_1q_3+p_2q_0-p_3q_1\\ p_0q_3-p_1q_2+p_2q_1+p_3q_0\\ \end{pmatrix} $$ </div> This can be re-stated as:</p> $$ r_0 = q_0p_0 - v_q \cdot v_p\\ $$ </div> $$ v_r = q_0v_p+p_0v_q + v_q \times v_p\\ $$ </div> where $r_0$ is the scalar part of the result, $v_r$ is the vector part of the result and $v_p$ and $v_q$ are the vector parts of the original quaternions. This can be considered to be the product of the two quaternions.</p> $$ \mathbf{r} = \mathbf{q}\mathbf{p} $$ </div> Section 2.11.1: Spin-Orbit Coupling - Development of Potential Energy 2022-11-13T20:54:32+00:00 2.11 Spin Orbit Coupling</h2> The rotation of planets and natural satellites is affected by the gravitational forces from other celestial bodies. As an extended application of the Lagrangian method for forced rigid bodies, we consider the rotation of celestial objects subject to gravitational forces.</p> </blockquote> In this section, we will develop expressions for potential energy for the graviational interaction of an “extended body” (i.e. not a point mass) with an external point mass. Combined with the rigid body kinetic energy, this can be used to create Lagrangians that model a number of systems.</p> 2.11.1 Development of the Potential Energy</h3> The rigid body can be modeled as a collection of particles subject to rigid constraints. Similar to the kinetic energy decribed in the previous section, the potential energy of a rigid body can also be expressed in terms of the moment of inertia and later expressed in terms of generalized coordinates.</p> </p> Figure 2.9 The gravitational potential energy of a point mass and a rigid body is the sum of the gravitational potential energy of the point mass with each constituent mass element of the rigid body.</strong></p> The gravitational potential energy of a rigid body is the sum of the potential energies of the individual point masses that make up the rigid body.</p> $$ V = - \sum_\alpha \frac{G M' m_\alpha}{r_\alpha} $$ </div> where $M’$ is the mass of the external point mass that is the source of the gravity, $r_\alpha$ is the distance from the point mass to the component particle in the rigid body and $G$ is the universal gravitational constant. The position of the component particle can be resolved as:</p> $$ \vec{r}_alpha = \vec{R} - \vec{\xi}_\alpha\\ $$ </div> where $\vec{R}$ is the vector from the external point mass to the center of mass of the rigid body. With this formulation, the distance to the particle, $r_\alpha$ becomes, $r_\alpha = R^2 + \xi^2_\alpha - 2R\xi_\alpha \cos\theta_\alpha$, where $\theta_\alpha$ is the angle between the lines from the center of mass to the constituent particle and to the point mass (see Figure 2.9).</p> Given that this is a three-dimensional body, $\xi_\alpha$ and $\theta_\alpha$ cannot uniquely specify the p0osition of the constituent particle. However, these are the only parameters required to define the potential energy as it is simply a function of the distance between the particle and the distant point mass. The potential energy is therefore defined as:</p> $$ \begin{eqnarray} V &= -GM' \sum_\alpha \frac{m_\alpha}{\left(R^2 + \xi^2_\alpha - 2R\xi_\alpha \cos\theta_\alpha\right)^{1/2}}\\ &= -GM' \sum_\alpha m_\alpha \left(R^2 + \xi^2_\alpha - 2R\xi_\alpha \cos\theta_\alpha\right)^{-1/2} \end{eqnarray} $$ </div> This can be expanded using Legendre Polynomials</a>. The Legendre polynomials $P_l$ may be obtained by expanding the expression $(1 + y^2 − 2yx)^{1/2}$ as a power series in $y$. The coefficient of $y_l$ is $P_l(x)$. The first few Legendre polynomials are: $P_0(x) = 1$, $P_1(x) = x$, $P_2(x)=\frac{3}{2}x^2−\frac{1}{2}$ , and so on. Then we get the following expression for potential energy:</p> $$ V = \frac{-GM'}{R} \sum_\alpha m_\alpha \sum_l \frac{\xi^l_\alpha}{R^l}P_l \cos(\theta_\alpha) $$ </div> Successive terms in this expansion typically drop off quickly since the distance between celestial bodies are vastly bigger than their size. Each term in the series has an upper bound. This is because the Legendre polynomials all have a magnitude less than one for arguments between -1 and 1 (which $\cos(\theta_\alpha)$ satisfies), and the distances $\xi_\alpha$ are all less than some maximum size $\xi_{max}$. Therefore, the sum over $m_\alpha$ times the upper bounds of each term is just $M$ times the upper bounds. Therefore,</p> $$ \left\|\sum_\alpha m_\alpha \frac{\xi^l_\alpha}{R^l}P_l \cos(\theta_\alpha)\right\| \leq M \frac{\xi^l_{max}}{R^l} $$ </div> Successive terms decrease by a factor of $\frac{\xi_{max}}{R}$. A body with a sufficiently strong gravitational force overcomes the material strength of the rigid body and converts it into a sphere over time. The higher order terms in the series are measuring the deviation of the rigid body from a sphere. We can truncate the series to different values of $l$ based on the fidelity required.</p> When $l=0$, the sum over $\alpha$ gives the total mass $M$ of the rigid body. For $l=1$, the sum is zero because $\vec{\xi}_\alpha$ is defiend relative to the center of mass. For $l=2$, the sum can be written in terms of the moment of inertia of the body as:</p> $$ \begin{align} \sum_\alpha m_\alpha \xi^2_\alpha P_2 \cos(\theta_\alpha) &= \sum_\alpha m_\alpha \xi^2_\alpha\left(\frac{3}{2}\cos^2\theta_\alpha -\frac{1}{2} \right)\\ &= \sum_\alpha m_\alpha \xi^2_\alpha\left(\frac{3}{2}(1 - \sin^2\theta_\alpha) -\frac{1}{2} \right)\\ &= \sum_\alpha m_\alpha \xi^2_\alpha\left((1 - \frac{3}{2}\sin^2\theta_\alpha) \right)\\ &= \frac{1}{2}( A + B + C - 3I )\tag{2.97} \end{align} $$ </div> where $A, B, C$ are the principal moments of inertia and $I$ is the moment of inertia of the body about the line between the center of mass of the body and the external point mass. $I$ depends on the orientation of the body w.r.t line between the bodies. Therefore, the potential energy of the body with terms up to $l=2$ is:</p> $$ V = \frac{-GM M'}{R} - \frac{GM'}{R} \left( A + B + C - 3I \right)\tag{2.98} $$ </div> This is also called MacCullagh’s formula</em>.</p> </p> Figure 2.10: The orientation of the rigid body is specified by the three angles from the line between the centers and the principal axes.</strong></p> Figure 2.10 shows a method for computing $I$ in terms of the principal moment of inertia. Let $\theta_a$, $\theta_b$, and $\theta_c$, are the angles of the principal axes $\hat{a}, \hat{b}, \hat{c}$, respectively, from the line connecting the center of mass and the point mass. Then $I$ can be found to be:</p> $$ I = A \cos^2\theta_a + B \cos^2\theta_b + C \cos^2\theta_c\\ $$ </div> The potential energy is then:</p> $$ V = \frac{-GM M'}{R} - \frac{GM'}{R} \left[ (1-3\cos^2\theta_a)A + (1-3\cos^2\theta_b)B + (1-3\cos^2\theta_c)C\right]\tag{2.99} $$ </div> Exercise 2.13: Bicycle Wheel (incomplete) 2022-11-13T20:15:14+00:00 Exercise 2.13: Bicycle Wheel</h3> a. Imagine that you are holding a bicycle wheel by the axle (in both hands) and the wheel is spinning so that the top edge is going away from your face. If you torque the wheel by pushing down with your right hand and pulling up with your left hand the wheel will precess. Which way does it try to turn?</strong></p> $$\require{cancel}$$</p> Assume that the axle of the wheel forms the $z$ axis of the system (positive to the right). Let the $x$ axis point forward, and the $y$ axis point up, forming a right-handed coordinate system. The bicycle wheel starts spinning about the axle with some speed $\omega^c$. Therefore the angular velocity vector is:</p> $$ \vec{\omega} = \omega^c \hat{z} $$ </div> Pushing the axle down on the right side and pulling it up on the left equals a positive torque about the $x$ axis, that is,</p> $$ \vec{T} = \mathbf{T}_a \hat{x} $$ </div> From Eq. 2.83 in the book</p> $$ \begin{align} A D \omega^a - \left(B - C\right) \omega^b \omega^c &= \mathbf{T}_a\tag{2.83a}\\ B D \omega^b - \left(C - A\right) \omega^c \omega^a &= \mathbf{T}_b\tag{2.83b}\\ C D \omega^c - \left(A - B\right) \omega^a \omega^b &= \mathbf{T}_c\tag{2.83c}\\ \end{align} $$ </div> Substituting $A = B$ (as the wheel is symmetric) and $\mathbf{T}_c = 0$ in Eq. 2.83c, we find that $D \boldsymbol{\omega^c} = 0$ which means that $\omega^c$ is a constant. Substituting $\mathbf{T}_b = 0$ and $A = B$ in Eq.2.83b,</p> $$ \begin{align} \overbrace{B}^{=A} D \omega^b - \left(C - A\right) \omega^c \omega^a &= 0\\ \frac{ A D \omega^b}{\left(C - A\right)\omega^c} &= \omega^a\\ \frac{A}{K_1} D \omega^b = \omega^a \end{align} $$ </div> where $K_1 = (C - A)\omega^c$. Substituting $\omega^a$ in Eq.2.83a, along with $A = B$,</p> $$ \begin{align} \mathbf{T}_a &= A D \omega^a - \left(\overbrace{B}^{=A} - C\right) \omega^b \omega^c\\ &= A D ( \frac{A}{K_1} D \omega^b ) - (A - C) \omega^c \omega^b\\ &= \frac{A^2}{K_1} D^2 \omega^b + K_1 \omega^b\\ \mathbf{T}_a &= \frac{ A^2 }{K_1} D^2 \omega^b + K_1 \omega^b\\ K_1 \mathbf{T}_a &= A^2 D^2 \omega^b + K_1^2 \omega^b \end{align} $$ </div> This shows that the $\omega^b$ has a motion governed by a second order differential equation dependent on the magnitude of torque applied about the $x$ axis. So the bicycle wheel will try to precess about the $y$ axis (i.e. turn left/right).</p> b. A free bicycle wheel rolls on a horizontal surface. If it starts to tilt, the torque from gravity will cause the wheel to turn. Which way will it turn? The reasoning that applied to part a does not directly apply to the rolling bicycle wheel, which is not a holonomic system. However, it is interesting to think about whether the behavior of the two systems is related.</strong></p> </span></code></pre> Exercise 2.12: Derivation of Euler Angle Kinematics 2022-11-13T07:06:08+00:00 Exercise 2.12: Derivation of Euler Angle Kinematics</h3> Fill in the details of the derivation of equation (2.73). You may want to use the computer to help with the algebra.</strong></p> $$ \begin{pmatrix}D\theta \\ D\varphi \\ D\psi \end{pmatrix} = \frac{1}{\sin\theta} \begin{pmatrix} \cos\psi \sin\theta & -\sin\psi\sin\theta & 0 \\ \sin\psi & \cos\psi & 0 \\ -\sin\psi \cos\theta & -\cos\psi\cos\theta & \sin\theta \\ \end{pmatrix}\begin{pmatrix}\omega^a \\ \omega^b \\ \omega^c\end{pmatrix}\tag{2.73} $$ </div> Note how the order of $\theta$, $\varphi$ and $\psi$ are different in the vector</strong></p> $$\require{cancel}$$</p> With 3-1-3 Euler angles, $\mathbf{M}$ is defined as:</p> $$ \mathbf{M} = \mathbf{R}_z(\varphi)\cdot\mathbf{R}_x(\theta)\cdot\mathbf{R}_z(\psi)\\ $$ </div> For 3-1-3 Euler angles, there are three rotations with two intermediate frames starting from the inertial frame. Let the inertial frame be represented by the $\hat{a}$, the frame after first rotation by $\hat{b’}$, and the frame after the second rotation by $\hat{b’’}$. Let $\hat{b}$ represent the final “body-frame”.</p> Therefore, ${}^{A}\omega^{B’} = \dot{\varphi} \hat{a}_3 = \dot{\varphi} \hat{b}_3’$, $^{B’}\omega^{B’‘} = \dot{\theta} \hat{b}_1’ = \dot{\theta} \hat{b}_1’‘$ and $^{B’‘}\omega^{B} = \dot{\psi} \hat{b}_3’’ = \dot{\psi} \hat{b}_3$ .</p> The total angular velocity is the sum of all three components, that is,</p> $$ \begin{align} ^{A}\vec{\omega}^{B} &=~^{A}\omega^{B'} +~^{B'}\omega^{B''} +~^{B''}\omega^{B} \\ &=\dot{\varphi} \hat{b}_3' + \dot{\theta} \hat{b}_1'' + \dot{\psi} \hat{b}_3 \\ \end{align} $$ </div> To get the components in body-frame, we need to convert $\hat{b}_3’$ and $\hat{b}_1’’$ to be in terms of $\hat{b}$.</strong></p> We know that the $\hat{b}$‘’ rotated about its $z$ axis, forms the body-frame, $\hat{b}$. Therefore, (need to draw coordinate frame rotations to get this expression)</p> $$ \begin{pmatrix}\hat{b}_1''\\ \hat{b}_2'' \\ \hat{b}_3''\end{pmatrix} = \begin{pmatrix}\cos\psi & -\sin\psi & 0\\ \sin\psi & \cos\psi & 0 \\0 & 0 & 1\\ \end{pmatrix} \begin{pmatrix}\hat{b}_1\\ \hat{b}_2 \\ \hat{b}_3\end{pmatrix} $$ </div> $$ \begin{align} \hat{b}_1'' &= \cos{\psi}~\hat{b}_1 - \sin\psi~\hat{b}_2\\ \hat{b}_2'' &= \sin{\psi}~\hat{b}_1 + \cos\psi~\hat{b}_2\\ \hat{b}_3'' &= \hat{b}_3 \end{align} $$ </div> Similarly, for the $\hat{b}’$ frame,</p> $$ \begin{pmatrix}\hat{b}_1'\\ \hat{b}_2' \\ \hat{b}_3'\end{pmatrix} = \begin{pmatrix} 1 & 0 & 0\\ 0 & \cos\theta & -\sin\theta\\ 0 & \sin\theta & \cos\theta\\ \end{pmatrix} \begin{pmatrix}\hat{b}''_1\\ \hat{b}''_2 \\ \hat{b}''_3\end{pmatrix} $$ </div> $$ \begin{align} \hat{b}_3' &= \sin\theta~\hat{b}_2'' + \cos\theta~\hat{b}_3''\\ &= \sin\theta\left(\sin{\psi}~\hat{b}_1 + \cos\psi~\hat{b}_2\right) + \cos\theta~\hat{b}_3\\ &= \sin\theta\sin{\psi}~\hat{b}_1 + \sin\theta\cos\psi~\hat{b}_2 + \cos\theta~\hat{b}_3\\ \end{align} $$ </div> Assuming that the body-frame is the principal axes frame, the angular velocity vector is:</p> $$ \begin{align} \vec{\omega} &= \dot{\varphi} \hat{b}_3' + \dot{\theta} \hat{b}_1'' + \dot{\psi} \hat{b}_3 \\ &= \dot{\varphi} \left(\sin\psi \sin\theta~\hat{b}_1 + \cos\psi\sin\theta~\hat{b}_2 + \cos\theta~\hat{b}_3 \right) + \dot{\theta}\left(\cos{\psi}~\hat{b}_1 - \sin\psi~\hat{b}_2\right) + \dot{\psi}~\hat{b}_3\\ \omega^a \hat{b}_1 + \omega^b \hat{b}_2 + \omega^c \hat{b}_3 &= (\sin\psi \sin\theta\dot{\varphi} + \dot{\theta} \cos{\psi})~\hat{b}_1 + \left( + \cos\psi \sin{\theta}\dot{\varphi} - \dot{\theta}\sin\psi\right)\hat{b}_2 + \left( \dot{\varphi}\cos\theta + \dot{\psi} \right)\hat{b}_3 \end{align} $$ </div> This can be written in matrix form as:</p> $$ \begin{pmatrix}\omega^a \\ \omega^b \\ \omega^c\end{pmatrix} = \begin{pmatrix} \sin\psi \sin\theta & \cos{\psi} & 0\\ \cos\psi\sin\theta & -\sin\psi & 0\\ \cos\theta & 0 & 1 \end{pmatrix} \begin{pmatrix}\dot{\varphi} \\ \dot{\theta} \\ \dot{\psi}\end{pmatrix} $$ </div> Inverting this equation, we get:</p> theta, phi, psi = </span>symbols</span>('</span>theta phi psi</span>', </span>real</span>=</span>True</span>) </span>A = </span>Matrix</span>([ [</span>sin</span>(psi)</span>sin</span>(theta), </span>cos</span>(psi), </span>0</span>], [</span>cos</span>(psi)</span>sin</span>(theta), -</span>sin</span>(psi), </span>0</span>], [</span>cos</span>(theta), </span>0</span>, </span>1</span>] ]) </span>simplify</span>(A.</span>inv</span>()) </span></code></pre> $\displaystyle \left[\begin{matrix}\frac{\sin{\left(\psi \right)}}{\sin{\left(\theta \right)}} & \frac{\cos{\left(\psi \right)}}{\sin{\left(\theta \right)}} & 0\\\cos{\left(\psi \right)} & - \sin{\left(\psi \right)} & 0\\- \frac{\sin{\left(\psi \right)}}{\tan{\left(\theta \right)}} & - \frac{\cos{\left(\psi \right)}}{\tan{\left(\theta \right)}} & 1\end{matrix}\right]$ </div> Therefore,</p> $$ \begin{pmatrix}\dot{\varphi} \\ \dot{\theta} \\ \dot{\psi}\end{pmatrix} = \frac{1}{\sin\theta}\begin{pmatrix} \sin\psi & \cos{\psi} & 0\\ \cos\psi\sin\theta & -\sin\psi\sin\theta & 0\\ -\sin\psi\cos\theta & -\cos\psi\cos\theta & \sin\theta \end{pmatrix}\begin{pmatrix}\omega^a \\ \omega^b \\ \omega^c\end{pmatrix} $$ </div> Swapping the rows 1 and 2 to match the order in the question, we get:</p> $$ \begin{pmatrix}D\theta \\ D\varphi \\D\psi\end{pmatrix} = \begin{pmatrix}\dot{\theta} \\ \dot{\varphi} \\\dot{\psi}\end{pmatrix} = \frac{1}{\sin\theta}\begin{pmatrix} \cos\psi\sin\theta & -\sin\psi\sin\theta & 0\\ \sin\psi & \cos{\psi} & 0\\ -\sin\psi\cos\theta & -\cos\psi\cos\theta & \sin\theta \end{pmatrix}\begin{pmatrix}\omega^a \\ \omega^b \\ \omega^c\end{pmatrix} $$ </div> References</h3> [1] : https://www.youtube.com/watch?v=af041z8jujU</a></p> Exercise 2.11: Conservation of Angular Momentum 2022-11-12T22:10:11+00:00 Exercise 2.11: Conservation of Angular Momentum</h3> Fill in the details of the argument that Noether’s theorem implies that vector angular momentum is conserved by the motion of the free rigid body.</strong></p> $$\require{cancel}$$</p> According to Noether’s theorem</a>, for any continuous symmetry in a system (aka a parametric family of symmetries), there is a conserved quantity.</p> In the case of rigid bodies, rotations about any axis is a symmetry. This can be proved as shown below:</p> The Lagrangian in rectangular coordinates for a rigid body with particles indexed by $\alpha$ is:</p> $$ L(t; x,y,z; v_x, v_y, v_z) = \frac{1}{2} \sum_\alpha m_\alpha \left( \dot{x}_\alpha^2 + \dot{y}_\alpha^2 + \dot{z}_\alpha^2\right) \tag{1} $$ </div> Consider a parameteric rotation about the $z$-axis:</p> $$ \begin{pmatrix}x_\alpha \\y_\alpha \\z_\alpha \end{pmatrix} = R_z(s)\begin{pmatrix}x_\alpha' \\y_\alpha' \\z_\alpha' \end{pmatrix} = \begin{pmatrix}x_\alpha' \cos{s} - y_\alpha'\sin{s}\\x_\alpha' \sin{s} + y_\alpha'\cos{s}\\z_\alpha'\end{pmatrix}\tag{2} $$ </div> Since a rotation is an orthogonal transformation, it does not change the magnitude of the vector,</p> $$ x_\alpha^2 + y_\alpha^2 + z_\alpha^2 = (x_\alpha')^2 + (y_\alpha')^2 + (z_\alpha')^2\\ $$ </div> Similarly, differentiating Eq.2 along a path, we get:</p> $$ \begin{pmatrix}\dot{x}_\alpha\\ \dot{y}_\alpha\\ \dot{z}_\alpha\end{pmatrix} = R_z(s)\begin{pmatrix}\dot{x}_\alpha'\\ \dot{y}_\alpha'\\ \dot{z}_\alpha'\end{pmatrix} $$ </div> Therefore,</p> $$ \dot{x}_\alpha^2 + \dot{y}_\alpha^2 + \dot{z}_\alpha^2 = \dot{x}_\alpha'^2 + \dot{y}_\alpha'^2 + \dot{z}_\alpha'^2 $$ </div> Combining these, we can see that the post-transformation Lagrangian $L’$ is:</p> $$ L'(t; x_\alpha',y_\alpha',z_\alpha'; \dot{x}_\alpha',\dot{y}_\alpha',\dot{z}_\alpha') = \frac{1}{2} \sum_\alpha m \left(\dot{x}_\alpha'^2 + \dot{y}_\alpha'^2 + \dot{z}_\alpha'^2 \right)\tag{3} $$ </div> Therefore $L’$ in Eq.3 is the exact same function as $L$ in Eq. 1 and hence there is a conserved value corresponding to the rotational symmetry about the z-axis. The momenta are defined as:</p> $$ \partial_2 L = \left[\sum_\alpha m_\alpha \dot{x}, \sum_\alpha m_\alpha \dot{y}, \sum_\alpha m_\alpha \dot{z}\right] $$ </div> and</p> $$ D\widetilde{F}(0)(t;x,y,z)=D\widetilde{R}_z(0)(x,y,z) = [ y, -x, 0]\\ $$ </div> Therefore the Noether integral is:</p> $$ \begin{align} \mathscr{I}(t; x_\alpha,y_\alpha,z_\alpha; \dot{x}_\alpha,\dot{y}_\alpha,\dot{z}_\alpha) &= ((\partial_2 L)(D\widetilde{F}(0))) (t; x_\alpha,y_\alpha,z_\alpha; \dot{x}_\alpha,\dot{y}_\alpha,\dot{z}_\alpha) \\ &= \sum_\alpha \left(m_\alpha \dot{x}_\alpha~y_\alpha -m_\alpha \dot{y}_\alpha~x_\alpha + (m_\alpha \dot{z}_\alpha)(0) \right) \\ &= \sum_\alpha m_\alpha \left(y_\alpha \dot{x}_\alpha - x_\alpha \dot{y}_\alpha \right) \end{align} $$ </div> This is the $z$ component of the angular momentum vector $\sum_\alpha \vec{\xi_\alpha} \times (m_\alpha \dot{\vec{\xi}}_\alpha)$</p> In the following program, we compute the noether integrals for rotations around all three coordinate axes.</p> (</span>defn </span>RotX </span>[angle] </span> (</span>fn </span>[[x</span>,</span> y</span>,</span> z]] </span> (</span>let </span>[ca (</span>cos</span> angle) </span> sa (</span>sin</span> angle)] </span> (</span>up</span> x </span> (</span>- </span>(</span></span> ca y) (</span></span> sa z)) </span> (</span>+ </span>(</span></span> sa y) (</span></span> ca z)))))) </span> </span>(</span>defn </span>RotY </span>[angle] </span> (</span>fn </span>[[x</span>,</span> y</span>,</span> z]] </span> (</span>let </span>[ca (</span>cos</span> angle) </span> sa (</span>sin</span> angle)] </span> (</span>up </span>(</span>+ </span>(</span></span> ca x) (</span></span> sa z)) </span> y </span> (</span>+ </span>(</span>- </span>(</span></span> sa x)) (</span></span> ca z)))))) </span> </span>(</span>defn </span>RotZ </span>[angle] </span> (</span>fn </span>[[x</span>,</span> y</span>,</span> z]] </span> (</span>let </span>[ca (</span>cos</span> angle) </span> sa (</span>sin</span> angle)] </span> (</span>up </span>(</span>- </span>(</span></span> ca x) (</span></span> sa y)) </span> (</span>+ </span>(</span></span> sa x) (</span></span> ca y)) </span> z)))) </span> </span>;; Coordinate transformation with three angular "inputs" for rotations about </span>;; all three axes </span>;; Composing with `coordinate`, extracts the second element of the tuple that is passed in as the argument </span>(</span>defn </span>F-tilde </span>[angle-x angle-y angle-z] </span> (</span>compose </span>(</span>RotX</span> angle-x) (</span>RotY</span> angle-y) (</span>RotZ</span> angle-z) coordinate)) </span> </span>;; Lagrangian for motion of single particle in rigid body </span>(</span>defn </span>L-rigid-body_particle </span>[m] </span> (</span>fn </span>[[t q v]] </span> (</span>- </span>(</span>* </span>1/2</span> m (</span>square</span> v))))) </span> </span>;; Define the Noether integral </span>(</span>def </span>the-Noether-integral </span> (</span>let </span>[L (</span>L-rigid-body_particle </span>'m_alpha)] </span> (</span>* </span>((</span>partial </span>2</span>) L) ((</span>D</span> F-tilde) </span>0 0 0</span>)))) </span> </span> </span>(</span>rendertex </span>(</span>the-Noether-integral </span> (</span>up </span>'t </span> (</span>up </span>'x_alpha 'y_alpha 'z_alpha) </span> (</span>up </span>'xdot_alpha 'ydot_alpha 'zdot_alpha)))) </span></code></pre> \begin{bmatrix}\displaystyle{- m_{\alpha}\,y_{\alpha}\,{\dot z}_{\alpha} + m_{\alpha}\,{\dot y}_{\alpha}\,z_{\alpha}} \cr \cr \displaystyle{m_{\alpha}\,x_{\alpha}\,{\dot z}_{\alpha} - m_{\alpha}\,{\dot x}_{\alpha}\,z_{\alpha}} \cr \cr \displaystyle{- m_{\alpha}\,x_{\alpha}\,{\dot y}_{\alpha} + m_{\alpha}\,{\dot x}_{\alpha}\,y_{\alpha}}\end{bmatrix} </div> The results above correspond to the components of the angular momentum vector for a single particle in a rigid body. Therefore the conserved quantities for a rigid body are:</p> $$ \begin{align} \sum_\alpha m_\alpha & \left( z_\alpha{\dot{y}_\alpha} - \dot{z}_\alpha y_\alpha \right)\\ \sum_\alpha m_\alpha & \left( x_\alpha{\dot{z}_\alpha} - \dot{x}_\alpha z_\alpha \right)\\ \sum_\alpha m_\alpha & \left( y_\alpha{\dot{x}_\alpha} - \dot{y}_\alpha x_\alpha \right)\\ \end{align} $$ </div> This proves that all three components of the angular moementum vector are conserved for a rigid body in free-rotation.</p> Section 2.9: Euler's Equations 2022-11-09T07:13:05+00:00 2.9 Euler’s Equations</h2> For a free rigid body we have seen that the components of the angular momentum on the principal axes comprise a self-contained dynamical system: the variation of the principal axis components depends only on the principal axis components. Here we derive equations that govern the evolution of these components.</p> </blockquote> The components of angular momentum (in column matrix form) on the principal axes are:</p> $$ \overline{\mathbf{L}}' = \mathbf{I}'\boldsymbol{\omega}'\\ $$ </div> where $\boldsymbol{\omega}‘$ are the angular velocity components on the principal axes and $\mathbf{I}’$ is the diagonal inertia tensor in the principal axes basis:</p> $$ \mathbf{I}' = \begin{bmatrix}A & 0 & 0 \\ 0 & B & 0 \\ 0 & 0 & C\end{bmatrix} $$ </div> If $\mathbf{M}$ is the rotation that rotates all vectorsand the body from the fixed reference frame to the actual orientation, then the components of angualr momentum in the inertial frame $\hat{e}_i$ are:</p> $$ \mathbf{L} = \mathbf{M} \mathbf{\overline{L}} $$ </div> For a free rigid vody, the vector angular momentum and therefore its components in the inertial frame are conserved. Therefore:</p> $$ \begin{align} D\mathbf{L} = D (\mathbf{M} \mathbf{\overline{L}}') &= D\mathbf{M}\mathbf{\overline{L}}' + \mathbf{M} D\mathbf{\overline{L}'}\\ \implies \mathbf{M} D\mathbf{\overline{L}'} &= -D\mathbf{M}\mathbf{\overline{L}}'\\ D\mathbf{\overline{L}'} &= -\mathbf{M}^{\mathscr{T}} D\mathbf{M}\mathbf{\overline{L}}'\tag{2.65} \end{align} $$ </div> From section 2.2</a>, we know that the components of the angular velocity can be written as:</p> $$ \begin{align} \boldsymbol{\omega}' &= \mathbf{M}^\mathscr{T} \mathscr{A}^{-1}(D \mathbf{M} \mathbf{M}^\mathscr{T}) \tag{2.21}\\ \implies \mathbf{M}\boldsymbol{\omega}' &= \mathscr{A}^{-1}(D \mathbf{M} \mathbf{M}^\mathscr{T}) \tag{2.21a}\\ \implies \mathscr{A}(\mathbf{M}\boldsymbol{\omega}') &= D \mathbf{M} \mathbf{M}^\mathscr{T} \tag{2.21b}\\ \implies \mathscr{A}(\mathbf{M}\boldsymbol{\omega}')\mathbf{M} &= D \mathbf{M} \tag{2.21c}\\ \end{align} $$ </div> Substituting Eq.2.21c in Eq.2.65 along with $\mathbf{I}‘\boldsymbol{\omega}’ = \overline{\mathbf{L}}’$</p> $$ \begin{align} \mathbf{I}' D\boldsymbol{\omega}' &= -\mathbf{M}^{\mathscr{T}} D\mathbf{M}\mathbf{I}'\boldsymbol{\omega}'\\ &= -\mathbf{M}^{\mathscr{T}} \mathscr{A}(\mathbf{M}\boldsymbol{\omega}') \mathbf{M}~ \mathbf{I}'\boldsymbol{\omega}' \tag{2.66} \end{align} $$ </div> Note</strong>: The function $\mathscr{A}$ converts a vector into an anti-symmetric matrix. Multiplying this matrix with a vector is equivalent to taking a cross product of the original vector with this second vector. We also know that rotating the cross product of two vectors gives the same vector as is obtained by taking the cross product of two rotated vectors, or $R(\vec{u} \times \vec{v}) = (R\vec{u} )\times(R\vec{v})$</p> These two terms can be written in terms of $\mathscr{A}$ as:</p> $$ R(\vec{u} \times \vec{v}) = \mathbf{R} \mathscr{A}(\mathbf{u}) \mathbf{v} $$ </div> $$ (R\vec{u})\times(R\vec{v}) = \mathscr{A}(\mathbf{R} \mathbf{u}) \mathbf{R}\mathbf{v}\\ $$ </div> $$ \begin{align} \implies \mathbf{R} \mathscr{A}(\mathbf{u}) \mathbf{v} &= \mathscr{A}(\mathbf{R} \mathbf{u}) \mathbf{R} \mathbf{v}\\ \implies \mathbf{R} \mathscr{A}(\mathbf{u}) &= \mathscr{A}(\mathbf{R} \mathbf{u}) \mathbf{R}\\ \mathscr{A}(\mathbf{u}) &= \mathbf{R}^{\mathscr{T}} \mathscr{A}(\mathbf{R} \mathbf{u}) \mathbf{R}\tag{2.67}\\ \end{align} $$ </div> Substituting Eq. 2.67 in Eq. 2.66:</p> $$ \begin{align} \mathbf{I}' D\boldsymbol{\omega}' &= - \mathscr{A}(\boldsymbol{\omega}') \mathbf{I}'\boldsymbol{\omega}' \tag{2.68} \end{align} $$ </div> This is the matrix form of Euler’s Equations</strong> that gives the derivative of the body components of angular velocity entirely in terms of the angular velocity components and the principal moments of inertia. If the components of $\boldsymbol{\omega}’$ are $(\omega^a, \omega^b, \omega^c)$, then the equations can be re-written as:</p> $$ \begin{align} A D\omega^a &= (B - C) \omega^b \omega^c\\ B D\omega^b &= (C - A) \omega^c \omega^a\\ C D\omega^c &= (A - B) \omega^a \omega^b\tag{2.69}\\ \end{align} $$ </div> These equations can also be written in terms of the components of angular momentum as:</p> $$ \begin{align} D L_a &= \left(\frac{1}{C} - \frac{1}{B}\right) L_b L_c\\ D L_b &= \left(\frac{1}{A} - \frac{1}{C}\right) L_c L_a\\ D L_c &= \left(\frac{1}{B} - \frac{1}{A}\right) L_a L_b\tag{2.69}\\ \end{align} $$ </div> These equations only</em> depend on the principal axes components of $L$. Equations 2.21b and 2.67 can be used to get the derivatives of the orientation of the body in terms of the angular velocity.</p> $$ \begin{align} D \mathbf{M} &= \mathscr{A}(\mathbf{M}\boldsymbol{\omega}')\mathbf{M}\tag{2.21c}\\ &= \mathbf{M} \overbrace{\mathbf{M}^{\mathscr{T}}~\mathscr{A}(\mathbf{M}\boldsymbol{\omega}')\mathbf{M}}^{\text{Refer Eq. 2.67}}\\ &= \mathbf{M} \mathscr{A}(\boldsymbol{\omega}') \end{align} $$ </div> $$ D\mathbf{M} = \mathbf{M}\mathscr{A}(\boldsymbol{\omega}')\tag{2.71} $$ </div> When the orientation of the body is represented by a DCM, this gives nine ordinary differential equations. These equations can be integrated witht eh initial conditions determined by the initial configuration matrix to get the evolution of the spatial orientation of the body. Combined with Euler’s equations, these equations completely definet the motion of a rigid body.</p> However, having to integrate nine equations is rather cumbersome when we know that the orientation can be represented by just three states (the Euler angles). In order to reduce this to a system of three equations we can go back to parameterizing the rotation matrix with the Euler angles. We can form the matrix $\mathbf{M}$ by composing $\mathscr{M}$ with an Euler coordinate path (i.e. write it as the product of three rotation matrices, $R_z$, $R_x$ and $R_z$). We can then solve for $D\theta$, $D\phi$ and $D\psi$ as:</p> $$ \begin{pmatrix} D\theta \\ D\phi \\ D\psi \end{pmatrix} = \frac{1}{\sin\theta}\begin{pmatrix} \cos\psi\sin\theta & -\sin\psi\sin\theta & 0\\ \sin\psi & \cos\psi & 0 \\ -\sin\psi\cos\theta & -\cos\psi\cos\theta & \sin\theta\end{pmatrix} \begin{pmatrix}\omega^a\\ \omega^b\\ \omega^c \end{pmatrix} $$ </div> These equations are singular for $\theta = 0$, as expected. To quote the book:</p> The singularity in the equations of motion for $\theta = 0$ does not correspond to anything funny in the motion of the rigid body. A practical solution to the singularity problem is to choose another set of Euler-like angles that have a singularity in a different place, and switch from one to the other when the going gets tough.</p> </blockquote> Euler’s equations for forced rigid bodies</h2> $$\require{cancel}$$</p> In this section, we derive Euler’s equations for a rigid body subject to an external torque. Consider a rigid body subject to some potential energy that is a function of time and configuration ($t$ and $q$). A suitable Lagrangian is $L = T - V$. If we use the 3-1-3 Euler angle set as the coordinates, the last of the three active rotations that define the coordinate is about the $z$ axis by the angle $\phi$. The Lagrange equation for $\phi$ is:</p> $$ D \partial_{\dot{\phi}} L = -D \underbrace{p_\phi}_{\text{conjugate momentum of }\phi} = \partial_{1,1} V(t; \theta(t), \phi(t), \psi(t)) $$ </div> where $\partial_{1,1}$ refers to a partial derivative with respect to a component (at index 1 or $\phi$) of the coordinate argument of the potential energy function. If we define the torque component $T_z$, to be minus the derivative of the potential energy with respect to the angle of rotation of the body about the z axis, then,</p> $$ T_z(t) = -D p_\phi = \partial_{1,1} V(t; \theta(t), \phi(t), \psi(t)) $$ </div> and so $D p_\phi (t) = T_z$. Since the orientation of the coordinate axes are arbitrary, we may choose and orient them as we want. Thus if we want any component of the vector torque, we may choose the z-axis so that we can compute it in this way. Therefore the vector torque gives the derivative of the vector angular momentum (why?</strong>):</p> $$ D\vec{L} = \vec{T} $$ </div> This can be substituted in Eq. 2.65 with $\mathbf{T}$ being the torque components in a column vector.</p> $$ D\overline{\mathbf{L}} = \overline{\mathbf{T}} = D\mathbf{M}~\overline{\mathbf{L}}' + \mathbf{M}D\overline{\mathbf{L}}'\\ $$ </div> Substituting in $\mathbf{I}‘\boldsymbol{\omega}’ = \overline{\mathbf{L}}’$, and $D\mathbf{M}$ from Eq. 2.21c,</p> $$ \begin{align} \overline{\mathbf{T}} &= \left(\mathscr{A}(\mathbf{M}\boldsymbol{\omega}')\mathbf{M}\right)~\mathbf{I}'\boldsymbol{\omega}' + \mathbf{M}\mathbf{I}'D\boldsymbol{\omega}'\\ \implies \mathbf{M}^\mathscr{T} \overline{\mathbf{T}} &= \underbrace{\left(\mathbf{M}^\mathscr{T} \mathscr{A}(\mathbf{M}\boldsymbol{\omega}')\mathbf{M}\right)}_{\text{see Eq. 2.67}}~\mathbf{I}'\boldsymbol{\omega}' + \mathbf{I}'D\boldsymbol{\omega}'\\ \implies \overbrace{\mathbf{M}^\mathscr{T} \overline{\mathbf{T}}}^{= \overline{\mathbf{T}}'} &= \mathscr{A}(\boldsymbol{\omega}') \mathbf{I}'\boldsymbol{\omega}' + \mathbf{I}' D\boldsymbol{\omega}'\\ \implies \overline{\mathbf{T}}' &= \mathscr{A}(\boldsymbol{\omega}') \mathbf{I}'\boldsymbol{\omega}' + \mathbf{I}' D\boldsymbol{\omega}'\tag{2.82} \end{align} $$ </div> where $\overline{\mathbf{T}}‘$ represents the torque vector components on the principal axes and $\mathbf{I}’$ is the inertia tensor in the basis vectors of the principal axes. The angular velocity rates can be determined from Eq. 2.82 as:</p> $$ \begin{align} A D \boldsymbol{\omega^a} - \left(B - C\right) \omega^b \omega^c &= \mathbf{T}_a\\ B D \boldsymbol{\omega^b} - \left(C - A\right) \omega^c \omega^a &= \mathbf{T}_b\\ C D \boldsymbol{\omega^c} - \left(A - B\right) \omega^a \omega^b &= \mathbf{T}_c\tag{2.83}\\ \end{align} $$ </div> The angular velocity components (on the principal axes) can be substituted by the angular momentum components on the principal axes as: $\omega^a = \frac{L_a}{A}, \omega^b = \frac{L_b}{B}, \omega^c = \frac{L_c}{C}$, to get:</p> $$ \begin{align} \cancel{A} \frac{D L_a}{\cancel{A}} - \left(B - C\right) \frac{L_b L_c}{BC} &= T_a\\ \cancel{B} \frac{D L_b}{\cancel{B}} - \left(C - A\right) \frac{L_c L_a}{CA} &= T_b\\ \cancel{C} \frac{D L_c}{\cancel{C}} - \left(A - B\right) \frac{L_a L_b}{AB} &= T_c\\ \end{align} $$ </div> This simplifies into:</p> $$ \begin{align} T_a &= D L_a - \left(\frac{1}{C} - \frac{1}{B}\right) L_b L_c\\ T_b &= D L_b - \left(\frac{1}{A} - \frac{1}{C}\right) L_c L_a\\ T_c &= D L_c - \left(\frac{1}{B} - \frac{1}{A}\right) L_a L_b\tag{2.80}\\ \end{align} $$ </div> where the torque components on the principal axes can be obtained as: $\overline{\mathbf{T}}’ = \mathbf{M}^{-1}\overline{\mathbf{T}}$.</p> It is to be noted that the torque does not affect the orientation directly, but instead only affects the angular momentum or angular velocity. Therefore Euler’s equations define the dynamics of the system while the derivatives of orientation define the kinematics of the system.</p> Section 2.8.2: Qualitative Features of Free Rigid Body Motion 2022-11-08T06:21:27+00:00 2.8.2 Qualitative Features of Free Rigid Body Motion</h2> The evolution of the components of the angular momentum on the principal axes has a remarkable property. For almost every initial condition the body components of the angular momentum periodically trace a simple closed curve.</p> </blockquote> </p> Figure 2.3: Trajectories of the components of the angular momentum vector on the principal axes, projected onto a plane. Each closed curve, except for the separatrix, is a different trajectory. All the trajectories shown here have the same energy</strong></p> The above figure shows the components of the angular momentum vector on the principal axes for different initial conditions. For most initial conditions we find a one-dimensional simple closed curve. Some trajectories on the front side appear to cross trajectories on the back side, but this is an artifact of projection. The family of trajectories appears to intersect at two points. The curve that is the union of these trajectories is called a separatrix</em>; it separates different types of motion.</p> The state space for the motion of a rigid body is six-dimensional - the three Euler angles and their time derivatives. Noether’s theorem gives us four conserved quantities - the three components of angular momentum as well as energy. This means the motion only has two degrees of freedom. The numerical result above also shows that the three components of angular momentum trace one-dimensional paths.</p> The total angular momentum is also conserved as its components are conserved. That is,</p> $$ L^2 = L_x^2 + L_y^2 +L_z^2\tag{2.58} $$ </div> While the components themselves do not change, their projection on to the principal axes change as the axes themselves are in motion, attached to the body. The magnitude of $L$ should be the same even if evaluated in the principal axes coordinates. Therefore,</p> $$ L^2 = L_a^2 + L_b^2 + L_c^2\tag{2.59} $$ </div> Previously, we found expressions for angular momentum and kinetic energy as:</p> $$ \begin{align} T_R &= \frac{1}{2} \left[ A(\omega^a)^2 + B(\omega^b)^2 + C(\omega^c)^2\right]\tag{2.41}\\ L_a &= A\omega^a\\ L_b &= B\omega^b\\ L_c &= C\omega^c\tag{2.51}\\ \end{align} $$ </div> These can be combined to get the following expression for kinetic energy in terms of the components of $L$</p> $$ E = \frac{1}{2}\left( \frac{L_a^2}{A} + \frac{L_b^2}{B} + \frac{L_c^2}{C} \right)\tag{2.60} $$ </div> Equations 2.59 and 2.60 constrain the motion of the components of angular momentum vector on the principal axes. Eq. 2.59 is the equation of a sphere and Eq. 2.60 is the equation of a triaxial ellipsoid. Since the angular momentum components satisfy both conditions, the component of the $L$ vector moves along the intersection of the angular momentum sphere and the energy ellipsoid. The intersection of a sphere and ellipsoid with the same center typically forms two closed curves.</p> The above equations were constructed with the assumption $A \leq B \leq C$. This means that the longest axis of the ellipsoid corresponds with the $\hat{c}$ direction which is the principal axis with the largest moment of inertia. And similarly the shortest axis of the energy ellipsoid coincides with the $\hat{a}$ direction (prinicipal axis for the smallest moment of inertia).</p> </li> The intersection curves can be seen to shrink to a point for two axes, $\hat{a}$ and $\hat{c}$, corresponding to the principal axes with the largest and smallest moments of inertia, respectively. If the $L$ vector starts at these points, they tend to stay there. This is called an equilibrium point</em>. Small displacements from this point at the start causes them to orbit the equilibrium point. This means that when the body rotates, the principal axes will describe a small orbit around the angular momentum vector in space (since the vector itself is constant). This is called a relative equilibrium</em>.</p> </li> Conversely, for the $\hat{b}$ axis, or the intermediate axis, the curves appear to cross. This is also an equilibrium point. If the angular moment starts exactly at that point, it will stay at that point. However, if the system is slightly displaced, it tends to move away from the point very quickly. This denotes an unstable equilibrium point. So a body starting its rotation close to the intermediate axis will quickly end up in a tumble (while the $L$ vector still</em> remains fixed in space).</p> </li> This leads to the “intermediate axis theorem”, also known as the tennis racket theorem</a>.</p> </li> Now consider the case where the rotating rigid body is somehow dissipating energy - maybe due to some flexing structural member. Since this is an internal process, this only decreases the energy while the angular momentum remains constant. This means that the intersection curve on which the system moves starts to deform. For a given $L$, there is a lower limit for energy. For this lowest energy state, the intersection is a pair of points on the maximum moment of inertia axis. This shows that with dissipating energy, a rotating rigid body ends up rotating around the principal axis of highest inertia - this is the lowest energy state consistent with a constant angular momentum.</p> A simple “proof” of this can be obtained from Eq.2.60 . In order to minimize $E$, we need to increase the component of $L$ corresponding to the smallest scale factor, ($1/C$), while keeping the magnitude of $L$ constant. This can be achieved by maximizing the $L_c$.</li> This was what caused eventual failure of the Explorer 1</a> satellite. This same process happens at a larger cosmic scale with planets and moons.</li> </ul> </li> </ul> The deviations from principal axis rotation for the Earth are tiny: the angle between the angular momentum vector and the ĉ axis for the Earth is less than one arc-second.</p> </blockquote> The above-mentioned deviations could be caused by Earthquakes, tides etc. In fact almost every other planet, asteroid and moon rotates about its principal axis with the largest moment of inertia. There are some exceptions - notably comets - which has reactions caused by the volatile jets that affect their rotation as they get closer to the Sun.</p> Among the natural satellites, the only known exception is Saturn’s satellite Hyperion, which is tumbling chaotically. Hyperion is especially out of round and subject to strong gravitational torques from Saturn.</p> </blockquote> Section 2.8.1: Computing the Motion of Free Rigid Bodies (incomplete) 2022-11-08T05:05:00+00:00 2.8.1 Computing the Motion of Free Rigid Bodies</h2> Lagrange’s equations for the motion of a free rigid body in terms of Euler angles are quite disgusting, so we will not show them here.</p> </blockquote> Some configurations may have coordinate singularities when using Euler angles (e.g. gimbal lock</a>). In the explicit Lagrange equations, the singularity arises when we try to find the expression for generalized accelerations. The expression for this involves the inverse of $\partial_2 \partial_2 L$. The determinant of this quantity may become zero when the Euler angle $\theta$ is zero (for 3-1-3 Euler angles).</p> (</span>def </span>Euler-state </span> (</span>up </span>'t </span> (</span>up </span>'theta 'varphi 'psi) </span> (</span>up </span>'thetadot 'varphidot 'psidot))) </span> </span>(</span>rendermd </span>(</span>determinant </span> (((</span>square </span>(</span>partial </span>2</span>)) (</span>rigid/T-rigid-body </span>'A 'B 'C)) </span>;; rigid/T-rigid-body = T-body-Euler from book </span> Euler-state))) </span></code></pre> $$ A\,B\,C\,{\sin}^{2}\left(\theta\right) $$ </div> So we cannot solve for the second derivatives when $\theta = 0$ and the Euler angles may change drastically when $\theta$ is small. This does not mean the actual motion of the rigid body is anything but well-behaved. The problem lies entirely in the representation of the motion using Euler angles. We may use another set of Euler angles when necessary to avoid this problem, but this tends to be cumbersome. In this section, we will be limiting our focus to trajectories that will not contain singularities for the chosen Euler angle set.</p> To obtain trjectories, we numerically integrate the Lagrange equations. The system derivative can be obtained directly from the Lagrangian using Lagrangian->state-derivative</code></p> TBD: Figure out plotting in Clojupyter</p> (</span>defn </span>rigid-sysder </span>[A B C] </span> (</span>Lagrangian->state-derivative </span>(</span>rigid/T-rigid-body</span> A B C))) </span> </span>(</span>defn </span>monitor-errors </span>[win A B C L0 E0] </span> (</span>fn </span>[state] </span> (</span>let </span>[t (</span>time</span> state) </span> L ((</span>rigid/Euler-state->L-body</span> A B C) state) </span> E ((</span>rigid/T-rigid-body</span> A B C) state)] </span> (</span>plot-point</span> win t (</span>relative-error </span>(</span>ref</span> L </span>0</span>) (</span>ref</span> L0 </span>0</span>))) </span> (</span>plot-point</span> win t (</span>relative-error </span>(</span>ref</span> L </span>1</span>) (</span>ref</span> L0 </span>1</span>))) </span> (</span>plot-point</span> win t (</span>relative-error </span>(</span>ref</span> L </span>2</span>) (</span>ref</span> L0 </span>2</span>))) </span> (</span>plot-point</span> win t (</span>relative-error</span> E E0))))) </span></code></pre> Syntax error compiling at (REPL:9:5). </span>Unable to resolve symbol: plot-point in this context </span> </span> Util.java: 221 clojure.lang.Util/runtimeException </span> core.clj: 3214 clojure.core$eval/invokeStatic </span> core.clj: 3210 clojure.core$eval/invoke </span> main.clj: 437 clojure.main$repl$read_eval_print__9086$fn__9089/invoke </span> main.clj: 458 clojure.main$repl$fn__9095/invoke </span> main.clj: 368 clojure.main$repl/doInvoke </span>RestFn.java: 1523 clojure.lang.RestFn/invoke </span> AFn.java: 22 clojure.lang.AFn/run </span> AFn.java: 22 clojure.lang.AFn/run </span>Thread.java: 1589 java.lang.Thread/run </span></code></pre> Exercise 2.10: Uniformly accelerated rigid body 2022-11-08T02:34:39+00:00 Exercise 2.10: Uniformly accelerated rigid body</h3> Show that a rigid body subject to a uniform acceleration rotates as a free rigid body, while the center of mass has a parabolic trajectory.</strong></p> $$\require{cancel}$$</p> The kinetic energy of the rigid body is equal to the sum of the translational and rotational kinetic energy ($T_R$).</p> $$ T = \frac{1}{2} m \left(\dot{x}^2 + \dot{y}^2 + \dot{z}^2 \right) + T_R(q_R) $$ </div> The potential energy of the body is equal to $V = m g y$ where $m$ is the total mass of the body assuming that the acceleration is acting in the negative $y$ direction. The potential energy here is not dependent on the mass distribution of the body (aka the moments of inertia) as it does not vary with distance (as in the case of a central potential).</p> If the position of the body is represented by rectangular coordinates $(x, y, z)$ and orientation is being represented by some set of generalized coordinates $q_R$, then the Lagrangian is:</p> $$ L(t; x,y,z, q_R; \dot{q},\dot{q_R}) = \frac{1}{2} m \left(\dot{x}^2 + \dot{y}^2 + \dot{z}^2 \right) - mgy + T_R(q_R) $$ </div> The Lagrangian can be decoupled into terms for translation (the first two terms) and rotation ($T_R(q_R)$). Therefore the Lagrange equations for the system also decouple as:</p> $$ D(\partial_2 L) - \partial_1 L = D([mx, my, mz]) - [0, mg, 0] = 0\\ $$ </div> Therefore the translational equations of motion are:</p> $$ \begin{bmatrix}\ddot{x}\\ \ddot{y}\\ \ddot{z}\end{bmatrix} = \begin{bmatrix} 0\\ -g \\ 0\end{bmatrix} $$ </div> Integrating these w.r.t time, we get:</p> $$ \begin{align} \begin{bmatrix}\dot{x}\\ \dot{y} \\ \dot{z}\end{bmatrix} &= \begin{bmatrix}X_1\\-gt + Y_1 \\ Z_1\end{bmatrix}\\ \implies \begin{bmatrix}x\\y \\ z\end{bmatrix} &= \begin{bmatrix}X_1 t + X_2 \\ -\frac{1}{2}gt^2 + Y_1 t + Y_2 \\ Z_1 t + Z_2\end{bmatrix} \end{align} $$ </div> These equations describe a parabola.</p> The motion of the rigid body is given by the Lagrangian, $T_R(q_R)$ which produces the dynamic equations for a free rigid body.</p> Section 2.8 : Motion of a Free Rigid Body 2022-11-07T08:17:06+00:00 2.8 Motion of a Free Rigid Body</h2> The kinetic energy of a rigid body, expressed in suitable generalized coordinates, is a Lagrangian for its motion. In section 2.2</a> we showed that the kinetic energy of a rigid body can be separated into translational and rotational kinetic energy. If we use two separate sets of coordinats to represent the translation and rotation, the Lagrangian becomes the sum of a translational Lagrangian and a rotational Lagrangian. In this section, we will look at the rotational motion of a rigid body, modeled using Euler angles as the generalized coordinates.</p> Conserved Quantities</h3> Since the Lagrangian of a rigid body has no explicit time-dependence, we can infer that energy (i.e. kinetic energy) is conserved. The Lagrangian also does not depend on the Euler angle $\varphi$ (since the expressions for the $\omega$ vector did not depend on $\varphi$ in section 2.7</a>), and therefore its momentum conjugate (the component of $\partial_2 L$ corresponding to $\phi$) is conserved. An explicit expression for the momentum conjugate of $\varphi$ is computed as:</p> (</span>def </span>Euler-state </span> (</span>up </span>'t </span> (</span>up </span>'theta 'varphi 'psi) </span> (</span>up </span>'thetadot 'varphidot 'psidot))) </span> </span>(</span>def </span>momentum-phi </span> (</span>ref </span>(((</span>partial </span>2</span>) (</span>rigid/T-rigid-body </span>'A 'B 'C)) Euler-state) </span> </span>1</span>)) </span> </span>(</span>rendermd</span> momentum-phi) </span></code></pre> $$ A\,\dot {\varphi}\,{\sin}^{2}\left(\psi\right)\,{\sin}^{2}\left(\theta\right) + B\,\dot {\varphi}\,{\sin}^{2}\left(\theta\right)\,{\cos}^{2}\left(\psi\right) + A\,\dot {\theta}\,\sin\left(\psi\right)\,\sin\left(\theta\right)\,\cos\left(\psi\right) - B\,\dot {\theta}\,\sin\left(\psi\right)\,\sin\left(\theta\right)\,\cos\left(\psi\right) + C\,\dot {\varphi}\,{\cos}^{2}\left(\theta\right) + C\,\dot {\psi}\,\cos\left(\theta\right) $$ </div> Due to the symmetries in the Lagrangian, we know that the quantity described above ($p_\varphi$) is conserved during the motion of a rigid body.</p> In the absence of external torques, we would also expect the angular momentum to be conserved. This can be verified by the Lagrangian formulation. The quantity computed above, $p_\varphi$, can be shown to be the $z$ component of the angular momentum. This is verified below:</p> (</span>def </span>L_z </span>(</span>ref </span>((</span>rigid/Euler-state->L-space </span>'A 'B 'C) Euler-state) </span> </span>2</span>)) </span> </span>(</span>rendermd </span>(</span>-</span> L_z momentum-phi)) </span></code></pre> $$ 0 $$ </div> Similar to the case of motion in a central potential</a>, since the choice of coordinate frames is arbitrary, if one rectangular component of $L$ is conserved, then all of its components are conserved. Therefore, the vector angular momentum is conserved for a rigid body</strong>.</p> This fact can also be shown using Noether’s theorem</a>. There exists a continuous family of rotations that can transform any orientation into any other orientation. The orientation of coordinate axes used to define the Euler angles are arbitrary and the kinetic energy (the Lagrangian) is the same regardless of choice of coordinate system. This meets the requirements of Noether’s theorem which tells us that there is an associated conserved quantity.</p> In particular, the family of rotations around each coordinate axis gives us conservation of the angular momentum component on that axis. We construct the vector angular momentum by combining these contributions.</p> </blockquote> See Exercise 2.11 for detailed proof of this (tbd .. will update link once completed).</p> Exercise 2.9: Euler angles 2022-11-07T08:15:00+00:00 Exercise 2.9: Euler Angles</h2> It is not immediately obvious that all orientations can be represented in terms of the Euler angles. To show that the Euler angles are adequate to represent all orientations, solve for the Euler angles that give an arbitrary rotation $R$. Keep in mind that some orientations do not correspond to a unique representation in terms of Euler angles.</strong></p> We will solve this for the “3-1-3” euler angles which involves an initial rotation around the $z$ axis, followed by the $x$ axis and then the $z$ axis again.</p> From Section 2.7</a>, we know that rotations about $z$ and $x$ axes can be represented as:</p> $$ \begin{align} \mathbf{R}_z(\psi) &= \begin{bmatrix} \cos\psi & -\sin\psi & 0\\ \sin\psi & \cos\psi & 0\\ 0 & 0 & 1\\ \end{bmatrix}\\ \mathbf{R}_x(\psi) &= \begin{bmatrix} 1 & 0 & 0\\ 0 & \cos\psi & -\sin\psi\\ 0 & \sin\psi & \cos\psi\\ \end{bmatrix}\\ \end{align} $$ </div> The rotation $R$ can then be represented in matrix form as:</p> $$ \begin{align} \mathbf{R}_{zxz}(\theta, \varphi, \psi) = \mathbf{R}_z(\varphi) \mathbf{R}_x(\theta) \mathbf{R}_z(\psi) \end{align} $$ </div> Expanding this matrix multiplication, we can get the matrix $\mathbf{R}_{zxz}$ as a function of $(\theta, \varphi, \psi)$</p> t = </span>symbols</span>('</span>t</span>', </span>real</span>=</span>True</span>) </span>theta, phi, psi = </span>symbols</span>('</span>theta phi psi</span>', </span>real</span>=</span>True</span>) </span> </span>Rz = </span>Matrix</span>([[</span>cos</span>(t), -</span>sin</span>(t), </span>0</span>], </span> [</span>sin</span>(t), </span>cos</span>(t), </span>0</span>], </span> [</span>0</span>, </span>0</span>, </span>1</span>]]) </span> </span>Rx = </span>Matrix</span>([[</span>1</span>, </span>0</span>, </span>0</span>], </span> [</span>0</span>, </span>cos</span>(t), -</span>sin</span>(t)], </span> [</span>0</span>, </span>sin</span>(t), </span>cos</span>(t)]]) </span> </span>R_zxz = Rz.</span>subs</span>(t, phi) * Rx.</span>subs</span>(t, theta) * Rz.</span>subs</span>(t, psi) </span>R_zxz </span></code></pre> $\displaystyle \left[\begin{matrix}- \sin{\left(\phi \right)} \sin{\left(\psi \right)} \cos{\left(\theta \right)} + \cos{\left(\phi \right)} \cos{\left(\psi \right)} & - \sin{\left(\phi \right)} \cos{\left(\psi \right)} \cos{\left(\theta \right)} - \sin{\left(\psi \right)} \cos{\left(\phi \right)} & \sin{\left(\phi \right)} \sin{\left(\theta \right)}\\\sin{\left(\phi \right)} \cos{\left(\psi \right)} + \sin{\left(\psi \right)} \cos{\left(\phi \right)} \cos{\left(\theta \right)} & - \sin{\left(\phi \right)} \sin{\left(\psi \right)} + \cos{\left(\phi \right)} \cos{\left(\psi \right)} \cos{\left(\theta \right)} & - \sin{\left(\theta \right)} \cos{\left(\phi \right)}\\\sin{\left(\psi \right)} \sin{\left(\theta \right)} & \sin{\left(\theta \right)} \cos{\left(\psi \right)} & \cos{\left(\theta \right)}\end{matrix}\right]$ </div> Any proper rotation can be represented by the rotation matrix $\mathbf{R}$ where</p> $$ \mathbf{R} = \begin{bmatrix}R_{11} & R_{12} & R_{13}\\ R_{21} & R_{22} & R_{23}\\ R_{31} & R_{32} & R_{33}\\ \end{bmatrix} $$ </div> Comparing $\mathbf{R}$ and $\mathbf{R}_{zxz}$, we get</p> $$ \begin{align} \cos{\theta} &= R_{33} \implies \theta = \arccos{(R_{33})}\\ \sin(\phi)\sin(\theta) &= R_{13}\\ -\cos(\phi)\sin(\theta) &= R_{23}\\ \sin{(\theta)}\cos{(\psi)} &= R_{32}\\ \sin{(\theta)}\sin{(\psi)} &= R_{31}\\ \end{align} $$ </div> We can therefore compute $(\theta, \phi, \psi)$ for a given arbitrary rotation. The particular set of Euler angles chosen may have coordinate singularities. For example, in the z-x-z Euler angle set chosen above, when $\theta = 0$, $\phi$ and $\psi$ are not defined. However, in this case, another set of Euler angles may be chosen that does not have a singularity in that particular configuration.</p> We have shown above that any arbitrary rotation, as represented by a direction cosine matrix, can be written in terms of Euler angles. This proves that Euler angles can represent any arbitrary rotation.</strong></p> Section 2.7: Euler Angles 2022-11-07T05:40:17+00:00 2.7 Euler Angles</h2> Euler Angles</em> are a set of generalized coordinates for describing the orientation of a rigid body. To quote the book:</p> Though the Euler angles allow us to specify all orientations and thus can be used as generalized coordinates, the definition of Euler angles is pretty arbitrary. In fact no reasoning has led us to them. This is reflected in our presentation of them by just saying “here they are.” Euler angles are well suited for some problems, but cumbersome for others.</p> </blockquote> We start with the reference orientation so that principal-axis unit vectors $\hat{a}, \hat{b}, \hat{c}$ are coincident with the basis vectors $\hat{e}_i$, labeled here by $\hat{x}, \hat{y}, \hat{z}$. The Euler angles are defined in terms of simple rotations about the coordinate axes. Let $R_x(\psi)$ be a right-handed rotation about $\hat{x}$ by angle $\psi$, and $R_z(\psi)$ be a right-handed rotation about $\hat{z}$ by angle $\psi$. The function $\mathscr{M}$ for Euler angles is written as a composition of three of these simple coordinate axis rotations:</p> $$ \mathscr{M}(\theta, \varphi, \psi) = R_z(\varphi) \circ R_x(\theta) \circ R_z(\psi) $$ </div> for Euler angles $\theta, \varphi, \psi$. While these angles can represent any orientation, any specific orientation may be represented by more than one set of Euler angle. For example, when $\theta = 0$, then the orientation does not uniquely define either $\varphi$ or $\psi$.</p> There are other sets of Euler angles that can serve as generlized coordinates. For example, we can use the Euler angles defined as:</p> $$ \mathscr{M}(\theta, \varphi, \psi) = R_x(\varphi) \circ R_y(\theta) \circ R_z(\psi) $$ </div> Sometimes these are useful when we want to control where in the configuration space the “singularity” in the coordinates show up. The fundamental rotations themselves can be represented as rotation matrices:</p> $$ \begin{align} \mathbf{R}_z(\psi) &= \begin{bmatrix} \cos\psi & -\sin\psi & 0\\ \sin\psi & \cos\psi & 0\\ 0 & 0 & 1\\ \end{bmatrix}\\ \mathbf{R}_x(\psi) &= \begin{bmatrix} 1 & 0 & 0\\ 0 & \cos\psi & -\sin\psi\\ 0 & \sin\psi & \cos\psi\\ \end{bmatrix}\\ \end{align} $$ </div> The rotation $\mathscr{M}$ can then be written as:</p> $$ \mathscr{M}(\theta, \varphi, \psi) = \mathbf{R}_x(\varphi) \mathbf{R}_y(\theta) \mathbf{R}_z(\psi) $$ </div> The rotation matrices and their products can be computed as shown below. These can then be combined with the procedures M-of-q->omega-of-t</code> and M-of-q->omega-body-of-t</code> from section 2.2</a> to compute the components of the angular velocity vector and the body components of the angular velocity vector.</p> The code below computes the components of the angular velocity vector for the given Euler angle set.</p> (</span>defn </span>Rz-matrix </span>[angle] </span> (</span>matrix-by-rows </span> (</span>list </span>(</span>cos</span> angle) (</span>- </span>(</span>sin</span> angle)) </span>0</span>) </span> (</span>list </span>(</span>sin</span> angle) (</span>cos</span> angle) </span>0</span>) </span> (</span>list </span>0 0 1</span>))) </span> </span>(</span>defn </span>Rx-matrix </span>[angle] </span> (</span>matrix-by-rows </span> (</span>list </span>1 0 0</span>) </span> (</span>list </span>0 </span>(</span>cos</span> angle) (</span>- </span>(</span>sin</span> angle))) </span> (</span>list </span>0 </span>(</span>sin</span> angle) (</span>cos</span> angle)))) </span> </span>;; Rotation function, M </span>(</span>defn </span>my-Euler->M </span>[[theta</span>,</span> phi</span>,</span> psi]] </span> (</span>* </span>(</span>Rz-matrix</span> phi) </span> (</span>Rx-matrix</span> theta) </span> (</span>Rz-matrix</span> psi))) </span> </span>;; Methods from section 2.2 are defined in the "rigid" namespace of sicmutils </span> </span>;; Body-components of angular velocity for given Euler angles </span>(</span>rendermd </span> (</span>matrix/->structure </span> (((</span>rigid/M-of-q->omega-body-of-t</span> my-Euler->M) </span> (</span>up </span>(</span>literal-function </span>'theta) </span> (</span>literal-function </span>'varphi) </span> (</span>literal-function </span>'psi))) </span> 't))) </span></code></pre> $$ \begin{bmatrix}\displaystyle{\begin{pmatrix}\displaystyle{\sin\left(\psi\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,D\varphi\left(t\right) + \cos\left(\psi\left(t\right)\right)\,D\theta\left(t\right)} \cr \cr \displaystyle{\cos\left(\psi\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,D\varphi\left(t\right) - \sin\left(\psi\left(t\right)\right)\,D\theta\left(t\right)} \cr \cr \displaystyle{\cos\left(\theta\left(t\right)\right)\,D\varphi\left(t\right) + D\psi\left(t\right)}\end{pmatrix}}\end{bmatrix} $$ </div> ;; Components of angular velocity vector (inertial?) </span>(</span>rendermd </span> (</span>matrix/->structure </span> ((</span>rigid/M->omega-body</span> Euler->M) </span> (</span>up </span>'t </span> (</span>up </span>'theta 'varphi 'psi) </span> (</span>up </span>'thetadot 'varphidot 'psidot))))) </span></code></pre> $$ \begin{bmatrix}\displaystyle{\begin{pmatrix}\displaystyle{\dot {\varphi}\,\sin\left(\psi\right)\,\sin\left(\theta\right) + \dot {\theta}\,\cos\left(\psi\right)} \cr \cr \displaystyle{\dot {\varphi}\,\cos\left(\psi\right)\,\sin\left(\theta\right) - \dot {\theta}\,\sin\left(\psi\right)} \cr \cr \displaystyle{\dot {\varphi}\,\cos\left(\theta\right) + \dot {\psi}}\end{pmatrix}}\end{bmatrix} $$ </div> ;; This can be further create a procedure that returns the omega vector for the 3-1-3 (z-x-z) Euler angle set </span>(</span>defn </span>Euler-state->omega-body </span>[[t</span>, </span>[theta</span>,</span> phi</span>,</span> psi]</span>, </span>[thetadot</span>,</span> phidot</span>,</span> psidot]]] </span> (</span>let </span>[omega-a (</span>+ </span> (</span></span> thetadot (</span>cos</span> psi)) </span> (</span></span> phidot (</span>sin</span> theta) (</span>sin</span> psi))) </span> omega-b (</span>+ </span> (</span>* </span>-1</span> thetadot (</span>sin</span> psi)) </span> (</span></span> phidot (</span>sin</span> theta) (</span>cos</span> psi))) </span> omega-c (</span>+ </span> (</span></span> phidot (</span>cos</span> theta)) psidot)] </span> (</span>up</span> omega-a omega-b omega-c))) </span> </span>(</span>rendermd </span> (</span>Euler-state->omega-body </span> (</span>up </span>'t </span> (</span>up </span>'theta 'varphi 'psi) </span> (</span>up </span>'thetadot 'varphidot 'psidot)))) </span></code></pre> $$ \begin{pmatrix}\displaystyle{\dot {\varphi}\,\sin\left(\psi\right)\,\sin\left(\theta\right) + \dot {\theta}\,\cos\left(\psi\right)} \cr \cr \displaystyle{\dot {\varphi}\,\cos\left(\psi\right)\,\sin\left(\theta\right) - \dot {\theta}\,\sin\left(\psi\right)} \cr \cr \displaystyle{\dot {\varphi}\,\cos\left(\theta\right) + \dot {\psi}}\end{pmatrix} $$ </div> The Euler-state->omega-body</code> procedure can now be used to write functions to compute kinetic energy and angular momentum</p> ;; From section 2.5 </span>(</span>defn </span>T-body </span>[A B C] </span> (</span>fn </span>[omega-body] </span> (</span>* </span>1/2 </span> (</span>+ </span>(</span></span> A (</span>square </span>(</span>ref</span> omega-body </span>0</span>))) </span> (</span></span> B (</span>square </span>(</span>ref</span> omega-body </span>1</span>))) </span> (</span></span> C (</span>square </span>(</span>ref</span> omega-body </span>2</span>))))))) </span> </span>;; From section 2.6 </span>(</span>defn </span>L-body </span>[A B C] </span> (</span>fn </span>[omega-body] </span> (</span>down </span>(</span></span> A (</span>ref</span> omega-body </span>0</span>)) </span> (</span></span> B (</span>ref</span> omega-body </span>1</span>)) </span> (</span></span> C (</span>ref</span> omega-body </span>2</span>))))) </span> </span> </span>;; Kinetic energy </span>(</span>defn </span>T-body-Euler </span>[A B C] </span> (</span>fn </span>[local] </span> ((</span>T-body</span> A B C) </span> (</span>Euler-state->omega-body</span> local)))) </span> </span>;; Angular momentum in principal axes coordinates </span>(</span>defn </span>L-body-Euler </span>[A B C] </span> (</span>fn </span>[local] </span> ((</span>L-body</span> A B C) </span> (</span>Euler-state->omega-body</span> local)))) </span> </span> </span>;; L in reference-frame </span>(</span>defn </span>L-space-Euler </span>[A B C] </span> (</span>fn </span>[local] </span> (</span>let </span>[angles (</span>coordinate</span> local)] </span> (</span>* </span>((</span>L-body-Euler</span> A B C) local) </span> (</span>transpose </span>(</span>Euler->M</span> angles)))))) </span> </span>;; These are all local-tuple functions similar to the Lagrangian </span></code></pre> Exercise 2.6: Principal moments of inertia 2022-11-07T03:04:57+00:00 Exercise 2.5: Principal moments of inertia</h2> For each of the configurations described below find the principal moments of inertia with respect to the center of mass, and find the corresponding principal axes.</strong></p> a. A regular tetrahedron consisting of four equal point masses tied together with rigid massless wire.</strong></p> Let the sides of the tetrohedron be two units long. The coordinates of the masses are (Reference</a>]:</p> $$ (\pm 1, 0, -\frac{1}{\sqrt{2}}), (0, \pm 1, \frac{1}{\sqrt{2}})\\ $$ </div> If the point masses all have mass $m$, the moments of inertia are:</p> $$ \begin{align} I_{00} &= \sum_i m_i \left(y_i^2 + z_i^2 \right)\\ &= m (0 + \frac{1}{2} + 0 + \frac{1}{2} + 1 + \frac{1}{2} + 1 + \frac{1}{2} = 4m\\ I_{01} &= -\sum\nolimits_i m_i x_i y_i \\ &= -m ( 0 + 0 + 0 + 0 ) = 0\\ I_{02} &= -\sum\nolimits_i m_i x_i z_i \\ &= -m ( -\frac{1}{\sqrt{2}} + \frac{1}{\sqrt{2}} + 0 + 0) = 0\\ \\ I_{10} &= - \sum\nolimits_i m_i y_i x_i\\ &= - m (0 + 0 + 0 + 0) = 0\\ I_{11} &= \sum\nolimits_i m_i \left(x_i^2 + z_i^2 \right)\\ &= m(1 + \frac{1}{2} + 1 + \frac{1}{2} + 0 + \frac{1}{2} + 0 + \frac{1}{2}) = 4m\\ I_{12} &= -\sum\nolimits_i m_i y_i z_i\\ &= - m(0 + 0 + \frac{1}{\sqrt{2}} - \frac{1}{\sqrt{2}} ) = 0 \\ I_{20} &= - \sum\nolimits_i m_i z_i x_i\\ &= - m(-\frac{1}{\sqrt{2}} + \frac{1}{\sqrt{2}} + 0 + 0) = 0\\ I_{21} &= - \sum\nolimits_i m_i z_i y_i\\ &= - m(0 + 0 + \frac{1}{\sqrt{2}} - \frac{1}{\sqrt{2}}) = 0\\ I_{22} &= \sum\nolimits_i m_i \left(x_i^2 + y_i^2 \right)\\ &= m(1 + 0 + 1 + 0 + 1 + 0 + 1 + 0) = 4m\\ \end{align} $$ </div> The inertia matrix is:</p> $$ \begin{align} I &= \begin{bmatrix}4m & 0 & 0\\ 0 & 4m & 0\\ 0 & 0 & 4m\end{bmatrix} \end{align} $$ </div> Since the matrix is already diagonal, the values of the diagonal elements are the principal moments of inertia:</p> $$ A = B = C = 4m\\ $$ </div> The principal axes are $\hat{x}, \hat{y}, \hat{z}$.</p> b. A cube of uniform density</strong></p> Assume origin at center of the cube. The moments of inertia are:</p> $$ \begin{align} I_{xx} = \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \left(y^2 + z^2\right) \rho~dx dy dz\\ I_{yy} = \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \left(x^2 + z^2\right) \rho~dx dy dz\\ I_{zz} = \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \left(x^2 + y^2\right) \rho~dx dy dz\\ \end{align} $$ </div> where $\rho$ is the density of the material, $\rho = \frac{M}{L^3}$. Since the cube is symmetric, the moments of inertia are all equal to each other, $I_{xx} = I_{yy} = I_{zz}$</p> Products of inertia are:</p> $$ \begin{align} I_{xy} &= \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} xy \rho~dx dy dz\\ I_{yz} &= \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} yz \rho~dx dy dz\\ I_{zx} &= \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} \int_{-L/2}^{L/2} zx \rho~dx dy dz\\ \end{align} $$ </div> As calculated below, the inertia matrix is diagonal with elements equal to $\frac{M L^2}{6}$. Therefore the principal moments of inertia are:</p> $$ A = B = C = \frac{M L^2}{6} $$ </div> The principal axes are $\hat{x}, \hat{y}, \hat{z}$.</p> x, y, z = </span>symbols</span>('</span>x y z</span>', </span>real</span>=</span>True</span>) </span>M, L = </span>symbols</span>('</span>M L</span>', </span>positive</span>=</span>True</span>) </span>rho = M/L*</span>3 </span> </span>Ixx = rho </span>integrate</span>(y</span>2 </span>+ z</span>2</span>, (x, -L/</span>2</span>, L/</span>2</span>), (y, -L/</span>2</span>, L/</span>2</span>), (z, -L/</span>2</span>, L/</span>2</span>)) </span>Iyy = rho * </span>integrate</span>(x</span>2 </span>+ z</span>2</span>, (x, -L/</span>2</span>, L/</span>2</span>), (y, -L/</span>2</span>, L/</span>2</span>), (z, -L/</span>2</span>, L/</span>2</span>)) </span>Izz = rho * </span>integrate</span>(x</span>2 </span>+ y</span>2</span>, (x, -L/</span>2</span>, L/</span>2</span>), (y, -L/</span>2</span>, L/</span>2</span>), (z, -L/</span>2</span>, L/</span>2</span>)) </span> </span>Ixy = rho * </span>integrate</span>(xy, (x, -L/</span>2</span>, L/</span>2</span>), (y, -L/</span>2</span>, L/</span>2</span>), (z, -L/</span>2</span>, L/</span>2</span>)) </span>Iyz = rho </span>integrate</span>(yz, (x, -L/</span>2</span>, L/</span>2</span>), (y, -L/</span>2</span>, L/</span>2</span>), (z, -L/</span>2</span>, L/</span>2</span>)) </span>Ixz = rho </span>integrate</span>(xz, (x, -L/</span>2</span>, L/</span>2</span>), (y, -L/</span>2</span>, L/</span>2</span>), (z, -L/</span>2</span>, L/</span>2</span>)) </span> </span>Iyx, Izy, Izx = Ixy, Iyz, Ixz </span> </span>I = </span>Matrix</span>([[Ixx, Ixy, Ixz], </span> [Iyx, Iyy, Iyz], </span> [Izx, Izy, Izz]]) </span> </span>I </span></code></pre> $\displaystyle \left[\begin{matrix}\frac{L^{2} M}{6} & 0 & 0\\0 & \frac{L^{2} M}{6} & 0\\0 & 0 & \frac{L^{2} M}{6}\end{matrix}\right]$ </div> c. Five equal point masses rigidly connected by massless stuff. The point masses are at the rectangular coordinates: (−1, 0, 0), (1, 0, 0), (1, 1, 0), (0, 0, 0), (0, 0, 1).</strong></p> The center of mass is at $[\frac{1}{5}, \frac{1}{5}, \frac{1}{5}]$.</p> import </span>numpy </span>as </span>np </span> </span>points = np.</span>array</span>([[-</span>1</span>, </span>0</span>, </span>0</span>], </span> [</span>1</span>, </span>0</span>, </span>0</span>], </span> [</span>1</span>, </span>1</span>, </span>0</span>], </span> [</span>0</span>, </span>0</span>, </span>0</span>], </span> [</span>0</span>, </span>0</span>, </span>1</span>]]) </span> </span> </span>N = points.shape[</span>0</span>] </span>center_of_mass = points.</span>mean</span>(</span>axis</span>=</span>0</span>) </span>cx,cy,cz = center_of_mass </span> </span>Ixx = </span>sum</span>([(y - cy)</span>2 </span>+ (z - cz)</span>2 </span>for </span>x, y, z </span>in </span>points]) </span>Iyy = </span>sum</span>([(x - cx)</span>2 </span>+ (z - cz)</span>2 </span>for </span>x, y, z </span>in </span>points]) </span>Izz = </span>sum</span>([(x - cx)</span>2 </span>+ (y - cy)</span>2 </span>for </span>x, y, z </span>in </span>points]) </span> </span>Iyz = </span>sum</span>([(y - cy)(z - cz)*</span>2 </span>for </span>x, y, z </span>in </span>points]) </span>Ixz = </span>sum</span>([(x - cx)(z - cz)*</span>2 </span>for </span>x, y, z </span>in </span>points]) </span>Ixy = </span>sum</span>([(x - cx)(y - cy)*</span>2 </span>for </span>x, y, z </span>in </span>points]) </span> </span>I = </span>Matrix</span>([[Ixx, Ixy, Ixz], </span> [Iyx, Iyy, Iyz], </span> [Izx, Izy, Izz]]) m </span> </span>I </span></code></pre> $\displaystyle \left[\begin{matrix}1.6 m & 0.48 m & - 0.12 m\\0 & 3.6 m & - 0.12 m\\0 & 0 & 3.6 m\end{matrix}\right]$ </div> eigenvects = I.</span>eigenvects</span>() </span>eigenvects </span></code></pre> [(1.6m, </span> 1, </span> [Matrix([ </span> [1.0], </span> [ 0], </span> [ 0]])]), </span> (3.6m, </span> 2, </span> [Matrix([ </span> [0.24], </span> [ 1.0], </span> [ 0]])])] </span></code></pre> a = eigenvects[</span>0</span>][</span>2</span>][</span>0</span>] </span>b = eigenvects[</span>1</span>][</span>2</span>][</span>0</span>] </span> </span>c = a.</span>cross</span>(b) </span>c </span></code></pre> $\displaystyle \left[\begin{matrix}0\\0\\1.0\end{matrix}\right]$ </div> The principal moments of inertia are:</p> $$ A = 1.6m, B = C = 3.6m\\ $$ </div> The principal axes are: $\hat{x},~ 0.24\hat{x} + 1.0\hat{y},~\hat{z}$</p> Exercise 2.8: Rotational angular momentum 2022-11-06T08:12:45+00:00 Exercise 2.8: Rotational angular momentum</h2> Verify that expression in Eq. (2.50) for the components of the rotational angular momentum Eq. (2.49) in terms of the inertia tensor is correct.</strong></p> $$ \vec{L} = \sum_\alpha m_\alpha \vec{\xi}_\alpha \times \left(\vec{\omega} \times \vec{\xi}_\alpha \right)\tag{2.49} $$ </div> $$ L_j = \sum_k I_{jk} \omega^k\tag{2.50} $$ </div> Consider an arbitrary inertial coordinate frame its the origin at the center of rotation and basis vectors $\hat{e}_0$, $\hat{e}_1$ and $\hat{e}_2$, such that $\hat{e}_0 \times \hat{e}_1 = \hat{e}_2$. If the components of $\vec{\omega}$ in this frame are $\omega^0$, $\omega^1$ and $\omega^2$, The inertia matrix of a body in this coordinate frame is:</p> $$ \begin{align} \vec{L} &= \sum_\alpha m_\alpha \vec{\xi}_\alpha \times \left(\vec{\omega} \times \vec{\xi}_\alpha \right) \\ L_i = \vec{L}\cdot \hat{e}_i &= \left( \sum_\alpha m_\alpha \vec{\xi}_\alpha \times \left(\vec{\omega} \times \vec{\xi}_\alpha \right) \right) \cdot \hat{e}_i\\ \end{align} $$ </div> Applying the triple product formula</a>, ${\displaystyle (\mathbf {a} \times \mathbf {b} )\cdot \mathbf {c} = \mathbf {a} \cdot (\mathbf {b} \times \mathbf {c} ) }$,</p> $$ \begin{align} L_j &= \sum_\alpha \left( m_\alpha \overbrace{\vec{\xi}_\alpha}^{"\mathbf{a}"} \times \underbrace{\left(\vec{\omega} \times \vec{\xi}_\alpha \right)}_{"\mathbf{b}"} \right) \cdot \overbrace{\hat{e}_j}^{"\mathbf{c}"}\\ &= \sum_\alpha m_\alpha \vec{\xi}_\alpha \cdot \left[ \left(\vec{\omega} \times \vec{\xi}_\alpha \right) \times \hat{e}_j\right]\\ &= \sum_\alpha m_\alpha \vec{\xi}_\alpha \cdot \left[ \left(\sum_k \hat{e}_k \omega^k \times \vec{\xi}_\alpha \right) \times \hat{e}_j \right]\\ &= \sum_k \omega^k \sum_\alpha m_\alpha \vec{\xi}_\alpha \cdot \left[ \left(\hat{e}_k \times \vec{\xi}_\alpha \right) \times \hat{e}_j \right]\\ \end{align} $$ </div> Applying the triple product formula</a> again, ${\displaystyle \mathbf {a} \cdot (\mathbf {b} \times \mathbf {c} )=\mathbf {b} \cdot (\mathbf {c} \times \mathbf {a} )}$,</p> $$ \begin{align} L_j &= \sum_k \omega^k \sum_\alpha m_\alpha \underbrace{\vec{\xi}_\alpha}_{"\mathbf{a}"} \cdot \left[ \overbrace{\left(\hat{e}_k \times \vec{\xi}_\alpha \right)}^{"\mathbf{b}"} \times \underbrace{\hat{e}_j}_{"\mathbf{c}"} \right]\\ &= \sum_k \omega^k \sum_\alpha m_\alpha \left(\hat{e}_k \times \vec{\xi}_\alpha \right) \cdot \left[ \hat{e}_j \times \vec{\xi}_\alpha \right]\\ &= \sum_k \omega^k \underbrace{\sum_\alpha m_\alpha \left(\hat{e}_j \times \vec{\xi}_\alpha \right) \cdot \left( \hat{e}_k \times \vec{\xi}_\alpha \right)}_{I_{jk}}\\ \\ L_j &= \sum_k I_{jk} \omega^k \end{align} $$ </div> where $I_{jk}$ are components of the inertia tensor.</p> Section 2.6: Vector Angular Momentum 2022-11-06T07:14:48+00:00 2.6 Vector Angular Momentum</h2> The vector angular momentum of a particle is the cross product of its position vector and its linear momentum vector. For a rigid body the vector angular momentum is the sum of the vector angular momentum of each of the constituents.</p> </blockquote> The vector angular momentum of a rigid body is</p> $$ \sum_\alpha \vec{x}_\alpha \times (m_\alpha \dot{\vec{x}}_\alpha) $$ </div> Similar to rotational kinetic energy, the vector angular momentum of a rigid body can also be decomposed to the angular momentum of the center of mass and the angular momentum about the center of mass. If we represent the position vectors as sum of the position of the center of mass, $\vec{X}$ and the vectors from the center of mass, $\vec{\xi}_\alpha$, we get:</p> $$ \begin{align} \vec{x}_\alpha &= \vec{X} + \vec{\xi}_\alpha\tag{2.43}\\ \dot{\vec{x}}_\alpha &= \dot{\vec{X}} + \dot{\vec{\xi}}_\alpha\tag{2.44}\\ \text{where }\vec{X} &= \frac{\sum_\alpha m_\alpha \vec{x}_\alpha}{M} \\ M &= \sum_\alpha m_\alpha \end{align} $$ </div> As a result of $\vec{X}$ being the center of mass,</p> $$ \sum_\alpha m_\alpha \vec{\xi}_\alpha = \sum_\alpha m_\alpha (\vec{x}_\alpha - \vec{X}) = \underbrace{\sum_\alpha m_\alpha \vec{x}_\alpha}_{= M\vec{X}} - \overbrace{\sum_\alpha m_\alpha}^{=M} \vec{X} = 0\\ $$ </div> Similarly, $\sum_\alpha m_\alpha \dot{\vec{\xi}}_\alpha$ is also equal to zero. Substituting these in the angular momentum, we get:</p> $$ \begin{align} \sum_\alpha & m_\alpha \left(\vec{X} + \vec{\xi}_\alpha \right) \times \left(\dot{\vec{X}} + \dot{\vec{\xi}}_\alpha\right)\\ &= \sum_\alpha m_\alpha (\vec{X} \times \dot{\vec{X}} + \vec{X} \times \dot{\vec{\xi}}_\alpha + \vec{\xi}_\alpha \times \dot{\vec{X}} + \vec{\xi}_\alpha \times \dot{\vec{\xi}}_\alpha )\\ &= \vec{X} \times M\dot{\vec{X}} + \vec{X} \times \cancelto{0}{\sum_\alpha m_\alpha \dot{\vec{\xi}}_\alpha} + \cancelto{0}{\sum_\alpha m_\alpha \vec{\xi}_\alpha } \times \dot{\vec{X}} + \sum_\alpha m_\alpha \vec{\xi}_\alpha \times \dot{\vec{\xi}}_\alpha\\ &= \vec{X} \times M\dot{\vec{X}} + \sum_\alpha \vec{\xi}_\alpha \times (m_\alpha \dot{\vec{\xi}}_\alpha)\tag{2.46} \end{align} $$ </div> The first term of Eq. 2.46, $\vec{X} \times M\dot{\vec{X}}$ is the angular momentum of the center of mass and the rotational angular momentum is $\sum_\alpha \vec{\xi_\alpha} \times (m_\alpha \dot{\vec{\xi_\alpha}})$. By substituting $\dot{\vec{\xi_\alpha}} = \vec{\omega} \times \vec{\xi_\alpha}$, we get:</p> $$ \vec{L} = \sum_\alpha m_\alpha \vec{\xi}_\alpha \times \left(\vec{\omega} \times \vec{\xi}_\alpha \right)\tag{2.49} $$ </div> Using the same technique as done for the rotational kinetic energy in Section 2.3</a>, we can resolve $\vec{\omega}$ into its components to find the angular momentum in terms of the moments of inertia as:</p> $$ L_j = \sum_k I_{jk} \omega^k\tag{2.50} $$ </div> where $I_{jk}$ are components of the inertia tensor (the same one used to compute rotational kinetic energy). In terms of the principal moments of inertia, the components of $L$ are:</p> $$ \begin{align} L_a &= A\omega^a\\ L_b &= B\omega^b\\ L_c &= C\omega^c\tag{2.51}\\ \end{align} $$ </div> These are also the partial derivatives of kinetic energy $T_R$ w.r.t angular velocities (Eq. 2.41 in Section 2.5</a>). Therefore $\vec{L}$ is written as a down-tuple (or a row-matrix).</p> If $\mathbf{M}$ is the matrix representation of the rotation that takes an angular-velocity vector $\boldsymbol{\omega}’$ to a rotated vector $\boldsymbol{\omega}$, the components transform as $\boldsymbol{\omega} = \mathbf{M}\boldsymbol{\omega}$. It is also conventient to work with a column matrix of the angular momentum components, $\overline{\mathbf{L}} = \mathbf{L}^{\mathscr{T}}$.</p> Applying this transformation along with $\mathbf{I}’ = \mathbf{M}\mathbf{I}\mathbf{M}^{\mathscr{T}}$ to angular momentum</p> $$ \begin{align} \overline{\mathbf{L}} &= \mathbf{I}\boldsymbol{\omega}\\ &= \mathbf{M}\mathbf{I}\mathbf{M}^{\mathscr{T}} \mathbf{M}\boldsymbol{\omega}'\\ &= \mathbf{M}\mathbf{I}\boldsymbol{\omega}' &= \mathbf{M} \overline{\mathbf{L}}'\tag{2.52} \end{align} $$ </div> Transposing the result in Eq. 2.52,</p> $$ \mathbf{L} = (\overline{\mathbf{L}})^{\mathscr{T}} = (\mathbf{M} \overline{\mathbf{L}}')^{\mathscr{T}} = \mathbf{L}' \mathbf{M}^{\mathscr{T}} $$ </div> Therefore, the angular momentum components transform as: $\mathbf{L} = \mathbf{L}’ \mathbf{M}^{\mathscr{T}}$</p> (</span>defn </span>L-body </span>[A B C] </span> (</span>fn </span>[[omega-a omega-b omega-c]] </span> (</span>down </span>(</span></span> A omega-a) </span> (</span></span> B omega-b) </span> (</span></span> C omega-c)))) </span> </span>(</span>defn </span>L-space </span>[M] </span> (</span>fn </span>[A B C] </span> (</span>fn </span>[omega-body] </span> (</span> </span>((</span>L-body</span> A B C) omega-body) </span> (</span>transpose</span> M))))) </span> </span> </span>(</span>rendermd </span>((</span>L-body </span>'A 'B 'C) </span> (</span>up </span>'omega_a 'omega_b 'omega_c))) </span></code></pre> $$ \begin{bmatrix}\displaystyle{A\,{\omega}_a}&\displaystyle{B\,{\omega}_b}&\displaystyle{C\,{\omega}_c}\end{bmatrix} $$ </div> Section 1.8.3: Central Forces in Three Dimensions 2022-11-06T00:16:30+00:00 1.8.3 Central Forces in Three Dimensions</h2> Consider the motion of a particle in a potential field $V(r)$ in three dimensions using spherical coordinates, $r, \theta, \varphi$, where $\theta$ is the colatitude and $\varphi$ is the longitude. The kinetic energy is:</p> $$ T(t; r, \theta, \varphi; \dot{r}, \dot{\theta}, \dot{\varphi} = \frac{1}{2} m \left(\dot{r}^2 + r^2\dot{\theta}^2 + r^2(\sin\theta)^2\dot{\varphi}^2 \right) $$ </div> (</span>defn </span>T3-spherical </span>[m] </span> (</span>fn </span>[[_</span>, </span>[r</span>,</span> theta</span>,</span> _]</span>, </span>[rdot</span>,</span> thetadot</span>,</span> phidot]]] </span> (</span>* </span>1/2</span> m </span> (</span>+ </span>(</span>square</span> rdot) </span> (</span>square </span>(</span></span> r thetadot)) </span> (</span>square </span>(</span></span> r (</span>sin</span> theta) phidot)))))) </span> </span>;; Lagrangian = T-V </span>(</span>defn </span>L3-central </span>[m Vr] </span> (</span>defn </span>Vs </span>[[_</span>, </span>[r</span>,</span> _</span>,</span> _]</span>,</span> _]] </span> (</span>Vr</span> r)) </span> (</span>- </span>(</span>T3-spherical</span> m) Vs)) </span></code></pre> #'user/L3-central </span></code></pre> ;; The generalized forces can be computed by taking the partial derivative of the Lagrangian w.r.t the coordinates </span>(</span>rendertex </span>( ((</span>partial </span>1</span>) (</span>L3-central </span>'m (</span>literal-function </span>'V))) </span> (</span>up </span>'t </span> (</span>up </span>'r 'theta 'phi) </span> (</span>up </span>'rdot 'thetadot 'phidot)))) </span> </span>;; Here \varphi is a "cyclic coordinate" as it does not appear in the Lagrangian explicitly </span>;; and hence does not have a force associated with it </span></code></pre> \begin{bmatrix}\displaystyle{m\,{\dot {\phi}}^{2}\,r\,{\sin}^{2}\left(\theta\right) + m\,r\,{\dot {\theta}}^{2} - DV\left(r\right)} \cr \cr \displaystyle{m\,{\dot {\phi}}^{2}\,{r}^{2}\,\sin\left(\theta\right)\,\cos\left(\theta\right)} \cr \cr \displaystyle{0}\end{bmatrix} </div> ;; Compute the momenta by taking partial derivative w.r.t generalized velocities </span>(</span>rendertex </span>( ((</span>partial </span>2</span>) (</span>L3-central </span>'m (</span>literal-function </span>'V))) </span> (</span>up </span>'t </span> (</span>up </span>'r 'theta 'phi) </span> (</span>up </span>'rdot 'thetadot 'phidot)))) </span></code></pre> \begin{bmatrix}\displaystyle{m\,\dot r} \cr \cr \displaystyle{m\,{r}^{2}\,\dot {\theta}} \cr \cr \displaystyle{m\,\dot {\phi}\,{r}^{2}\,{\sin}^{2}\left(\theta\right)}\end{bmatrix} </div> The momentum conjugate to $\varphi$ is conserved. We can show that this is actually the $z$ component of the angular momentum vector $r \times (m\vec{v})$, for position $\vec{r}$ and linear momentum $m\vec{v}$ by writing the $z$ component of the angular momentum in spherical coordinates:</p> ;; z component of ang momentum </span>(</span>defn </span>ang-mom-z </span>[m] </span> (</span>fn </span>[[_</span>,</span> xyz</span>,</span> v]] </span> (</span>ref </span>(</span>cross-product</span> xyz (</span></span> m v)) </span>2</span>))) </span> </span>;; Coordinate conversion </span>(</span>defn </span>s->r2 </span>[[_</span>, </span>[r</span>,</span> theta</span>,</span> phi]]] </span> (</span>let </span>[x (</span></span> r (</span>sin</span> theta) (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> theta) (</span>sin</span> phi)) </span> z (</span></span> r (</span>cos</span> theta))] </span> (</span>up</span> x y z))) </span> </span>(</span>rendermd </span> ((</span>compose </span>(</span>ang-mom-z </span>'m) (</span>F->C</span> s->r)) </span> (</span>up </span>'t </span> (</span>up </span>'r 'theta 'phi) </span> (</span>up </span>'rdot 'thetadot 'phidot)))) </span> </span>;; results in m phidot r² sin²(θ) which is equal to the momentum conjugate of phi </span></code></pre> $$ m\,\dot {\phi}\,{r}^{2}\,{\sin}^{2}\left(\theta\right) $$ </div> Since the choice of $z$ axis arbitrary based on the coordinate system, if one component is conserved, then all components are conserved. Therefore, angular momentum is conserved. We can choose</strong> the $z$ axis such that all the angular momentum is in the $z$ component.</p> So for a general position vector $\vec{x}$, since $\vec{x}\cdot L = \vec{x}\cdot(m\vec{x}\times\vec{v}) = \vec{v}\cdot(\vec{x}\times\vec{x}) = 0$ ( from the scalar triple product), the motion is confined to the plane perpendicular to the angular momentum i.e., colatitude $\theta = \pi/2$ and $\dot{\theta} = 0$. This motion was discussed before in Section 1.6</p> Ref: https://physics.stackexchange.com/q/731892/47598</a></p> Computing the energy from the Lagrangian, we can see that it does equal $T+V$</p> (</span>rendermd </span> ((</span>Lagrangian->energy </span>(</span>L3-central </span>'m (</span>literal-function </span>'V))) </span> (</span>up </span>'t </span> (</span>up </span>'r 'theta 'phi) </span> (</span>up </span>'rdot 'thetadot 'phidot)))) </span> </span>;; The energy is conserved because the Lagrangian has no explicit time dependence. </span></code></pre> $$ \frac{1}{2}\,m\,{\dot {\phi}}^{2}\,{r}^{2}\,{\sin}^{2}\left(\theta\right) + \frac{1}{2}\,m\,{r}^{2}\,{\dot {\theta}}^{2} + \frac{1}{2}\,m\,{\dot r}^{2} + V\left(r\right) $$ </div> Exercise 2.5: A constraint on the moments of inertia 2022-11-06T00:07:04+00:00 Exercise 2.5: A constraint on the moments of inertia</h2> Show that the sum of any two of the moments of inertia is greater than or equal to the third moment of inertia. You may assume the moments of inertia are with respect to orthogonal axes.</strong></p> Consider an arbitrary orthogonal coordinate frame with axes $x$, $y$ and $z$. The inertia matrix of a body in this coordinate frame is:</p> $$ \begin{align} I = \begin{bmatrix}\sum\nolimits_i m_i \left(y_i^2 + z_i^2 \right) & -\sum\nolimits_i m_i x_i y_i & -\sum\nolimits_i m_i x_i z_i\\ - \sum\nolimits_i m_i y_i x_i & \sum\nolimits_i m_i \left(x_i^2 + z_i^2 \right) & -\sum\nolimits_i m_i y_i z_i\\ - \sum\nolimits_i m_i z_i x_i & -\sum\nolimits_i m_i z_i y_i & \sum\nolimits_i m_i \left(x_i^2 + y_i^2 \right)\\ \end{bmatrix} \end{align} $$ </div> Therefore the moments of inertia are: $\left[ \sum\nolimits_i m_i \left(y_i^2 + z_i^2 \right), \sum\nolimits_i m_i \left(x_i^2 + z_i^2 \right), \sum\nolimits_i m_i \left(x_i^2 + y_i^2 \right) \right]$</p> $$ \begin{align} I_{xx} + I_{yy} - I_{zz} &= \sum\nolimits_i m_i \left(y_i^2 + z_i^2 \right) + \sum\nolimits_i m_i \left(x_i^2 + z_i^2 \right) - \sum\nolimits_i m_i \left(x_i^2 + y_i^2 \right)\\ &= \sum\nolimits_i m_i \left(\cancel{y_i^2} + 2 z_i^2 + \cancel{x_i^2} - \cancel{x_i^2} - \cancel{y_i^2}\right)\\ &= \sum\nolimits_i m_i \left(2 z_i^2\right)\\ \end{align} $$ </div> Since $z_i^2$ are all positive, $\sum\nolimits_i m_i \left(2 z_i^2\right) \geq 0$. Therefore,</p> $$ \begin{align} I_{xx} + I_{yy} - I_{zz} &\geq 0 \\ \implies I_{xx} + I_{yy} &\geq I_{zz} \\ \end{align} $$ </div> Exercise 2.4: Jupiter 2022-11-05T23:47:04+00:00 Exercise 2.4: Jupiter</h2> a. The density of a planet increases toward the center. Provide an argument that the moment of inertia of a planet is less than that of a sphere of uniform density of the same mass and radius.</strong></p> The higher masses at the center of the planet are scaled by the smaller distances and the smaller masses at the periphery are multiplied the larger distances. With uniform density, there would be more mass at the periphery, contributing to a higher total moment of inertia.</p> b. The density as a function of radius inside Jupiter is well approximated by</strong></p> $$ \rho(r) = \frac{M}{R^3} \frac{\sin{(\pi r/R)}}{4r/R} $$ </div> where $M$ is the mass and $R$ is the radius of Jupiter. Find the moment of inertia of Jupiter in terms of $M$ and $R$.</strong></p> \| z axis </span> \| </span> \| </span> >\| \|<--- r sinΦ </span> , - ~ ~ ~ - ,\| </span> , ' \|------<>' , </span> , \| / , </span> , \| Φ /R , </span> , \| / , </span> , +-/--------R-->, </span> , \| , </span> , \| , </span> , \| , </span> , \| , ' </span> ' - , _ _ _ , ' </span> \| </span></code></pre> Consider an infinitesimal volume at position $(r, \theta, \phi)$ where $r$ is the radial distance from the center, $\theta$ is the longitude and $\phi$ is the colatitude. Assume that the north-south axis is the axis we are interested in. The distance of the volume from the axis is $r_\perp = r\sin\phi$. The dimensions of the elemental volume are $dr$ in the radial direction, $d\theta$ along the longitude and $d\phi$ along the colatitude. The arc lengths of the “sides” of the element are $r\sin\phi d\theta$ and $r d\phi$. The volume is $dV = r\sin\phi~d\theta~rd\phi~dr$.</p> $$ \begin{align} I &= \iiint_Q r_\perp^2 dm \\ &= \iiint_Q r^2 \sin^2{\phi}~\rho(r)~dV \\ &= \iiint_Q r^2 \sin^2{\phi}~\rho(r)~r\sin\phi~d\theta~rd\phi~dr \\ &= \iiint_Q r^2 \sin^2{\phi}~\rho(r)~r^2 \sin{\phi}~d\theta~d\phi~dr \\ &= \iiint_Q \rho(r) r^4 \sin^3{\phi}~d\theta~d\phi~dr \\ &= \int_0^R \int_{-\pi}^{\pi} \int_{0}^{\pi} \rho(r) r^4 \sin^3{\phi}~d\phi~d\theta~dr\\ &= \int_0^R \rho(r) r^4 \int_{-\pi}^{\pi} \int_{0}^{\pi} \sin^3{\phi}~d\phi~d\theta~dr\\ \end{align} $$ </div> Reference: https://math.stackexchange.com/questions/1475096/why-does-the-volume-element-in-spherical-polar-coordinates-contain-a-sine-of-the</a></p> r = </span>symbols</span>('</span>r</span>', </span>positive</span>=</span>True</span>) </span>theta, phi = </span>symbols</span>('</span>theta phi</span>', </span>real</span>=</span>True</span>) </span>M, R = </span>symbols</span>('</span>M R</span>', </span>positive</span>=</span>True</span>) </span> </span>rho = M/R*</span>3 </span> </span>sin</span>(pir/R)/(</span>4</span>r/R) </span> </span>integral_1 = </span>integrate</span>( </span>sin</span>(phi)*</span>3</span>, (phi, </span>0</span>, pi)) </span>integral_2 = </span>integrate</span>( integral_1, (theta, -pi, pi) ) </span>integral_3 = </span>integrate</span>( rho r*</span>4 </span> integral_2, (r, </span>0</span>, R)) </span>simplify</span>(integral_3) </span></code></pre> $\displaystyle \frac{2 M R^{2} \left(-6 + \pi^{2}\right)}{3 \pi^{2}}$ </div> The moment of inertia of Jupiter is:</p> $$ I = \frac{2}{3\pi^2} MR^2 \left(\pi^2 -6\right) $$ </div> Exercise 2.3: Some useful moments of inertia 2022-11-05T19:11:34+00:00 Exercise 2.3: Some useful moments of inertia</h2> Show that the moments of inertia of the following objects are as given:</strong></p> a. The moment of inertia of a sphere of uniform density with mass $M$ and radius $R$ about any line through the center is</strong> $\frac{2}{5} M R^2$</p> $$\require{cancel}$$</p> The moment of inertia of a body about some axis is given by the expression:</p> $$ I_{P}=\iiint _{Q}\rho (x,y,z)\left\\|\mathbf {r} \right\\|^{2}dV\\ $$ </div> Since the sphere is symmetric, the moment of inertia about any axis through its center of mass is the same. Here we assume that the axis is the $z$ axis. We split the sphere into a collection of infinitesimally thin concentric cylinderical shells around the $z$ axis.</p> The moment of inertia is:</p> $$ I = \int x^2 dm\\ $$ </div> where $r$ is the distance of a cylinderal shell from the $z$ axis and $dm$ is its mass. The mass $dm$ is equal to $\rho dV$ where $\rho$ is the density of the material and $dV$ is the volume of the cylindrical shell.</p> For a sphere of radius $R$, the density $\rho$ is:</p> $$ \rho = \frac{M}{\frac{4}{3}\pi R^3} = \frac{3M}{4\pi R^3}\\ $$ </div> </span> </span> z </span> \| </span> .---------. </span> ( \| ) -- </span> \|\|~--------~\|\| \| </span> \|\| \| \|\| \| </span> \|\| \| \|\| \| </span> \|\| \| \|\| y </span> \|\| \| \|\| \| </span> \|\| \|<-x->\|\| \| </span>-------.------------- </span> \|\| \|\| </span> \|\| \|\| </span> \|\| \|\| </span> \|\| \|\| </span> \|\| \|\| </span> \|\| \|\| </span> (------------) </span></code></pre> The height of the cylindrical shell at distance $x$ from the $z$ axis is equal to $2y$. The thickness of shell is erqual to $dx$ . Therefore volume of the cylindrical shell is:</p> $$ \begin{align} dV &= 2 \pi r h \Delta r\\ &= 2 \pi x (2y) dx \\ &= 4 \pi x \sqrt{R^2 - x^2} dx\\ \end{align} $$ </div> Therefore the mass of the cylindrical shell is:</p> $$ \begin{align} dm &= \rho dV \\ &= \frac{3 M}{\cancel{4\pi} R^3} \cancel{4 \pi} x \sqrt{R^2 - x^2} dx \\ dm &= \frac{3 M}{R^3} x \sqrt{R^2 - x^2} dx\\ \end{align} $$ </div> The moment of inertia is:</p> $$ \begin{align} I = \int_{-R}^{+R} x^2 dm \\ = \int_{-R}^{+R} x^2 \frac{3 M}{R^3} x \sqrt{R^2 - x^2} dx \\ = \frac{3 M}{R^3}\int_{-R}^{+R} x^3 \sqrt{R^2 - x^2} dx\\ \end{align} $$ </div> This expression is integrated using sympy</code> below:</p> R, M = </span>symbols</span>('</span>R M</span>', </span>positive</span>=</span>True</span>) </span>x = </span>symbols</span>('</span>x</span>', </span>real</span>=</span>True</span>) </span>(</span>3</span>M / R</span>3</span>) </span>integrate</span>(x*</span>3 </span> </span>sqrt</span>(R</span>2 </span>- x</span>2</span>), (x, </span>0</span>, R)) </span></code></pre> $\displaystyle \frac{2 M R^{2}}{5}$ </div> b. The moment of inertia of a spherical shell with mass $M$ and radius $R$ about any line through the center is:</strong> $\frac{2}{3} MR^2$</p> Again, we can pick any diameter as the axis, and we choose the $z$-axis. Consider an infinitesimally thin ring around the z-axis that is part of the shell (which is itself of radius $R$).</p> \| z axis </span> \| </span> , - ~ ~ ~ - , </span> , '=======\|=======' , <-- thickness is R dθ </span> , \| / , </span> , \| θ /R , </span> , \| / , </span> , +-/--------R-->, </span> , \| , </span> , \| , </span> , \| , </span> , \| , ' </span> ' - , _ _ _ , ' </span> \| </span></code></pre> If the angle of a line from the origin to the edge of the ring to the $z$ axis is $\theta$, the radius of the ring is therefore $R\sin{\theta}$. The thickness of the ring is $R d\theta$. Area of the ring is:</p> $$ \begin{align} dA &= 2\pi (r) Rd\theta \\ &= 2\pi R\sin{\theta} R d\theta\\ &= 2\pi R^2 \sin{\theta} d\theta \end{align} $$ </div> If $\sigma$ is the area-density of the sphere ($\sigma = \frac{M}{4 \pi R^2}$), the mass of the ring $dm = dA \sigma$. The moment of inertia of the ring is therefore:</p> $$ \begin{align} dI &= r^2 dm \\ &= R^2 \sin^2{\theta} dm \\ &= R^2 \sin^2{\theta} \sigma dA \\ &= (R^2 \sin^2{\theta}) \sigma (2\pi R^2 \sin{\theta} d\theta)\\ &= (R^2 \sin^2{\theta}) (\frac{M}{\cancelto{2}{4} \cancel{\pi R^2}} \cancel{2} \cancel{\pi R^2} \sin{\theta} d\theta)\\ &= R^2\frac{M}{2} \sin^3{\theta} d \theta\\ \end{align} $$ </div> To obtain the moment of inertia of the body, we integrate $dI$ over $\theta$ from $0$ to $\pi$ ($\theta = 0$ corresponds to the “north pole” of the sphere and $\theta = \pi$ corresponds to the south pole.)</p> Reference: https://www.youtube.com/watch?v=Y2X0xjwxxwI</a></p> R, M = </span>symbols</span>('</span>R M</span>', </span>positive</span>=</span>True</span>) </span>theta = </span>symbols</span>('</span>theta</span>', </span>real</span>=</span>True</span>) </span> </span>M * R*</span>2 </span>/ </span>2 </span> </span>integrate</span>(</span>sin</span>(theta)*</span>3</span>, (theta, </span>0</span>, pi)) </span></code></pre> $\displaystyle \frac{2 M R^{2}}{3}$ </div> c. The moment of inertia of a cylinder of uniform density with mass M and radius R about the axis of the cylinder is</strong> $\frac{1}{2} M R^2$</p> </span> </span> z </span> \| </span> .--------. </span> ( \| ) -- </span> \|~--------~\| \| </span> \| \| \| \| </span> \| \| \| \| </span> \| \| \| H/2 </span> \| \| \| \| </span> \| \|<-R->\| \| </span>-------.------------- </span> \| \| </span> \| \| </span> \| \| </span> \| \| </span> \| \| </span> \| \| </span> (----------) </span></code></pre> Let $z$ axis be the axis of the cylinder. Split the cylinder into concentric infinitesimally thin cylindrical shell around the $z$ axis. The radius of such a shell is $x$ and its thickness is $dx$. The volume of the shell is:</p> $$ \begin{align} dV &= 2 \pi r h \Delta r\\ &= 2 \pi x H dx \end{align} $$ </div> The density of the cylinder is $\rho = \frac{M}{\pi R^2 H}$. Therefore the mass of the cylindrical shell is:</p> $$ \begin{align} dm &= \rho dV \\ &= \frac{M}{\cancel{\pi} R^2 \cancel{H}} 2 \cancel{\pi} x \cancel{H} dx\\ &= \frac{2 M}{R^2} x dx\\ \end{align} $$ </div> Therefore the moment of inertia of the entire cylinder is:</p> $$ \begin{align} I &= \int dI\\ &= \int_0^R x^2 dm \\ &= \int_0^R x^2 \frac{2 M}{R^2} x dx \\ &= \frac{2 M}{R^2} \int_0^R x^3 dx \\ &= \frac{2 M}{R^2} \left.\left[ \frac{x^4}{4}\right]\right\vert_{0}^{R}\\ &= \frac{\cancel{2} M}{\cancel{R^2}} \left[ \frac{R^\cancelto{2}{4}}{\cancelto{2}{4}} \right]\\ &= \frac{1}{2}MR^2\\ \end{align} $$ </div> d. The moment of inertia of a thin rod of uniform density per unit length with mass M and length L about an axis perpendicular to the rod through the center of mass is</strong> $\frac{1}{12} ML^2$</p> y-axis </span> ^ </span> \| </span> \|<---- L/2 --->\| </span> \| \| </span> \| dx \| </span> \| >\|\|< \| </span> \|---x-->\|\| \| </span>==============+==============\| --> x-axis </span> </span></code></pre> Consider an element at distance $x$ from the center of mass with length $dx$. The mass of this element is $dm = dx \sigma$ if $\sigma$ is the linear-density of the rod, $\sigma = \frac{M}{L}$.</p> The moment of inertia of this element is:</p> $$ dI = x^2 dm = x^2 \sigma dx = \frac{M}{L} x^2 dx\\ $$ </div> Therefore the moment of inertia of the rod is:</p> $$ \begin{align} I &= \int_{-L/2}^{L/2} \frac{M}{L} x^2 dx \\ &= \frac{M}{L} \left.\left[ \frac{x^3}{3} \right]\right\vert_{-L/2}^{L/2}\\ &= \frac{M}{L} \left[ \frac{L^3}{24} - \frac{-L^3}{24} \right] \\ &= \frac{M}{\cancel{L}} \left[ \frac{L^\cancelto{2}{3}}{12} \right]\\ &= \frac{1}{12} M L^2\\ \end{align} $$ </div> Section 2.5: Principal Moments of Inertia 2022-11-05T17:53:57+00:00 2.5 Principal Moments of Inertia</h2> In the previous section</a>, we showed how the inertia tensor transforms under a rotation:</p> $$ \mathbf{I}' = \mathbf{R}^{\mathscr{T}} \mathbf{I} \mathbf{R} \tag{2.35} $$ </div> This transformation can be used to show that there are special rectangular coordinate frames for which the inertia tensor is diagonal, that is, $I^\prime_{ij} = 0\text{ for }i \neq j$. Let’s assume that $\mathbf{I}^\prime$ is diagonal and we need to solve for the rotation matrix $\mathbf{R}$ the gets us $\mathbf{I}^\prime$ from $\mathbf{I}$.</p> Left-multiply both sides of Eq. 2.35 by $\mathbf{R}$ to get:</p> $$ \begin{align} \mathbf{R} \mathbf{I'} &= \mathbf{R}\mathbf{R}^{\mathscr{T}} \mathbf{I} \mathbf{R} \\ &= \mathbf{I} \mathbf{R}\tag{2.36} \end{align} $$ </div> We can extract out the columns of this matrix by mutliplying it on the right with the coordinate axis unit vectors, $\mathbf{e}_i$. These vectors have a 1 in the $i$-th row and zero elsewhere. Multiply $\mathbf{R}$ with $\mathbf{e}_i$ extracts out the basis vector of the rotated frame, $\mathbf{e}^\prime_i$. That is, $\mathbf{e}^\prime_i = \mathbf{R} \mathbf{e}_i$. Right-multiplying Eq. 2.36 by $\mathbf{e}_i$, we get:</p> $$ \mathbf{R} \mathbf{I^\prime} \mathbf{e}_i = \mathbf{I}\mathbf{R}\mathbf{e}_i = \mathbf{I}\mathbf{e}^\prime_i\tag{2.37} $$ </div> Since $\mathbf{I}^\prime$ is diagonal,</p> $$ \mathbf{I}\mathbf{e}^\prime_i = I^\prime_{ii} \mathbf{e}^\prime_i \tag{2.38} $$ </div> From Eqs. 2.37 and 2.38, we get:</p> $$ \mathbf{I} \mathbf{e}^\prime_i = I^\prime_{ii} \mathbf{e}^\prime_i\\ $$ </div> This equation says that transforming the vector $\mathbf{e}^\prime_i$ using the matrix $\mathbf{I}$ is equivalent to scaling the vector by the scalar value $I^\prime_{ii}$. This means that $I^\prime_{ii}$ is an eigen-value and $\mathbf{e}^\prime_i$ is the associated eigen-vector of $\mathbf{I}$.</p> Since $\mathbf{e}^\prime_i$ are the columns of a rotation matrix, and rotqtion matrix are orthogonal, the vectors themselves are orthonormal, i.e. they are unit vectors and their dot products with each other are zero.</p> For a real, symmetric matrix (like $\mathbf{I}$). the eigen values are real. If the eigen values are distinct, then the eigen-vectors are orthogonal. However, if the eigen values are not distinct (say in the case of a symmetric body liuke a sphere), we have degrees of freedom on choosing the eigen vectors - and we may pick $\mathbf{e}_i$ that are orthogonal. For example, for a cylinder, one of the eigen vectors(corresponding to the central axis) are distinct and the other two (corrsponding to the diameters of the circular faces) are equal. This means that any of the diameters can be considered an eigen vector.</p> This the rotated coordinate system has a special orientation with respect to the body. The basis vectors correspond to particular directions w.r.t the body. The axes through the center of mass in these directions are defined as the principal axes</em>. Thus the moments of inertia about the principal axes are the eigenvalues $I^\prime_{ii}$ and are called the principal moments of inertia</em>.</p> The principal moments of inertia are often labeled according their size: $A \leq B \leq C$ with the corresponding axes: $\hat{a}$, $\hat{b}$ or $\hat{c}$. The components of some vector $\mathbf{x}$ when represented in terms of the principal axes are called body components</em> of the vector. Rewriting the kinetic energy in terms of the principal moments of inertia,</p> $$ T_R = \frac{1}{2} \left[ A(\omega^a)^2 + B(\omega^b)^2 + C(\omega^c)^2\right]\tag{2.41} $$ </div> where $(\omega^a, \omega^b, \omega^c)$ are the components of the angular momentum vector on the principal axes.</p> (</span>defn </span>T-body </span>[A B C] </span> (</span>fn </span>[omega-body] </span> (</span> </span>1/2 </span> (</span>+ </span>(</span></span> A (</span>square </span>(</span>ref</span> omega-body </span>0</span>))) </span> (</span></span> B (</span>square </span>(</span>ref</span> omega-body </span>1</span>))) </span> (</span></span> C (</span>square </span>(</span>ref</span> omega-body </span>2</span>))))))) </span> </span>(</span>rendermd </span>((</span>T-body </span>'A 'B 'C) </span> (</span>up </span>'omega_a 'omega_b 'omega_c))) </span></code></pre> $$ \frac{1}{2}\,A\,{{\omega}_a}^{2} + \frac{1}{2}\,B\,{{\omega}_b}^{2} + \frac{1}{2}\,C\,{{\omega}_c}^{2} $$ </div> </span></code></pre> Exercise 2.2: Steiner's Theorem 2022-11-04T05:30:04+00:00 Exercise 2.2: Steiner’s theorem</h3> Let I be the moment of inertia of a body with respect to some given line through the center of mass. Show that the moment of inertia I′ with respect to a second line parallel to the first is</strong></p> $$ I' = I + M R^2\\ $$ </div> where $M$ is the mass of the body and $R$ is the distance between the lines.</strong></p> $$\require{cancel}$$</p> The position of any particle with respect to the axis can be resolved into a parallel component and a perpendicular component. Only the perpendicular component influences the moment of inertia and so the analysis can be performed in a plane perpendicular to the axis and generalized to the whole object.</p> So consider a cross sectional area of the object such that the original axis is perpendicular to this area. Let the center of mass of the area be the origin of the coordinate frame, with basis vectors $\hat{x}$ and $\hat{y}$ in the plane and perpendicular to each other, and $\hat{z}$ being the rotational axis. Let the new parallel axis be passing through the point $w$ on this plane at position $(x_w, y_w)$, parallel to the $\hat{z}$ axis. The distance of this point $w$ from the origin is $R = \sqrt{x_w^2 + y_w^2}$.</p> The moment of inertia of about the original axis through the center of mass is:</p> $$ \begin{align} I &= \sum\nolimits_\alpha m_\alpha r_\alpha ^2 \end{align} $$ </div> where $r_\alpha$ is the distance of the particle at index $\alpha$ from the origin (the center of mass) and is equal to $\sqrt{x^2_\alpha + y^2_\alpha}$.</p> The distance a particle $\alpha$ to the new axis is given by $d_\alpha = \sqrt{ (x_\alpha - x_w)^2 + (y_\alpha - y_w)^2 }$. Therefore, the moment of inertia about the new axis is:</p> $$ \begin{align} I' &= \sum\nolimits_\alpha m_\alpha d_\alpha ^2 \\ &= \sum\nolimits_\alpha m_\alpha \left( (x_\alpha - x_w)^2 + (y_\alpha - y_w)^2 \right)\\ &= \sum\nolimits_\alpha m_\alpha \left( x_\alpha^2 + x^2_w - 2x_\alpha x_w + y^2_\alpha +y^2_w - 2y_\alpha y_w \right) \\ &= \sum\nolimits_\alpha m_\alpha \left( \underbrace{(x_\alpha^2 + y^2_\alpha)}_{=r_\alpha ^2} + \underbrace{(x^2_w + y^2_w)}_{=R^2} - 2x_\alpha x_w - 2y_\alpha y_w \right) \\ &= \sum\nolimits_\alpha m_\alpha r_\alpha ^2 + \sum\nolimits_\alpha m_\alpha R^2 -2 x_w \sum\nolimits_\alpha m_\alpha x_\alpha -2 y_w \sum\nolimits_\alpha m_\alpha y_\alpha \end{align} $$ </div> The total mass of the body $M = \sum\nolimits_\alpha m_\alpha$. Since the origin is the center of mass of the plane, $ \sum\nolimits_\alpha m_\alpha x_\alpha = \sum\nolimits_\alpha m_\alpha y_\alpha = 0$.</p> $$ \begin{align} I' &= \sum\nolimits_\alpha m_\alpha r_\alpha ^2 + \sum\nolimits_\alpha m_\alpha R^2 -2 x_w \cancel{\sum\nolimits_\alpha m_\alpha x_\alpha} -2 y_w \cancel{\sum\nolimits_\alpha m_\alpha y_\alpha} \end{align} $$ </div> Therefore, the moment of inertia about the parallel axis is:</p> $$ I' = I + MR^2\\ $$ </div> Section 2.4: Inertia Tensor 2022-11-04T04:44:49+00:00 2.4 Inertia Tensor</h2> The representation of kinetic energy in terms of the inertia tensor involved a rectangular coordinate frame with basis vectors, $\hat{e}$. However the kinetic energy must be the same regardless of the coordinate frame use. This fact can be used to derive how the inertia tensor transforms if the body or the coordinate frame are rotated.</p> Active and passive rotations</h4> Rotating the vector $\vec{x}$ by the rotation $R$ produces a new vector $\vec{x’} = R\vec{x}$. $\vec{x}$ may be written in terms of some arbitrary rectangular coordinate system with the basis vectors ($\hat{e_1}$, $\hat{e_2}$, $\hat{e_3}$). Let $\mathbf{x}$ represent the column vector</em> components $x^0$, $x^1$ and $x^2$ fo the vector in this coordinate frame. Let $\mathbf{R}$ be the matrix representation of the rotaton $R$ w.r.t the same coordinate frame. With these definitions, the rotation can be written as: $\mathbf{x}’ = \mathbf{R}\mathbf{x}$. Since this rotation carries the vectors to new vectors, it is an active rotation</strong>.</p> Alternately, we can rotate the basis vectors used to represent the vectors. While the vectors themselves may be unchanged, the components used to represent them are changed because the basis vectors are now in new orientations. If the new, rotated basis vector are represented by $\hat{e}‘_i = R\hat{e}_i$. The componenet along the rotated basis vector is the dot product of the vector $\vec{x}$ with the new basis vector, that is: $(x’)^i = \vec{x} \cdot \hat{e}’_i = \vec{x} \cdot (R \hat{e}_i)$.</p> Since the rotation of two vectors preserves the angle (and hence the dot product), between them,</p> $$ \begin{align} \vec{x} \cdot \vec{y} &= (R\vec{x})\cdot(R\vec{y})\\ => R^{-1} \vec{x} \cdot \vec{y} &= \vec{x} \cdot (R\vec{y})\\ \end{align} $$ </div> Therefore,</p> $$ (x')^i = \vec{x} \cdot (\mathbf{R} \hat{e}_i) = R^{-1} \vec{x} \cdot \hat{e}_i \\ => \mathbf{x}' = \mathbf{R}^{-1} \mathbf{x} $$ </div> This type of rotation is called a passive rotation</strong> where the vectors were unchanged and the coordinate frame was rotated. For such a rotation, the components of a fixed vector changes as if it was actively rotated by the inverse rotation</strong>.</p> Transformation of moments of inertia under rotation</h4> The kinetic energy in terms of the coordinate frame $\hat{e}_i$ is:</p> $$ T = \frac{1}{2} \sum\nolimits_{ij} \omega^i \omega^j I_{ij} \tag{2.30} $$ </div> In matrix notation, this can be written as :</p> $$ T = \frac{1}{2} \boldsymbol{\omega}^{\mathscr{T}} \mathbf{I} \boldsymbol{\omega}\tag{2.31} $$ </div> where $\boldsymbol{\omega}$ is the column vector containing the components of the angular velocity vector $\vec{\omega}$ in the $\hat{e}_i$ coordinate frame. Applying a passive rotation $R$ to the coordinate frame gets us the new coordinate frame basis vectors $\hat{e}’_i = R \hat{e}_i$. The components of $\boldsymbol{\omega}$ in the new frame satisfies the condition:</p> $$ \begin{align} \boldsymbol{\omega}' &= \mathbf{R}^{-1} \boldsymbol{\omega}\\ => \boldsymbol{\omega} &= \mathbf{R} \boldsymbol{\omega}' \end{align} $$ </div> Therefore the kinetic energy is:</p> $$ \begin{align} T &= \frac{1}{2} \boldsymbol{\omega}^{\mathscr{T}} \mathbf{I} \boldsymbol{\omega} \\ &= \frac{1}{2} (\mathbf{R} \boldsymbol{\omega}')^{\mathscr{T}} \mathbf{I} \mathbf{R} \boldsymbol{\omega}' \\ &= \frac{1}{2} (\boldsymbol{\omega}')^{\mathscr{T}}\mathbf{R}^{\mathscr{T}} \mathbf{I} \mathbf{R} \boldsymbol{\omega}'\tag{2.33} \\ \end{align} $$ </div> However, the kinetic energy in the $\hat{e}’$ frame is:</p> $$ T = \frac{1}{2} (\boldsymbol{\omega}')^{\mathscr{T}} \mathbf{I}' \boldsymbol{\omega} \tag{2.34} $$ </div> where the components are in terms of the $\hat{e}’$ frame. Comparing equations 2.34 and 2.33, we get:</p> $$ \mathbf{I}' = \mathbf{R}^{\mathscr{T}} \mathbf{I} \mathbf{R} \tag{2.35} $$ </div> This type of transformation is called a “similarity transformation” and this is how the inertia tensor transforms under passive rotation.</p> Seam carving algorithm 2022-11-04T01:54:02.252+00:00 Seam carving is an algorithm that can be used to resize an image while removing the least important pixels from it.</p> One possible implementation is to use an edge-detection algorithm first to create an edge-map1</a></sup>. This is followed by finding continuous lines that run from top to the bottom, where the only directions of movement allowed are “south”, “south-east” and “south-west”, that minimize the sum of “edge” values. This can be solved using a dynamic programming approach of starting at the bottom and assigning the “minimum-cost-to-bottom” to each cell.</p> Once this is done, we can find the path throug hthe image with the least cost and remove it.</p> ^1</sup>Seam Carving \| Week 2 \| 18.S191 MIT Fall 2020 \| Grant Sanderson</a></p> </div> Section 1.6.2: Systems with Rigid Constraints 2022-11-03T05:17:50+00:00 1.6.2 Systems with Rigid Constraints</h2> So far we have found $L = T-V$ to be a suitable Lagrangian for systems of point particles subject to forces derived from a potential. In this section, we will find that $L = T − V$, expressed in irredundant</em> coordinates, is also a suitable Lagrangian for modeling systems of point particles with rigid constraints.</p> Lagrangians for rigidly constrained systems</h3> We start with a system of $N$ point masses, indexed by $\alpha$ in 3D space. We choose a set of generalized coordinates $q$ that have the system constraints built into them. The rectangular coordinates can then be defined as:</p> $$ \mathbf{x}_\alpha = f_\alpha(t, q)\\ $$ </div> where all the coordinate constraints are built into the functions $f_\alpha$. The velocities can then be obtained in terms of the generalized velocities, $v$ in the same manner as in the last section as:</p> $$ \mathbf{v}_\alpha = \partial_0 f_\alpha(t, q) + \partial_1 f_\alpha(t, q) v\\ $$ </div> The kinetic energy in rectangular coordinates can be obtained as:</p> $$ \widetilde{T}(t; x_0 ... x_{N-1}; v_0 ... v_{N-1}) = \sum_\alpha \frac{1}{2} m_\alpha \mathbf{v}_\alpha^2\\ $$ </div> Converting to generalized coordinates:</p> $$ T(t, q, v) = \sum_\alpha \frac{1}{2} m_\alpha \left( \partial_0 f_\alpha(t, q) + \partial_1 f_\alpha(t, q) v \right) $$ </div> Similarly, the potential energy in generalized coordinates is:</p> $$ V(t, q, v) = \widetilde{V}(t, f(t, q)) $$ </div> The Lagrangian can then be obtained as $L = T - V$.</p> A pendulum driven at the pivot</h3> Consider a pendulum of length $l$ and mass $m$, modeled as a point mass, supported by a pivot that is driven in the vertical direction by a given function of time $y_s(t)$. This system has a single degree of freedom and can be represented by the generalized coordinate $\theta$, the angle of the pendulum from the vertical.</p> </p> The position of the bob is given in rectangular coordinates by</p> $$ x = l\sin{\theta} \text{ and } y = y_s(t) - l\cos{\theta} $$ </div> The velocities are:</p> $$ v_x = l\dot{\theta}\cos{\theta} \text{ and } v_y = Dy_s(t) + l\dot{\theta}\sin{\theta} $$ </div> The kinetic energy is:</p> $$ \begin{align} \widetilde{T}(t; x,y; v_x, v_y) &= \frac{1}{2}m(v_x^2 + v_y^2) \\ T(t,\theta,\dot{\theta}) &= \frac{1}{2}m ( (l\dot{\theta}\cos{\theta})^2 + (Dy_s(t) + l\dot{\theta}\sin{\theta})^2 \\ &= \frac{1}{2}m \left( l^2\dot{\theta}^2(\cos^2{\theta} + \sin^2{\theta}) + (Dy_s(t))^2 + 2l\dot{\theta}\sin{\theta}Dy_s(t) \right)\\ &= \frac{1}{2}m \left( l^2\dot{\theta}^2 + (Dy_s(t))^2 + 2l\sin{\theta}Dy_s(t) \dot{\theta} \right) \end{align} $$ </div> The potential energy $\widetilde{V}(t; x,y) = mgy$ in rectangular coordinates. Therefore in generalized coordinates,</p> $$ V(t,\theta,\dot{\theta}) = mg (y_s(t) - l\cos{\theta}) $$ </div> ;; Computing EoMs </span>(</span>defn </span>T-pend-on-pivot </span>[m l g y_s] </span> (</span>fn </span>[[t [theta] [thetadot]]] </span> (</span>let </span>[Dy_s ((</span>D</span> y_s) t)] </span> (</span> </span>1/2</span> m </span> (</span>+ </span>(</span>square </span>(</span></span> l thetadot)) </span> (</span>square</span> Dy_s) </span> (</span> </span>2</span> l (</span>sin</span> theta) Dy_s thetadot) </span> ) </span> ) </span> ) </span> ) </span>) </span> </span>(</span>defn </span>V-pend-on-pivot </span>[m l g y_s] </span> (</span>fn </span>[[t [theta] [thetadot]]] </span> (</span></span> m g (</span>- </span>(</span>y_s</span> t) (</span></span> l (</span>cos</span> theta)))) </span>)) </span> </span>(</span>def </span>L-pend-on-pivot </span>(</span>-</span> T-pend-on-pivot V-pend-on-pivot)) </span> </span>;; (render </span>;; (let [local ((Gamma (up (literal-function 'theta))) 't) </span>;; L (L-pend-on-pivot 'm 'l 'g (literal-function 'y_s)) </span>;; ] </span>;; (L local) </span>;; )) </span> </span>;; EOMs for pendulum driven at pivot </span>(</span>let </span>[L (</span>L-pend-on-pivot </span>'m 'l 'g (</span>literal-function </span>'y_s)) </span> state (</span>up </span>(</span>literal-function </span>'theta))] </span> (</span>rendertex </span>(((</span>Lagrange-equations</span> L) state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{g\,l\,m\,\sin\left(\theta\left(t\right)\right) + {l}^{2}\,m\,{D}^{2}\theta\left(t\right) + l\,m\,\sin\left(\theta\left(t\right)\right)\,{D}^{2}y_s\left(t\right)}\end{bmatrix} </div> Exercise 2.1: Rotational kinetic energy 2022-11-02T06:11:12+00:00 Exercise 2.1: Rotational kinetic energy</h3> Show that the rotational kinetic energy can also be written as:</strong></p> $$ T = \frac{1}{2} I\omega^2\\ $$ </div> where $I$ is the moment of inertia about the line through the center of mass with direction $\hat{\omega}$ and $\omega$ is the instantaneous rate of rotation.</strong></p> $$\require{cancel}$$</p> Let $\hat{\omega}$ be one of the basis vectors of the coordinate system, $\hat{e_0}$, and with its origin at the center of mass of the body. For a constituent particle in the body, $(\xi_\alpha^1)^2 + (\xi_\alpha^2)^2 = \xi_\alpha^\perp$ will equal to the distance from the particle to the line $\hat{e_0}$ which is the same as the line $\hat{\omega}$. Therefore, the inertia component, $I_{00}$ is:</p> $$ \begin{align} I_{00} &= \sum_\alpha m_\alpha \left( (\xi_\alpha^1)^2 + (\xi_\alpha^2)^2 \right) \\ &= \sum_\alpha m_\alpha \left( \xi_\alpha^\perp \right)^2\\ &= I\\ \end{align} $$ </div> where $I$ is the moment of inertia about the line $\hat{\omega}$. Also, by definition, the components of the angular velocity vector, $\vec{\omega}$, are:</p> $$ \begin{align} \omega^0 &= \omega\\ \omega^1 &= 0\\ \omega^2 &= 0\\ \end{align} $$ </div> since we defined $\vec{\omega}$ as being in the direction $\hat{\omega} = \hat{e}_0$. Therefore the kinetic energy is:</p> $$ \begin{align} T &= \frac{1}{2} \sum_{ij} \omega^i\omega^j I_{ij} \\ &= \frac{1}{2} \left( \omega^0\omega^0 I_{00} + \omega^0\cancel{\omega^1} I_{01} + \omega^0 \cancel{\omega^2} I_{02} + ... \right) \\ &= \frac{1}{2} I_{00} \omega^0 \omega^0 \end{align} $$ </div> All the other terms in the expression for $T$ cancel out as the components $\omega^1$ and $\omega^2$ are equal to zero. Therefore,</p> $$ T = \frac{1}{2} I (\omega)^2\\ $$ </div> Section 2.3: Moments of Inertia 2022-11-02T06:01:17+00:00 2.3 Moments of Inertia</h2> The rotational kinetic energy consists of the sum of the kinetic energies of all the constituent particles. This can in turn be written in terms of the angular velocities and some aggregate properties that describe the mass distribution in the rigid body.</p> $$ T = \frac{1}{2}\sum_\alpha m_\alpha \dot{\vec{\xi}}_\alpha \cdot \dot{\vec{\xi}}_\alpha\\ $$ </div> substituting in the relation between $\vec{\omega}$ and $\dot{\vec{\xi}}_{\alpha}$</p> $$ \frac{1}{2}\sum_\alpha m_\alpha \dot{\vec{\xi}}_{\alpha} \cdot \dot{\vec{\xi}}_\alpha = \frac{1}{2}\sum_\alpha m_\alpha \left( \vec{\omega} \times \vec{\xi}_{\alpha} \right) \cdot \left( \vec{\omega} \times \vec{\xi}_\alpha \right)\\ $$ </div> Here, we introduce an arbitrary inertial coordinate frame its the origin at the center of rotation and basis vectors $\hat{e}_0$, $\hat{e}_1$ and $\hat{e}_2$, such that $\hat{e}_0 \times \hat{e}_1 = \hat{e}_2$. If the components of $\vec{\omega}$ in this frame are $\omega^0$, $\omega^1$ and $\omega^2$,</p> $$ \begin{align} \frac{1}{2} & \sum_\alpha m_\alpha \left( \left(\sum_i \hat{e}_i \omega^i \right) \times \vec{\xi}_\alpha \right) \cdot \left( \left(\sum_j \hat{e}_j \omega^j \right) \times \vec{\xi}_\alpha \right)\\ &= \frac{1}{2} \sum_{ij} \omega^i\omega^j\sum_\alpha m_\alpha ( \hat{e}_i \times \vec{\xi}_\alpha) \cdot (\hat{e}_j \times \vec{\xi}_\alpha) \\ &= \frac{1}{2} \sum_{ij} \omega^i\omega^j I_{ij} \end{align} $$ </div> where</p> $$ I_{ij} = \sum_\alpha m_\alpha ( \hat{e}_i \times \vec{\xi}_\alpha) \cdot (\hat{e}_j \times \vec{\xi}_\alpha)\tag{2.24} $$ </div> The nine time-dependent</em> (?!) quantities, $I_{ij}$ form the components of the inertia tensor</em> w.r.t the chosen coordinate system.</p> If the components of $\vec{\xi_\alpha}$ are $\xi_{\alpha}^0$, $\xi_{\alpha}^1$ and $\xi_{\alpha}^2$, we can rewrite $\vec{\xi}_\alpha$ as a sum over its components and simplify the vector products of the basis vectors. Thus we can get expressions for the components of the inertia tensor. The components of the inertia tensor can be arranged to form the inertia matrix</em>.</p> $$ \mathbf{I} = \begin{bmatrix}I_{00} & I_{01} & I_{02}\\ I_{10} & I_{11} & I_{12}\\ I_{20} & I_{21} & I_{22}\end{bmatrix}\tag{2.25} $$ </div> where</p> $$ \begin{align} I_{00} &= \sum_\alpha m_\alpha \left( (\xi_\alpha^1)^2 + (\xi_\alpha^2)^2 \right)\\ I_{11} &= \sum_\alpha m_\alpha \left( (\xi_\alpha^2)^2 + (\xi_\alpha^0)^2 \right)\\ I_{22} &= \sum_\alpha m_\alpha \left( (\xi_\alpha^0)^2 + (\xi_\alpha^1)^2 \right)\\ I_{ij} &= - \sum_\alpha m_\alpha \xi_\alpha^i \xi_\alpha^j\quad\text{ for } i \neq j\\ \end{align} $$ </div> The components of the inertia tensor are real and symmetric, i.e., $I_{jk} = I_{kj}$. In general, the moment of inertia</em> about a line can be defined as $\sum_\alpha m_\alpha (\xi_\alpha^\perp)^2$ where $\xi_\alpha^\perp$ is the distance from the line to the particle with index $\alpha$. The diagonal components of the inertia tensor are the moments of inertia about the lines coinciding with the basis vectors. The off-diagonal components are called the products of inertia</em>.</p> Since the inertia tensor involves only the second order moments of mass, the motion of a free rigid body does not depend on the detailed shape of the body. If two bodies have the same inertia tensor, they have the same kinetic energy regardless of what they look like. The potential energy might have effects based on the shape of the body but for the kinetic energy, the inertia tensor is all that matters.</p> For solid objects, the summation has to be converted to an integral. The general expression for moment of inertia is:</p> $$ I_{P}=\iiint _{Q}\rho (x,y,z)\left\\|\mathbf {r} \right\\|^{2}dV $$ </div> where $\rho (x,y,z)$ is the density of the material, $\mathbf {r}$ is a vector perpendicular to the axis of rotation and extending from a point on the rotation axis to a point $(x,y,z)$ in the solid, and the integration is evaluated over the volume $V$ of the body $Q$.</p> Section 1.8.4: The Restricted Three Body Problem 2022-11-02T04:49:30+00:00 1.8.4 The Restricted Three-Body Problem</h2> Consider two bodies of masses $M_0$ and $M_1$ in circular orbits about their barycenter. Assume that a third particle has a small enough mass $m$ to not have any effect on the orbits of the other two objects. This third particle moves in a field of time-varying gravitational potential energy.</p> Let $a$ be the constant distance between the two bodies. If the center of mass is at the origin of the coordinate system, then the distances of the two bodies from the origin are given by:</p> $$ a_0 = \frac{M_1}{M_0 + M_1}a, \quad a_1 = \frac{M_0}{M_0 + M_1}a\\ $$ </div> Each body revolves around the barycenter with angular frequency $\Omega$, with radii as defined above. Kepler’s Law gives the relation between $\Omega$ and $a$ as:</p> $$ \Omega^2a^3 = G(M_0 + M_1) $$ </div> We choose our axes so that at time $t_0$, mass $M_1$ is on the positive $\hat{x}$-axis and $M_0$ is on the negative $\hat{x}$-axis. The gravitational potential energy function is:</p> $$ V(t, r) = - \left(\frac{GM_0m}{r_0} + \frac{GM_1m}{r_1} \right) $$ </div> where:</p> $$ \begin{align} r_0 &= \sqrt{(x-x_0)^2 + (y-y_0)^2} \\ r_1 &= \sqrt{(x-x_1)^2 + (y-y_1)^2} \\ \\ x_0 &= -a_0\cos(\Omega t) \\ y_0 &= -a_0\sin(\Omega t) \\ x_1 &= a_1\cos(\Omega t) \\ y_1 &= -a_1\sin(\Omega t) \\ \Omega &= \frac{G(M_0+M_1)}{a^3} \end{align} $$ </div> It is convenient to instead use a coordinate frame that is rotating along with the two bigger bodies, such that the bodies appear fixed. place the axes so that the two bodies are on the new $\hat{x}’$ axis and we can choose rotating and non-rotating axes to be coincident at time, $t=0$. We can transform to the rotating rectangular coordinates as we did in Section 1.6.1 and get the new Lagrangian as</p> $$ L(t; x_r, y_r; \dot{x}_r, \dot{y}_r) = \frac{1}{2}m(\dot{x}_r^2 + \dot{y}_r^2) + \frac{1}{2}m\Omega^2(x_r^2 + y_r^2) + m\Omega(x_r \dot{y}_r - \dot{x}_r y_r) + \frac{G M_0 m}{r_0} + \frac{G M_1 m}{r_1} \tag{1.150} $$ </div> where now $r_0^2 = (x_r - -a_0)^2 + (y_r-0)^2$ and $r_0^2 = (x_r - a_1)^2 + (y_r-0)^2$.</p> This Lagrangian in rotating coordinates is independent</em> of time. Therefore the energy state function defined by this Lagrangian is conserved. Since it is clearest if we express this in terms of $\Omega$, $a_0$ and $a_1$, we should make those explicit parameters to the Lagrangian.</p> (</span>defn </span>L0 </span>[m V] </span> (</span>fn </span>[[t</span>,</span> q</span>,</span> v]] </span> (</span>- </span>(</span>* </span>1/2</span> m (</span>square</span> v)) (</span>V</span> t q)) </span> )) </span> </span>(</span>defn </span>V_3BP </span>[a GM0 GM1 m] </span> (</span>fn </span>[t [x y]] </span> (</span>let </span>[Omega (</span>sqrt </span>(</span>/ </span>(</span>+</span> GM0 GM1) (</span>expt</span> a </span>3</span>))) </span> a0 (</span>* </span>(</span>/</span> GM1 (</span>+</span> GM0 GM1)) a) </span> a1 (</span>* </span>(</span>/</span> GM0 (</span>+</span> GM0 GM1)) a) </span> x0 (</span>* </span>-1</span> a0 (</span>cos </span>(</span></span> Omega t))) </span> y0 (</span> </span>-1</span> a0 (</span>sin </span>(</span></span> Omega t))) </span> x1 (</span> </span>+1</span> a1 (</span>cos </span>(</span></span> Omega t))) </span> y1 (</span> </span>+1</span> a1 (</span>sin </span>(</span></span> Omega t))) </span> r0 (</span>sqrt </span>(</span>+ </span>(</span>square </span>(</span>-</span> x x0)) (</span>square </span>(</span>-</span> y y0)))) </span> r1 (</span>sqrt </span>(</span>+ </span>(</span>square </span>(</span>-</span> x x1)) (</span>square </span>(</span>-</span> y y1))))] </span> (</span>- </span>(</span>+ </span>(</span>/ </span>(</span></span> GM0 m) r0) (</span>/ </span>(</span></span> GM1 m) r1)))))) </span> </span>(</span>defn </span>LR3B </span>[m a0 a1 Omega GM0 GM1] </span> (</span>fn </span>[[t</span>,</span> q</span>,</span> qdot]] </span> (</span>let </span>[x (</span>ref</span> q </span>0</span>) </span> y (</span>ref</span> q </span>1</span>) </span> r0 (</span>sqrt </span>(</span>+ </span>(</span>square </span>(</span>+</span> x a0)) (</span>square</span> y))) </span> r1 (</span>sqrt </span>(</span>+ </span>(</span>square </span>(</span>-</span> x a1)) (</span>square</span> y))) </span> xdot (</span>ref</span> qdot </span>0</span>) </span> ydot (</span>ref</span> qdot </span>1</span>)] </span> (</span>+ </span>(</span> </span>1/2</span> m (</span>square</span> qdot)) </span> (</span>* </span>1/2</span> m (</span>square</span> Omega) (</span>square</span> q)) </span> (</span></span> m Omega (</span>- </span>(</span></span> x ydot) (</span></span> xdot y))) </span> (</span>/ </span>(</span></span> GM0 m) r0) (</span>/ </span>(</span></span> GM1 m) r1))))) </span> </span> </span>(</span>rendermd </span>( </span>(</span>Lagrangian->energy </span> (</span>LR3B </span>'m 'a_0 'a_1 'Omega 'GM_0 'GM_1) </span>) </span> (</span>up </span>'t (</span>up </span>'x_r 'y_r) (</span>up </span>'v_rx 'v_ry))) </span>) </span></code></pre> $$ \frac{\frac{-1}{2}\,{\Omega}^{2}\,m\,{x_r}^{2}\,\sqrt {{a_0}^{2}\,{a_1}^{2} -2\,{a_0}^{2}\,a_1\,x_r + {a_0}^{2}\,{x_r}^{2} + {a_0}^{2}\,{y_r}^{2} + 2\,a_0\,{a_1}^{2}\,x_r -4\,a_0\,a_1\,{x_r}^{2} + 2\,a_0\,{x_r}^{3} + 2\,a_0\,x_r\,{y_r}^{2} + {a_1}^{2}\,{x_r}^{2} + {a_1}^{2}\,{y_r}^{2} -2\,a_1\,{x_r}^{3} -2\,a_1\,x_r\,{y_r}^{2} + {x_r}^{4} + 2\,{x_r}^{2}\,{y_r}^{2} + {y_r}^{4}} + \frac{-1}{2}\,{\Omega}^{2}\,m\,{y_r}^{2}\,\sqrt {{a_0}^{2}\,{a_1}^{2} -2\,{a_0}^{2}\,a_1\,x_r + {a_0}^{2}\,{x_r}^{2} + {a_0}^{2}\,{y_r}^{2} + 2\,a_0\,{a_1}^{2}\,x_r -4\,a_0\,a_1\,{x_r}^{2} + 2\,a_0\,{x_r}^{3} + 2\,a_0\,x_r\,{y_r}^{2} + {a_1}^{2}\,{x_r}^{2} + {a_1}^{2}\,{y_r}^{2} -2\,a_1\,{x_r}^{3} -2\,a_1\,x_r\,{y_r}^{2} + {x_r}^{4} + 2\,{x_r}^{2}\,{y_r}^{2} + {y_r}^{4}} + \frac{1}{2}\,m\,{v_{rx}}^{2}\,\sqrt {{a_0}^{2}\,{a_1}^{2} -2\,{a_0}^{2}\,a_1\,x_r + {a_0}^{2}\,{x_r}^{2} + {a_0}^{2}\,{y_r}^{2} + 2\,a_0\,{a_1}^{2}\,x_r -4\,a_0\,a_1\,{x_r}^{2} + 2\,a_0\,{x_r}^{3} + 2\,a_0\,x_r\,{y_r}^{2} + {a_1}^{2}\,{x_r}^{2} + {a_1}^{2}\,{y_r}^{2} -2\,a_1\,{x_r}^{3} -2\,a_1\,x_r\,{y_r}^{2} + {x_r}^{4} + 2\,{x_r}^{2}\,{y_r}^{2} + {y_r}^{4}} + \frac{1}{2}\,m\,{v_{ry}}^{2}\,\sqrt {{a_0}^{2}\,{a_1}^{2} -2\,{a_0}^{2}\,a_1\,x_r + {a_0}^{2}\,{x_r}^{2} + {a_0}^{2}\,{y_r}^{2} + 2\,a_0\,{a_1}^{2}\,x_r -4\,a_0\,a_1\,{x_r}^{2} + 2\,a_0\,{x_r}^{3} + 2\,a_0\,x_r\,{y_r}^{2} + {a_1}^{2}\,{x_r}^{2} + {a_1}^{2}\,{y_r}^{2} -2\,a_1\,{x_r}^{3} -2\,a_1\,x_r\,{y_r}^{2} + {x_r}^{4} + 2\,{x_r}^{2}\,{y_r}^{2} + {y_r}^{4}} - {GM}_0\,m\,\sqrt {{a_1}^{2} -2\,a_1\,x_r + {x_r}^{2} + {y_r}^{2}} - {GM}_1\,m\,\sqrt {{a_0}^{2} + 2\,a_0\,x_r + {x_r}^{2} + {y_r}^{2}}}{\sqrt {{a_0}^{2}\,{a_1}^{2} -2\,{a_0}^{2}\,a_1\,x_r + {a_0}^{2}\,{x_r}^{2} + {a_0}^{2}\,{y_r}^{2} + 2\,a_0\,{a_1}^{2}\,x_r -4\,a_0\,a_1\,{x_r}^{2} + 2\,a_0\,{x_r}^{3} + 2\,a_0\,x_r\,{y_r}^{2} + {a_1}^{2}\,{x_r}^{2} + {a_1}^{2}\,{y_r}^{2} -2\,a_1\,{x_r}^{3} -2\,a_1\,x_r\,{y_r}^{2} + {x_r}^{4} + 2\,{x_r}^{2}\,{y_r}^{2} + {y_r}^{4}}} $$ </div> With some “hand simplification (tbd)” this turns into:</p> (+ ( 1/2 m (expt v_r^x 2)) </span> (* 1/2 m (expt v_r^y 2)) </span> (/ (* -1 GM_0 m) </span> (sqrt (+ (expt (+ x_r a_0) 2) (expt y_r 2)))) </span> (/ (* -1 GM_1 m) </span> (sqrt (+ (expt (- x_r a_1) 2) (expt y_r 2)))) </span> (* -1/2 m (expt Omega 2) (expt x_r 2)) </span> (* -1/2 m (expt Omega 2) (expt y_r 2))) </span></code></pre> If we separate this into a velocity-dependent part and a velocity-independent part we get</p> $$ \mathscr{E}(t; x_r, y_r; \dot{x}_r, \dot{y}_r) = \frac{1}{2} m (\dot{x}_r^2 + \dot{y}_r^2) + mU_r(x_r, y_r)\\ \text{where}\\ U_r(x_r, y_r) = - \left( \frac{GM_0}{r_0} + \frac{GM_1}{r_1} + \frac{1}{2} \Omega^2 (x_r^2 + y_r^2) \right) $$ </div> This constant of motion is called the Jacobi Constant</em></strong>. This is traditionally defined as $C_\mathscr{J} = -2\mathscr{E}$. Note that this energy state function does not have terms that are linear in $\dot{x}_r$ or $\dot{y}_r$, although they appear in the Lagrangian.</p> Section 1.6 : How to Find Lagrangians 2022-11-02T03:45:51+00:00 1.6 How to Find Lagrangians</h2> It is possible to work back from Newton’s second law and obtain the Lagrangian $L = T - V$.</p> Constant Acceleration</h3> Consider a particle of mass $m$ in a gravitational field with acceleration, $g$. The potential energy is $mgh$ and kinetic energy is $\frac{1}{2} m v^2$. Therefore, a Lagrangian for the system is:</p> $$ L(t; x,y; v_x, v_y) = \frac{1}{2} m (v_x^2 + v_y^2) - mgy\\ $$ </div> The EOMs for this system can be obtained by applying the EL equations as follows:</p> (</span>defn </span>L-const-accel </span>[m g] </span> (</span>fn </span>[[_ [x y] [v_x v_y]]] </span> (</span>- </span>(</span>* </span>1/2</span> m (</span>+ </span>(</span>square</span> v_x) (</span>square</span> v_y))) (</span></span> m g y)))) </span> </span>(</span>let </span>[L (</span>L-const-accel </span>'m 'g) </span> state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y))] </span> (</span>rendertex </span>(((</span>Lagrange-equations</span> L) state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{m\,{D}^{2}x\left(t\right)} \cr \cr \displaystyle{g\,m + m\,{D}^{2}y\left(t\right)}\end{bmatrix} </div> The above equations describe constant velocity in the $x$ direction and constant acceleration in the $y$ direction.</p> Central Force Field</h3> Consider the motion of a particle of mass $m$ through a potential field, $U(r)$ whose value depends only on the distance $r$ to the center of attraction (e.g. gravity). In rectangular coordinates, the Lagrangian is:</p> $$ L(t; x,y; v_x, v_y) = \frac{1}{2} m (v_x^2 + v_y^2) - U(\sqrt{x^2 + y^2}) $$ </div> Applying EL equations, the equations of motion can be derived as:</p> (</span>defn </span>L-central-rectangular </span>[m U] </span> (</span>fn </span>[[_ [x y] [v_x v_y]]] </span> (</span>let </span>[r (</span>sqrt </span>(</span>+ </span>(</span>square</span> x) (</span>square</span> y)))] </span> (</span>- </span>(</span> </span>1/2</span> m (</span>+ </span>(</span>square</span> v_x) (</span>square</span> v_y))) (</span>U</span> r))))) </span> </span>(</span>def </span>eom-central-rectangular </span>(</span>let </span>[L (</span>L-central-rectangular </span>'m (</span>literal-function </span>'U))] </span> (</span>Lagrange-equations</span> L))) </span> </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y))] </span> (</span>rendertex </span>((</span>eom-central-rectangular</span> state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{\frac{m\,{D}^{2}x\left(t\right)\,\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2}} + x\left(t\right)\,DU\left(\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2}}\right)}{\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2}}}} \cr \cr \displaystyle{\frac{m\,{D}^{2}y\left(t\right)\,\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2}} + y\left(t\right)\,DU\left(\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2}}\right)}{\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2}}}}\end{bmatrix} </div> These equations can be rewriten as:</p> $$ m D^2 x(t) = -\frac{x(t)}{r(t)} DU(r(t)) \\ m D^2 y(t) = -\frac{y(t)}{r(t)} DU(r(t)) \\ \text{where }r(t) = \sqrt{x(t)^2 + y(t)^2} $$ </div> This is the same form as two components of $F = ma$ where the particle is acted upon by a radial force of magnitude $-D U(r)$.</p> If we describe the system in polar coordinates instead, then $x = r \cos{\varphi} \text{ and } y = r \sin{\varphi}$.</p> Consider a configuration path that is represented in both rectangular and polar coordinates. Let $\widetilde{x}$ and $\widetilde{y}$ be components of the rectangular coordinate path, and let $\widetilde{r}$ and $\widetilde{\varphi}$ be components of the corresponding polar coordinate path. Applying the above conversion and differentiating, we get:</p> $$ \begin{align} \widetilde{x}(t) &= \widetilde{r}(t) \cos{ \widetilde{\varphi}(t) } \\ \widetilde{y}(t) &= \widetilde{r}(t) \sin{ \widetilde{\varphi}(t) } \\ => D \widetilde{x}(t) &= D \widetilde{r}(t) \cos{\widetilde{\varphi}(t)} - \widetilde{r}(t) \sin{\widetilde{\varphi}(t)} D \widetilde{\varphi}(t) \\ D \widetilde{y}(t) &= D \widetilde{r}(t) \sin{\widetilde{\varphi}(t)} + \widetilde{r}(t) \cos{\widetilde{\varphi}(t)} D \widetilde{\varphi}(t) \\ => v_x &= \dot{r}\cos{\varphi} - r\dot{\varphi} \sin{\varphi} \\ v_y &= \dot{r}\sin{\varphi} + r\dot{\varphi} \cos{\varphi} \end{align} $$ </div> From the above expressions for generalized velocities, the expression for kinetic energy can be obtained as:</p> $$ T = \frac{1}{2} m ( \dot{r}^2 + r^2\dot{\varphi}^2 ) $$ </div> And the Lagrangian as:</p> $$ L = \frac{1}{2} m ( \dot{r}^2 + r^2\dot{\varphi}^2 ) - U(r) $$ </div> Applying Lagrange’s Equations, we get:</p> (</span>defn </span>L-central-polar </span>[m U] </span> (</span>fn </span>[[_ [r phi] [rdot phidot]]] </span> (</span>- </span>(</span>* </span>1/2</span> m (</span>+ </span>(</span>square</span> rdot) (</span>* </span>(</span>square</span> r) (</span>square</span> phidot)))) (</span>U</span> r)))) </span> </span>(</span>def </span>eom-central-polar </span>(</span>let </span>[L (</span>L-central-polar </span>'m (</span>literal-function </span>'U))] </span> (</span>Lagrange-equations</span> L))) </span> </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'varphi))] </span> (</span>rendertex </span>((</span>eom-central-polar</span> state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{- m\,{\left(D\varphi\left(t\right)\right)}^{2}\,r\left(t\right) + m\,{D}^{2}r\left(t\right) + DU\left(r\left(t\right)\right)} \cr \cr \displaystyle{2\,m\,D\varphi\left(t\right)\,r\left(t\right)\,Dr\left(t\right) + m\,{\left(r\left(t\right)\right)}^{2}\,{D}^{2}\varphi\left(t\right)}\end{bmatrix} </div> ;; F->C in book </span>(</span>defn </span>F2C </span>[F] </span> (</span>fn </span>[q-prime] </span> ((</span>Gamma </span>(</span>F</span> q-prime)) 't) </span> )) </span> </span>(</span>defn </span>p2r </span>[[_ [r phi] [rdot phidot]]] </span> (</span>let </span>[x (</span></span> r (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> phi))] </span> (</span>up</span> x y))) </span> </span>;; Local tuple after coordinate conversion from polar -> rectilinear </span>(</span>rendertex </span>((</span>F2C</span> p2r) </span> (</span>up </span>'t </span> (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'phi)) </span> (</span>up </span>(</span>literal-function </span>'rdot) (</span>literal-function </span>'phidot))) </span> )) </span></code></pre> \begin{pmatrix}\displaystyle{t} \cr \cr \displaystyle{\begin{pmatrix}\displaystyle{r\left(t\right)\,\cos\left(\phi\left(t\right)\right)} \cr \cr \displaystyle{r\left(t\right)\,\sin\left(\phi\left(t\right)\right)}\end{pmatrix}} \cr \cr \displaystyle{\begin{pmatrix}\displaystyle{- r\left(t\right)\,\sin\left(\phi\left(t\right)\right)\,D\phi\left(t\right) + Dr\left(t\right)\,\cos\left(\phi\left(t\right)\right)} \cr \cr \displaystyle{r\left(t\right)\,\cos\left(\phi\left(t\right)\right)\,D\phi\left(t\right) + Dr\left(t\right)\,\sin\left(\phi\left(t\right)\right)}\end{pmatrix}}\end{pmatrix} </div> The first equation says that mass times radial acceleration is equal to the sum of the force due to the potential field ($U(r)$) and the centrifugal force $mr\dot{\varphi}^2$. The second equation can be interpreted as $\frac{d}{dt}(mr^2 \dot{\varphi}) = 0$ or that the angular momentum is conserved.</p> Section 1.6.1: Coordinate Transformations 2022-11-02T03:45:41+00:00 1.6.1 Coordinate Transformations</h2> Assume we have a mechanical system whose motion is described by a Lagrangian that depends on time, position and velocities. Assume also that we have a coordinate transformation $x = F(t, x’)$ that goes from “primed” to “unprimed” coordinates. The Lagrangian $L$ is expressed in unprimed coordinates. We want to find the Lagrangian expressed in primed coordinates. If $q$ is a configuration path in unprimed coordinates an $q’$ is in primed coordinates, then they must satisfy:</p> $$ L' \circ \Gamma[q'] = L \circ \Gamma [q]\\ $$ </div> In general, the requirement that paths in two different coordinate systems be consistent with the coordinate transformation can be used to deduce how all of the components of the local tuple transform. Given a coordinate transformation $F$, let $C$ be the corresponding function that maps local tuples in the primed coordinate system to corresponding local tuples in the unprimed coordinate system:</p> $$ C \circ \Gamma[q'] = \Gamma[q] $$ </div> Therefore,</p> $$ L' = L \circ C\\ $$ </div> Substituting q and q’ into the coordinate transformation, and taking its derivative w.r.t $t$ and applying the chain rule,</p> $$ Dq(t) = \partial_0 F(t, q'(t)) + \partial_1 F(t, q'(t)) Dq'(t) \\ \\ \text{where } \partial_0 F(t, q'(t)) \text{ is the time derivative of } F(t, q'(t)) \\ \text{ and } \partial_1 F(t, q'(t)) \text{ is the Jacobian of F w.r.t q'} $$ </div> Therefore the generalized velocity transforms as:</p> $$ v = \partial_0 F(t, x') + \partial_1 F(t, x') v'\\ $$ </div> If our local tuples have higher-derivative components,</p> $$ \begin{align} (t, x, v, ... ) &= C(t, x', v', ...) \\ &= (t, F(t' x'), \partial_0 F(t, x') + \partial_1 F(t, x') v', ...) \end{align} $$ </div> Note</h4> $L’ = L \circ C$ and $C$ converts from primed</strong> to unprimed</strong>. Therefore, the coordinate conversion function from primed</strong> to unprimed</strong> is used to create the conversion from unprimed</strong> to primed</strong> Lagrangian. There is sort of an opposite thing going on here.</p> </blockquote> Section 2.2: Kinematics of Rotation 2022-11-02T03:01:37+00:00 2.2 Kinematics of Rotation</h2> The motion of a rigid body about a center of rotation (a body-fixed reference point) is characterized at each point in time by an axis of rotation and a rate of rotation</p> </li> According to Euler’s theorem of rotations</a>, we can go from one orientation of a rigid body to another in a single rotation</p> Rotations are not commutative in general, i.e., the order of rotations matter</li> However the combination of any number of rotations in some order can be represented by a single rotation</li> </ul> </li> Orientations are specified by the rotations it takes to reach that orientation from some reference orientation.</p> </li> </ul> Let $q$ by the path describing the motion of the body and $M(q(t))$ be the rotation that takes the body from a reference orientation to the orientation specified by $q(t)$. Let $\vec{\xi_\alpha}(t)$ be some vector in the body-frame (to some constituent particle) in orientation given by $q(t)$, and $\vec{\xi’_\alpha}$ be the same body-frame vector in the reference orientation, then:</p> $$ \vec{\xi}_\alpha(t) = \mathscr{M}(q(t)) \vec{\xi'}_\alpha\tag{2.11} $$ </div> To find the kinetic energy, we need to combine the contributions of all the constituent particles, aka, the velocities of the particles.</p> $$ \vec{\xi}_\alpha(t) = \mathscr{M}(q(t)) \vec{\xi'}_\alpha = M(t)\vec{\xi'}_\alpha\tag{2.12} $$ </div> where $M = \mathscr{M} \circ q$. Taking the time derivative:</p> $$ D\vec{\xi}_\alpha(t) = DM(t)\vec{\xi'}_\alpha\tag{2.13} $$ </div> By inverting Eq. 2.12, we can write $\vec{\xi’}_{\alpha}$ in terms of $\vec{\xi}_{\alpha}$,</p> $$ D\vec{\xi}_\alpha(t) = DM(t)(M(t))^{-1}\vec{\xi}_\alpha(t)\tag{2.13} $$ </div> Since $M(t)$ is a rotation represented by an orthogonal matrix $\mathbf{M}(t)$, with the property, $(\mathbf{M}(t))^{-1}$ = $(\mathbf{M}(t))^{\intercal}$. Therefore, $\mathbf{M}(t)(\mathbf{M}(t))^{\intercal}$ = $\mathbf{I}$ and hence $D(\mathbf{M}\mathbf{M}^\intercal) = \mathbf{0}$.</p> $$ \mathbf{0} = D(\mathbf{M}\mathbf{M}^\intercal) = D(\mathbf{M})\mathbf{M}^\intercal + \mathbf{M}D \mathbf{M}^\intercal\tag{2.15} $$ </div> Note: $(AB)^\intercal = B^\intercal A^\intercal => (D\mathbf{M}\mathbf{M}^\intercal)^\intercal = (\mathbf{M}^\intercal)^\intercal D\mathbf{M}^\intercal = \mathbf{M}D \mathbf{M}^\intercal$</p> </blockquote> $$ D(\mathbf{M})\mathbf{M}^\intercal = -\mathbf{M}D \mathbf{M}^\intercal = -(D\mathbf{M}\mathbf{M}^\intercal)^\intercal\tag{2.16} $$ </div> This shows that $D(\mathbf{M})\mathbf{M}^\intercal$ is anti-symmetric. If $\mathbf{u}$ has the components $(x, y, z) $, all anti-symmetric 3x3 matrices have the following form:</p> $$ \mathscr{A}(\mathbf{u}) = \begin{pmatrix}0 &-z& y\\ z &0 &-x\\-y &x &0\end{pmatrix}\\ $$ </div> Multuplying this matrix by a vector is equivalent to a cross-product by the vector $\vec{u}$ (and $\mathbf{u}$ is the matrix representation of $\vec{u}$. The inverse of the function $\mathscr{A}$ is one that extracts the components of $\mathbf{u}$ from a given skew-symmetric matrix.</p> Note: $\mathscr{A}^{-1}$ is not</em> the inverse of the skew-symmetric matrix. Rather, this is a function that by definition, extracts the components of $\vec{u}$ from a skew-symmetric matrix.</p> </blockquote> So the matrix multiplication $D\mathbf{M}\mathbf{M}^\intercal$ can be interpreted as a cross-product with a vector that we can call $\vec{\omega}$ which is the angular velocity vector. Therefore,</p> $$ \boldsymbol{\omega} = \mathscr{A}^{-1}(D \mathbf{M} \mathbf{M}^\intercal) \tag{2.18} $$ </div> Therefore the differential equations of the constituent particles can be written as:</p> $$ D \vec{\xi}_\alpha(t) = \vec{\omega}(t) \times \vec{\xi}_\alpha(t)\tag{2.19} $$ </div> This shows that the velocity o the constituent particles are perpendicular to their position vectors and proportional to the rate of rotation and distance from the instantaneous center:</p> $$ \dot{\vec{\xi}}_\alpha = \vec{\omega} \times \vec{\xi}_\alpha\tag{2.20} $$ </div> The components, $\boldsymbol{\omega}‘$ of the angular velocity vector in the body frame are $\boldsymbol{\omega}’ = \mathbf{M}^\intercal \boldsymbol{\omega}$, or</p> $$ \boldsymbol{\omega}' = \mathbf{M}^\intercal \mathscr{A}^{-1}(D \mathbf{M} \mathbf{M}^\intercal) \tag{2.21} $$ </div> Note: Need to figure out why it is $\mathbf{M}^\intercal$ and not $\mathbf{M}$ in Eq. 2.21. Is this not a “rotation” of the vector? Question posted at: https://physics.stackexchange.com/questions/734684/angular-velocity-in-body-frame-vs-inertial-frame</a></strong></p> This is a kinematic relationship that is valid for any path and can be used to obtain the components of angular velocity given the configuration and velocity at any time.</p> Implementation of angular velocity functions</h3> (</span>defn </span>M-of-q->omega-of-t </span>[M-of-q] </span> (</span>fn </span>[q] </span> (</span>fn </span>[t] </span> (</span>let </span>[M-on-path (</span>compose</span> M-of-q q) </span> omega-cross t] </span> (</span>* </span>((</span>D</span> M-on-path) t) </span> (</span>transpose </span>(</span>M-on-path</span> t))) </span> (</span>rigid/antisymmetric->column-matrix </span>(</span>omega-cross</span> t))) </span>))) </span> </span>;; `omega-cross` produces the matrix representation of cross product "omega x" </span>;; antisymmetric->column-matrix corresponds to A^{-1} and extracts vector components from </span>;; a skew symmetric matrix </span> </span> </span>;; This function gives components of omega in body-fixed axes </span>(</span>defn </span>M-of-q->omega-body-of-t </span>[M-of-q] </span> (</span>fn </span>[q] </span> (</span>fn </span>[t] </span> (</span>* </span>(</span>transpose </span>(</span>M-of-q </span>(</span>q</span> t))) </span> (((</span>M-of-q->omega-of-t</span> M-of-q) q) t))))) </span> </span> </span>;; We use Gamma-bar to convert these functions of path to functions of local tuple </span> </span>(</span>defn </span>M->omega </span>[M-of-q] </span> (</span>Gamma-bar </span> (</span>M-of-q->omega-of-t</span> M-of-q))) </span> </span>(</span>defn </span>M->omega-body </span>[M-of-q] </span> (</span>Gamma-bar </span> (</span>M-of-q->omega-body-of-t</span> M-of-q))) </span> </span>:ok </span></code></pre> :ok </span></code></pre> These procedures will return angular velocities as a function of state (aka local tuple)</p> Exercise 1.12: Lagrange's Equations 2022-11-01T01:59:57+00:00 Exercise 1.12: Lagrange’s Equations</h3> Compute Lagrange’s equations for the Lagrangians in exercise 1.9 using the Lagrange-equations procedure.</strong></p> a. An ideal planar pendulum consists of a bob of mass m connected to a pivot by a massless rod of length $l$ subject to uniform gravitational acceleration g. A Lagrangian is $L(t, \theta, \dot{\theta}) = \frac{1}{2} m l^2 \dot{\theta}^2 + m g l\cos{\theta}$ . The formal parameters of $L$ are $t$, $\theta$, and $\dot{\theta}$; $\theta$ measures the angle of the pendulum rod to a plumb line and $\dot{\theta}$ is the angular velocity of the rod.</strong></p> (</span>defn </span>L-pendulum </span>[m g l] </span> (</span>fn </span>[[_ [theta] [thetadot]]] </span> (</span>+ </span>(</span>* </span>1/2</span> m (</span>square</span> l) (</span>square</span> thetadot)) </span> (</span></span> m g l (</span>cos</span> theta))))) </span> </span>(</span>def </span>eom-pendulum </span> (</span>Lagrange-equations </span>(</span>L-pendulum </span>'m 'g 'l))) </span> </span>(</span>rendertex </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'theta))] </span> ((</span>eom-pendulum</span> state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{g\,l\,m\,\sin\left(\theta\left(t\right)\right) + {l}^{2}\,m\,{D}^{2}\theta\left(t\right)}\end{bmatrix} </div> b. A particle of mass m moves in a two-dimensional potential $V(x, y) = (x^2 + y^2)/2 + x^2y − y^3/3$, where $x$ and $y$ are rectangular coordinates of the particle. A Lagrangian is $L(t;x,y;v_x,v_y)=\frac{1}{2} m (v_x^2+v_y^2) − V(x,y)$.</strong></p> (</span>defn </span>potential-field </span>[x y] </span> (</span>+ </span>(</span>/ </span>(</span>+ </span>(</span>square</span> x) (</span>square</span> y)) </span>2</span>) </span> (</span> </span>(</span>square</span> x) y) </span> (</span>- </span>(</span>/ </span>(</span>cube</span> y) </span>3</span>)) </span> )) </span>(</span>defn </span>L-particle-potential-field </span>[m V] </span> (</span>fn </span>[[_ [x y] [v_x v_y]]] </span> (</span>- </span>(</span>* </span>1/2</span> m (</span>+ </span>(</span>square</span> v_x) (</span>square</span> v_y))) </span> (</span>V</span> x y)))) </span> </span>(</span>def </span>eom-particle-potential-field </span> (</span>Lagrange-equations </span>(</span>L-particle-potential-field </span>'m potential-field))) </span> </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y))] </span> ((</span>eom-particle-potential-field</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{m\,{D}^{2}x\left(t\right) + 2\,x\left(t\right)\,y\left(t\right) + x\left(t\right)} \cr \cr \displaystyle{m\,{D}^{2}y\left(t\right) + {\left(x\left(t\right)\right)}^{2} - {\left(y\left(t\right)\right)}^{2} + y\left(t\right)}\end{pmatrix} </div> c. A Lagrangian for a particle of mass m constrained to move on a sphere of radius $R$ is $L(t;\theta,\phi;\alpha,\beta)=\frac{1}{2}mR^2(\alpha^2+(\beta \sin\theta)^2)$. The angle $\theta$ is the colatitude of the particle and $\phi$ is the longitude; the rate of change of the colatitude is $\alpha$ and the rate of change of the longitude is $\beta$.</strong></p> (</span>defn </span>L-particle-on-sphere </span>[m R] </span> (</span>fn </span>[[_ [theta phi] [alpha beta]]] </span> (</span>* </span>1/2</span> m (</span>square</span> R) </span> (</span>+ </span>(</span>square</span> alpha) </span> (</span>square </span>(</span></span> beta (</span>sin</span> theta))) </span> ) </span> ) </span>)) </span> </span>(</span>def </span>eom-particle-on-sphere </span> (</span>Lagrange-equations </span>(</span>L-particle-on-sphere </span>'m 'R))) </span> </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'theta) (</span>literal-function </span>'phi))] </span> ((</span>eom-particle-on-sphere</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{- {R}^{2}\,m\,\sin\left(\theta\left(t\right)\right)\,{\left(D\phi\left(t\right)\right)}^{2}\,\cos\left(\theta\left(t\right)\right) + {R}^{2}\,m\,{D}^{2}\theta\left(t\right)} \cr \cr \displaystyle{2\,{R}^{2}\,m\,\sin\left(\theta\left(t\right)\right)\,D\phi\left(t\right)\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right) + {R}^{2}\,m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{D}^{2}\phi\left(t\right)}\end{pmatrix} </div> Exercise 1.14: Coordinate-independence of Lagrange Equations 2022-11-01T01:56:19+00:00 Exercise 1.14: Coordinate-independence of Lagrange equations</h3> Check that the Lagrange equations for central force motion in polar coordinates and in rectangular coordinates are equivalent.</strong></p> In order to do this, compute the expressions for accelerations $a_x(t)$ and $a_y(t)$ in terms of the polar coordinates and substitute into the lagrange’s equations in cartesian coordinates.</strong></p> (</span>defn </span>L-central-rectangular </span>[m U] </span> (</span>fn </span>[[_ [x y] [v_x v_y]]] </span> (</span>let </span>[r (</span>sqrt </span>(</span>+ </span>(</span>square</span> x) (</span>square</span> y)))] </span> (</span>- </span>(</span> </span>1/2</span> m (</span>+ </span>(</span>square</span> v_x) (</span>square</span> v_y))) (</span>U</span> r))))) </span> </span> </span>(</span>def </span>eom-central-rectangular </span>(</span>let </span>[L (</span>L-central-rectangular </span>'m (</span>literal-function </span>'U))] </span> (</span>Lagrange-equations</span> L))) </span> </span> </span>(</span>def </span>eom-central-r2p </span>(</span>let </span>[r (</span>literal-function </span>'r) </span> phi (</span>literal-function </span>'varphi) </span> rt (</span>literal-function </span>'r) </span> x (</span></span> r (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> phi)) </span> v_x (</span>D</span> x) </span> v_y (</span>D</span> y) </span> a_x (</span>D</span> v_x) </span> a_y (</span>D</span> v_y) </span> state (</span>up</span> x y) </span> eom ((</span>eom-central-rectangular</span> state) 't) </span> ] </span> (</span>apply</span> up eom) </span> )) </span>(</span>rendertex</span> eom-central-r2p) </span></code></pre> \begin{pmatrix}\displaystyle{- m\,\cos\left(\varphi\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,r\left(t\right) -2\,m\,D\varphi\left(t\right)\,\sin\left(\varphi\left(t\right)\right)\,Dr\left(t\right) - m\,r\left(t\right)\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}\varphi\left(t\right) + m\,\cos\left(\varphi\left(t\right)\right)\,{D}^{2}r\left(t\right) + \cos\left(\varphi\left(t\right)\right)\,DU\left(r\left(t\right)\right)} \cr \cr \displaystyle{- m\,{\left(D\varphi\left(t\right)\right)}^{2}\,r\left(t\right)\,\sin\left(\varphi\left(t\right)\right) + 2\,m\,\cos\left(\varphi\left(t\right)\right)\,D\varphi\left(t\right)\,Dr\left(t\right) + m\,\cos\left(\varphi\left(t\right)\right)\,r\left(t\right)\,{D}^{2}\varphi\left(t\right) + m\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}r\left(t\right) + \sin\left(\varphi\left(t\right)\right)\,DU\left(r\left(t\right)\right)}\end{pmatrix} </div> (</span>let </span>[eom eom-central-r2p </span> eom1 (</span>ref</span> eom </span>0</span>) </span> eom2 (</span>ref</span> eom </span>1</span>)] </span> (</span>rendertexvec </span>(</span>up </span>(</span>simplify </span>(</span>+</span> eom1 eom2))))) </span></code></pre> \begin{pmatrix}\displaystyle{- m\,\cos\left(\varphi\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,r\left(t\right) - m\,{\left(D\varphi\left(t\right)\right)}^{2}\,r\left(t\right)\,\sin\left(\varphi\left(t\right)\right) + 2\,m\,\cos\left(\varphi\left(t\right)\right)\,D\varphi\left(t\right)\,Dr\left(t\right) + m\,\cos\left(\varphi\left(t\right)\right)\,r\left(t\right)\,{D}^{2}\varphi\left(t\right) -2\,m\,D\varphi\left(t\right)\,\sin\left(\varphi\left(t\right)\right)\,Dr\left(t\right) - m\,r\left(t\right)\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}\varphi\left(t\right) + m\,\cos\left(\varphi\left(t\right)\right)\,{D}^{2}r\left(t\right) + m\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}r\left(t\right) + \cos\left(\varphi\left(t\right)\right)\,DU\left(r\left(t\right)\right) + \sin\left(\varphi\left(t\right)\right)\,DU\left(r\left(t\right)\right)}\end{pmatrix} </div> Rewriting the above equations, we get</p> $$ \begin{align} -mr\dot{\varphi}^2 \cos{\varphi} + (mr\ddot{\varphi} + 2m\dot{r}\dot{\varphi})(-\sin{\varphi}) + m\ddot{r}\cos{\varphi} + DU(r)\cos{\varphi} &= 0 \\ -mr\dot{\varphi}^2 \sin{\varphi} + (mr\ddot{\varphi} + 2m\dot{r}\dot{\varphi})\cos{\varphi} + m\ddot{r}\sin{\varphi} + DU(r)\sin{\varphi} &= 0 \end{align} $$ </div> Multiply first eqn by $\cos{\varphi}$ and the second by $\sin{\varphi}$ and add</p> $$ -mr\dot{\varphi}^2 + m\ddot{r} + DU(r) = 0\\ $$ </div> Multiply first eqn by $\sin{\varphi}$ and the second by $\cos{\varphi}$ and subtract to get</p> $$ mr \ddot{\varphi} + 2m\dot{r}\dot{\varphi} = 0\\ $$ </div> These are the same equations of motion that we obtained by directly building the Lagrangian from polar coordinates.</p> Exercise 1.13: Higher-derivative Lagrangians 2022-11-01T01:56:16+00:00 Exercise 1.13: Higher-derivative Lagrangians</h3> a. Write a procedure to compute the Lagrange equations for Lagrangians that depend upon acceleration, as in exercise 1.10. Note that Gamma can take an optional argument giving the length of the initial segment of the local tuple needed. The default length is 3, giving components of the local tuple up to and including the velocities.</strong></p> Lagrange’s equations for Lagrangians that depend on acceleration was derived as:</p> $$ D^2(\partial_3 L \cdot \Gamma[q]) − D(\partial_2 L\cdot \Gamma[q])+\partial_1 L\cdot \Gamma[q]=0\\ $$ </div> (</span>defn </span>Lagrange-equations-accel </span>[L] </span> (</span>fn </span>[q] </span> (</span>let </span>[state-path (</span>Gamma</span> q </span>4</span>)] </span> (</span>+ </span>(</span>D </span>(</span>D </span>(</span>compose </span>((</span>partial </span>3</span>) L) state-path))) </span> (</span>-</span>(</span>D </span>(</span>compose </span>((</span>partial </span>2</span>) L) state-path))) </span> (</span>compose </span>((</span>partial </span>1</span>) L) state-path)) </span> ))) </span></code></pre> #'user/Lagrange-equations-accel </span></code></pre> b. Use your procedure to compute the Lagrange equations for the Lagrangian:</strong></p> $$ L(t, x, v, a) = - \frac{1}{2} m x a - \frac{1}{2} k x^2\\ $$ </div> (</span>defn </span>L-accel </span>[m k] </span> (</span>fn </span>[ [_ [x] [v] [a]] ] </span> (</span>- </span>(</span>* </span>-1/2</span> m x a) (</span>* </span>1/2 </span>'k (</span>square</span> x))))) </span> </span>(</span>def </span>eom-L-accel </span> (</span>Lagrange-equations-accel </span>(</span>L-accel </span>'m 'k))) </span> </span> </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x))] </span> ((</span>eom-L-accel</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{- k\,x\left(t\right) - m\,{D}^{2}x\left(t\right)}\end{pmatrix} </div> c. For more fun, write the general Lagrange equation procedure that takes a Lagrangian that depends on any number of derivatives, and the number of derivatives, to produce the required equations of motion.</strong></p> The Generaized Lagrange’s Equation seems like a sum of alternate signed terms based on examination.</p> $$ L = \sum_{i=0}^{n} (-1)^i D^i \left( \partial_{i+1} L \cdot \Gamma[q] \right) $$ </div> Exercise 1.11: Kepler's Third Law 2022-10-31T01:33:12+00:00 Exercise 1.11: Kepler’s third law</h3> A Lagrangian suitable for studying the relative motion of two particles, of masses $m_1$ and $m_2$, with potential energy $V$, is:</strong></p> $$ L = \frac{1}{2} m \left(\dot{r}^2 + (r\dot{\phi})^2\right) + V(r) $$ </div> The argument $m$ is the reduced mass of the system:</strong></p> $$ m = \frac{m_1 m_2}{m_1 + m_2} $$ </div> For gravity, the potential energy function is:</strong></p> $$ V(r) = -\frac{G m_1 m_2}{r} $$ </div> Consider the simple situation of the particles in circular orbits around their common center of mass. Construct a circular orbit and plug it into the Lagrange equations. Show that the residual gives Kepler’s law:</strong></p> $$ n^2 a^3 = G(m_1 + m_2) $$ </div> where $n$ is the angular frequency of the orbit and a is the distance between particles.</strong></p> ;; Define Lagrangian and derive EoMs </span>(</span>defn </span>L-central-polar </span>[m V] </span> (</span>fn </span>[[_ [r phi] [rdot phidot]]] </span> (</span>- </span>(</span>* </span>1/2</span> m </span> (</span>+ </span>(</span>square</span> rdot) (</span>square </span>(</span></span> r phidot))) ) </span> (</span>V</span> r)) </span> )) </span> </span>(</span>def </span>m </span>(</span>/ </span>(</span> </span>'m_1 'm_2) (</span>+ </span>'m_1 'm_2) )) </span>(</span>def </span>V </span>(</span>fn </span>[r] (</span>- </span>(</span>/ </span>(</span>* </span>'G 'm_1 'm_2) r)))) </span> </span>(</span>def </span>eom-kepler </span> (</span>Lagrange-equations </span>(</span>L-central-polar</span> m V))) </span> </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'phi))] </span> ((</span>eom-kepler</span> state) 't))) </span></code></pre> ;; Circular orbit </span>; r(t) = a </span>; phi(t) = n * t </span>(</span>def </span>circ-solution </span> (</span>up </span>(</span>fn </span>[t] 'a) (</span>fn </span>[t] (</span>* </span>'n t)))) </span>(</span>rendertex </span>(</span>circ-solution </span>'t)) </span></code></pre> (</span>rendertexvec </span>((</span>eom-kepler</span> circ-solution) 't)) </span></code></pre> \begin{pmatrix}\displaystyle{\frac{- {a}^{3}\,m_1\,m_2\,{n}^{2} + G\,{m_1}^{2}\,m_2 + G\,m_1\,{m_2}^{2}}{{a}^{2}\,m_1 + {a}^{2}\,m_2}} \cr \cr \displaystyle{0}\end{pmatrix} </div> The above equation simplifies to:</p> $$ \begin{align} -a^3 m_1 m_2 n^2 + G m_1 m_2 (m_1 + m_2) &= 0 \\ => G (m_1 + m_2) &= a^3 n^2\\ \end{align} $$ </div> Exercise 1.15: Equivalence 2022-10-31T01:09:08+00:00 Exercise 1.15: Equivalence</h3> Here we use the p->r</code> conversion function to convert the Lagrangian in rectangular coordinates to polar coordinates (and compare to results from notes and exercise 1.14 where it was computed explicitly).</strong></p> ;; The Coordinate conversion function `C` </span>(</span>defn </span>p2r </span>[[_ [r phi] [rdot phidot]]] </span> (</span>let </span>[x (</span></span> r (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> phi))] </span> (</span>up</span> x y))) </span> </span>;; F->C is part of sicmutils and is more complex than in the book for this section </span>(</span>defn </span>F2C </span>[F] </span> (</span>fn </span>[local] </span> (</span>let </span>[v (</span>ref</span> local </span>2</span>) </span> t (</span>ref</span> local </span>0</span>)] </span> (</span>up</span> t </span> (</span>F</span> local) </span> (</span>+ </span>(((</span>partial </span>0</span>) F) local) </span> (</span>* </span>(((</span>partial </span>1</span>) F) local) v)))))) </span> </span>(</span>defn </span>L-central-rectangular </span>[m U] </span> (</span>fn </span>L </span>[[_ [x y] [v_x v_y]]] </span> (</span>let </span>[r (</span>sqrt </span>(</span>+ </span>(</span>square</span> x) (</span>square</span> y)))] </span> (</span>- </span>(</span>* </span>1/2 </span>'m (</span>+ </span>(</span>square</span> v_x) (</span>square</span> v_y))) (</span>U</span> r))))) </span> </span>;; L' = L . C </span>(</span>defn </span>L-central-polar-using-F2C </span>[m U] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-central-rectangular</span> m U) (</span>F2C</span> p2r)) </span> q-prime))) </span> </span>;; Verify LE in polar coordinates match what was expected </span>(</span>let </span>[L (</span>L-central-polar-using-F2C </span>'m (</span>literal-function </span>'U)) </span> state (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'varphi))] </span> (</span>rendertex </span>(((</span>Lagrange-equations</span> L) state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{- m\,r\left(t\right)\,{\left(D\varphi\left(t\right)\right)}^{2} + m\,{D}^{2}r\left(t\right) + DU\left(r\left(t\right)\right)}&\displaystyle{m\,{\left(r\left(t\right)\right)}^{2}\,{D}^{2}\varphi\left(t\right) + 2\,m\,r\left(t\right)\,D\varphi\left(t\right)\,Dr\left(t\right)}\end{bmatrix} </div> Exercise 1.16: Central force motion 2022-10-31T01:09:03+00:00 Exercise 1.16: Central force motion</h3> Find Lagrangians for central force motion in three dimensions in rectangular coordinates and in spherical coordinates. First, find the Lagrangians analytically, then check the results with the computer by generalizing the programs that we have presented.</strong></p> ;; 3D central force Lagrange's eqns </span>(</span>defn </span>L-central-rect-3d </span>[m U] </span> (</span>fn </span>L </span>[[_ [x y z] [v_x v_y v_z]]] </span> (</span>let </span>[r (</span>sqrt </span>(</span>+ </span>(</span>square</span> x) (</span>square</span> y) (</span>square</span> z)))] </span> (</span>- </span>(</span>* </span>1/2 </span>'m (</span>+ </span>(</span>square</span> v_x) (</span>square</span> v_y) (</span>square</span> v_z))) (</span>U</span> r))))) </span> </span>(</span>def </span>eom-central-rect-3d </span>(</span>Lagrange-equations </span>(</span>L-central-rect-3d </span>'m (</span>literal-function </span>'U)))) </span> </span>(</span>rendertexvec </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y) (</span>literal-function </span>'z))] </span> ((</span>eom-central-rect-3d</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{\frac{m\,{D}^{2}x\left(t\right)\,\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}} + x\left(t\right)\,DU\left(\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}\right)}{\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}}} \cr \cr \displaystyle{\frac{m\,\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}\,{D}^{2}y\left(t\right) + y\left(t\right)\,DU\left(\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}\right)}{\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}}} \cr \cr \displaystyle{\frac{m\,\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}\,{D}^{2}z\left(t\right) + z\left(t\right)\,DU\left(\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}\right)}{\sqrt {{\left(x\left(t\right)\right)}^{2} + {\left(y\left(t\right)\right)}^{2} + {\left(z\left(t\right)\right)}^{2}}}}\end{pmatrix} </div> (</span>defn </span>p2r-3d </span>[[_ [r theta phi] _]] </span> (</span>let </span>[x (</span></span> r (</span>sin</span> theta) (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> theta) (</span>sin</span> phi)) </span> z (</span></span> r (</span>cos</span> phi))] </span> (</span>up</span> x y z))) </span> </span>(</span>defn </span>L-central-polar-3d-using-F2C </span>[m U] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-central-rect-3d</span> m U) (</span>F->C</span> p2r-3d)) </span> q-prime))) </span> </span>(</span>def </span>eom-central-polar-3d-using-F2C </span>(</span>Lagrange-equations </span>(</span>L-central-polar-3d-using-F2C </span>'m (</span>literal-function </span>'U)))) </span> </span>(</span>rendertex </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'theta) (</span>literal-function </span>'varphi)) </span> local ((</span>Gamma</span> state) 't)] </span> (</span>p2r-3d</span> local))) </span>(</span>render </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'theta) (</span>literal-function </span>'varphi)) </span> local ((</span>Gamma</span> state) 't) </span> L (</span>L-central-polar-3d-using-F2C </span>'m (</span>literal-function </span>'U)) </span> ] </span> (</span>L</span> local))) </span> </span>(</span>rendertexvec </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'r) (</span>literal-function </span>'theta) (</span>literal-function </span>'varphi)) </span> ] </span> ((</span>eom-central-polar-3d-using-F2C</span> state)'t))) </span> </span>;; "exercise for the reader ..." </span></code></pre> \begin{pmatrix}\displaystyle{\frac{- m\,r\left(t\right)\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} - m\,r\left(t\right)\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} - m\,r\left(t\right)\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} + m\,r\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}\theta\left(t\right) - m\,r\left(t\right)\,\cos\left(\varphi\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}\varphi\left(t\right) + 2\,m\,\sin\left(\theta\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,Dr\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} -2\,m\,\cos\left(\varphi\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,D\varphi\left(t\right)\,Dr\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} + m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}r\left(t\right) + m\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}r\left(t\right) + {\sin}^{2}\left(\theta\left(t\right)\right)\,DU\left(r\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)\,DU\left(r\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\right)}{\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}}} \cr \cr \displaystyle{\frac{- m\,{\left(r\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,\cos\left(\theta\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} - m\,{\left(r\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} + m\,{\left(r\left(t\right)\right)}^{2}\,{\cos}^{2}\left(\theta\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}\theta\left(t\right) + 2\,m\,r\left(t\right)\,{\cos}^{2}\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,Dr\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} + m\,r\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}r\left(t\right) + r\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,DU\left(r\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\right)}{\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}}} \cr \cr \displaystyle{\frac{2\,m\,{\left(r\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right)\,D\varphi\left(t\right)\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} + m\,{\left(r\left(t\right)\right)}^{2}\,\cos\left(\varphi\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} - m\,{\left(r\left(t\right)\right)}^{2}\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}\varphi\left(t\right) - m\,{\left(r\left(t\right)\right)}^{2}\,{\cos}^{2}\left(\theta\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}\varphi\left(t\right) -2\,m\,r\left(t\right)\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,D\varphi\left(t\right)\,Dr\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} -2\,m\,r\left(t\right)\,D\varphi\left(t\right)\,{\cos}^{2}\left(\theta\left(t\right)\right)\,Dr\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} - m\,r\left(t\right)\,\cos\left(\varphi\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}r\left(t\right) + 2\,m\,{\left(r\left(t\right)\right)}^{2}\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\,{D}^{2}\varphi\left(t\right) + 4\,m\,r\left(t\right)\,D\varphi\left(t\right)\,Dr\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)} - r\left(t\right)\,\cos\left(\varphi\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,DU\left(r\left(t\right)\,\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}\right)}{\sqrt {{\sin}^{2}\left(\theta\left(t\right)\right) + {\cos}^{2}\left(\varphi\left(t\right)\right)}}}\end{pmatrix} </div> Exercise 1.17: Bead on a helical wire 2022-10-31T01:02:55+00:00 Exercise 1.17: Bead on a helical wire</h3> A bead of mass $m$ is constrained to move on a frictionless helical wire. The helix is oriented so that its axis is horizontal. The diameter of the helix is $d$ and its pitch (turns per unit length) is $h$. The system is in a uniform gravitational field with vertical acceleration $g$. Formulate a Lagrangian that describes the system and find the Lagrange equations of motion.</strong></p> The system here has a single degree of freedom - the parameter $s$ describing the horizontal position of the bead along the x-axis. Let $r$ be the radius of the helix. The bead advances horizontally by distance $1/h$ for every rotation around the helix. The angle around the helix is equal to $\frac{2\pi}{1/h}s = 2\pi hs$.</p> So when $s = 0$, $x, y, z = 0, 0, 0$. Halfway up the first loop,</p> $$ s = \frac{1}{2h}\\ x = s = \frac{1}{2h},\\ y = r \cos{\left(2\pi h \frac{1}{2h}\right)} = r\cos{\pi},\\ y = r \sin{\left(2\pi h \frac{1}{2h}\right)} = r\sin{\pi},\\ $$ </div> The coordinates of the bead in rectangular coordinates are:</p> $$ \begin{align} x(t) &= s(t) \\ y(t) &= \frac{d}{2} \cos{2 \pi h s} \\ y(t) &= \frac{d}{2} \sin{2 \pi h s} \\ \end{align} $$ </div> The velocities in rectangular coordinates are:</p> $$ \begin{align} v_x(t) &= \dot{s}\\ v_y(t) &= -\pi d h \dot{s} \sin{2 \pi h s} \\ v_z(t) &= \pi d h \dot{s} \cos{2 \pi h s} \\ \end{align} $$ </div> The kinetic energy in generalized coordinates is:</p> $$ \begin{align} T(t,s,\dot{s}) &= \frac{1}{2} m \left({v_x}^2 + {v_y}^2 + {v_z}^2\right) \\ &= \frac{1}{2} m \left( \dot{s}^2 + \left( \pi^2 d^2 h^2 \dot{s}^2 \right) (\sin^2{2 \pi h s} + \cos^2{2 \pi h s}) \right) \\ &= \frac{1}{2} m \dot{s}^2 \left( 1 + \pi^2 d^2 h^2 \right) \end{align} $$ </div> The potential energy in generalized coordinates is:</p> $$ V(t,s,\dot{s}) = mgy(t) = m g \frac{d}{2} \cos{2 \pi h s} $$ </div> ;; Computing EoMs </span>(</span>defn </span>T-bead-helical </span>[m g d h] </span> (</span>fn </span>[[t [s] [sdot]]] </span> (</span> </span>1/2</span> m (</span>square</span> sdot) </span> (</span>+ </span>1 </span>(</span>square </span>'pi) (</span>square</span> d) (</span>square</span> h)) </span> ) </span> ) </span>) </span> </span>(</span>defn </span>V-bead-helical </span>[m g d h] </span> (</span>fn </span>[[t [s] [sdot]]] </span> (</span></span> m g (</span>/</span> d </span>2</span>) (</span>cos </span>(</span> </span>2 </span>'pi h s))) </span>)) </span> </span>(</span>def </span>L-bead-helical </span>(</span>-</span> T-bead-helical V-bead-helical)) </span> </span>(</span>render </span> (</span>let </span>[local ((</span>Gamma </span>(</span>up </span>(</span>literal-function </span>'s))) 't) </span> L (</span>L-bead-helical </span>'m 'g 'd 'h) </span> ] </span> (</span>L</span> local) </span> )) </span> </span>;; EOMs for bead on helical wire under gravity </span>(</span>let </span>[L (</span>L-bead-helical </span>'m 'g 'd 'h) </span> state (</span>up </span>(</span>literal-function </span>'s))] </span> (</span>rendertex </span>(((</span>Lagrange-equations</span> L) state) 't))) </span></code></pre> \begin{bmatrix}\displaystyle{- d\,g\,h\,m\,\pi\,\sin\left(2\,h\,\pi\,s\left(t\right)\right) + {d}^{2}\,m\,{D}^{2}s\left(t\right) + {h}^{2}\,m\,{D}^{2}s\left(t\right) + m\,{\pi}^{2}\,{D}^{2}s\left(t\right) + m\,{D}^{2}s\left(t\right)}\end{bmatrix} </div> The equations of motion for the bead on a helical wire is derived as:</p> $$ \ddot{s} = \frac{dgh\pi \sin{\left( 2\pi h s \right)}} { d^2 + h^2 + \pi^2 + 1 } $$ </div> Exercise 1.19: Two-bar linkage 2022-10-31T01:02:53+00:00 Exercise 1.19: Two-bar linkage</h3> The two-bar linkage shown in the figure below is constrained to move in the plane. It is composed of three small massive bodies interconnected by two massless rigid rods in a uniform gravitational field with vertical acceleration g. The rods are pinned to the central body by a hinge that allows the linkage to fold. The system is arranged so that the hinge is completely free: the members can go through all configurations without collision. Formulate a Lagrangian that describes the system and find the Lagrange equations of motion. Use the computer to do this, because the equations are rather big.</strong></p> </p> Figure 1.3</strong></p> Use three sets of rectangular coordinates, one for each body. The generalized coordinates could be represented by the position of $m_2$ and two angles, $\theta_1$ and $\theta_3$, positive CCW and measured from the X axis.</p> $$ \begin{align} x_1(t) &= x + l_1\cos\theta_1 \\ x_1(t) &= y + l_1\sin\theta_1 \\ x_2(t) &= x\\ y_2(t) &= y\\ x_3(t) &= x + l_1\cos\theta_3 \\ x_3(t) &= y + l_1\sin\theta_3 \\ \end{align} $$ </div> (</span>defn </span>twobar-linkage->rect </span>[l_1 l_2] </span> (</span>fn </span>[[_ [x y theta_1 theta_3] _]] </span> (</span>up </span>(</span>+</span> x (</span></span> l_1 (</span>cos</span> theta_1))) </span> (</span>+</span> y (</span></span> l_1 (</span>sin</span> theta_1))) </span> x </span> y </span> (</span>+</span> x (</span></span> l_2 (</span>cos</span> theta_3))) </span> (</span>+</span> y (</span></span> l_2 (</span>sin</span> theta_3))) </span> ))) </span> </span>(</span>defn </span>L-const-accel-three-bodies </span>[m_1 m_2 m_3 g] </span> (</span>fn </span>[[_ [x_1 y_1 x_2 y_2 x_3 y_3] [v_x1 v_y1 v_x2 v_y2 v_x3 v_y3]]] </span> (</span>let </span>[T1 (</span>* </span>1/2 </span>(</span></span> m_1 (</span>+ </span>(</span>square</span> v_x1) (</span>square</span> v_y1)))) </span> T2 (</span> </span>1/2 </span>(</span></span> m_2 (</span>+ </span>(</span>square</span> v_x2) (</span>square</span> v_y2)))) </span> T3 (</span> </span>1/2 </span>(</span></span> m_3 (</span>+ </span>(</span>square</span> v_x3) (</span>square</span> v_y3)))) </span> T (</span>+</span> T1 T2 T3) </span> V1 (</span></span> m_1 g y_1) </span> V2 (</span></span> m_2 g y_2) </span> V3 (</span></span> m_3 g y_3) </span> V (</span>+</span> V1 V2 V3)] </span> (</span>-</span> T V)))) </span> </span> </span>(</span>defn </span>L-twobar-linkage </span>[m_1 m_2 m_3 g l_1 l_2] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-const-accel-three-bodies</span> m_1 m_2 m_3 g) (</span>F->C </span>(</span>twobar-linkage->rect</span> l_1 l_2))) </span> q-prime))) </span> </span>(</span>def </span>eom-twobar-linkage </span> (</span>let </span>[L (</span>L-twobar-linkage </span>'m_1 'm_2 'm_3 'g 'l_1 'l_2)] </span> (</span>Lagrange-equations</span> L) </span>)) </span> </span>(</span>rendertexvec </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y) (</span>literal-function </span>'theta_1) (</span>literal-function </span>'theta_3))] </span> ((</span>eom-twobar-linkage</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{- l_1\,m_1\,\cos\left({\theta}_1\left(t\right)\right)\,{\left(D{\theta}_1\left(t\right)\right)}^{2} - l_2\,m_3\,\cos\left({\theta}_3\left(t\right)\right)\,{\left(D{\theta}_3\left(t\right)\right)}^{2} - l_1\,m_1\,\sin\left({\theta}_1\left(t\right)\right)\,{D}^{2}{\theta}_1\left(t\right) - l_2\,m_3\,\sin\left({\theta}_3\left(t\right)\right)\,{D}^{2}{\theta}_3\left(t\right) + m_1\,{D}^{2}x\left(t\right) + m_2\,{D}^{2}x\left(t\right) + m_3\,{D}^{2}x\left(t\right)} \cr \cr \displaystyle{- l_1\,m_1\,{\left(D{\theta}_1\left(t\right)\right)}^{2}\,\sin\left({\theta}_1\left(t\right)\right) - l_2\,m_3\,{\left(D{\theta}_3\left(t\right)\right)}^{2}\,\sin\left({\theta}_3\left(t\right)\right) + l_1\,m_1\,\cos\left({\theta}_1\left(t\right)\right)\,{D}^{2}{\theta}_1\left(t\right) + l_2\,m_3\,\cos\left({\theta}_3\left(t\right)\right)\,{D}^{2}{\theta}_3\left(t\right) + g\,m_1 + g\,m_2 + g\,m_3 + m_1\,{D}^{2}y\left(t\right) + m_2\,{D}^{2}y\left(t\right) + m_3\,{D}^{2}y\left(t\right)} \cr \cr \displaystyle{g\,l_1\,m_1\,\cos\left({\theta}_1\left(t\right)\right) + {l_1}^{2}\,m_1\,{D}^{2}{\theta}_1\left(t\right) + l_1\,m_1\,\cos\left({\theta}_1\left(t\right)\right)\,{D}^{2}y\left(t\right) - l_1\,m_1\,\sin\left({\theta}_1\left(t\right)\right)\,{D}^{2}x\left(t\right)} \cr \cr \displaystyle{g\,l_2\,m_3\,\cos\left({\theta}_3\left(t\right)\right) + {l_2}^{2}\,m_3\,{D}^{2}{\theta}_3\left(t\right) + l_2\,m_3\,\cos\left({\theta}_3\left(t\right)\right)\,{D}^{2}y\left(t\right) - l_2\,m_3\,\sin\left({\theta}_3\left(t\right)\right)\,{D}^{2}x\left(t\right)}\end{pmatrix} </div> Exercise 1.20: Sliding pendulum 2022-10-31T01:02:50+00:00 Exercise 1.20: Sliding pendulum</h3> Consider a pendulum of length $l$ attached to a support that is free to move horizontally, as shown in the figure. Let the mass of the support be $m_1$ and the mass of the pendulum bob be $m_2$. Formulate a Lagrangian and derive Lagrange’s equations for this system.</strong></p> </p> Figure 1.4</strong></p> Consider the two bodies with their rectangular coordinates:</p> $$ \begin{align} x_1 &= x \\ y_1 &= y \\ x_2 &= x + l\cos{\theta} \\ y_2 &= y + l\sin{\theta} \\ \end{align} $$ </div> Use coordinate transform along with a constant-acceleration lagrangian for two particles to compute the equations for the system</p> (</span>defn </span>sliding-pend->rect </span>[l] </span> (</span>fn </span>[[_ [x y theta] _]] </span> (</span>up</span> x </span> y </span> (</span>+</span> x (</span></span> l (</span>cos</span> theta))) </span> (</span>+</span> y (</span></span> l (</span>sin</span> theta))) </span> ))) </span> </span>(</span>defn </span>L-const-accel-two-bodies </span>[m_1 m_2 g] </span> (</span>fn </span>[[_ [x_1 y_1 x_2 y_2] [v_x1 v_y1 v_x2 v_y2]]] </span> (</span>let </span>[T1 (</span>* </span>1/2 </span>(</span></span> m_1 (</span>+ </span>(</span>square</span> v_x1) (</span>square</span> v_y1)))) </span> T2 (</span> </span>1/2 </span>(</span></span> m_2 (</span>+ </span>(</span>square</span> v_x2) (</span>square</span> v_y2)))) </span> T (</span>+</span> T1 T2) </span> V1 (</span></span> m_1 g y_1) </span> V2 (</span></span> m_2 g y_2) </span> V (</span>+</span> V1 V2)] </span> (</span>-</span> T V)))) </span> </span>(</span>defn </span>L-sliding-pend </span>[m_1 m_2 g l] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-const-accel-two-bodies</span> m_1 m_2 g) (</span>F->C </span>(</span>sliding-pend->rect</span> l))) </span> q-prime))) </span> </span>(</span>def </span>eom-sliding-pend </span> (</span>let </span>[L (</span>L-sliding-pend </span>'m_1 'm_2 'g 'l)] </span> (</span>Lagrange-equations</span> L) </span>)) </span> </span>(</span>rendertexvec </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y) (</span>literal-function </span>'theta))] </span> ((</span>eom-sliding-pend</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{- l\,m_2\,\cos\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2} - l\,m_2\,\sin\left(\theta\left(t\right)\right)\,{D}^{2}\theta\left(t\right) + m_1\,{D}^{2}x\left(t\right) + m_2\,{D}^{2}x\left(t\right)} \cr \cr \displaystyle{- l\,m_2\,{\left(D\theta\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right) + l\,m_2\,\cos\left(\theta\left(t\right)\right)\,{D}^{2}\theta\left(t\right) + g\,m_1 + g\,m_2 + m_1\,{D}^{2}y\left(t\right) + m_2\,{D}^{2}y\left(t\right)} \cr \cr \displaystyle{g\,l\,m_2\,\cos\left(\theta\left(t\right)\right) + {l}^{2}\,m_2\,{D}^{2}\theta\left(t\right) + l\,m_2\,\cos\left(\theta\left(t\right)\right)\,{D}^{2}y\left(t\right) - l\,m_2\,\sin\left(\theta\left(t\right)\right)\,{D}^{2}x\left(t\right)}\end{pmatrix} </div> Exercise 1.18: Bead on a triaxial surface 2022-10-31T01:02:48+00:00 Exercise 1.18: Bead on a triaxial surface</h3> A bead of mass $m$ moves without friction on a triaxial ellipsoidal surface. In rectangular coordinates the surface satisfies</strong></p> $$ \frac{x^2}{a^2} + \frac{y^2}{b^2} + \frac{z^2}{c^2} = 1 $$ </div> for some constants $a$, $b$, and $c$. Identify suitable generalized coordinates, formulate a Lagrangian, and find Lagrange’s equations.</strong></p> The parameteric equations for an ellipsoid are:</p> $$ \begin{align} x &= a\sin{\theta}\cos{\varphi} \\ y &= b\sin{\theta}\sin{\varphi} \\ z &= c\cos{\theta} \end{align} $$ </div> (</span>defn </span>L-free-particle </span>[mass] </span> (</span>fn </span>[[_ _ v]] </span> (</span> </span>1/2</span> mass (</span>dot-product</span> v v))) </span>) </span> </span>(</span>defn </span>elliptical->rect </span>[a b c] </span> (</span>fn </span>[[_ [theta phi] _]] </span> (</span>up </span>(</span></span> a (</span>sin</span> theta) (</span>cos</span> phi)) </span> (</span></span> b (</span>sin</span> theta) (</span>sin</span> phi)) </span> (</span></span> c (</span>cos</span> theta))))) </span> </span>;; ;; L' = L . C </span>(</span>defn </span>L-ellipsoid </span>[m a b c] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-free-particle</span> m) (</span>F->C </span>(</span>elliptical->rect</span> a b c))) </span> q-prime))) </span> </span>(</span>def </span>eom-ellipsoid </span> (</span>let </span>[L (</span>L-ellipsoid </span>'m 'a 'b 'c)] </span> (</span>Lagrange-equations</span> L) </span>)) </span> </span>(</span>rendertexvec </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'theta) (</span>literal-function </span>'varphi))] </span> ((</span>eom-ellipsoid</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{- {a}^{2}\,m\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right) - {a}^{2}\,m\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2} -2\,{a}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,{\cos}^{2}\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,D\varphi\left(t\right)\,\sin\left(\varphi\left(t\right)\right) + 2\,{b}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,{\cos}^{2}\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,D\varphi\left(t\right)\,\sin\left(\varphi\left(t\right)\right) - {b}^{2}\,m\,\cos\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right)\,{\sin}^{2}\left(\varphi\left(t\right)\right) - {b}^{2}\,m\,\cos\left(\theta\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\varphi\left(t\right)\right) + {a}^{2}\,m\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,{\cos}^{2}\left(\theta\left(t\right)\right)\,{D}^{2}\theta\left(t\right) - {a}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}\varphi\left(t\right) + {b}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}\varphi\left(t\right) + {b}^{2}\,m\,{\cos}^{2}\left(\theta\left(t\right)\right)\,{\sin}^{2}\left(\varphi\left(t\right)\right)\,{D}^{2}\theta\left(t\right) + {c}^{2}\,m\,\cos\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,\sin\left(\theta\left(t\right)\right) + {c}^{2}\,m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{D}^{2}\theta\left(t\right)} \cr \cr \displaystyle{{a}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\theta\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right) + {a}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,\sin\left(\varphi\left(t\right)\right) + 2\,{a}^{2}\,m\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,D\varphi\left(t\right)\,{\sin}^{2}\left(\varphi\left(t\right)\right) + 2\,{b}^{2}\,m\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,D\varphi\left(t\right) - {b}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\theta\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right) - {b}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\varphi\left(t\right)\right)}^{2}\,\sin\left(\varphi\left(t\right)\right) - {a}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}\theta\left(t\right) + {a}^{2}\,m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\sin}^{2}\left(\varphi\left(t\right)\right)\,{D}^{2}\varphi\left(t\right) + {b}^{2}\,m\,{\cos}^{2}\left(\varphi\left(t\right)\right)\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{D}^{2}\varphi\left(t\right) + {b}^{2}\,m\,\cos\left(\varphi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,\sin\left(\theta\left(t\right)\right)\,\sin\left(\varphi\left(t\right)\right)\,{D}^{2}\theta\left(t\right)}\end{pmatrix} </div> Exercise 1.40: Bead on a triaxial surface (incomplete) 2022-10-31T00:25:47+00:00 Exercise 1.40: Bead on a triaxial surface</h3> Consider again the motion of a bead constrained to move on a triaxial surface (exercise 1.18). Reformulate this using rectangular coordinates as the generalized coordinates with an explicit constraint that the bead must stay on the surface. Find a Lagrangian and show that the Lagrange equations are equivalent to those found in exercise 1.18</a> (solution</a>).</strong></p> We model the system as a point mass constrained to stay on a triaxial surface using the following coordinate constraint:</p> $$ \varphi(t; x,y,z; \dot{x},\dot{y},\dot{z}) = \frac{x^2}{a^2} + \frac{y^2}{b^2} + \frac{z^2}{c^2} - 1 = 0 $$ </div> where $a$, $b$ and $c$ are parameters defining the surface. The augmented Lagrangian is:</p> $$ L' = \frac{1}{2} m \dot{x}^2 + \lambda \left(\frac{x^2}{a^2} + \frac{y^2}{b^2} + \frac{z^2}{c^2} - 1\right) $$ </div> (</span>defn </span>L-free-particle </span>[mass] </span> (</span>fn </span>[[_ _ v]] </span> (</span> </span>1/2</span> mass (</span>dot-product</span> v v))) </span>) </span> </span>(</span>defn </span>ellipsoid-constraint </span>[a b c] </span> (</span>fn </span>[[_ [x y z] _]] </span> (</span>- </span>(</span>+ </span>(</span>/ </span>(</span>square</span> x) (</span>square</span> a)) </span> (</span>/ </span>(</span>square</span> y) (</span>square</span> b)) </span> (</span>/ </span>(</span>square</span> z) (</span>square</span> c))) </span>1</span>) </span> ) </span>) </span> </span>(</span>defn </span>Augment-Lagrangian </span>[L lambda phi] </span> (</span>+</span> L (</span></span> lambda phi))) </span> </span>(</span>defn </span>L-bead-on-ellipsoid </span>[m a b c] </span> (</span>fn </span>[[t [x y z lambda] [xdot ydot zdot lambdadot]]] </span> (</span>let </span>[L (</span>L-free-particle</span> m) </span> phi (</span>ellipsoid-constraint</span> a b c) </span> q (</span>up</span> t (</span>up</span> x y z) (</span>up</span> xdot ydot zdot))] </span> (</span>+ </span>(</span>L</span> q) (</span></span> lambda (</span>phi</span> q)))))) </span></code></pre> #'user/L-bead-on-ellipsoid </span></code></pre> (</span>def </span>eom-system </span> (</span>Lagrange-equations </span>(</span>L-bead-on-ellipsoid </span>'m 'a 'b 'c))) </span> </span>(</span>def </span>eqs-system </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x) (</span>literal-function </span>'y) (</span>literal-function </span>'z) (</span>literal-function </span>'lambda))] </span> ((</span>eom-system</span> state) 't))) </span> </span>(</span>rendertexvec</span> eqs-system) </span></code></pre> \begin{pmatrix}\displaystyle{\frac{{a}^{2}\,m\,{D}^{2}x\left(t\right) -2\,x\left(t\right)\,\lambda\left(t\right)}{{a}^{2}}} \cr \cr \displaystyle{\frac{{b}^{2}\,m\,{D}^{2}y\left(t\right) -2\,y\left(t\right)\,\lambda\left(t\right)}{{b}^{2}}} \cr \cr \displaystyle{\frac{{c}^{2}\,m\,{D}^{2}z\left(t\right) -2\,z\left(t\right)\,\lambda\left(t\right)}{{c}^{2}}} \cr \cr \displaystyle{\frac{{a}^{2}\,{b}^{2}\,{c}^{2} - {a}^{2}\,{b}^{2}\,{\left(z\left(t\right)\right)}^{2} - {a}^{2}\,{c}^{2}\,{\left(y\left(t\right)\right)}^{2} - {b}^{2}\,{c}^{2}\,{\left(x\left(t\right)\right)}^{2}}{{a}^{2}\,{b}^{2}\,{c}^{2}}}\end{pmatrix} </div> We can eliminate one of the coordinate as the system only has two degrees of freedom. First lets define some terminology:</p> $$\require{cancel}$$</p> $$ \begin{align} K_1 &= \frac{a^2}{c^2}, K_2 = \frac{a^2}{b^2}\\ D^2(x(t)) &= \ddot{x}, D^2 y(t) = \ddot{y}, D^2 z(t) = \ddot{z}\\ \end{align} $$ </div> From the constraint,</p> $$ \begin{align} a^2 x &= a^2 b^2 c^2 - a^2 b^2 z - a^2 c^2 y \\ x &= \frac{a^2 b^2 c^2 - a^2 b^2 z - a^2 c^2 y}{b^2 c^2} \\ x &= a^2 - K_1 z - K_2 y \\ => \dot{x} &= - K_1 \dot{z} - K_2 \dot{y} \\ => \ddot{x} &= -K_1 (\ddot{z}z + \dot{z}^2) -K_2 (\ddot{y}y + \dot{y}^2) \end{align} $$ </div> From the first equation,</p> $\lambda = \frac{m a^2 \ddot{x}}{x}$</p> Substituting $\lambda$ into the second equation, we get:</p> $$ \begin{align} b^2 \cancel{m} \ddot{y} &= 2 y \frac{\cancel{m} a^2 \ddot{x}}{x} \\ => \ddot{y} &= 2 y \frac{a^2}{b^2} \left(\frac{-K_1 (\ddot{z}z + \dot{z}^2) -K_2 (\ddot{y}y + \dot{y}^2)}{a^2 - K_1 z - K_2 y}\right)\\ => \ddot{y} &= - 2 y K_2 \frac{K_1 (\ddot{z}z + \dot{z}^2) + K_2 (\ddot{y}y + \dot{y}^2)}{a^2 - K_1 z - K_2 y} \end{align} $$ </div> Substituting $\lambda$ into the third equation, we get:</p> $$ \begin{align} c^2 \cancel{m} \ddot{z} &= 2 y \frac{\cancel{m} a^2 \ddot{x}}{x} \\ => \ddot{z} &= 2 z \frac{a^2}{c^2} \left(\frac{-K_1 (\ddot{z}z + \dot{z}^2) -K_2 (\ddot{y}y + \dot{y}^2)}{a^2 - K_1 z - K_2 y}\right)\\ => \ddot{z} &= - 2 z K_1 \frac{K_1 (\ddot{z}z + \dot{z}^2) + K_2 (\ddot{y}y + \dot{y}^2)}{a^2 - K_1 z - K_2 y} \end{align} $$ </div> </span></code></pre> Section 2.1: Rotational Kinetic Energy 2022-10-30T04:42:17+00:00 2 Rigid Bodies</h2> The polhode rolls without slipping on the herpolhode lying in the invariable plane.</p> Herbert Goldstein, Classical Mechanics</em>, footnote, p. 207.</p> </blockquote> A rotating top - an axisymmetric body subject to gravity, with a point on the axis of symmetry that is fixed in space</p> The axis of the top precesses about the vertical, apparently moving perpendicular to the direction in which gravity is pulling it</li> </ul> </li> Book thrown into the air - has two stable configurations about longest and shortest axes. Starts tumbling when rotated about intermediate axis</p> </li> The Moon always points the same face towards the Earth regardless of the interactions with the Sun and other planets</p> </li> A rigid body can be thought to consist of a large number of constituent particles with rigid constraints among them. While the dynamics are the same as any other rigidly constrained system, new tools are needed as the number of particles/constraints are very high.</p> </li> We need to define the kinetic and potential energies to define the Lagrangian for a system</p> The strategy is to first rewrite the kinetic and potential energies in terms of quantities that characterize essential aspects of the distribution of mass in the body and the state of motion of the body</li> </ul> </li> For rotational kinetic energy, a small number of parameters completely specify the state of motion and the relevant aspects of the distribution of mass in the body</p> </li> For potential energy, some specific problems the potential energy can be represented with a small number of parameters, but in general we have to make approximations to obtain a representation with a manageable number of parameters</p> </li> </ul> 2.1 Rotational Kinetic Energy</h2> A rigid body can be considered to consist of a large number of particles with mass $m_\alpha$, $\vec{x_\alpha}$, and velocities $\dot{\vec{x}}_\alpha$ with positional constraints between them. The kinetic energy is:</p> $$ \sum_{\alpha} \frac{1}{2} m_\alpha\dot{\vec{x}}_\alpha \cdot \dot{\vec{x}}_\alpha\\ $$ </div> The configuration of a rigid body is fully specified by the position of any</em> point inthe body and the orientation of the body. Therefore, we define the position vectors based on a reference point on the body $X$. The position of each particle relative to the reference point can be represented by $\xi_\alpha$:</p> $$ \vec{x}_\alpha = \vec{X} + \vec{\xi}_\alpha\tag{2.2} $$ </div> The corresponding velocities are given by:</p> $$ \dot{\vec{x}}_\alpha = \dot{\vec{X}} + \dot{\vec{\xi}}_\alpha\tag{2.3} $$ </div> The kinetic energy of the body can be rewritten as:</p> $$ \begin{align} \sum_{\alpha} \frac{1}{2} & m_\alpha (\vec{X} + \vec{\xi}_\alpha) \cdot (\vec{X} + \vec{\xi}_\alpha) \\ &= \sum_{\alpha} \frac{1}{2} m_\alpha (\vec{X} \cdot \vec{X} + \vec{X} \cdot \vec{\xi}_\alpha + \vec{\xi}_\alpha\cdot\vec{\xi}_\alpha)\tag{2.4} \end{align} $$ </div> If we choose the center of mass of the body as the reference point,</p> $$ \vec{X} = \frac{1}{M} \sum_{\alpha} m_\alpha\vec{x}_\alpha\\ $$ </div> where $M = \sum_\alpha m_\alpha$ is the total mass of the body, then</p> $$ \sum_{\alpha} m_\alpha\vec{\xi_\alpha} = \sum_\alpha m_\alpha (\vec{x}_\alpha - \vec{X})\tag{2.6} $$ </div> Taking the derivative of this, we can see that the relative velocities satisfy $\sum_\alpha m_\alpha \dot{\xi}_\alpha = 0$. So the kinetic energy is equal to:</p> $$ \begin{align} T &= \frac{1}{2} \left(\sum_{\alpha} m_\alpha \dot{\vec{X}} \cdot \dot{\vec{X}} + \sum_{\alpha} m_\alpha \dot{\vec{X}} \cdot \vec{\xi}_\alpha + \sum_{\alpha} m_\alpha \dot{\vec{\xi}}_\alpha\cdot\dot{\vec{\xi}}_\alpha\right) \\ &= \frac{1}{2} \left(\sum_{\alpha} m_\alpha \dot{\vec{X}} \cdot \dot{\vec{X}} + \dot{\vec{X}} \sum_{\alpha} \underbrace{m_\alpha \dot{\vec{\xi}}_\alpha}_{= 0} + \sum_{\alpha} m_\alpha \dot{\vec{\xi}}_\alpha\cdot\dot{\vec{\xi}}_\alpha\right)\\ &= \frac{1}{2} \sum_{\alpha} m_\alpha \dot{\vec{X}} \cdot \dot{\vec{X}} + \frac{1}{2} \sum_{\alpha} m_\alpha \dot{\vec{\xi}}_\alpha \cdot \dot{\vec{\xi}}_\alpha\tag{2.8} \end{align} $$ </div> This shows that kinetic energy of the rigid body can be separated into two pieces. The translational kinetic energy is:</p> $$ \frac{1}{2} \sum_{\alpha} m_\alpha \dot{\vec{X}} \cdot \dot{\vec{X}}\tag{2.9} $$ </div> The rotational kinetic energy is:</p> $$ \frac{1}{2} \sum_{\alpha} m_\alpha \dot{\vec{\xi}}_\alpha \cdot \dot{\vec{\xi}}_\alpha\tag{2.10} $$ </div> When written in appropriate generalized coordinates, the kinetic energy is a Lagrangian for a free rigid body. Choosing generalized coordinates such that the coordinates specifying the position of the center of mass is separate from those specifying the orientation, then the Lagrange equations completely decouple. This makes the dynamics of translation decoupled from that of translation.</p> However, this is not true in the general case once potential energies are included in the system. So the motion of the center of mass and the rigid body may be coupled through the potential energy. However, in some specific cases, such as for example, a rigid body moving in a uniform gravitational field, the equations may decouple.</p> Exercise 1.39: Combining Lagrangians 2022-10-30T00:29:36+00:00 Exercise 1.39: Combining Lagrangians</h3> a. Make another primitive component, compatible with the spring-mass structures described in this section</a>. For example, make a pendulum that can attach to the spring-mass system. Build a combination and derive the equations of motion. Be careful, the algebra is horrible if you choose bad coordinates.</strong></p> ;; Assume that the springs only move horizontally and are not affected by gravity </span>(</span>defn </span>LspringmassA </span>[m_1 k_1] </span> (</span>fn </span>L1 </span>[[_</span>, </span>[x_1]</span>, </span>[xdot_1]]] </span> (</span>- </span>(</span>* </span>1/2</span> m_1 (</span>square</span> xdot_1)) (</span>* </span>1/2</span> k_1 (</span>square</span> x_1))) </span> )) </span> </span>(</span>defn </span>LspringmassB </span>[m_2 k_2] </span> (</span>fn </span>L2 </span>[[_</span>, </span>[x_2</span>,</span> xi]</span>, </span>[xdot_2</span>,</span> xidot]]] </span> (</span>- </span>(</span>* </span>1/2</span> m_2 (</span>square </span>(</span>+</span> xdot_2 xidot))) (</span>* </span>1/2</span> k_2 (</span>square</span> x_2))) </span> )) </span> </span>;; pendulum is attached at the end of the second spring-mass </span>;; x_3 defines the attachment point and is constrained to be equal to </span>;; X_1 + X_2 + x_1 + x_2 </span>(</span>defn </span>L-pendulum </span>[m l g] </span> (</span>fn </span>L3 </span>[[_</span>, </span>[x_3 theta]</span>, </span>[x3_dot thetadot]]] </span> (</span>+ </span>(</span></span> m (</span>+ </span>(</span> </span>(</span>square</span> l) (</span>square</span> thetadot)) (</span>square</span> x3_dot))) (</span></span> m g l (</span>cos</span> theta))) </span>)) </span> </span>(</span>defn </span>L-system </span>[m_1 m_2 m_3 k_1 k_2 l g] </span> (</span>fn </span>L </span>[[t</span>, </span>[x_1</span>,</span> x_2</span>,</span> x_3</span>,</span> xi</span>,</span> theta</span>,</span>lambda_1</span>,</span>lambda_2]</span>, </span>[xdot_1</span>,</span> xdot_2</span>,</span> xdot_3</span>,</span> xidot</span>,</span> thetadot</span>,</span> lambdadot1</span>,</span> lambdadot2]]] </span> (</span>let </span>[L1 (</span>LspringmassA</span> m_1 k_1) </span> L2 (</span>LspringmassB</span> m_2 k_2) </span> L3 (</span>L-pendulum</span> m_3 l g) </span> phi1 (</span>-</span> xi (</span>+ </span>'X_1 x_1)) </span>;; linking two spring-mass systems </span> phi2 (</span>-</span> x_3 (</span>+ </span>'X_1 x_1 'X_2 x_2)) </span>;; connecting pendulum to second spring-mass </span> ] </span> (</span>+ </span>(</span>L1 </span>(</span>up</span> t (</span>up</span> x_1) (</span>down</span> xdot_1))) </span> (</span>L2 </span>(</span>up</span> t (</span>up</span> x_2 xi) (</span>up</span> xdot_2 xidot))) </span> (</span>L3 </span>(</span>up</span> t (</span>up</span> x_3 theta) (</span>up</span> xdot_3 thetadot))) </span> (</span></span> lambda_1 phi1) </span> (</span></span> lambda_2 phi2) </span> ) </span> ) </span>)) </span> </span> </span>(</span>rendermd </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x_1) (</span>literal-function </span>'x_2) (</span>literal-function </span>'x_3) </span> (</span>literal-function </span>'xi) (</span>literal-function </span>'theta) </span> (</span>literal-function </span>'lambda_1) (</span>literal-function </span>'lambda_2)) </span> local ((</span>Gamma</span> state) 't)] </span> ((</span>L-system </span>'m_1 'm_2 'm_3 'k_1 'k_2 'l 'g) local))) </span></code></pre> $$ {l}^{2}\,m_3\,{\left(D\theta\left(t\right)\right)}^{2} + g\,l\,m_3\,\cos\left(\theta\left(t\right)\right) + \frac{-1}{2}\,k_1\,{\left(x_1\left(t\right)\right)}^{2} + \frac{-1}{2}\,k_2\,{\left(x_2\left(t\right)\right)}^{2} + \frac{1}{2}\,m_1\,{\left(Dx_1\left(t\right)\right)}^{2} + \frac{1}{2}\,m_2\,{\left(Dx_2\left(t\right)\right)}^{2} + m_2\,Dx_2\left(t\right)\,D\xi\left(t\right) + \frac{1}{2}\,m_2\,{\left(D\xi\left(t\right)\right)}^{2} + m_3\,{\left(Dx_3\left(t\right)\right)}^{2} - X_1\,{\lambda}_1\left(t\right) - X_1\,{\lambda}_2\left(t\right) - X_2\,{\lambda}_2\left(t\right) - x_2\left(t\right)\,{\lambda}_2\left(t\right) - x_1\left(t\right)\,{\lambda}_1\left(t\right) - x_1\left(t\right)\,{\lambda}_2\left(t\right) + {\lambda}_1\left(t\right)\,\xi\left(t\right) + {\lambda}_2\left(t\right)\,x_3\left(t\right) $$ </div> (</span>def </span>eom-system </span> (</span>Lagrange-equations </span>(</span>L-system </span>'m_1 'm_2 'm_3 'k_1 'k_2 'l 'g))) </span> </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x_1) (</span>literal-function </span>'x_2) (</span>literal-function </span>'x_3) </span> (</span>literal-function </span>'xi) (</span>literal-function </span>'theta) </span> (</span>literal-function </span>'lambda_1) (</span>literal-function </span>'lambda_2))] </span> ((</span>eom-system</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{k_1\,x_1\left(t\right) + m_1\,{D}^{2}x_1\left(t\right) + {\lambda}_1\left(t\right) + {\lambda}_2\left(t\right)} \cr \cr \displaystyle{k_2\,x_2\left(t\right) + m_2\,{D}^{2}x_2\left(t\right) + m_2\,{D}^{2}\xi\left(t\right) + {\lambda}_2\left(t\right)} \cr \cr \displaystyle{2\,m_3\,{D}^{2}x_3\left(t\right) - {\lambda}_2\left(t\right)} \cr \cr \displaystyle{m_2\,{D}^{2}x_2\left(t\right) + m_2\,{D}^{2}\xi\left(t\right) - {\lambda}_1\left(t\right)} \cr \cr \displaystyle{g\,l\,m_3\,\sin\left(\theta\left(t\right)\right) + 2\,{l}^{2}\,m_3\,{D}^{2}\theta\left(t\right)} \cr \cr \displaystyle{X_1 + x_1\left(t\right) - \xi\left(t\right)} \cr \cr \displaystyle{X_1 + X_2 + x_2\left(t\right) + x_1\left(t\right) - x_3\left(t\right)}\end{pmatrix} </div> Section 1.11: Summary 2022-10-29T21:22:55+00:00 Summary</h2> This chapter was primarily introducing the Lagrangian method of analyzing mechanical systems. Here are some of the key points:</p> To start with, we need to distinguish between realizable motions and other possible motions of the system. This is achieved using the “action function”, which is constructed to be stationary only on paths that describe realizable motions, with respect to variations in the path. This is called the principle of stationary action</em> or principle of least action</em> and is the foundation of classical mechanics (and apparently electrodynamics, quantum mechanics and general relativity). The stationary action principle is a coordinate-independent description of realizable paths. Regardless of if the system has constraints, we may choose any system of coordinates that uniquely determines the configuration of the system.</p> An action is defined as the integral of a function, the Lagrangian</em> along a path. For many mechanical systems, the appropriate choice for a Lagrangian is the difference between the kinetic energy and potential energy of the system. This is not unique and there may be many choices of valid Lagrangians for a given system.</p> </li> By applying the Euler-Lagrange operator to the Lagrangian, we can derive a set of ordinary differential equations called the Lagrange equations</em> that describes the motion of the system. Any realizable path saisfies these equations of motion</em>.</p> </li> We can add a “total-time derivative” to a Lagrangian without affecting the Lagrange equations of system</p> </li> The entire time-history of a system can be simulated from a starting point with an initial state (which usually consists of the coordinates and the rate of change of the coordinates at the initial time) using these equations of motion</p> </li> </ul> </li> If there are continuous symmetries in a system, there are conserved quantities associated with that system (Noether’s theorem</a>)</p> If the Lagrangian can be formulated such that the symmetries manifest as missing coordinates in the Lagrangian, then there are conserved momenta that are “conjugate” to these coordinates</li> If the Lagrangian is independent of time then there is a conserved energy.</li> </ul> </li> Constraints</a> in a dynamic system can be either holonomic or non-holonomic</p> The constraints can be added to the systems by augmenting the Lagrangian with the constraint function.</li> With Holonomic constraints, the “Lagrange multiplier” $\lambda$ and redundant coordinates can be eliminated from the system and the dynamic equations formulated in terms of just the coordinates and velocities. Holonomic constraints are those which are either coordinate functions, or can be represented as coordinate functions (called integrable constraints)</li> </ul> </li> Non-holonomic constraints have a velocity dependency and systems with these constraints do not currently have a general solution</li> </ul> </li> </ul> Section 1.10.3: Non-holonomic Constraints 2022-10-29T20:57:43+00:00 1.10.3 Non-holonomic Systems</h2> Systems with constraints that are no integrable are called non-holonomic systems</em>. A constraint is considered to be non-integrable if it cannot be written in terms of an equivalent coordinate constraint. One example of this is a ball rolling without slipping in a bowl, or any 2D surface. The ball may return to the same spot in the bowl, but its orientation when it gets there is entirely dependent on the path that it took to get there and may be completely different. So the constraint cannot be used to eliminate any coordinates.</p> There is no general solution for equations of motion governing nonholonomic systems. Her we can look at a restricted set of nonholonomic systems with constraints that are linear in velocities, i.e.</p> $$ \psi(t, q, v) = G_1(t,q)v + G_0(t,q)\tag{1.230} $$ </div> We assume that $\psi$ is not a total time derivative. Based on some of the references in the book, if $L$ is the Lagrangian for the unconstrained system, the equations of motions are asserted to be:</p> $$ \mathscr{E}[L] \circ \Gamma[q] = \lambda(G_1 \circ \Gamma[q]) = \lambda(\partial_2 \psi \circ \Gamma[q]) \tag{1.231} $$ </div> With $\psi = 0$, the system is completely specified and the evolution of its dynamics is defined. While Eq.1.231 is identical to Eq. 1.218 from the previous section</a>, the derivation does not apply here since the assumptions made there do not hold.</p> Eq. 1.185 in Section 1.10</a> defines the condition that the variation $\eta$ must satisfy in order for it to be consistent with the velocity-dependent constraint function $\psi$. It is restated here:</p> $$ (\partial_1 \psi \circ \Gamma[q])\eta + (\partial_2 \psi \circ \Gamma[q])D\eta = 0\tag{1.185} $$ </div> We can no longer eliminate $\eta$ by the logic used in Section 1.10.1, because $\eta$ is no longer orthogonal to $\partial_1 \psi \circ \Gamma[q]$ and we cannot rewrite the constraint as a coordinate constraint because it is not integrable by assumption.</p> The following derivation for of the nonholonomic equations is from Arnold et.al[6]. We define a “virtual velocity”, $\xi$ to be any velocity satisfying the following condition:</p> $$ (\partial_2 \psi \circ \Gamma[q])\xi = 0\tag{1.236} $$ </div> The “principle of d’Alembert–Lagrange” states that:</p> $$ (\mathscr{E}[L] \psi \circ \Gamma[q])\xi = 0\tag{1.237} $$ </div> for any virtual velocity, $\xi$. This could also be restated as “any virtual velocity $\xi$ is orthogonal to $\mathscr{E}[L] \psi \circ \Gamma[q]$. We picked $\xi$ to be arbitrary except that it be orthogonal to $\partial_2 \psi \circ \Gamma[q]$. Therefore, $\partial_2 \psi \circ \Gamma[q]$ must be parallel to $\mathscr{E}[L] \psi \circ \Gamma[q]$. So,</p> $$ \mathscr{E}[L] \circ \Gamma[q] = \lambda(\partial_2 \psi \circ \Gamma[q]) \tag{1.238} $$ </div> which are the non-holonomic equations.</p> The basic idea at the end is that the nonholonomic equations do not follow from the action principle. To quote the book:</p> It comes down to this: the nonholonomic equations do not follow from the action principle. They are something else. Whether they are correct or not depends on whether or not they agree with experiment.</p> </blockquote> In the previous sections, we showed how for systems with coordinate constraints or derivative constraints, the Lagrange equations can be derived from a Lagrangian that is augmented with the constraint. However, if we apply the same technique with non-holonomic constraints, the Lagrange equations obtained are not the same as Eq. 1.238 (or 1.231). For example, consider the following augmented Lagrangian:</p> $$ L['(t; q,\lambda; \dot{q},\dot{\lambda})=L(t,q,\dot{q})+\lambda\psi(t,q,\dot{q}) \tag{1.239} $$ </div> The Lagrange equations associated with the coordinates are found to be:</p> $$ \begin{align} 0 &= \mathscr{E}[L]\circ\Gamma[q] \\ &\quad + D\lambda(\partial_2 \psi \circ \Gamma[q]) + \lambda D (\partial_2 \psi \circ \Gamma[q]) - \lambda(\partial_1 \psi \circ \Gamma[q]) \tag{1.240} \end{align} $$ </div> The Lagrange equation associated with tthe constraint is the constraint equation: $\psi\circ\Gamma[q] = 0$. The equations here involve both $\lambda$ and $D\lambda$. The usual state variables, $q$ and $Dq$ and the constraint are not enough to completely specify the initial conditions for the dynamic system. We need to specify an initial value for $\lambda$ as well (and possibly integrate it along with the states?). This reminds me of the Euler-Lagrange equations as applied to optimal control problems were we have a “costate” $\lambda$ that is integrated along with the states.</p> In general, for any particular physical system, equations (1.231) and (1.240) are not the same, and in fact they have different solutions. It is not apparent that either set of equations accurately models the physical system. The first approach to nonholonomic systems is not justified by extension of the arguments for the holonomic case and the other is not fully determined. Perhaps this indicates that the models are inadequate, that more details of how the constraints are maintained need to be specified.</p> </blockquote> [6] V. I. Arnold, V. V. Kozlov, and A. I. Neishtadt, “Mathematical Aspects of Classical and Celestial Mechanics,” Dynamical Systems III, Springer Verlag, 1988.</p> Section 1.10.2: Derivative Constraints 2022-10-29T19:41:05+00:00 1.10.2 Derivative Constraints</h2> In this section we look at a specific type of velocity-dependent constraints, which are “total-time derivatives” of a velocity independent function. The methods in Section 1.10.1</a> do not apply here as the constraint is velocity-dependent.</p> Let this constraint $\psi = 0$ be a velocity-dependent constraint. If $\psi$ is a total-time derivative, this means that there exists some velocity-independent</em> function, $\varphi$ such that:</p> $$ \psi \circ \Gamma[q] = D(\varphi \circ \Gamma[q]) $$ </div> Since $\varphi$ is velocity independant, $\partial_2 \varphi = 0$. The relationship between $\psi$ and $\varphi$ can be restated (as local-tuple functions) as:</p> $$ \psi = D_t \varphi = \partial_0 \varphi + \partial_1 \varphi \dot{Q}\tag{1.214} $$ </div> We can find $\psi$ by solving this PDE. The constraint is defined as $\psi = 0$. This implies that $\varphi = K$ for some constant $K$. Conversely, if we know that $\varphi = K$, then $\psi = 0$ follows. Thus, the velocity-dependent constraint, $\psi = 0$ is equivalent to the velocity-independent constraint, $\varphi = K$</strong>.</p> If $L$ is the unconstrained Lagrangian, the Lagrange equations with the constraint $\varphi = K$ are:</p> $$ \mathscr{E}[L] \circ \Gamma[q] + \lambda(\mathscr{E}[\varphi] \circ \Gamma[q]) = 0\\ $$ </div> where $\lambda$ is a function of time that will be eliminated during the solution process. $K$ can be ignored here as $\lambda(\varphi - K)$ and $\lambda(\varphi)$ result in the same Lagrange equations. The function $\varphi$ is independent of velocity and $\partial_2 \varphi = 0$. So we can use the same techniques from Section 1.10.1 to get the Lagrange equations for the system as:</p> $$ \mathscr{E}[L] \circ \Gamma[q] - \lambda(\partial_1 \varphi \circ \Gamma[q]) = 0\\ $$ </div> From Eq. 1.214, we can also infer that $\psi$ is the partial of $\varphi$ w.r.t velocity, or $\partial_2 \psi = \partial_1 \varphi$. Therefore, the Lagrange equations with the constraint $\psi = 0$ can also be written as:</p> $$ \mathscr{E}[L] \circ \Gamma[q] - \lambda(\partial_2 \psi \circ \Gamma[q]) = 0\tag{1.218} $$ </div> This is important because it shows that we can write the Lagrangian in terms of $\psi$ without having to compute $\varphi$, as long as we can show that $\varphi$ exists</em>.</p> We can also get the same result using the Augmetned Lagrangian technique. Consider the augmented Lagrangian below</p> $$ L' = L + \lambda' \psi\\ $$ </div> The Lagrange equations for $L’$ are:</p> $$ \mathscr{E}[L'] \circ \Gamma[q] = -D\lambda (\partial_2 \varphi \circ \Gamma[q]) \tag{1.218} $$ </div> where $D\lambda’ = \lambda$. This shows that Eq. 1.218 and Eq. 1.219 are the same equations.</p> The technique defined in this section can be used for systems with constraints that can be written in terms of the derivative of a velocity-independent constraint</em>. Such constraints are called integrable constraints</em>. Any system where the constraints are coordinate constraints, or can be put in the form of a coordinate constraint are called holonomic constraints</strong>.</p> Goldstein’s Hoop</h3> $$\require{cancel}$$</p> </p> Figure 1.10: A massive hoop rolling, without slipping, down an inclined plane.</strong></p> “Goldstein’s hoop” is an example of a dynamic system with an integrable constraint: a hoop of mass $M$ and radius $R$ rolling down a one-dimensional inclined plane (Figure 1.10). This problem can be formulated in terms of two coordinates, $\varphi$, the angular displacement of an arbitrary point on the hoop from some arbitrary reference line, and $x$, the linear progress of the center of the hoop down the plane. The cojnstraint is that the hoop rolls without slipping, or in other words, the change is $\theta$ is directly reflected a change in $x$. The constraint function is:</p> $$ \psi(t; x,\theta; \dot{x},\dot{\varphi}) = R\dot{\theta} - \dot{x} = 0\\ $$ </div> This constraint is represented as a relation between generalized velocities, which can be integrated to get $x = R\theta + c$. This integrated constraint is a velocity-independent constraint. The augmented Lagrangian can be formulated in terms of the original constraint or its derivative.</p> The kinetic energy consists of the energy of rotation of the hoop (described later in Chapter 2 as $\frac{1}{2}MR^2\dot{\theta}^2$) and the energy from the motion of its center of mass. The potential energy of the system decreses as the hoop proceeds down the slope. Thus the augmented Lagrangian is:</p> $$ L(t; x,\theta,\lambda; \dot{x},\dot{\theta},\dot{\lambda}) = \frac{1}{2}MR^2\dot{\theta}^2 + \frac{1}{2}M\dot{x}^2 - (-Mg x\sin\varphi) + \lambda(R\dot{\theta} - \dot{x})\tag{1.122} $$ </div> Lagrange equations for this Lagrangian can be obtained as:</p> $$ \begin{align} M D^2x - D\lambda &= Mg \sin\varphi \tag{1.223}\\ M R^2 D^2\theta + R D\lambda &= 0 \tag{1.224}\\ R D\theta - Dx &= 0 \tag{1.225}\\ \end{align} $$ </div> Differentiating the third equation, we get</p> $$ R D^2\theta = D^2 x\tag{1.226} $$ </div> Multiplying Eq. 1.223 by R and adding with Rq. 1.224</p> $$ \begin{align} 0 &= M R D^2x - \cancel{RD\lambda} - M R g \sin\varphi + M R^2 D^2\theta + \cancel{R D\lambda} \\ &= \cancel{M} \cancel{R} D^2x - \cancel{M} \cancel{R} g \sin\varphi + \cancel{M} R^\cancel{2} D^2\theta \\ &= D^2x + R D^2\theta - g \sin\varphi \\ &= 2 D^2x - g\sin\varphi \\ => D^2x &= -\frac{1}{2}g\sin\varphi \tag{1.227} \end{align} $$ </div> This acceleration is just half of what the acceleration would have been for a point mass sliding down a frictionless inclied plane. Also notable is that the acceleration is independent of both $M$ and $R$. From the Lagrange equations, $D\lambda$ can be interepreted as the frictional force that is causing the hoop to roll instead of slide. Combining Eq. 1.223 and Eq. 1.227, this force can be found to be:</p> $$ D\lambda = \frac{1}{2} Mg \sin\varphi\tag{1.228} $$ </div> and the angular acceleration $D^2\theta$ is:</p> $$ -\frac{1}{2}\frac{g}{R}\sin\varphi\tag{1.229} $$ </div> Section 1.10.1: Coordinate Constraints 2022-10-29T07:27:33+00:00 1.10.1 Coordinate Constraints</h2> In the previous section</a>, we showed that for motion of a system with the constraint $\varphi(t, q(t), Dq(t)) = 0$, for stationary action, the path variations, $\eta(t)$, must be tangent to the constraint surface. And in order for the variation to be tangent to the constraint at a given time, it must satisfy the condition:</p> $$ \begin{align} (\partial_1 \varphi \circ \Gamma[q])\eta + (\partial_2 \varphi \circ \Gamma[q])D\eta = 0 \end{align} $$ </div> Now consider constraints that are only functions of the coordinates, i.e,</p> $$ \partial_2 \varphi = 0\\ $$ </div> Now the variation is tangent to the constraint if</p> $$ (\partial_1 \varphi \circ \Gamma[q])\eta = 0 \tag{1.186} $$ </div> We also know from Eq. 1.183 in the previous section that,</p> $$ \{ (\partial_1 L \circ \Gamma[q]) - D\left( \partial_2 L \circ \Gamma[q] \right) \} \eta = 0 \tag{1.183} $$ </div> Eq. 1.186 and 1.183 together should determine the motion of the constrained system.</p> Eq 1.183 is satisfied if the dot product of the first term (aka the residual of Lagranges Equations) and $\eta(t)$ is zero at all times. This is also the definition for two functions of time to be orthogonal to each other. To quote footnote 92 from the book:</p> We take two tuple-valued functions of time to be orthogonal if at each instant the dot product of the tuples is zero. Similarly, tuple-valued functions are considered parallel if at each moment one of the tuples is a scalar multiple of the other. The scalar multiplier is in general a function of time.</p> </blockquote> So the residual of the Lagrange equations is orthogonal to any $\eta(t)$. Also, $\eta(t)$ is tangent to the constraint surface, which means that it is orthogonal to the normal to the constraint surface.</p> A vector that is orthogonal to all vectors orthogonal to a given vector is parallel to the given vector.</p> </blockquote> Therefore, the residual of Lagrange equations is parallel to the normal to the constraint surface; which means the two functions are proportional:</p> $$ (\partial_1 L \circ \Gamma[q]) - D\left( \partial_2 L \circ \Gamma[q] \right) = \lambda (\partial_1 \varphi \circ \Gamma[q])\tag{1.187} $$ </div> The proportionality factor $\lambda$ is itself a function of time and need not be a constant. This equation, along with the constraint equation $\varphi \circ \Gamma[q] = 0$ is enough to determine the path $q$ and to eliminate the unknown function $\lambda$.</p> We can now form an augmented Lagrangian by treating $\lambda$ as one of the coordinates.</p> $$ L'(t; q,\lambda;\dot{q},\dot{\lambda}) = L(t,q,\dot{q})+ \lambda\varphi(t,q,\dot{q}) $$ </div> The Lagrange equations associated with the coordinates are just the modified Lagrangian in Eq. 1.187. The equation assoicated with $\lambda$ is just the constraint equation. So the system is fully specified. This Lagrangian is also of the same form as the one described in Section 1.6.2</a>.</p> How do we eliminate $\lambda$ from the Lagrange Equations?</h3> If the new function $\lambda$, can be written as a composition of a local tuple function over the original, unaugmented</em> path: $\lambda = \Lambda \circ \Gamma[q]$, then it is a redundant degree of freedom and can be eliminated from the system if required.</p> Consider the Lagrangian with an extra term $\Lambda\varphi$ where $\varphi$ is the constraint function:</p> $$ L'' = L + \Lambda\varphi\\ $$ </div> The Lagrange equations for $L’‘$ is the same as that for $L$ but with some extra terms arising from $\Lambda\varphi$. Applying the Euler-Lagrange operator</a> to $L’’$:</p> $$ \begin{align} \mathscr{E}[L''] &= \mathscr{E}[L + \Lambda\varphi] = \mathscr{E}[L] + \mathscr{E}[\Lambda\varphi]\\ &= \mathscr{E}[L] + \mathscr{E}[\Lambda] \varphi + \Lambda\mathscr{E}[\varphi] + (D_t \Lambda)\partial_2 \varphi + (D_t \varphi)\partial_2 \Lambda \end{align} $$ </div> Composing $\mathscr{E}[L]$ with $\Lambda[q]$ results in the Lagrange equations for $L’’$. Since the constraints are satisfied on the path, $\varphi \circ \Gamma[q] = 0$, which implies that $D_t(\Lambda \circ \Gamma[q]) = 0$.</p> Therefore, composing $\mathscr{E}[L]$ with $\Lambda[q]$, we get:</p> $$ \begin{align} \mathscr{E}[L'']\circ\Gamma[q] &= \mathscr{E}[L]\circ\Gamma[q] + (\mathscr{E}[\Lambda]\circ\Gamma[q])\underbrace{\cancel{\varphi}}_{=0} + \underbrace{(\Lambda\circ\Gamma[q])}_{=\lambda}(\mathscr{E}[\varphi]\circ\Gamma[q])\\ &\quad+ (D_t \Lambda)(\partial_2 \varphi\circ\Gamma[q]) + (\underbrace{\cancel{D_t \varphi}}_{=0})(\partial_2 \Lambda\circ\Gamma[q]) \\ &= \mathscr{E}[L]\circ\Gamma[q] + \lambda(\mathscr{E}[\varphi]\circ\Gamma[q]) + (D_t \Lambda)(\partial_2 \varphi\circ\Gamma[q]) \end{align} $$ </div> $\partial_2\varphi = 0$ as the constraints do not depend on velocity. Then,</p> $$ \mathscr{E}[L'']\circ\Gamma[q] = \mathscr{E}[L]\circ\Gamma[q] + \lambda(\mathscr{E}[\varphi]\circ\Gamma[q])\tag{1.192} $$ </div> We can see here that the Lagrange equations for $L’‘$ is the same as that for $L’$, with an extra term. Comparing this to Eq. 1.187, we can see that $\lambda = \Lambda \circ \Gamma[q]$, which is determined purely by the unaugmented state. Therefore $\lambda$ can be eliminated from the Lagrange equations of the augmented Lagrangian.</p> The explicit Lagrange equations derived from the augmented Lagrangian depend on the accelerations $D^2 q$ as well as $\lambda$. Now that $\lambda$ has been showed to be derived purely form the unaugmented state, so too is $D^2 q$ (as there are no other elements in the dynamic equations). Therefore the dynamic evolution of the system is determined purely by the dynamical state.</p> The Pendulum using Constraints</h3> $$\require{cancel}$$</p> </p> Figure 1.8</strong></p> The pendulum can be modeled as a point-mass constrained to always be at a constant distance from a pivot point. The system can be represented by the following Lagrangian and constraint:</p> $$ \begin{align} L(t; x,y; v_x,v_y) &= \frac{1}{2} m (v_x^2 + v_y^2) - mgy\\ x^2+y^2-l^2 &= 0 \end{align} $$ </div> The augmented Lagrangian is:</p> $$ L(t; x,y,\lambda; v_x,v_y,\dot{\lambda}) = \frac{1}{2} m (v_x^2 + v_y^2) - mgy + \lambda(x^2+y^2-l^2)\\ $$ </div> The Lagrange equations for this augmented Lagrangian is:</p> $$ \begin{align} m D^2x - 2\lambda x = 0 \tag{1.196}\\ m D^2y + mg - 2\lambda y = 0 \tag{1.197}\\ x^2 + y^2 - l^2 = 0\tag{1.198}\\ \end{align} $$ </div> These equations can be simplified by switching to polar coordinates, $x = r\sin{\theta}$ and $y = -r\cos{\theta}$. Substituting this in the constraint equation, we get, $r = l$. Plugging this into the equations 1.196 and 1.197:</p> $$ \begin{align} 0 & = m D^2 (l\sin\theta) - 2\lambda l\sin\theta \\ & = m (D(l \cos\theta D\theta)) - 2\lambda l\sin\theta\\ 0 &= ml (\cos\theta D^2\theta - \sin\theta (D\theta)^2) - 2\lambda l\sin\theta \tag{1.200} \end{align} $$ </div> $$ \begin{align} 0 &= m D^2 (-l\cos\theta) + mgl - 2\lambda (-l\cos\theta) \\ &= m (D(l \sin\theta D\theta)) + 2\lambda l\cos\theta \\ 0 &= ml (\sin\theta D^2\theta + \cos\theta (D\theta)^2) + 2\lambda l\cos\theta + mg \tag{1.201} \end{align} $$ </div> Multiply Eq. 1.200 by $\cos\theta$ and Eq. 1.201 by $\sin{\theta}$ and add to get:</p> $$ \begin{align} 0 &=ml (\cos\theta D^2\theta - \sin\theta (D\theta)^2)\cos\theta - \cancel{2\lambda l\sin\theta \cos \theta}\\ & \quad+ ml (\sin\theta D^2\theta + \cos\theta (D\theta)^2)\sin\theta + \cancel{2\lambda l\cos\theta \sin\theta} + mg\sin\theta\\ &= ml (\cos^2\theta D^2\theta) - \cancel{ml \sin\theta \cos\theta(D\theta)^2} \\ & \quad+ ml (\sin^2 \theta D^2\theta) + \cancel{ml \cos\theta \sin\theta(D\theta)^2} + mg\sin\theta \\ &=ml D^2\theta (\cos^2\theta + \sin^2 \theta ) + mg\sin\theta \\ 0&= ml D^2\theta + mg\sin\theta \end{align} $$ </div> This is indeed the same equation as what we get if we used $\theta$ as an unconstrained generalized coordinate for the pendulum. We can also compute $\lambda$ in terms of the other variables from Eq.1.196 as:</p> $$ \begin{align} \lambda &= \frac{m D^2 x}{2x} = \frac{m D^2 (l\sin\theta)}{2l\sin\theta} \\ &= \frac{m (D(l \cos\theta D\theta))}{2l\sin\theta} \\ &= \frac{ml \cos\theta D^2\theta - ml \sin\theta (D\theta)^2}{2l\sin\theta} \\ &= \frac{\overbrace{ml D^2\theta}^{-mg\sin\theta}\cos\theta - ml \sin\theta (D\theta)^2}{2l\sin\theta} \\ &= \frac{-mg\cancel{\sin\theta}\cos\theta - ml \cancel{\sin\theta} (D\theta)^2}{2l\cancel{\sin\theta}} \\ \lambda & = \frac{-1}{2l} \left(mg\cos\theta - ml(D\theta)^2\right) \end{align} $$ </div> This further confirms what we showed in the previous section, that $\lambda$ really is the composition function of the local state of the path. Also, to be noted here is the $2l\lambda$ is a force – the sum of the outward component of gravity and the centrifugal force. This is the tension in the pendulum rod. It is effectively the force that is constraining the mass to stay at a constant distance from the pivot.</p> Building systems from parts</h3> </p> Figure 1.9: A compound spring-mass system is decomposed into two subsystems.</strong></p> We can analyze compound systems using augmented Lagrangians to enforce constraints between the individual parts. Consider the compound spring-mass system at the top of Figure 1.9. One way to analyze this is as a single system with two coordinates $x_1$ and $x_2$ to represent the extension of the springs from their equilibrium lengths of $X_1$ and $X_2$.</p> An alternative procedure would be to break it into two parts – one being the spring-mass attached to the wall, and the other being the second spring-mass system with its attachment point specified by an additional coordinate $\xi$ (which may have its own velocity). The Lagrangian for each part can be written separately. The Lagrangian of the combined system is the sum of the two component Lagrangians along with a constraint $\xi = X_1 + x_1$ to ensure that the two systems are attached.</p> So the Lagrangian for the part attached to the wall is:</p> $$ L_1(t; x_1; \dot{x_1}) = \frac{1}{2}m_1\dot{x_1}^2 - \frac{1}{2}k_1 x_1^2\\ $$ </div> and the Lagrangian for the part that attaches to it is:</p> $$ L_2(t; \xi,x_2; \dot{\xi},\dot{x_2}) = \frac{1}{2}m_2(\dot{\xi} + \dot{x_2})^2 - \frac{1}{2}k_2 x_2^2\\ $$ </div> Combining the two Lagrangians with the contact constraint, we get:</p> $$ L(t; x_1, x_2, \xi; \dot{x_1},\dot{x_2},\dot{\xi}) = L_1(t; x_1; \dot{x_1}) + L_2(t; \xi,x_2; \dot{\xi},\dot{x_2}) + \lambda(\xi - (X_1 + x_1)) $$ </div> The Lagrange’s equations for the system are:</p> $$ \begin{align} m_1D^2 x_1 = -k_1 x_1 - \lambda \tag{1.207} \\ m_2(D^2\xi + D^2 x_2) = -k_2 x_2 \tag{1.208} \\ m_2(D^2\xi + D^2 x_2) = \lambda \tag{1.209} \\ 0 = \xi - (X_1 + x_1) \tag{1.210} \end{align} $$ </div> For eliminating $\xi$ and $\lambda$, substitute Eq. 1.210 into Eq. 1.209,</p> $$ m( \underbrace{D^2X_1}_{=0} + D^2 x_1 + D^2 x_2 ) = \lambda\\ $$ </div> Substituting for $\lambda$ in Eq. 1.207,</p> $$ \begin{align} m_1 D^2 x_1 &= -k_1 x_1 - m_2 D^2 x_1 - m_2 D^2 x_2\\ m_1 D^2 x_1 + m_2 (D^2 x_1 + D^2 x_2) + k_1 x_1 &= 0\tag{1.211} \end{align} $$ </div> Substituting for $\xi$ in Eq. 1.208,</p> $$ \begin{align} m_2(D^2 x_1+ D^2 x_2) + k_2 x_2 &= 0\tag{1.212} \end{align} $$ </div> Equations 1.211 and 1.212 are the equations of motion for the compound system. This is a general strategy that can be used to create a library of primitive components.</p> Each component may be characterized by a Lagrangian with additional degrees of freedom for the terminals where that component may be attached to others. We then can construct composite Lagrangians by combining components, using constraints to glue together the terminals.</p> </blockquote> Section 1.10 : Constrained Motion 2022-10-28T01:12:02+00:00 1.10 Constrained Motion</h2> When using the Lagrangian method, we may choose the coordinate system that is the most convenient - the number of coordinates may match exactly with the number of degrees of freedom of the system, or we may pick a system that has redundant coordinates along with explicit constraints among coordinates. As an example, a pendulum can be modeled using just the angle of the pendulum from the vertical, or as a point mass with a constraint stating that it should stay a constant distance from the pivot point. The constraints described in this section are more general than the ones developed in Section 1.6.2</a>.</p> Consider a dynamic system with $n$ degrees of freedom, specified by $n+1$ coordinates, along with a path constraint of the form:</p> $$ \varphi(t, q(t), Dq(t)) = 0\\ $$ </div> In order to formulate the equations of motion, one approach would be to use the constraint equation to eliminate one of the coordinates, and then use the resulting irredundant coordinates to develop Lagrange’s Equations. Any equations developed using redundant coordinates with constraints should be equivalent.</p> In order to do this, consider the method used originally for deriving Lagrange’s equations. Realizable paths were those that had a stationary “action” compared to nearby paths. “Stationary” here means that the action does not change for small changes in the path. We considering constrained motion, these varied paths must also satisfy the constraints. This has some effects on the derivation of Lagrange’s equations. Regardless of the method used, the condition for stationary action condenses to the following form (Eq. 1.17</a> or Eq. 1.34</a>):</p> $$ 0 = \int_{t_0}^{t_f} \{ (\partial_1 L \circ \Gamma[q]) - D\left( \partial_2 L \circ \Gamma[q] \right) \} \eta \tag{1.182} $$ </div> where $\eta$ is the variation in the path. In the unconstrained case, we may have arbitrary variations and so the only way for Eq.1.182 to be satisfied was for the integrand to be zero. Furthermore, since $\eta$ can be arbitrarily chosen, the term multiplying with $\eta$ must be zero for the action to be stationary, thereby getting to Lagrange’s equations.</p> Once we add in constraints, $\eta$ can no longer be arbitrarily chosen. While the intgrand must still be zero for Eq. 1.182 to be satisfied, we can no loner conclude that the factor multiplying $\eta$ must be zero. Therefore,</p> $$ \{ (\partial_1 L \circ \Gamma[q]) - D\left( \partial_2 L \circ \Gamma[q] \right) \} \eta = 0 \tag{1.183} $$ </div> with $\eta$ subject to the constraints of the dynamic system.</p> A path $q$ satisfies the constraint if $\bar{\varphi}[q] = \varphi \circ \Gamma[q] = 0$. Since we only allow varied paths that satisfy the constraint, the variation of the constraint must be zero:</p> $$ \delta_\eta(\bar{\varphi}) = 0 \tag{1.184} $$ </div> The variation must be “tangent” to the constraint surface</p> </blockquote> Expanding Eq. 1.184 with the chain rule (Eq. 1.26</a>) and the definition $\delta_\eta \Gammaq</a> = (0,\eta(t),D\eta(t))$ (Eq. 1.31</a>), the variation is tangent to the constraint surface if:</p> $$ \begin{align} \delta_\eta(\bar{\varphi}) &= \delta_\eta( \varphi \circ \Gamma[q]) \\ &= (D\varphi \circ \Gamma[q]) \delta_\eta\Gamma[q] \\ &= \left(\partial_0 \varphi \circ \Gamma[q], \partial_1 \varphi \circ \Gamma[q], \partial_2 \varphi \circ \Gamma[q]\right) \cdot [0, \eta, D\eta] \\ &= (\partial_1 \varphi \circ \Gamma[q])\eta + (\partial_2 \varphi \circ \Gamma[q])D\eta = 0\tag{1.185} \end{align} $$ </div> These are functions of time, so the variation at a given time is tangent to the constraint surface at that time.</p> Exercise 1.38: Properties of ℰ, the Euler Lagrange Operator 2022-10-27T06:15:32+00:00 Exercise 1.38: Properties of $\mathscr{E}$, the Euler-Lagrange Operator</h3> Refer to Section 1.9</a> for more details</strong></p> Let $F$ and $G$ be two Lagrangian-like functions of a local tuple, $C$ be a local-tuple transformation function, and $c$ a constant. Demonstrate the following properties:</p> a. $\mathscr{E}[F+G]=\mathscr{E}[F]+\mathscr{E}[G]$</h4> $$ \begin{align} \mathscr{E}[F+G] &= D_t\partial_2 (F + G) - \partial_1 (F + G) \\ &= D_t\partial_2 F - \partial_1 F + D_t\partial_2 G - \partial_1 G \\ \\ \therefore \mathscr{E}[F+G] &= \mathscr{E}[F] + \mathscr{E}[G] \\ \end{align} $$ </div> b. $\mathscr{E}[cF]=c\mathscr{E}[F]$</h4> $$ \begin{align} \mathscr{E}[cF] &= D_t\partial_2 (cF) - \partial_1 (cF) \\ &= c D_t\partial_2 F - c \partial_1 F = c (D_t\partial_2 F - \partial_1 F)\\ \\ \therefore \mathscr{E}[cF] &= c \mathscr{E}[F] \end{align} $$ </div> c. $\mathscr{E}[FG]=\mathscr{E}[F]G+F\mathscr{E}[G]+(D_t F)\partial_2 G+\partial_2 F(D_t G)$</h4> $$ \begin{align} \mathscr{E}[FG] &= D_t\partial_2 (FG) - \partial_1 (FG) \\ &= D_t G\partial_2 F + F \partial_2 G) - F\partial_1 G -G\partial_1 F\\ &= D_t (G\partial_2 F) + D_t(F \partial_2 G) - F\partial_1 G -G\partial_1 F \\ &= (D_t G)(\partial_2 F) + (D_t \partial_2 F)(G) + (D_t F)(\partial_2 G) + (D_t \partial_2 G)(F) - F (\partial_1 G) -G (\partial_1 F) \quad ; \text{Rearranging terms .. }\\ &= \left(D_t \partial_2 F - \partial_1 F \right)(G) + F\left(D_t \partial_2 G - \partial_1 G\right) + (D_t F)\partial_2 G + (D_t G)\partial_2 F \\ \\ \therefore \mathscr{E}[FG] &= \mathscr{E}[F] G + F\mathscr{E}[G] + (D_t F)\partial_2 G + (D_t G)\partial_2 F \end{align} $$ </div> d. $\mathscr{E}[F \circ C]=D_t(D F\circ C)\partial_2C+D F \circ C\mathscr{E}[C]$</h4> $$ \begin{align} \mathscr{E}[F \circ C] &= D_t(\partial_2 (F \circ C)) - \partial_1 (F \circ C) \\ &= D_t \big( (DF \circ C)(\partial_2 C) \big) - (DF \circ C )\partial_1 C \qquad;\text{by chain rule}\frac{\partial F(C(v))}{\partial v} = \underbrace{\frac{\partial F}{\partial C}}_{= DF \circ C} \frac{\partial C}{\partial v}\\ &= D_t (DF \circ C) (\partial_2 C) + (DF \circ C) D_t \partial_2 C - (DF \circ C )\partial_1 C \\ \\ \therefore \mathscr{E}[F \circ C] &= D_t (DF \circ C) (\partial_2 C) + (DF \circ C)\mathscr{E}[C] \end{align} $$ </div> Exercise 1.37: Velocity transformation 2022-10-27T05:15:14+00:00 Exercise 1.38: Velocity transformation</h3> Use the procedure Gamma-bar to construct a procedure that transforms velocities given a coordinate transformation. Apply this procedure to the procedure p->r</code> to deduce (again) equation (1.67) on page 42.</p> $$ \begin{align} v_x &= \dot{r} \cos{\varphi} − r \dot{\varphi} \sin{\varphi} \\ v_y &= \dot{r} \sin{\varphi} + r \dot{\varphi} \cos{\varphi}\tag{1.67} \end{align} $$ </div> We need to define a function F->C_v</code> that takes a local tuple coordinate transformation function $F$ and returns a new local tuple function $C_v$. $C_v$ when evaluated on a local tuple, returns the expression for velocity in terms of the new coordinates.</p> If the fucntion $F$ is defined as $x = F(t, x’)$, then $v = C_v(t, x’, v’)$.</p> We start with a path-dependent function $\bar{C_v}$ with path $q’$ as its input, defined as:</p> $$ \bar{C_v}[q'] := \dot{Q} \circ \Gamma \left[ F \circ \Gamma[q'] \right] $$ </div> where $\dot{Q}$ is a selector function that extracts the velocity component of a local tuple. We get $C_v$ by applying the Gamma-bar</code> function on $\bar{C_v}$</p> $$ C_v = \bar{\Gamma}[ \bar{C_v} ] $$ </div> (</span>defn </span>F->C_v </span> [F] </span> (</span>fn </span>C_v </span>[local] </span> (</span>let </span>[f-bar (</span>fn </span>[q-prime] </span> (</span>let </span>[q (</span>compose</span> F (</span>Gamma</span> q-prime))] </span>;; q = F . Gamma[q'] </span> (</span>compose</span> velocity (</span>Gamma</span> q)) </span>;; </span> )) </span> ] </span> ((</span>Gamma-bar</span> f-bar) local)) </span>)) </span> </span>(</span>rendertex </span>((</span>F->C_v</span> p->r) </span> (</span>up </span>'t (</span>up </span>'r 'varphi) (</span>up </span>'rdot 'varphidot))) </span> ) </span></code></pre> \begin{pmatrix}\displaystyle{- r\,\dot {\varphi}\,\sin\left(\varphi\right) + \dot r\,\cos\left(\varphi\right)} \cr \cr \displaystyle{r\,\dot {\varphi}\,\cos\left(\varphi\right) + \dot r\,\sin\left(\varphi\right)}\end{pmatrix} </div> ^ The above answer matches Eq. 1.67</p> Section 1.9: Abstraction of Path Functions 2022-10-27T01:12:46+00:00 1.9 Abstraction of Path Functions</h2> Note: This section may seem rather dry from its title. But this is driving towards some important results.</strong></p> When we were deriving the local-tuple transformation $C$, corresponding to a coordinate transformation $F$, the main factor was finding the relationship between the velocities in the two coordinate systems (e.g. $v$ and $v’$). We did this by inserting coordinate paths into the transformation function, $F$, finding its derivatives and then extracting out the velocity components.</p> $$ \begin{align} x &= F(t, x') \\ => v &= \partial_0 F + \partial_1 F v' \end{align} $$ </div> This last step is an example from a more general scenario where we want to abstract a local tuple function from a path function. Consider a function, $f$ of the local tuple. We typically apply $f$ to a path by composing it with $\Gamma$. $\Gamma$ is a function which extracts the local tuple from a path (the path itself is usually denoted computationally as symbolic coordinate functions like $x(t)$, $y(t)$ etc.). Given $f$, a corresponding path-dependent function $\bar{f}[q]$ can be defined using $\Gamma$ as $\bar{f}[q] = f \circ \Gamma[q]$. The question now is given $\bar{f}$, how can we reconstitute $f$.</p> We know that $f$ depends only on a certain finite number of components, $n$ of the local-tuple (say, $t$, $x$ and $v$). Therefore $\bar{f}$ also depends only on the corresponding local components of the path. It is important to note that the path may be more complex than can be represented by $n$ components. Even so, the path-dependent function $\bar{f}$ still</em> has same value for all the paths that share the same first $n$ local components.</p> By “reconstituting” $f$, what we mean here is that we want to find the value of $f$ for some local tuple argument, when we only know the function definition of $\bar{f}$. To do this, we take the argument of $f$ (which is a finite initial segment of the local tuple), constructing a path that has this local description (say, using a power series), and then finding the value of $\bar{f}$ for this path.</p> Two paths that have the same $n$ initial components of the local tuple in its description (or “have the same local description up to the nth derivative”) are said to osculate with order $n$ contact</em>. One example of this is a path, and a truncated power series representation of the path up to order $n$, have order $n$ contact. If we have a power-series representation of the path available up to $n$-th order, and a local tuple function takes fewer than $n$ components of the local tuple, then as far as this function is concerned, the path and the trunctated power series are equivalent.</p> Let $O$ be a function that generates an osculating path with the given local tuple components, i.e.</p> $$ \begin{align} O(t, q, v, ...)(t) &= q \\ D(O(t, q, v, ...))(t) &= v\\ \text{etc. and in general:}\\ (t, q, v, ...) &= \Gamma[O(t, q, v, ...)](t) \end{align} $$ </div> $O$ is defined to take a finite number of local tuple components, $n$. $O$ can be considered to be “inverse” of the $\Gamma$ function. One caveat is that it only make sense to use $O$ when we have concrete expressions defining the entire local tuple of interest, rather than symbolic functions. One possible way of construction $O$ is using a power series:</p> $$ O(t, q, v, ...)(t') = q + v(t' - t) + \frac{1}{2} a (t' - t)^2 + ...\\ $$ </div> So, given a path function $\bar{f}$, we can reconstitute the $f$ function as:</p> $$ \begin{align} f(t, q, v, ...) &= (f \circ \Gamma[O(t, q, v, ...)]) (t)\\ &= \bar{f}[O(t,q,v,...)](t) \end{align} $$ </div> Using this we can define $\bar{\Gamma}$ as a function that takes a path function and returns the corresponding local-tuple function, $f = \bar{\Gamma}[\bar{f}]$. $\bar{\Gamma}$ is defined as:</p> $$ \bar{\Gamma}[f](t, q, v, ...) = \bar{f}[O(t, q, v, ...)](t) $$ </div> $\bar{\Gamma}$ is defined in Clojure below. osculating-path</code> is the implementation of the $O$ function.</p> (</span>defn </span>osculating-path2 </span> "</span>Defines a path function f(t) using a Taylor series about the time given in reference state</span>" </span> [state_ref] </span> (</span>let </span>[[t_ref q_ref] state_ref </span> N (</span>count</span> state_ref)] </span> (</span>fn </span>[t] </span> (</span>let </span>[dt (</span>-</span> t t_ref)] </span> (</span>loop </span>[n </span>2 </span> sum q_ref </span> dtn-by-n! dt] </span> (</span>if </span>(</span>=</span> n N) </span>;; exit loop when n == N </span> sum </span>;; return sum </span> (</span>recur </span>(</span>inc</span> n) </span>;; update loop variables and repeat </span> (</span>+</span> sum (</span> </span>(</span>nth</span> state_ref n) dt*n-by-n!)) </span> (</span>/ </span>(</span></span> dt*n-by-n! dt) n))) </span>))))) </span> </span>(</span>defn </span>Gamma-bar2 </span>[f-bar] </span> (</span>fn </span>f </span>[local] </span> (</span>let </span>[t (</span>first</span> local)] </span> ((</span>f-bar </span>(</span>osculating-path2</span> local)) t) </span> ) </span> ) </span>) </span> </span></code></pre> Despite it’s name Gamma-bar2</code> is not</strong> the inverse of $\Gamma[q]$. $\Gamma[q]$ takes a path, and returns a local tuple (the inverse of $\Gamma[q]$ is actually $O$ which takes a local tuple and returns a path). Gamma-bar2</code> takes a function of a path, and returns a function of local tuples – this is a subtle but important difference. One operates on the path/tuple, and the other operates on functions of paths/tuples.</p> Gamma-bar2</code> can be used to define a more general version of the F->C</code> function. The procedure F->C</code> first constructs a path-dependent procedure f-bar</code> that takes a coordinate path in the primed system and returns the local tuple of the corresponding path in the unprimed coordinate system. It then uses Gamma-bar2</code> to abstract f-bar to arbitrary local tuples in the primed coordinate system. The resulting procedure C</code> can take local tuples with n</code> components in the primed coordinate system and generate local tuples of n</code> terms in the unprimed coordinate system.</p> E.g. p->r</code> which is defined as:</p> (</span>defn </span>p->r </span>[[t</span>, </span>[r</span>,</span> phi]</span>, </span>[rdot</span>,</span> phidot]]] </span> (</span>let </span>[x (</span></span> r (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> phi))] </span> (</span>up</span> x y) </span> ) </span>) </span></code></pre> p->r</code> takes a local tuple in polar coordinates and returns a path</strong> in rectangular coordinates (NOT</strong> the local tuple). f-bar</code> takes the input path</strong> q-prime</code> in polar coordinates. Converts it into local tuple in polar coordinates using Gamma[q-prime]</code>. This local tuple is then passed to p->r</code> which returns a path</strong> in rectangular coordinates. This is then passed to Gamma</code> to return the local tuple of n</code> components in rectangular coordinates. Gamma-bar</code> ensures that the input which consists of a polar local tuple of n</code> components is converted to a path before being handed off to f-bar</code> which then returns a local tuple of n</code> components in rectangular coordinates.</p> So to summarize, p->r</code> takes in a tuple</strong> and outputs a path</strong> or coordinate function in rectangular coordinates. However, instead of passing in a tuple directly to p->r</code>, we pass in a path</strong>, and convert it into a tuple first by calling (Gamma q-prime)</code>. The output of p->r</code> is then wrapped in Gamma <> n</code> to extract n</code> components of the local tuple out of this new path, which is then returned to the caller. This whole function is a path-dependent function that takes a path in polar coordinates as the input and spits out a local tuple in rectangular coordinates. Wrapping this in Gamma-bar</code> makes it a function that instead takes a local tuple as input.</p> (</span>defn </span>super-F->C </span>[F] </span> (</span>fn </span>C </span>[local] </span> (</span>let </span>[n (</span>count</span> local) </span> f-bar (</span>fn </span>[q-prime] </span> (</span>let </span>[q (</span>compose</span> F (</span>Gamma</span> q-prime))] </span> (</span>Gamma</span> q n)))] </span> ((</span>Gamma-bar2</span> f-bar) local)) </span>)) </span> </span>(</span>defn </span>p2r </span>[[_</span>, </span>[r</span>,</span> phi]</span>,</span> _]] </span> (</span>let </span>[x (</span></span> r (</span>cos</span> phi)) </span> y (</span></span> r (</span>sin</span> phi))] </span> (</span>up</span> x y) </span> ) </span>) </span>;; This can be demonstrated using the existing coordinate conversion </span>;; function p->r which converts from polar coordinates to rectangular </span>;; coordinates. Here it is shown operating on a local tuple with 4 terms. </span>(</span>rendertex </span> ((</span>super-F->C</span> p2r) </span> (</span>up </span>'t (</span>up </span>'r 'theta) (</span>up </span>'rdot 'thetadot) (</span>up </span>'rdotdot 'thetadotdot)))) </span></code></pre> This is a very convoluted function at first look but also elegant in certain ways. My understanding is that we go through this roundabout way of path->tuple->path->tuple so that we can expand/contract the number of components of the path description that we are interested in. One example of this can be seen when applying F->C</code> to the coordinate</code> function which simply extracts the position out of the local tuple (it returns the same local tuple that was passed in).</p> (rendertex </span> ((super-F->C coordinate) </span> (up 't (up 'r 'theta) (up 'rdot 'thetadot) (up 'rdotdot 'thetadotdot)))) </span></code></pre> $$ \begin{pmatrix}\displaystyle{t} \cr \cr \displaystyle{\begin{pmatrix}\displaystyle{r} \cr \cr \displaystyle{\theta}\end{pmatrix}} \cr \cr \displaystyle{\begin{pmatrix}\displaystyle{\dot r} \cr \cr \displaystyle{\dot {\theta}}\end{pmatrix}} \cr \cr \displaystyle{\begin{pmatrix}\displaystyle{\ddot r} \cr \cr \displaystyle{\ddot {\theta}}\end{pmatrix}}\end{pmatrix} $$ </div> The F</code> function “contracts” (probably inaccurate terminology here) the local tuple that is passed in into just the position coordinates aka “path”. And to extract out more components from this, it is necessary to wrap the input in Gamma</code> and the function itself in Gamma-bar</code>.</p> Gamma-bar</code> can also be used to compute the total time derivative $D_t F$ of the local tuple function $F$.</p> $$ D_t (F \circ \Gamma[q]) = \bar{\Gamma}[ D(F \circ \Gamma[q]) ] $$ </div> Need more explanation as to why this works</strong></p> Given a procedure $F$ implementing a local-tuple function and a path $q$, we construct a new procedure (compose F (Gamma q))</code>. The procedure DF-on-path</code> implements the derivative of this function of time. We then abstract this off the path with Gamma-bar</code> to give the total time derivative.</p> </blockquote> Dt</code> takes as input a function of the local tuple F</code> and outputs a function of the local tuple. This function when evaluated for a some local tuple state, returns the time-derivative of F</code> at that time. Dt</code> is used to define the Euler-Lagrange operator in the next section</p> (</span>defn </span>Dt </span>[F] </span> (</span>fn </span>DtF </span>[state] </span> (</span>let </span>[n (</span>count</span> state) </span> DF-on-path (</span>fn </span>[q] </span> (</span>D </span>(</span>compose</span> F (</span>Gamma</span> q (</span>-</span> n </span>1</span>)))))] </span> ((</span>Gamma-bar</span> DF-on-path) state))) </span> ) </span></code></pre> Lagrange equations “at a moment” or the Euler Lagrange operator</h3> The Euler-Lagrange equations can be defined as a path-dependent function, $\bar{\mathscr{E}}[L][q]$, the operates on a path, $q$ and returns zero if it s feasible path (according to the Lagrangian $L$).</p> $$ \bar{\mathscr{E}}[L][q] = D_t(\partial_2 L \circ \Gamma[q]) - \partial_1 L \circ \Gamma[q] $$ </div> These path-dependent E-L equations can be converted to local-tuple function, $\mathscr{E}[L]$ using Gamma-bar</code>.</p> $$ \mathscr{E}[L] = \bar{\Gamma}(\bar{\mathcal{E}}[L]) \\ $$ </div> $\mathscr{E}[L] \circ \Gamma[q] = 0$ for realizable paths. $\mathscr{E}$ is called the Euler-Lagrange operator</strong>.</p> $$ \mathscr{E}[L] = D_t \partial_2 L - \partial_1 L \tag{1.180} $$ </div> (</span>defn </span>my-Euler-Lagrange-operator </span>[L] </span> (</span>- </span>(</span>Dt </span>((</span>partial </span>2</span>) L)) ((</span>partial </span>1</span>) L))) </span> </span>(</span>defn </span>L-harmonic </span>[m k] </span> (</span>fn </span>[[_ q v]] </span> (</span>- </span>(</span> </span>1/2</span> m (</span>square</span> v)) (</span>* </span>1/2</span> k (</span>square</span> q))))) </span> </span>(</span>rendermd </span>((</span>my-Euler-Lagrange-operator </span> (</span>L-harmonic </span>'m 'k)) </span> (</span>up </span>'t 'x 'v 'a))) </span></code></pre> (</span>rendermd </span>((</span>compose </span> (</span>Euler-Lagrange-operator </span>(</span>L-harmonic </span>'m 'k)) </span> (</span>Gamma </span>(</span>literal-function </span>'x) </span>4</span>)) </span> 't) </span> ) </span></code></pre> The Euler-Lagrange operator</strong> takes in a Lagrangian function as input and directly create a new function which will define the Euler-Lagrange equations on passing in the local tuple.</p> Summary</h3> The functions/operators introduced in this section such as Gamma-bar</code>, Dt</code> and Euler-Lagrange-operator</code> seem to be aimed at delaying evaluation as much as possible. We can stay in the realm of functions until the very end where we evaluate it on a local tuple to get the answer. Because these functions are eventually operating on paths, we need to make sure they are represented as path-dependent functions before transforming them. However, we wrap the path-dependant function in Gamma-bar</code> at the end to make sure that we can still pass in the input as a local tuple.</p> While there is still more I could understand about the mechanism/logic by which this is possible, this is where I will stop for now.</p> Exercise 1.36: Noether integral 2022-10-25T06:24:52+00:00 Exercise 1.36: Noether integral</h3> Consider motion on an ellipsoidal surface. The surface is specified by $\frac{x^2}{a^2}+\frac{y^2}{b^2}+\frac{z^2}{c^2}=1$</p> Formulate a Lagrangian for frictionless motion on this surface. Assume that two of the axes of the ellipsoid are equal: b = c.</p> Using angular coordinates $(\theta, \phi)$, where $\theta$ is colatitude from the $z$-axis, and $\phi$ is longitude measured from the $x$-axis, formulate a Lagrangian that captures the symmetry of this ellipsoid: rotational symmetry around the $x$-axis. Formulate a parametric transformation that represents this symmetry and show that the Lagrangian you formulated is invariant under this transformation. Compute the Noether integral associated with this symmetry.</p> Note that the choice of coordinates does not build in this symmetry.</p> With $\theta$ being the colatitude from the $z$-axis, and $\phi$ being the longitude measured from the $x$ axis, The parameteric equations for an ellipsoid are:</p> $$ \begin{align} x &= a\sin{\theta}\cos{\phi} \\ y &= b\sin{\theta}\sin{\phi} \\ z &= c\cos{\theta} \end{align} $$ </div> ;; Coordinate transformation for (theta, phi) to rectilinear coordinates </span>(</span>defn </span>elliptical->rect </span>[a b c] </span> (</span>fn </span>[[_ [theta phi] _]] </span> (</span>up </span>(</span></span> a (</span>sin</span> theta) (</span>cos</span> phi)) </span> (</span></span> b (</span>sin</span> theta) (</span>sin</span> phi)) </span> (</span></span> c (</span>cos</span> theta))))) </span> </span>;; Free particle Lagrangian </span>(</span>defn </span>L-free-particle </span>[mass] </span> (</span>fn </span>[[_ _ v]] </span> (</span> </span>1/2</span> mass (</span>dot-product</span> v v))) </span> ) </span> </span>;; Lagrangian for motion constrained to the ellipsoid </span>(</span>defn </span>L-ellipsoid </span>[m a b c] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-free-particle</span> m) (</span>F->C </span>(</span>elliptical->rect</span> a b c))) </span> q-prime))) </span> </span>(</span>rendermd </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'theta) (</span>literal-function </span>'phi)) </span> local ((</span>Gamma</span> state) 't) </span> ] </span> ((</span>L-ellipsoid </span>'m 'a 'b 'c) local))) </span></code></pre> $$ \frac{1}{2}\,{a}^{2}\,m\,{\cos}^{2}\left(\phi\left(t\right)\right)\,{\cos}^{2}\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2} - {a}^{2}\,m\,\cos\left(\phi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,\sin\left(\phi\left(t\right)\right)\,D\phi\left(t\right) + \frac{1}{2}\,{a}^{2}\,m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\sin}^{2}\left(\phi\left(t\right)\right)\,{\left(D\phi\left(t\right)\right)}^{2} + \frac{1}{2}\,{b}^{2}\,m\,{\cos}^{2}\left(\phi\left(t\right)\right)\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\phi\left(t\right)\right)}^{2} + {b}^{2}\,m\,\cos\left(\phi\left(t\right)\right)\,\cos\left(\theta\left(t\right)\right)\,D\theta\left(t\right)\,\sin\left(\theta\left(t\right)\right)\,\sin\left(\phi\left(t\right)\right)\,D\phi\left(t\right) + \frac{1}{2}\,{b}^{2}\,m\,{\cos}^{2}\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\phi\left(t\right)\right) + \frac{1}{2}\,{c}^{2}\,m\,{\left(D\theta\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\theta\left(t\right)\right) $$ </div> The above Lagrangian is for the motion of a particle constrained to move on an ellipsoid.</p> The question asks that we look at a spheroid with $b = c$ and look at the symmetry about the $x$ axis. Without losing generality, we can instead consider the case where $a = b$ and look at the symmetry about the $z$ axis. This rotation gets reduced to a simple addition to $\phi$, i.e.</p> $$ \begin{pmatrix}\theta\\\phi\end{pmatrix} = R_x(s)(\begin{pmatrix}\theta'\\\phi'\end{pmatrix}) = \begin{pmatrix}\theta'\\\phi' + s\end{pmatrix} $$ </div> ;; Assuming two of the axes are equal, i.e., a = b </span>(</span>def </span>L-ellipsoid-sym </span>(</span>L-ellipsoid </span>'m 'a 'a 'c)) </span> </span>(</span>rendermd </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'theta) (</span>literal-function </span>'phi)) </span> local ((</span>Gamma</span> state) 't) </span> ] </span> (</span>L-ellipsoid-sym</span> local))) </span></code></pre> $$ \frac{1}{2}\,{a}^{2}\,m\,{\cos}^{2}\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2} + \frac{1}{2}\,{a}^{2}\,m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\phi\left(t\right)\right)}^{2} + \frac{1}{2}\,{c}^{2}\,m\,{\left(D\theta\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\theta\left(t\right)\right) $$ </div> ;; Defining a parameteric transformation to rotate about the "z" axis </span>(</span>defn </span>RotZ </span>[angle] </span> (</span>fn </span>[[theta</span>,</span> phi]] </span> (</span>up </span> theta </span> (</span>+</span> phi angle)))) </span> </span>;; Compose with "coordinate" to extract `q` from local tuple (t, q, qdot) </span>(</span>defn </span>F-tilde </span>[angle] </span> (</span>compose </span>(</span>RotZ</span> angle) coordinate)) </span> </span>(</span>def </span>F-tilde-rotated-by-s </span>(</span>F-tilde </span>'s)) </span> </span>;; Lagrangian after "s" degree rotation about X-axis </span>(</span>def </span>L-ellipsoid-sym-rotated </span> (</span>fn </span>[q-prime] </span> ((</span>compose</span> L-ellipsoid-sym (</span>F->C</span> F-tilde-rotated-by-s)) </span> q-prime))) </span> </span>(</span>rendermd </span> (</span>let </span>[state (</span>up </span>(</span>literal-function </span>'theta) (</span>literal-function </span>'phi)) </span> local ((</span>Gamma</span> state) 't) </span> ] </span> (</span>L-ellipsoid-sym-rotated</span> local))) </span></code></pre> $$ \frac{1}{2}\,{a}^{2}\,m\,{\cos}^{2}\left(\theta\left(t\right)\right)\,{\left(D\theta\left(t\right)\right)}^{2} + \frac{1}{2}\,{a}^{2}\,m\,{\sin}^{2}\left(\theta\left(t\right)\right)\,{\left(D\phi\left(t\right)\right)}^{2} + \frac{1}{2}\,{c}^{2}\,m\,{\left(D\theta\left(t\right)\right)}^{2}\,{\sin}^{2}\left(\theta\left(t\right)\right) $$ </div> The symmetry about $z$ axis is verified as the Lagrangian is unchanged post-rotation as shown above.</p> ;; Define the Noether integral </span>(</span>def </span>the-Noether-integral </span> (</span>* </span>((</span>partial </span>2</span>) L-ellipsoid-sym) ((</span>D</span> F-tilde) </span>0 </span>))) </span> </span>(</span>rendermd </span>(</span>the-Noether-integral </span> (</span>up </span>'t </span> (</span>up </span>'theta 'phi) </span> (</span>up </span>'thetadot 'phidot)))) </span></code></pre> $$ {a}^{2}\,m\,\dot {\phi}\,{\sin}^{2}\left(\theta\right) $$ </div> The conserved quantity is $m (a\sin{\theta})^2\dot{\phi}$. Here, $\dot{\phi}$ is the rate of angular movement of the particle about the $z$ axis or the rate of change of longitude, and $a\sin(\theta)$ is the “radius”. This quantity is analogous to angular momentum.</p> Section 1.8.5: Noether's Theorem 2022-10-24T01:14:12+00:00 1.8.5 Noether’s Theorem</h2> If a dynamical system has a symmetry, a coordinate system can be chosen so that the Lagrangian does not depend on a coordinate associated with the symmetry. There is also a conserved quantity associated with the symmetry (Section 1.8</a>). However, there are general symmetries that no coordinate systems can fully express. For example, motion around a central potential is spherically symmetric, i.e., the dynamical system is invariant under rotation about any axis. However, the Lagrangian for this system only demonstrates symmetry about a single axis.</p> In general, a Lagrangian is said to have a symmetry if there exists a coordinate transformation that leaves the Lagrangian unchanged</strong>. In this section we consider the more general case of continous symmetries</strong>. A continuous symmetry</strong> is defined as a parametric family of symmetries. Emmy Noether proved that for any continuous symmetry, there is a conserved quantity</strong>.</p> Consider a parametric coordinate transformation, $\widetilde{F}$ with parameter $s$. This means that $\widetilde{F}$ represents an infinite number of coordinate transformations, one for each value of $s$.</p> An example would be a function that takes an angle, $s$, as the input and spits out a coordinate transformation that rotates the primed coordinate frame, $x’$ about some axis by that angle.</p> $$ x = \widetilde{F}(s) (t, x') $$ </div> There is a corresponding parametreic state transformation $\widetilde{C}$ associated with $\widetilde{F}$ that transforms the velocity $v’$ as well the time (i.e. the local tuple that forms the input to the Lagrangian).</p> $$ \begin{align} (t, x, v) &= \widetilde{C}(s) (t, x', v') \\ &= (t, \widetilde{F}(t,x'), \partial_0 \widetilde{F} + \partial_1 \widetilde{F} v', ...) \end{align} $$ </div> We require that $\widetilde{F}(0)$ represent the identity transformation $x’ = \widetilde{F}(0)(t, x’)$, with $\widetilde{C}$ as the corresponding identity state transformation. If the Lagrangian $L$ has a continous symmetry corresponding to $\widetilde{F}$, then the Lagrangian should be unchanged when the coordinates are transformed using $\widetilde{F}$. Therefore:</p> $$ \widetilde{L}(s) = L\cdot \widetilde{C}(s) = L\\ $$ </div> for any $s$. Expanding $\widetilde{C}$ in the above expression, we get:</p> $$ \widetilde{L}(s) = L\left(t,\quad\widetilde{F}(s)(t, x'),\quad\partial_1\widetilde{F}(s)(t, x')v' \right)\\ $$ </div> Undoing the “chainrule” in the second term and writing it in terms of the total time derivative,</p> $$ \widetilde{L}(s) = L\left(t,\quad\widetilde{F}(s)(t, x'),\quad D_t\widetilde{F}(s)(t, x', v') \right) $$ </div> Note: One of the assumptions in the following derivation is that $\partial_0 L = \frac{\partial L}{\partial t} = 0$</strong></p> That $\widetilde{L}(s) = L$ for any $s$ implies that $D\widetilde{L}(s) = 0$ (where the $D$ operator represents derivative w.r.t $s$). Therefore, applying the chain rule for each of the components of $\widetilde{L}$, the derivative of $\widetilde{L}$ w.r.t $s$ is:</p> $$ \begin{align} 0 &= D\widetilde({L}(s)(t, x', v'))\\ &= \left(\underbrace{\partial_0 L}_{=\frac{\partial L}{\partial t} = 0} + \partial_1 L(t, x, v)\right) (D\widetilde{F})(s)(t, x') + \underbrace{\partial_2 L(t,x,v) D(D_t\widetilde{F}(s)(t, x')}_{\text{can swap }D_t\text{ and }D\text{, as }D\text{ w.r.t }s\text{ is unstructured}} \\ &= \partial_1 L(t, x, v) (D\widetilde{F})(s)(t, x') + \partial_2 L(t,x,v) D_t(D\widetilde{F}(s))(t, x') \\ &= (\partial_1 L \circ \Gamma[q]) \left( (D\widetilde{F})(s) \circ \Gamma[q']\right) + (\partial_2 L \circ \Gamma[q])\left( D_t(D\widetilde{F}(s)) \circ \Gamma[q']\right) \tag{1.157} \end{align} $$ </div> According to Lagrange equations, the first term of Eq. 1.157 is: $(\partial_1 L \circ \Gamma[q]) \left( (D\widetilde{F})(s) \circ \Gamma[q’]\right) = (D_t\partial_2 L \circ \Gamma[q]) \left((D\widetilde{F})(s) \circ \Gamma[q’]\right)$. Substituting this in Eq. 1.157,</p> $$ 0 = (D_t \partial_2 L \circ \Gamma[q])\left( (D\widetilde{F}(s)) \circ \Gamma[q']\right) + (\partial_2 L \circ \Gamma[q])\left( D_t(D\widetilde{F}(s)) \circ \Gamma[q']\right) \tag{1.159} $$ </div> When $s = 0$, since $\widetilde{F}(0)$ is the identity transformation, the paths $q$ and $q’$ are the same. Therefore, $\Gamma[q] = \Gamma[q’]$ and Eq. 1.158 becomes</p> $$ \begin{align} 0 &= \left ((D_t \partial_2 L)(D\widetilde{F}(0)) + (\partial_2 L)(D_t(D\widetilde{F}(0)))\right) \circ \Gamma[q] \\ &= D_t ((\partial_2 L) (D\widetilde{F}(0))) \circ \Gamma[q] \tag{1.160} \end{align} $$ </div> Therefore the state function $\mathscr{I}$:</p> $$ \mathscr{I} = (\partial_2 L) (D\widetilde{F}(0)) $$ </div> is conserved along all solution trajectories. This quantity is called the Noether integral</strong></em>. It is the product of the momentum $\partial_2 L$ and a vector associated with the symmetry.</p> Illustration : Motion in a Central Potential</h3> Consider the motion of a particle in a central potential. The Lagrangian in rectangular coordinates is:</p> $$ L(t; x,y,z; v_x, v_y, v_z) = \frac{1}{2} m \left( v_x^2 + v_y^2 + v_z^2\right) - U(\sqrt{x^2 + y^2 + z^2}) $$ </div> Consider a parameteric rotation about the $z$-axis:</p> $$ \begin{pmatrix}x\\y\\z\end{pmatrix} = R_z(s)(\begin{pmatrix}x'\\y'\\z'\end{pmatrix}) = \begin{pmatrix}x' \cos{s} - y'\sin{s}\\x' \sin{s} + y'\cos{s}\\z'\end{pmatrix} \tag{1.163} $$ </div> Since a rotation is an orthogonal transformation, it does not change the magnitude of the vector,</p> $$ x^2 + y^2 + z^2 = (x')^2 + (y')^2 + (z')^2\\ $$ </div> Similarly, differentiating Eq.1.163 along a path, we get:</p> $$ \begin{pmatrix}v_x\\v_y\\v_z\end{pmatrix} = R_z(s)\begin{pmatrix}v_x'\\v_y'\\v_z'\end{pmatrix} $$ </div> Therefore, $v_x^2 + v_y^2 + v_z^2 = v_x’^2 + v_y’^2 + v_z’^2$. Combining these, we can see that the post-transformation Lagrangian $L’$ is:</p> $$ L'(t; x',y,z'; v_x',v_y',v_z') = \frac{1}{2} m \left( (v'_x)^2 + (v'_y)^2 + (v'_z)^2\right) - U(\sqrt{(x')^2 + (y')^2 + (z')^2 }) $$ </div> Therefore $L’$ is the exact same function as $L$ and hence there is a conserved value corresponding to the rotational symmetry about the z-axis. The momenta are defined as:</p> $$ \partial_2 L = [m v_x, m v_y, m v_z] $$ </div> and</p> $$ D\widetilde{F}(0)(t;x,y,z)=D\widetilde{R}_z(0)(x,y,z) = [ y, -x, 0] $$ </div> Note about the $D$ operator</strong></p> The $D$ operator has the highest precedence, and therefore:</p> $$ D\widetilde{F}(0)(t; x,y,z) = D\widetilde{F}(s)(x, y, z)\|_{s=0} = \left.\begin{bmatrix} -x \sin{s} - y\cos{s}\\x \cos{s} - y\sin{s}\\0\end{bmatrix}\right\|_{s=0} $$ </div> Here we are taking the derivative w.r.t $s$ and consider $x$, $y$ and $z$ to be constants. Also note that the original $\widetilde{F}(s)$ was defined in terms of the primed coordinates while here it was evaluated on the unprimed coordinates.</p> Therefore, the Noether integral is:</p> $$ \begin{align} \mathscr{I}(t; x,y,z; v_x,v_y,v_z) &= ((\partial_2 L)(D\widetilde{F}(0))) (t; x,y,z; v_x,v_y,v_z) \\ &= mv_xy -mv_yx + (mv_z)(0) \\ &= m(yv_x - xv_y) \end{align} $$ </div> This is the $z$ component of the angular momentum vector, $\vec{x} \times m\vec{v}$</p> (</span>defn </span>RotX </span>[angle] </span> (</span>fn </span>[[x</span>,</span> y</span>,</span> z]] </span> (</span>let </span>[ca (</span>cos</span> angle) </span> sa (</span>sin</span> angle)] </span> (</span>up</span> x </span> (</span>- </span>(</span></span> ca y) (</span></span> sa z)) </span> (</span>+ </span>(</span></span> sa y) (</span></span> ca z)))))) </span> </span>(</span>defn </span>RotY </span>[angle] </span> (</span>fn </span>[[x</span>,</span> y</span>,</span> z]] </span> (</span>let </span>[ca (</span>cos</span> angle) </span> sa (</span>sin</span> angle)] </span> (</span>up </span>(</span>+ </span>(</span></span> ca x) (</span></span> sa z)) </span> y </span> (</span>+ </span>(</span>- </span>(</span></span> sa x)) (</span></span> ca z)))))) </span> </span>(</span>defn </span>RotZ </span>[angle] </span> (</span>fn </span>[[x</span>,</span> y</span>,</span> z]] </span> (</span>let </span>[ca (</span>cos</span> angle) </span> sa (</span>sin</span> angle)] </span> (</span>up </span>(</span>- </span>(</span></span> ca x) (</span></span> sa y)) </span> (</span>+ </span>(</span></span> sa x) (</span></span> ca y)) </span> z)))) </span> </span>;; Coordinate transformation with three angular "inputs" for rotations about </span>;; all three axes </span>;; Composing with `coordinate`, extracts the second element of the tuple that is passed in as the argument </span>(</span>defn </span>F-tilde </span>[angle-x angle-y angle-z] </span> (</span>compose </span>(</span>RotX</span> angle-x) (</span>RotY</span> angle-y) (</span>RotZ</span> angle-z) coordinate)) </span> </span>;; Lagrangian for motion in central potential </span>(</span>defn </span>L-central-rectangular </span>[m U] </span> (</span>fn </span>[[t q v]] </span> (</span>- </span>(</span>* </span>1/2</span> m (</span>square</span> v)) </span> (</span>U </span>(</span>sqrt </span>(</span>square</span> q)))))) </span> </span>;; Define the Noether integral </span>(</span>def </span>the-Noether-integral </span> (</span>let </span>[L (</span>L-central-rectangular </span>'m (</span>literal-function </span>'U))] </span> (</span>* </span>((</span>partial </span>2</span>) L) ((</span>D</span> F-tilde) </span>0 0 0</span>)))) </span> </span> </span>(</span>rendertex </span>(</span>the-Noether-integral </span> (</span>up </span>'t </span> (</span>up </span>'x 'y 'z) </span> (</span>up </span>'v_x 'v_y 'v_z)))) </span></code></pre> \begin{bmatrix}\displaystyle{- m\,v_y\,z + m\,v_z\,y}&\displaystyle{m\,v_x\,z - m\,v_z\,x}&\displaystyle{- m\,v_x\,y + m\,v_y\,x}\end{bmatrix} </div> These are all three components of the angular momentum. Therefore, angular momentum is conserved for a particle in motion in a central potential</p> Exercise 1.21: A dumbbell 2022-10-20T03:14:33+00:00 Exercise 1.21: A dumbbell</h3> In this exercise we will recapitulate the derivation of the Lagrangian for constrained systems for a particular simple system.</p> Consider two massive particles in the plane constrained by a massless rigid rod to remain a distance l apart, as in figure 1.5. There are apparently four degrees of freedom for two massive particles in the plane, but the rigid rod reduces this number to three.</p> We can uniquely specify the configuration with the redundant coordinates of the particles, say $x_0(t)$, $y_0(t)$ and $x_1(t)$, $y_1(t)$. The constraint $(x_1(t) − x_0(t))^2 + (y_1(t) − y_0(t))^2 = l^2$ eliminates one degree of freedom.</p> </p> Figure 1.5</strong></p> a. Write Newton’s equations for the balance of forces for the four rectangular coordinates of the two particles, given that the scalar tension in the rod is $F$.</strong></p> $$ \begin{align} m_0 \ddot{x}_0 &= F \cos\theta = F \frac{x_1 - x_0}{l}\\ m_0 \ddot{y}_0 &= F \sin\theta = F \frac{y_1 - y_0}{l}\\ m_1 \ddot{x}_1 &= -F \cos\theta = -F \frac{x_1 - x_0}{l}\\ m_1 \ddot{y}_1 &= -F \sin\theta = -F \frac{x_1 - x_0}{l} \\ \end{align} $$ </div> b. Write the formal Lagrangian $\mathbf{L}(t;x_0,y_0,x_1,y_1,F;\dot{x}_0,\dot{y}_0,\dot{x}_1,\dot{y}_1,\dot{F})$ such that Lagrange’s equations will yield the Newton’s equations you derived in part a.</strong></p> Restating Eq. 1.93 from the book:</p> $$ L(t; x, F; \dot{x}, \dot{F}) = \sum_\alpha \frac{1}{2}m_\alpha\mathbf{\dot{x}_\alpha}^2 - V(t,x) + \sum_{\{\alpha,\beta \| \alpha<\beta, \beta\leftrightarrow\alpha\}} \frac{F_{\alpha\beta}}{2l_{\alpha\beta}}[ (\mathbf{x_\beta}(t) - \mathbf{x_\alpha}(t))^2 - l_{\alpha\beta}^2 ] \tag{1.93} $$ </div> This is a Lagrangian that can reproduce Newton’s equations for particles constrained by a fixed-distance constraint using force $F_{\alpha\beta}$.</p> For the dumb-bell, the Lagrangian is</p> $$ L = \frac{1}{2} \left(m_0 (\dot{x_0}^2 + \dot{y_0}^2) + m_1 (\dot{x_1}^2 + \dot{y_1}^2) \right) + \frac{F}{2l}[ (x_1 - x_0)^2 + (y_1 - y_0)^2 - l^2 ] $$ </div> (</span>defn </span>L-dumbbell </span>[m0 m1 l] </span> (</span>fn </span>[[_</span>, </span>[x0</span>,</span> y0</span>,</span> x1</span>,</span> y1</span>,</span> F]</span>, </span>[vx0</span>,</span> vy0</span>,</span> vx1</span>,</span> vy1</span>,</span> dF]]] </span> (</span>let </span>[T1 (</span>* </span>1/2</span> m0 (</span>+ </span>(</span>square</span> vx0) (</span>square</span> vy0))) </span> T2 (</span>* </span>1/2</span> m1 (</span>+ </span>(</span>square</span> vx1) (</span>square</span> vy1))) </span> dx (</span>-</span> x1 x0) </span> dy (</span>-</span> y1 y0) </span> dist (</span>+ </span>(</span>square</span> dx) (</span>square</span> dy)) </span> F-by-2l (</span>/</span> F (</span>* </span>2</span> l))] </span> (</span>+</span> T1 T2 </span> (</span></span> F-by-2l (</span>-</span> dist (</span>square</span> l))) </span> ) </span> ) </span>)) </span> </span>(</span>rendermd </span>(</span>let </span>[L (</span>L-dumbbell </span>'m_0 'm_1 'l) </span> state (</span>up </span>(</span>literal-function </span>'x_0) (</span>literal-function </span>'y_0) (</span>literal-function </span>'x_1) (</span>literal-function </span>'y_1) (</span>literal-function </span>'F)) </span> local ((</span>Gamma</span> state) 't) </span> ] </span> (</span>L</span> local))) </span></code></pre> $$ \frac{\frac{1}{2}\,l\,m_0\,{\left(Dx_0\left(t\right)\right)}^{2} + \frac{1}{2}\,l\,m_0\,{\left(Dy_0\left(t\right)\right)}^{2} + \frac{1}{2}\,l\,m_1\,{\left(Dx_1\left(t\right)\right)}^{2} + \frac{1}{2}\,l\,m_1\,{\left(Dy_1\left(t\right)\right)}^{2} + \frac{-1}{2}\,{l}^{2}\,F\left(t\right) + \frac{1}{2}\,F\left(t\right)\,{\left(x_1\left(t\right)\right)}^{2} - F\left(t\right)\,x_1\left(t\right)\,x_0\left(t\right) + \frac{1}{2}\,F\left(t\right)\,{\left(x_0\left(t\right)\right)}^{2} + \frac{1}{2}\,F\left(t\right)\,{\left(y_1\left(t\right)\right)}^{2} - F\left(t\right)\,y_1\left(t\right)\,y_0\left(t\right) + \frac{1}{2}\,F\left(t\right)\,{\left(y_0\left(t\right)\right)}^{2}}{l} $$ </div> ;; Deriving Lagrange equations for L-dumbbell </span> </span>(</span>def </span>eom-dumbbell </span>(</span>Lagrange-equations </span>(</span>L-dumbbell </span>'m_0 'm_1 'l))) </span> </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x_0) (</span>literal-function </span>'y_0) </span> (</span>literal-function </span>'x_1) (</span>literal-function </span>'y_1) </span> (</span>literal-function </span>'F))] </span> ((</span>eom-dumbbell</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{\frac{l\,m_0\,{D}^{2}x_0\left(t\right) + F\left(t\right)\,x_1\left(t\right) - F\left(t\right)\,x_0\left(t\right)}{l}} \cr \cr \displaystyle{\frac{l\,m_0\,{D}^{2}y_0\left(t\right) + F\left(t\right)\,y_1\left(t\right) - F\left(t\right)\,y_0\left(t\right)}{l}} \cr \cr \displaystyle{\frac{l\,m_1\,{D}^{2}x_1\left(t\right) - F\left(t\right)\,x_1\left(t\right) + F\left(t\right)\,x_0\left(t\right)}{l}} \cr \cr \displaystyle{\frac{l\,m_1\,{D}^{2}y_1\left(t\right) - F\left(t\right)\,y_1\left(t\right) + F\left(t\right)\,y_0\left(t\right)}{l}} \cr \cr \displaystyle{\frac{\frac{1}{2}\,{l}^{2} + \frac{-1}{2}\,{\left(x_1\left(t\right)\right)}^{2} + x_1\left(t\right)\,x_0\left(t\right) + \frac{-1}{2}\,{\left(x_0\left(t\right)\right)}^{2} + \frac{-1}{2}\,{\left(y_1\left(t\right)\right)}^{2} + y_1\left(t\right)\,y_0\left(t\right) + \frac{-1}{2}\,{\left(y_0\left(t\right)\right)}^{2}}{l}}\end{pmatrix} </div> These equations of motion are equivalent to the Newtonian equations derivated initially, along with the constraint equation</p> 1.21 c. Make a change of coordinates to a coordinate system with center of mass coordinates $x_{CM}$, $y_{CM}$, angle $\theta$, distance between the particles $c$, and tension force $F$. Write the Lagrangian in these coordinates, and write the Lagrange equations.</strong></p> Mass $m_0$ is at a distance $\frac{m_1 c}{m_0 + m_1}$ from the center of mass and $m_1$ is at a distance $\frac{m_0 c}{m_0 + m_1}$ from the center of mass. Therefore the change of coordinates can be defined as:</p> $$ \begin{align} x_0 = x_{CM} - \frac{m_1 c}{m_0 + m_1} \cos{\theta} \\ y_0 = y_{CM} - \frac{m_1 c}{m_0 + m_1} \sin{\theta} \\ x_1 = x_{CM} + \frac{m_0 c}{m_0 + m_1} \cos{\theta} \\ y_1 = y_{CM} + \frac{m_0 c}{m_0 + m_1} \sin{\theta} \\ \end{align} $$ </div> We can use the F->C</code> coordinate change function to derive the new Lagrangian.</p> ;; Coordinate transform from CM-coordinates to rectangular </span>(</span>defn </span>CM->rect </span>[m0 m1] </span> (</span>fn </span>[[_</span>, </span>[x_cm</span>,</span> y_cm</span>,</span> theta</span>,</span> c</span>,</span> F]</span>,</span> _ ]] </span> (</span>let </span>[total-mass (</span>+</span> m0 m1) </span> m0dist (</span></span> c (</span>/</span> m1 total-mass)) </span> m1dist (</span></span> c (</span>/</span> m0 total-mass)) </span> ] </span> (</span>up </span> (</span>-</span> x_cm (</span></span> m0dist (</span>cos</span> theta))) </span> (</span>-</span> y_cm (</span></span> m0dist (</span>sin</span> theta))) </span> (</span>+</span> x_cm (</span></span> m1dist (</span>cos</span> theta))) </span> (</span>+</span> y_cm (</span></span> m1dist (</span>sin</span> theta))) </span> F </span> ) </span> ) </span>)) </span> </span>(</span>defn </span>L-dumbbell-CM </span>[m0 m1 l] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-dumbbell</span> m0 m1 l) (</span>F->C </span>(</span>CM->rect</span> m0 m1))) </span> q-prime))) </span> </span>(</span>rendermd </span> (</span>let </span>[L (</span>L-dumbbell-CM </span>'m_0 'm_1 'l) </span> state (</span>up </span>(</span>literal-function </span>'x_CM) </span> (</span>literal-function </span>'y_CM) </span> (</span>literal-function </span>'theta) </span> (</span>literal-function </span>'c) </span> (</span>literal-function </span>'F)) </span> local ((</span>Gamma</span> state) 't) </span> ] </span> (</span>L</span> local) </span> )) </span></code></pre> $$ \frac{l\,m_0\,m_1\,{\left(c\left(t\right)\right)}^{2}\,{\left(D\theta\left(t\right)\right)}^{2} + l\,{m_0}^{2}\,{\left(Dx_{CM}\left(t\right)\right)}^{2} + l\,{m_0}^{2}\,{\left(Dy_{CM}\left(t\right)\right)}^{2} + l\,m_0\,m_1\,{\left(Dc\left(t\right)\right)}^{2} + 2\,l\,m_0\,m_1\,{\left(Dx_{CM}\left(t\right)\right)}^{2} + 2\,l\,m_0\,m_1\,{\left(Dy_{CM}\left(t\right)\right)}^{2} + l\,{m_1}^{2}\,{\left(Dx_{CM}\left(t\right)\right)}^{2} + l\,{m_1}^{2}\,{\left(Dy_{CM}\left(t\right)\right)}^{2} - {l}^{2}\,m_0\,F\left(t\right) - {l}^{2}\,m_1\,F\left(t\right) + m_0\,F\left(t\right)\,{\left(c\left(t\right)\right)}^{2} + m_1\,F\left(t\right)\,{\left(c\left(t\right)\right)}^{2}}{2\,l\,m_0 + 2\,l\,m_1} $$ </div> ;; Computing Lagrange Equations </span>(</span>def </span>eom-dumbbell-cm </span>(</span>Lagrange-equations </span>(</span>L-dumbbell-CM </span>'m_0 'm_1 'l))) </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x_CM) (</span>literal-function </span>'y_CM) </span> (</span>literal-function </span>'theta) </span> (</span>literal-function </span>'c) </span> (</span>literal-function </span>'F))] </span> ((</span>eom-dumbbell-cm</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{m_0\,{D}^{2}x_{CM}\left(t\right) + m_1\,{D}^{2}x_{CM}\left(t\right)} \cr \cr \displaystyle{m_0\,{D}^{2}y_{CM}\left(t\right) + m_1\,{D}^{2}y_{CM}\left(t\right)} \cr \cr \displaystyle{\frac{m_0\,m_1\,{\left(c\left(t\right)\right)}^{2}\,{D}^{2}\theta\left(t\right) + 2\,m_0\,m_1\,c\left(t\right)\,D\theta\left(t\right)\,Dc\left(t\right)}{m_0 + m_1}} \cr \cr \displaystyle{\frac{- l\,m_0\,m_1\,c\left(t\right)\,{\left(D\theta\left(t\right)\right)}^{2} + l\,m_0\,m_1\,{D}^{2}c\left(t\right) - m_0\,F\left(t\right)\,c\left(t\right) - m_1\,F\left(t\right)\,c\left(t\right)}{l\,m_0 + l\,m_1}} \cr \cr \displaystyle{\frac{\frac{1}{2}\,{l}^{2} + \frac{-1}{2}\,{\left(c\left(t\right)\right)}^{2}}{l}}\end{pmatrix} </div> From the first two equations, the acceleration of the center of mass is zero. From the 5th equation, we can deduce that $c(t) = l$ and therefore, $Dc = 0$ and $D^2 c = 0$.</p> 1.21d. You may deduce from one of these equations that $c(t) = l$. From this fact we get that $D c = 0$ and $D^2 c = 0$. Substitute these into the Lagrange equations you just computed to get the equation of motion for $x_{CM}$, $y_{CM}$, $\theta$.</strong></p> ;; Substituting $c(t) = l$ in the EOMs, we get: </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x_CM) (</span>literal-function </span>'y_CM) </span> (</span>literal-function </span>'theta) </span> (</span>fn </span>[t] 'l) </span> (</span>literal-function </span>'F))] </span> ((</span>eom-dumbbell-cm</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{m_0\,{D}^{2}x_{CM}\left(t\right) + m_1\,{D}^{2}x_{CM}\left(t\right)} \cr \cr \displaystyle{m_0\,{D}^{2}y_{CM}\left(t\right) + m_1\,{D}^{2}y_{CM}\left(t\right)} \cr \cr \displaystyle{\frac{{l}^{2}\,m_0\,m_1\,{D}^{2}\theta\left(t\right)}{m_0 + m_1}} \cr \cr \displaystyle{\frac{- l\,m_0\,m_1\,{\left(D\theta\left(t\right)\right)}^{2} - m_0\,F\left(t\right) - m_1\,F\left(t\right)}{m_0 + m_1}} \cr \cr \displaystyle{0}\end{pmatrix} </div> The third equation now reduces to $\ddot{\theta} = 0$. The fourth equation has the quantity $\frac{m_0 m_1}{m_0 + m_1}$ which is called the “reduced mass</a>” in a Newtonian two-body problem. ().</p> Substituting the reduced mass as $m$ in the fourth EOM, we get:</p> $$ -l m \dot{\theta}^2 = F(t) $$ </div> This expression is very similar to the expression for centrifugal force.</p> 1.21e. Make a Lagrangian ($= T − V$) for the system described with the irredundant generalized coordinates $x_{CM}$, $y_{CM}$, $\theta$ and compute the Lagrange equations from this Lagrangian. They should be the same equations as you derived for the same coordinates in part d.</strong></p> We define a Lagrangian for two free particles with masses $m_0$ and $m_1$ and then apply a coordinate transformation to the irredundant coordinates using F->C</code>.</p> ;; Lagrangian with just the end particles </span>(</span>defn </span>L-free-two-particles </span>[m0 m1] </span> (</span>fn </span>[[_</span>,</span> _</span>, </span>[vx0 vy0 vx1 vy1]]] </span> (</span>let </span>[T0 (</span> </span>1/2</span> m0 (</span>+ </span>(</span>square</span> vx0) (</span>square</span> vy0))) </span> T1 (</span>* </span>1/2</span> m1 (</span>+ </span>(</span>square</span> vx1) (</span>square</span> vy1)))] </span> (</span>+</span> T0 T1) </span> ))) </span> </span>;; Coordinate transform with irredundant coordinates (unlike in part d, no "c" or "F" here) </span>(</span>defn </span>dumbbell->rect </span>[m0 m1 l] </span> (</span>fn </span>[[_</span>, </span>[x_cm</span>,</span> y_cm</span>,</span> theta]</span>,</span> _ ]] </span> (</span>let </span>[total-mass (</span>+</span> m0 m1) </span> m0dist (</span></span> l (</span>/</span> m1 total-mass)) </span> m1dist (</span></span> l (</span>/</span> m0 total-mass)) </span> ] </span> (</span>up </span> (</span>-</span> x_cm (</span></span> m0dist (</span>cos</span> theta))) </span> (</span>-</span> y_cm (</span></span> m0dist (</span>sin</span> theta))) </span> (</span>+</span> x_cm (</span></span> m1dist (</span>cos</span> theta))) </span> (</span>+</span> y_cm (</span></span> m1dist (</span>sin</span> theta))) </span> ) </span> ) </span>)) </span> </span>(</span>defn </span>L-dumbbell-part-e </span>[m0 m1 l] </span> (</span>fn </span>[q-prime] </span> ((</span>compose </span>(</span>L-free-two-particles</span> m0 m1) (</span>F->C </span>(</span>dumbbell->rect</span> m0 m1 l))) </span> q-prime))) </span> </span>(</span>rendermd </span> (</span>let </span>[L (</span>L-dumbbell-part-e </span>'m_0 'm_1 'l) </span> state (</span>up </span>(</span>literal-function </span>'x_CM) </span> (</span>literal-function </span>'y_CM) </span> (</span>literal-function </span>'theta)) </span> local ((</span>Gamma</span> state) 't) </span> ] </span> (</span>L</span> local) </span> )) </span></code></pre> $$ \frac{{l}^{2}\,m_0\,m_1\,{\left(D\theta\left(t\right)\right)}^{2} + {m_0}^{2}\,{\left(Dx_{CM}\left(t\right)\right)}^{2} + {m_0}^{2}\,{\left(Dy_{CM}\left(t\right)\right)}^{2} + 2\,m_0\,m_1\,{\left(Dx_{CM}\left(t\right)\right)}^{2} + 2\,m_0\,m_1\,{\left(Dy_{CM}\left(t\right)\right)}^{2} + {m_1}^{2}\,{\left(Dx_{CM}\left(t\right)\right)}^{2} + {m_1}^{2}\,{\left(Dy_{CM}\left(t\right)\right)}^{2}}{2\,m_0 + 2\,m_1} $$ </div> ;; Computing Lagrange Equations </span>(</span>def </span>eom-dumbbell-part-e </span>(</span>Lagrange-equations </span>(</span>L-dumbbell-part-e </span>'m_0 'm_1 'l))) </span>(</span>rendertexvec </span>(</span>let </span>[state (</span>up </span>(</span>literal-function </span>'x_CM) (</span>literal-function </span>'y_CM) </span> (</span>literal-function </span>'theta))] </span> ((</span>eom-dumbbell-part-e</span> state) 't))) </span></code></pre> \begin{pmatrix}\displaystyle{m_0\,{D}^{2}x_{CM}\left(t\right) + m_1\,{D}^{2}x_{CM}\left(t\right)} \cr \cr \displaystyle{m_0\,{D}^{2}y_{CM}\left(t\right) + m_1\,{D}^{2}y_{CM}\left(t\right)} \cr \cr \displaystyle{\frac{{l}^{2}\,m_0\,m_1\,{D}^{2}\theta\left(t\right)}{m_0 + m_1}}\end{pmatrix} </div> These equations of motion are identical to the ones obtained in part d</strong>.</p> Coordinate Functions aka Charts 2022-10-16T06:26:58.868+00:00 A coordinate function $\chi$ maps a point in a coordinate patch of a manifold</a> to a coordinate tuple of real numbers:</p> $$ x = \chi(m) $$ </div> where $x$ represents a convenient tuple structure. $x$ is usually represented as an “up vector” indexed by superscripts. The number of components of $x$ is equal to the number of dimensions of the manifold.</p> Coordinate transformations</h2> Assume we have two coordinate functions $\chi$ and $\chi’$. The coordinate transformation from $\chi’$ coordinates to $\chi’$ coordinates is just the composition $\chi \circ \chi’^{-1}$, where $\chi’^{-1} $ is the functional inverse of $\chi’$</p> Point On A Manifold 2022-10-16T06:20:21.404+00:00 Note:</strong></p> This is just my current understanding while studying Functional Differential Geometry</em>. This may be completely wrong and may change in the future.</p> A point on a manifold is an abstract entity representing a location/place on the manifold. When we actually do anything with a point, we use coordinates to represent it. Coordinate functions or charts</em> are used to convert a point into a coordinate tuple. These charts may also have an “inverse”. However the inverse is always used along with another chart in order to get a different coordinate tuple.</p> Manifolds 2022-10-16T06:00:54.961+00:00 A manifold</em> is a generalization of the idea of a smooth surface embedded in Euclidean space. The critical feature of an n-dimensional manifold is that locally (near any point), it looks like n-dimensional Euclidean space.</p> Parts of a Manifold</h2> Around every point</a> on the manifold, is a “simply-connected open set” called the coordinate patch</em>, that maps every point to a tuple of n real numbers, and a one-to-one continuous function, the coordinate function</a></em> or chart</em>, mapping every point in that open set to a tuple of n real numbers, the coordinates</em>.</p> A consistent system of coordinate patches and coordinate functions that covers the entire manifold is called an atlas</em>.</p> Examples</h2> An example of a two-dimensional manifold is the surface of a sphere or of a coffee cup. The space of all configurations of a double pendulum is a more abstract example (and has the shape of a torus).</p> An example of a coordinate function is mapping of points on a sphere to the tuple of latitude and longitude. It is to be noted that the “simply connected open set” or “patch” here does not include either poles (as longitude is undefined at the poles ) or the 180 deg meridian (due to discontinuity in longitude). These places will have to be covered by other coordinate systems.</p> ^1</sup>Functional Differential Geometry</a>, Sussman and Wisdom</p> </div> Generating Perpendicular Basis Vectors in a Plane 2022-10-14T03:14:56.441+00:00 This is an easier/less computationally expensive method compared to the one described in Points in a plane using null space</a>. This is based on Cross Product By Matrix Multiplication</a>.</p> We start with the unit vector $\mathbf{u}$, normal to the plane of interest. We compute the cross product matrix $U_\times$ as:</p> $$ U_\times = \begin{bmatrix} 0 & -u_3 & u_2\\ u_3 & 0 & -u_1\\ -u_2 & u_1 & 0 \end{bmatrix} $$ </div> where $u_1$, $u_2$ and $u_3$ are the components of $\mathbf{u}$. Since $\mathbf{u}$ is a non-null unit vector, either the first or the second column of $U_\times$ will be a non-null vector. This vector will also be perpendicular to $\mathbf{u}$. This can be verified by the dot product:</p> $$ \begin{align} (\text{Column 1}) \cdot \mathbf{u} &= u_3 u_2 - u_2 u_3 = 0 \\ (\text{Column 2}) \cdot \mathbf{u} &= -u_3 u_1 + u_1 u_3 = 0 \\ \end{align} $$ </div> We pick either the first or second column of $U_\times$ and convert it into a unit vector, depending on whichever one is non-null. This will be the first of the orthogonal unit vectors, $\mathbf{v}$. The second orthogonal unit vector is computed as:</p> $$ \mathbf{w} = \frac{\mathbf{u} \times \mathbf{v}}{\|\mathbf{u} \times \mathbf{v}\|} $$ </div> Linear combinations of $\mathbf{v}$ and $\mathbf{w}$ can be used to generate vectors in the plane normal to $\mathbf{u}$.</p> Cross Product by Matrix Multiplication 2022-10-14T03:12:52.909+00:00 For two vectors $\vec{a}$ and $\vec{b}$, the cross product $\vec{a} \times \vec{b}$ can be computed using matrix multiplcation1</a></sup> as:</p> $$ \vec{a} \times \vec{b} = A_\times \vec{b} $$ </div> where $A_\times$ is defined as:</p> $$ A_\times = \begin{bmatrix} 0 & -a_3 & a_2\\ a_3 & 0 & -a_1\\ -a_2 & a_1 & 0 \end{bmatrix} $$ </div> where $a_1$, $a_2$ and $a_3$ are the components of $\vec{a}$.</p> ^1</sup>Cross Product: Conversion to Matrix Multiplication</a></p> </div> Bdot attitude controller 2022-09-15T01:34:31.565+00:00 A “bdot” (or $\mathbf{\dot{B}}$) attitude controller is used to detumble a spacecraft using just a magnetometer and torque rods. It does not require any other rate-sensing instruments like gyros. The controller is usually implemented as a derivative controller acting on the sensed magnetic field $\mathbf{B}$. The control torque in the body frame is defined as:</p> $$ \tau_x = - \frac{k_x \mathbf{\dot{B}}_x}{\|\mathbf{B}\|}, \quad \tau_y = - \frac{k_y \mathbf{\dot{B}}_y}{\|\mathbf{B}\|}, \quad \tau_z = - \frac{k_z \mathbf{\dot{B}}_y}{\|\mathbf{B}\|} $$ </div> where $\mathbf{\dot{B}}_i$ is the component of the derivative of $\mathbf{B}$ about the $i$ axis. $\mathbf{\dot{B}}$ is computed using a digital differentiator filter</a> from discrete samples of $\mathbf{B}$.</p> Caveats</h2> This method will obviously only work when the spacecraft is operating within a magnetic field (e.g. in near-Earth space)</p> </li> The sampling cadence should be set up such that the use of the torque rods do not cause errors in magnetometer measurements. This can be ensured by sampling the data when the torque rods are not energized. That should also be sufficient delay after the rods are turned off in order to avoid residual effects from the rods’ magnetic fields.</p> </li> </ul> NAND2Tetris Note 05 - Hack Assembly Language 2022-09-05T04:09:53.894+00:00 The “Hack” computer built during this course has its own instruction set consisting of two instructions: the A-command and the C-command.</p> Registers</h2> A</code> -> address. Used to access memory D</code> -> General purpose data register M</code> -> Psuedo register that actually accesses RAM[A]</code></p> A-instruction</h2> Denoted as @<a></code> where a</code> is a positive number, this instruction loads the specified literal into the A</code> (or address) register. This is encoded as:</p> 0 <value (15 bits)></p> C-instruction</h2> The c-command has the format: dest = comp; jmp</code>, where dest</code> is the destination (if any), comp</code> is the computation to be performed and jmp</code> is a jumpy instruction. This is encoded as the following in a 16-bit instruction:</p> 111 a c1 c2 c3 c4 c5 c6 d1 d2 d3 j1 j2 j3 ^ denotes “C”</p> a through c6 defines the computation to be performed as inputs to the ALU. There is a table describing every operation allowed here. d1 d2 d3 defines the destination of the computation (or 0 0 0 for null), j1 j2 j3 reperesents a jump instruction (conditional, uncondtional, null etc.)</p> I/O</h2> I/O is performed by writing/reading from specific memory addresses. Display on the screen is accomplished by writing to 8K 16-bit registers starting at address 16384</code>. Each bit represents a pixel in a 256x512 matrix stored in row-major form.</p> For pixel at (row, col): 32row + col/16 -> word index col % 16 -> bit index within word</p> The keyboard value is represented by a single 16-bit value at the address 24576</code>.</p> Assembly language</h2> R1-R15 are built-in symbols for addresses from 1-15. This helps remove confusion between literals and addresses to some extent when using the A instruction. SCREEN and KBD and I/O base addresses.</p> Labels</h3> Labels can be specified as (LABEL). This can be used as jump destinations. Example:</p> // Infinite loop </span>(END) </span>@END </span>0;JMP </span></code></pre> Variables</h3> @</p> Automatically uses an available memory address as long as there is no corresponding label. Allocated from address 16 onward.</p> NAND2Tetris Note 04 - Sequential Logic and Memory 2022-09-04T19:36:00.037+00:00 All of the chips described in the previous course notes used what is called “combinational logic”, where the output is available instantenously and there is no time-component to their operation. Combinational chips compute functions that depend solely on combinations of their input values.</p> Sequential logic incorporates the concept of time, or more specifically, discretized time in the form of a clock signal into determining their output. This is the core concept behind digital circuits with memory. Just like how NAND formed the basic building blocks of combinational logic, the “D-Flip-Flip” is the fundamental building block used to build sequential logic. A D-Flip-Flop can be built out of nand-gates using a loop-based design but that is beyond the scope of the course.</p> Clocked Data Flip Flop (D Flip-Flop or DFF)</h2> The D Flip-Flop has one input “in” and one output “out”. There’s also an implicit “clock” signal that cycles from high to low and back to high to make a single “clock cycle”. The output of the D flip-flip is simply the input of the last time step (with the output of the initial timestep being indeterminate).</p> D-Flip-Flops are combined in various ways with combinational logic circuits to build up basic memory units like a 1-bit register, larger addressed registers (RAM) and counters that form the basis of computer memory.</p> One-Bit Register</h2> A bit regsiter has two inputs “in” and “load” and a single output “out”. The output is the same as the last output if “load” is zero. It is equal to “in” if “load” is set to one. The HDL imlementation uses a Mux to select between the lastOutput and the current input. This is then passed into a DFF and the output of the DFF is the output of the register.</p> Mux(a=lastOutput, b=in, sel=load, out=dffIn); </span>DFF(in=dffIn, out=out, out=lastOutput); </span></code></pre> The output of the DFF is fanned out to the input of the Mux as well. This is possible because HDL is not</em> a programming language. It can be thought of as a description of electrical wiring. So the output line of the DFF is looped back to the input of the Mux here.</p> 16-bit register</h2> A 16-bit register chip has a 16-bit input in</code>, a single bit load</code> input and a 16-bit output, out</code>. This can be implemented by stacking 8 one-bit register and fanning out the load input to all of them. The inputs and outputs of each “bit” chip is wired to the individual bits of in</code> and out</code> respectively.</p> RAM8 chip</h2> This is a chip that can store 8 “words” (in this case 16-bit words). The chip has a 16-bit in</code> input, 3-bit address</code> input and a 16-bit output, out</code>. It uses a Demuxer to split out the address</code> into 8 different load</code> bits which are then fed into Register</code> chips. in</code> is fanned out to all the underlying Register</code> chips. The outputs of the registers are then connected to the out</code> pin through a Multiplexer with the address</code> as its selector.</p> RAM64, RAM512, RAM4K and RAM16K</h2> These are built in the same manner as RAM8</code> but by composing RAMx</code> chips using a Demuxer and Muxer. RAM64</code> has a 6-bit address</code> input, where the 3 most-significant bits select the underlying RAM8</code> chip and the 3 LSBs signify the address in the underlying RAM8</code>. Therefore the load</code> bit is wired to the RAM8</code> chips through a Demuxer with address[3..5]</code> as the sel</code> input and address[0..2]</code> is passed through directly to the underlying chips. The output is similarly muxed using address[3..5]</code> as the selector. The higher capacity chips are built in the same way by stacking 4 or 8 lower capacity chips and an appropriately sized Demuxer and Muxer.</p> NAND2Tetris Note 03 - The Hack ALU 2022-09-04T19:35:45.742+00:00 The Airthmetic and Logic Unit is a core part of a computer based on the Von Neumann architecture. It consists of digital circuitry that can perform a variety of arthmetic or logic operations as the name suggests. The Nand2Tetris has a relative simple design for an ALU that can perform a few different functions defined below:</p> The ALU Computes one of the following functions: x+y, x-y, y-x, 0, 1, -1, x, y, -x, -y, !x, !y,</li> x+1, y+1, x-1, y-1, x&y, x\|y on two 16-bit inputs,</li> according to 6 input bits denoted zx,nx,zy,ny,f,no.</li> In addition, the ALU computes two 1-bit outputs:</li> if the ALU output == 0, zr is set to 1; otherwise zr is set to 0;</li> if the ALU output < 0, ng is set to 1; otherwise ng is set to 0.</li> </ul> </li> </ul> The input bits zx</code>, nx</code>, zy</code> and ny</code> define the “pre-processing” tasks to be performed on the inputs x</code> and y</code> prior to computation. zx</code> zeros out the whole x</code> input if set to one and nx inverts the input (after the effect of zx</code> if any) if it is set to true. zy</code> and ny</code> performs similar actions on the y input. f</code> selects between the operations x & y</code> (if f == 0) and x + y</code> (if f == 1). no</code> performs a bitwise inverse on the output of the operation due to f</code> if it is set to true. Different combinations of input flags results in one of the 18 operations described above.</p> The two extra outputs zr</code> and ng</code> are set based on the characteristics of the final output. This ALU design is specific to the “Hack” computer being developed as part of this course. Other computers may have more options implemented in the ALU. This is a design trade-off as to how many operations need to be implemented in hardware as opposed to software. In case of “Hack”, operations like multiplication and division will be implemented in software later.</p> Two's Complement Notation for Binary Addition 2022-09-04T03:41:18.681+00:00 Two’s complement is a format for representing negative numbers in binary. A number -X</code> is represented as an N</code> bit value using the binary value of 2^N-X</code>. E.g. -5 in 4-bit integers would be 2^4 - 5</code> = 11</code> (or 0b1010</code>). The advantage of using this representation is that it makes addition of negative numbers possible with existing binary adder circuits (or logic gate implementation). The reason this works is that the output we get from an adder circuit is actually the “modulo 2^n” representation.</p> Example: -2 + -3 using 4-bit integers</p> -2 in 2’s complement is 2^4 - 2 = 16-2 = 14 or 0b1110</code> -3 in 2’s complement is 2^4 - 3 = 16-3 = 13 or 0b1101</code></p> Performing binary addition of 0b1110</code> and 0b1101</code> we get, 0b1011</code> and a carry bit of 1 which is discarded. 0b1011</code> is 11</code> in decimal. This is equal to -5</code> in 2’s complement representation which is the correct answer.</p> In order to do subtractions using a digital adder circuit, it becomes necessary to compute “-x” given a value “x”. This is done as follows:</p> Negative value of X in 2’s complement notation is given by</p> 2^n - x = 1 + 2^n - 1 - x = 1 + (2^n -1 ) - x = 1 + (0b111111… - x) = 1 + ~X where ~ is the bitwise inverse = ~(X + 0b11111…) (from ALU truth table)</p> Other properties</h2> (x + 1) = ~(~x + 0b1111….) (x - 1) = x + 0b1111…. (x - y) = ~(~x + y) (y - x) = ~(x + y)</p> ^{1</sup> Nand2Tetris Unit 2.3</p> </div>}^2</sup>Two’s complement - Wikipedia</a></p> </div> NAND2Tetris Note 02 - Elementary Logic Gates 2022-09-01T04:35:04.243+00:00 Elementary Logic Gates</h2> NOT AND OR XOR => output 1 if inputs different MUX: => a, b, sel; if sel == 0: out = a, else: out = b DMUX: => in, sel (outputs a and b): if sel == 0: a = in else b = in</p> 16-bit variants</h2> NOT16 : 16 bits in and out AND16 : Two 16-bit inputs, One 16-it output OR16 : Two 16-bit inputs, One 16-it output</p> Multi-way variants</h2> Or8Way : Single 16-bit input, 1 bit output Mux4Way16 : Four 16-bit inputs, One 2-bit “sel” input, One 8-bit output Mux8Way16 : Eight 16-bit inputs, One 3-bit “sel” input, One 8-bit ouput DMux4Way : Single 1-bit input, 2-bit selector, Four 1-bit outputs DMux8Way : Single 1-bit input, 3-bit selector, Eight 1-bit outputs</p> The multi-way mux and dmux can be implemented by composing the other mux/dmux components.</p> NAND2Tetris Note 01 2022-09-01T01:49:00.451+00:00 Nand2tetris is a course where we build a full general purpose computer up from basic logic gates - in fact, just NAND gates. This is because a NAND gate can be used to form all the other basic logic gates - AND, OR and NOT. The “hardware” will be built in a simplified Hardware Description Language (or HDL). This HDL is similar to the “actual” HDLs like Verilog and VHDL. The course also introduces a “testing” language which provides a way to define a bunch of test cases with inputs and outputs for a given “chip” spec. The supplied “Hardware Simulation” program is able to load HDL files as well as testing scripts and verify designs.</p> The goal is to build up the next building blocks - CPU, RAM and “chipset” from the basic logic gates, and tehn build it into a computer platform with its own assembly language. Later the second part of the course involves building a language called “Hack” which can presumably be used to build Tetris.</p> Points in a plane using null space 2022-08-24T01:49:19.119+00:00 A plane can be defined using its normal vector n</code>. Points in the plane represented by this vector can be generated by first computing the null space of this vector. This gives the two basis vectors (assuming 3D space) for the plane. These basis vectors can then be scaled as necessary to generate points. For example, to generate a circle of points in a plane:</p> import </span>numpy </span>as </span>np </span>import </span>scipy </span>as </span>sp </span>import </span>scipy.linalg </span> </span>n = np.</span>array</span>([</span>0</span>,</span>0</span>,</span>1</span>]); </span>plane_basis = sp.linalg.</span>null_space</span>([n]) </span> </span>numPoints = </span>4 </span>theta = np.</span>linspace</span>(</span>0</span>, </span>2</span>np.pi, numPoints+</span>1</span>) </span>x = np.</span>cos</span>(theta[:-</span>1</span>]) </span>y = np.</span>sin</span>(theta[:-</span>1</span>]) </span> </span># points is a 3xnumPoints matrix where each column is a point </span>points = plane_basis @ np.</span>array</span>([x, y]) </span></code></pre> An easier/less expensive method can be found at [[202209132014_generating-perpendicular-basis-vectors-in-a-plane]]</p> Allocating Torques to Reaction Wheels 2022-08-20T01:49:19.119+00:00 Allocating torques to RWAs are accomplished by first defining a “distribution matrix” which contains the spin axes of the individual wheels, and then using this matrix to allocate torques.Each column of the distribution matrix consists of the unit vector for the spin axis of one wheel, resulting in a 3xN matrix for an RWA with N wheels.</p> In general:</p> tau_RWA = rwaMatrixInv * tau_b + alpha * rwaNullSpace </span></code></pre> where tau_b</code> is the required torque in the body frame, rwaMatrixInv</code> is the inverse of the distribution matrix, alpha</code> is a row vector of size m</code> where m</code> is the nullity of rwaMatrix</code> .</p> For a three wheel system, the null space is empty and therefore the second term of the above expression does not apply.There is a unique solution to allocate any torques for a properly oriented RWA.The solution is the one that minimizes the L2 norm of the allocated torques and is a unique solution.</p> For RWAs with more than three wheels, the null-space presents flexibility in allocating torques to satisfy various conditions.If alpha</code> is selected as a zero vector, the solution minimizes the L2-norm of the allocated torques.alpha</code> can be selected to further optimize the allocation to satisfy other conditions.Minimizing the L-infinity norm of hte torque better uses the capacity of the RWA.However, computing alpha in the general case is non-trivial.Ref [1] describes a method for minimizing the L-infinity norm for four-wheel RWAs.</p> Four wheel reaction wheel allocator for pyramid configurations</h2> For a four wheel system, the nullity of rwaMatrix</code> is equal to one and hence alpha</code> is a scalar.i.e.</p> tau_L2 = rwaMatrixInv * tau_b </span>tau_Linf = tau_L2 + alpha * tau_null </span></code></pre> where tau_null</code> is the null space of rwaMatrix</code>.</p> For symmetric 4 wheel configurations, tau_null</code> is equal to [1, 1, 1, 1]</code> and the value of alpha can be computed as:</p> alpha = - (min(tau_L2) + max(tau_L2))/2 </span></code></pre> For non-symmetric pyramid configurations, a different method is used where six separate values are computed as follows:</p> alpha_1 = - (tau_L2(1) + tau_L2(2)) / ( tau_null(1) + tau_null(2) ) </span>alpha_2 = - (tau_L2(1) + tau_L2(3)) / ( tau_null(1) + tau_null(3) ) </span>alpha_3 = - (tau_L2(1) + tau_L2(4)) / ( tau_null(1) + tau_null(4) ) </span>alpha_4 = - (tau_L2(2) + tau_L2(3)) / ( tau_null(2) + tau_null(3) ) </span>alpha_5 = - (tau_L2(2) + tau_L2(4)) / ( tau_null(2) + tau_null(4) ) </span>alpha_6 = - (tau_L2(3) + tau_L2(4)) / ( tau_null(3) + tau_null(4) ) </span></code></pre> The value of alpha that gives the smallest maximum absolute value of tau_rwa</code> is selected.</p> Note</em></p> The above algorthms assume that the null space of rwaMatrix</code> is entirely positive (or equal to [1, 1, 1, 1]</code> in case of symmetric RWAs).However, it is possible that some of these may be negative based on how the axes are oriented.In this case, the sign of the corresponding column in rwaMatrix</code> is the be negated and the direction of the torque allocated for that particular wheel has to be reversed.</p> References</h2> [1] “Optimal uses of reaction wheels in the pyramid configuration using a new minimum infinity-norm solution”, Link</a></p> What is TLA+? 2022-06-10T03:31:49.999+00:00 TLA+ is a language for creating “specifications” for computer programs/algorithms and then verify all the possible execution paths and mathematically prove assertions. The program is represented as a state machine where everything from variables to the program counter “pc” is part of the state. The spec contains an initial state and rule specifying “next state” as a bunch of logical statements linked by “and” (/) or “or” aka / clauses.</p> ^1</sup>The Man Who Revolutionized Computer Science With Math</a></p> </div> ^2</sup>Introduction to TLA+</a></p> </div> Attitude Control using Reaction Wheels 2022-05-19T05:47:36.416+00:00 Reactions wheels are used for controlling spacecraft attitude to a very high precision. It works by using an electric motor to spin a flywheel that causes the spacecraft to rotate in the opposite direction. A set of three orthogonally arranged reaction wheels can fully control the spacecraft attitude. In an isolated system, a reaction wheel assembly (RWA) can be used indefinitely without requiring any energy input other than power for the motors. However, disturbance torques add energy into the system, causing the angular momentum of the wheels to increase. When they get saturated, some other source of torque, such as RCS thrusters or torque-rods need to be used to desaturate them.</p> Torque allocation to a 3-wheel system can be accomplished by projecting the torque vector to each individual spin axis via a dot product. With more than three wheels, the added degrees of freedom results in an infinite number of possible solutions. The optimal solution in this case is picked by one of the following strategies. More generalized strategies are available for allocating torques</a> in systems with more than three reaction wheels [1].</p> References</h2> [1] Section 4.3.8, “Fundamentals of Spacecraft Attitude Determination and Control”, Markley, F. L. and Crassidis, J. L.,</p> TRIAD Algorithm For Attitude Determination 2022-04-04T03:13:13.208+00:00 The TRIAD or Tri-Axial Attitude Determination algorithm is used for attitude determination given two body-frame vectors ($b_1$ and $b_2$) and two corresponding inertial or “reference” frame vectors ($r_1$ and $r_2$). The attitude is determined as an “Attitude matrix”, $\mathbf{A}$, which is the DCM</a> that rotates the vectors from the reference frame to the body frame.</p> The first vector is assumed to have more accurate measurement and so the algorithm is set up such that the estimate satisfies $\mathbf{A} r_1 = b_1$, exactly and $\mathbf{A} r_2 = b_2$ only approximately.</p> Algorithm</h2> The TRIAD algorithm forms the orthogonal triads, {$v_1$, $v_2$, $v_3$} from $r_1$ and $r_2$ and {$w_1$, $w_2$, $w_3$} from $b_1$ and $b_2$, respectively.</p> $$ \begin{align} v_1 &= r_1,&\quad v_2 = r_x = \frac{r_1 \times r_2}{\|\|r_1 \times r_1\|\|},& \quad &v_3 = r_1 &\times r_x& \\ w_1 &= b_1,&\quad w_2 = b_x = \frac{b_1 \times b_2}{\|\|b_1 \times b_1\|\|},& \quad &w_3 = b_1 &\times b_x& \end{align} $$ </div> The estimate of A is given by: $$ \mathbf{A} = w_1 v_1^\intercal + w_3 v_3^\intercal + w_2 v_2^\intercal $$</p> Solving VulnHub CTF - Mercury 2022-03-20T05:08:47.753+00:00 Used a walkthrough for tips here. Here are the rough steps:</p> Run kali linux VM alongside the CTF vm with Running Virtualbox VMs with networking</a></li> Run sudo netdiscover</code> to find out the IP of target</li> Run nmap <ip></code> to discover open ports and find that 8080</code> is open</li> Port 8080 hosts a web app that can be accessed through the browser</li> Visit /robots.txt</code> to find a new path /mercuryfacts</code>. (dirb</code> command in kali can also be used to “discover” robots.txt if not known already)</li> mercuryfacts/<id></code> is vulnerable to SQL injection as found by putting backtick in place of the ID</li> sqlmap</code> can be used to further exploit this to eventually show passwords in the table users</code> in the database mercury</code></li> The password for webmaster</code> can be used to ssh into the machine. cat user_flag.txt</code> for user flag.</li> Check the mercuryfacts/notes.txt</code> file to see a base64 encoded password for linuxmaster</code>. Login as linuxmaster</code>. Run sudo -l</code> to figure out what all commands are allowed. Discover the script at /usr/bin/check_syslog.sh</code> that uses the tail</code> command</li> Add current directory to PATH. Create a symlink to vim</code> named tail</code></li> Run sudo –preserve-env=PATH /usr/bin/check_syslog.sh</code> to enter vim as superuser</li> Run :!/bin/sh</code> to enter root shell.</li> cat /root/root_flag.txt</code> for root flag</li> </ol> Running Virtualbox VMs with networking 2022-03-20T05:08:45.753+00:00 Run the VMs with “Host-Only Networking”. This should allow each VM to get its own IP address and let them communicate with each other.</p> Solve Wordle Using Information Theory 2022-02-06T17:05:33.089+00:00 This is a note about how to use information theory to create an optimal strategy for solving “Wordle”.</p> Initial ideas</h2> For any given word, we can find a distribution for probabilities for each pattern of colors that could be revealed. Example, for “WEARY”, there is some number of words that do not contain any of the letters, some that contain W, some with W and E, some with E at the first position, etc.</p> We can geenrate the list of all possible outcomes for a given word, and check how many words in the list match the patterns to come up with a probability.</p> Key</strong> A guess is “informative” if it is unlikely, i.e., the more unlikely the pattern, the fewer possibilities remain to be checked. A highly unlikely guess, if correct, significantly cuts down the solution space.</p> The expected amount of information from the distribution for a certain word is</p> $$ E[\text{Information}] = \sum_x {p(x) \cdot \text{Something}} $$</p> This “something” should measure how informative that pattern is. We could try to lower the average number of matches. The fewer the number of matches for a pattern, the more informative that pattern is. Instead we can use a concept from information theory.</p> What is a “bit”?</h2> An observation that can cut the space of possibilities in half, that is called a bit of information.</p> Therefore</p> p(1 bit) = 1/2 </span>p(2 bits) = 1/4 </span>p(3 bits) = 1/8 etc. </span></code></pre> Or, for information $I$</p> $$ \left(\frac{1}{2}\right)^I = p \implies 2^I = \frac{1}{p}\ I = \log_2{\left(\frac{1}{p}\right)} $$</p> This is a better way of representing probability. You can say that you get 20 bits of information instead of saying that the probability of such a thing occuring is 0.00000095.</p> Information (or bits) add together the same way probabilities multiply, thanks to the logarithm.</p> Applying information theory to the problem</h2> $$ E[\text{Information}] = \sum_x {p(x) \cdot \log_2{\left(\frac{1}{p(x)}\right)} } $$</p> This is the average number of bits you could get from a certain word. The higher the probability of seeing a pattern, the lower the number of bits.</p> This metric can be used to rank the guess in order of number of expected bits of information.</p> Note:</strong></p> This expected value of information is also called “entropy” ($H$). This was a suggestion by von Neumann to Claude Shannon. While this has some connection to the entropy from thermodynamics, Shannon was dealing purely with probability distribution when he used the term. </p> Strategy</h2> First give a guess based on the word that gives the highest expected number of bits of information. Then for the next guess use the more restricted list of words based on the result of the first guess, and so on.</p> The solver can be run across every single word in the word-list to work out an average score.</p> A better strategy?</h2> Assign a probability for each word for being in the final list based on frequency of use in the English language instead of a uniform distribution. Grant ranks them by frequency and uses a sigmoid function to assign probabilities. Use this to measure the “remaining uncertainty” of the possible word candidates left. So even if the number of possible words is higher, the uncertainty would be lower thanks to the weighted distribution.</p> Expected Score</h2> TBD.</p> References</h2> [1] The mathematically optimal Wordle strategy</a>, 3Blue1Brown</p> Orbiter Addon Development in Rust 2022-01-10T23:49:12-06:00 This short article will explore how to create a spacecraft addon for the Orbiter</a> spaceflight simulator in the Rust</a> programming language. I previously took a stab at this back in 2020 with limited success</a>. I was much less knowledgeable about Rust at the time and the tooling around C++ bindings were not as mature then. This post is a companion to this new repository</a> that contains a proof-of-concept for building a spacecraft addon for Orbiter in Rust.</p> Why Rust?</h2> Rust is a relatively new high level systems programming language with a focus on safety. Orbiter is written in C++ and therefore its addons are also typically written in C++. Rust development for Orbiter is facilitated using the cxx</a> crate.</p> Design</h2> The repository in its current form produces a DLL file as its build artifact that can be loaded into Orbiter as an addon module. Anyone wanting to create a Rust addon will clone/fork the repository and build it along with the the Rust code for their addon.</del>(See update below).</p> There are a limited number of Orbiter SDK functions currently available as Rust bindings in this prototype. This will expand in the future to hopefully encompass the majority of the API. The repository includes a demo addon that models NASA’s Surveyor</a> probe. This follows from the C++ tutorial at OrbiterWiki</a> and implements retro-thruster staging and differential thrust attitude control.</p> Developing custom spacecraft addons</h2> Update 01/11/2022: This section has been changed to reflect changes to the crate</strong></em> All the spacecraft-specific code in the repository lives in its own file (src/shuttle_pb.rs</code> for example).</del> An addon crate implementing a spacecraft should import the orbiter_rs</code> crate. It should then set its crate-type to cdylib</code>.</p> [package] </span>name </span>= "</span>shuttlepb</span>" </span>version </span>= "</span>0.1.0</span>" </span>authors </span>= ["</span>Thomas Antony</span>"] </span>edition </span>= "</span>2018</span>" </span> </span>[lib] </span>crate-type </span>= ["</span>cdylib</span>"] </span> </span>[dependencies] </span>orbiter_rs </span>= { </span>version </span>= "</span>0.1</span>", </span>path </span>= "</span>/path/to/orbiter-rs</span>" } </span></code></pre> The crate should then have a lib.rs</code> containing a struct that implements the OrbiterVessel</code> trait. It should then use the init_vessel</code> macro as shown below. This macro generates a stub that is links the Rust code to the OrbiterSDK. For example, in lib.rs</code>:</p> use </span>orbiter_rs::{ </span> ODebug, OrbiterVessel, VesselContext, </span>_V</span>, init_vessel, FileHandle </span>}; </span> </span>#[</span>derive</span>(Default, Debug)] </span>pub struct </span>ShuttlePB { </span> </span>_some_param</span>: </span>i32 </span>} </span> </span>impl </span>OrbiterVessel </span>for </span>ShuttlePB { </span> </span>fn </span>set_class_caps</span>(&</span>mut </span>self</span>, </span>context</span>: &VesselContext, </span>_cfg</span>: FileHandle) { </span> context.SetSize(</span>1.0</span>); </span> context.SetPMI(</span>_V</span>!(</span>0.50</span>, </span>0.50</span>, </span>0.50</span>)); </span> context.AddMesh("</span>ShuttlePB</span>".</span>to_string</span>()); </span> } </span>} </span> </span>init_vessel!( </span> </span>fn </span>init</span>(</span>_h_vessel</span>: OBJHANDLE, </span>_flight_model</span>: </span>i32</span>) -> ShuttlePB </span> { </span> ShuttlePB::default() </span> } </span> </span>fn </span>exit</span>() {} </span>); </span></code></pre> The addon may use any of the wrapped functions currently available. Any other Orbiter SDK functions will require wrappers to be generated for them. An automated tool like autocxx</a> may be worth investigating for this purpose.</p> Building and Installing</h2> The addon can be built using cargo build</code> assuming that Visual Studio 2019 is available. Other C++ compilers may or may not work. Deploying the addon also requires a config file and any meshes and other dependencies. An example can be seen in Config/Surveyor.cfg</code>. Once you build the addon, the DLL will be available in the target/i686-pc-windows-msvc/debug</code> folder. This will need to be renamed to match whatever module name you haev in the configuration file.</p> Summary</h2> This proof-of-concept gives a basic framework for building Orbiter addons in Rust. It is not a complete system by any metric and will require significant amounts of work before it can be considered that.</p> Transparent Rust bindings for C++ structs 2022-01-11T03:28:20.283+00:00 This is a short note about the things I discovered about creating transparent bindings for C++ structs into Rust using cxx</a>.</p> C types</h2> For scalar types like DWORD, and pointer types that reslve down to void, a ctype wrapper macro can be used to generate a “new-type” that transparently resolves to the underlying type on the C++ side without having to use Box</code> or unique_ptr</code>.</p> This is can be further simplified using a macro adapted from the one at https://github.com/dtolnay/cxx/issues/254#issuecomment-747860504</a>. The macro looks something like this:</p> #[</span>macro_export</span>] </span>macro_rules! </span>ctype_wrapper { </span> (</span>$r</span>:</span>ident</span>, </span>$c</span>:</span>ty</span>) => { </span> </span>/// Newtype wrapper for a `</span>$c</span>` </span> #[</span>derive</span>(Debug, Eq, Clone, PartialEq, Hash, Default, Copy)] </span> #[</span>allow</span>(non_camel_case_types)] </span> #[</span>repr</span>(transparent)] </span> </span>pub struct </span>$r</span>(pub </span>$c</span>); </span> </span>unsafe impl </span>cxx::ExternType </span>for </span>$r </span>{ </span> </span>type </span>Id = cxx::type_id!(</span>$r</span>); </span> </span>type </span>Kind = cxx::kind::Trivial; </span> } </span> }; </span> (</span>$r</span>:</span>ident</span>, </span>$c</span>:</span>ty</span>, </span>$nice_name</span>:</span>ident</span>) => { </span> </span>/// Newtype wrapper for a `</span>$c</span>` </span> #[</span>derive</span>(Debug, Eq, Clone, PartialEq, Hash, Default, Copy)] </span> #[</span>allow</span>(non_camel_case_types)] </span> #[</span>repr</span>(transparent)] </span> </span>pub struct </span>$r</span>(pub </span>$c</span>); </span> </span>unsafe impl </span>cxx::ExternType </span>for </span>$r </span>{ </span> </span>type </span>Id = cxx::type_id!(</span>$r</span>); </span> </span>type </span>Kind = cxx::kind::Trivial; </span> } </span> </span>type </span>$nice_name </span>= </span>$r</span>; </span> }; </span>} </span></code></pre> The macro has two variants that are almost the same. They generate a newtype wrapping the given underling type and also implements the cxx::ExternType</code> trait for it allowing to pass it by value to/from C++ code. The variant with 3 arguments can be used to create a type alias for at the same time. For example:</p> ctype_wrapper!(</span>THRUSTER_HANDLE</span>, </span>usize</span>, ThrusterHandle); </span></code></pre> will generate a new-type called THRUSTER_HANDLE</code> wrapping usize</code> as well as an alias called ThrusterHandle</code>. Eithe the type or its alias now be used within an extern "C++"</code> section as:</p> ... </span>extern </span>"</span>C++</span>" { </span> </span>type </span>THRUSTER_HANDLE = </span>crate</span>::ThrusterHandle; </span>} </span></code></pre> Structs</h3> It is possible to define a struct in Rust (outside of the FFI module), with all of the fields (assuming they are all compatible with CXX’s restrictions). A simple example is shown below for a 3-element vector type.</p> #[</span>derive</span>(Debug, Default)] </span>pub struct </span>VECTOR3([</span>f64</span>; 3]); </span>impl </span>VECTOR3 { </span> </span>pub fn </span>new</span>(</span>x</span>: </span>f64</span>, </span>y</span>: </span>f64</span>, </span>z</span>: </span>f64</span>) -> </span>Self </span>{ </span> </span>Self</span>([x, y, z]) </span> } </span>} </span>unsafe impl </span>cxx::ExternType </span>for </span>VECTOR3 { </span> </span>type </span>Id = cxx::type_id!("</span>VECTOR3</span>"); </span> </span>type </span>Kind = cxx::kind::Trivial; </span>} </span>type </span>Vector3 = </span>VECTOR3</span>; </span>// Alias </span></code></pre> This wraps an underlying VECTOR3</code> struct on the C++ side as</p> typedef union </span>{ </span> </span>double</span> data[</span>3</span>]; </span> </span>struct </span>{</span>double</span> x, y, z;}; </span>} VECTOR3; </span></code></pre> This type can also now be passed by value to/from C++ code without requiring any other wrapper around it.</p> What is the Gamma Function? 2021-12-13T03:06:04.286+00:00 The gamma function is a generalization of the factorial to complex numbers. The factorial is function defined for positive natural numbers as the product of all the positive numbers preceding it.</p> $$ n! = n (n-1) (n-2) ... $$ </div> The factorial is also defined by the recurrent relation: $n! = n (n-1)!$. The gamma function is based on this recurrent relation. The gamma function is a complex valued function that also has this same feature, i.e.</p> $$ \Gamma(z) = z \Gamma(z - 1) $$ </div> This was derived by Daneil Bernoulli to be the improper integeral:</p> $$ \Gamma(z) = \int_0^\infty \frac{x^{z-1}}{e^x} dx \quad\text{ for all } \Re(z) > 0 $$ </div> The function has some interesting structure when evaluated over the complex plane and this is examined in the referenced video.</p> ^1</sup>The Gamma Function</a></p> </div> Deriving the MSL/Apollo Entry Guidance Algorithm 2021-08-19T15:05:51-05:00 </a> </div> This post is a companion to the video</a> linked above and includes a full derivation of the Apollo entry guidance longitudinal control algorithm. Please watch the video for more context. Full source code of Jupyter notebooks implementing the algorithm can be found at thomasantony/msl-apollo-entry-guidance</strong></a>.</p> NASA’s Mars Science Laboratory</a> mission showcased an advancement in entry technology that allowed it to land much closer to its designated landing site than previous missions. It used with great success, the same guidance algorithm originally used by the Apollo Command Module when returning from the moon. By modulating its lift vector, MSL was able to counteract errors in its trajectory during hypersonic flight and combined with the famous “sky-crane” maneuver</a>, deliver the Curiosity rover to within 2.5 km of its targeted landing site next to Gale Crater. Last year’s Mars 2020</a> mission used the same guidance system to successfully land the Perseverance rover within Jezero crater.</p> Apollo Guidance Algorithm Overview</h2> The goal of the Apollo guidance algorithm is to minimize the error in “range” along the ground when compared to that of a pre-computed reference trajectory. It does not try to exactly match the reference trajectory, but instead computes a constant bank angle that is supposed to minimize the downrange distance error at the point where the vehicle reaches terminal altitude. This computation is repeated several times a second in the same manner as a closed-loop control system to correct for deviations in the trajectory due to external or internal factors.</p> The guidance algorithm uses bank angle to control the amount of vertical lift. This has the side-effect of causing lateral motion that takes the spacecraft away from the desired path. In order to account for this, the bank angle commanded is reversed when the predicted cross-range error exceeds a certain amount, effectively creating a series of S-turns. This is similar to the S-turns performed by the Space Shuttle during its re-entry.</p> This article focuses on the downrange error control.</p> 2DOF Dynamic Model</h2> The MSL entry vehicle is modeled in two-dimensions using a vehicle-centric polar coordinate system. The state variables in the model are altidude ($h$), downrange distance ($s$), speed ($v$) and flight path angle($\gamma$). Their equations of motion are as follows:</p> $$ \begin{align} \frac{d h}{dt} &= v \sin{\gamma} \nonumber \\ \frac{d s}{dt} &= v \cos{\gamma} \\ \frac{d v}{dt} &= -{{D/m}} - {{g}} \sin(\gamma) \\ \frac{d \gamma}{dt} &= \frac{1}{v} \left(\frac{v^2 \cos(\gamma)}{{{R_M}} + h} + \frac{L \cos{u}}{m} - {{g}}\cos(\gamma)\right) \\ \end{align} $$ </div> where</p> $$ \begin{align} \frac{D}{m} &= \frac{\rho v^2}{2 \beta} &;& \text{ Drag Acceleration}\\ \frac{L}{m} &= \frac{D}{m}\enspace (L/D) &;&\text{ Lift Acceleration}\\ \nonumber\\ \rho &= \rho_0 e^{-h/H} &;& \text{ Atmosphere Model}\\ \nonumber\\ \beta &= 120 \text{kg/m$^2$} &;& \text{ Ballistic Coefficient} \\ (L/D) &= 0.24 &;&\text{ Lift-to-Drag Ratio} \end{align} $$ </div> Surface atmospheric density, $\rho_0$ and scale height, $H$ define the exponential atmospheric model. $g$ is a constant value for acceleration due to gravity. $u$ is the bank angle of the vehicle. The states are collectively referred to as $\mathbf{x}$. The equations of motions may be collectively referred to as $\mathbf{f}(\mathbf{x}, u, t)$.</p> Deriving the Apollo Entry Guidance Algorithm</h2> Note on the Variation Operator</h3> This derivation requires the use of the “variation operator”, denoted by $\delta$, sometimes called a functional derivative</a> or variational derivative. A functional is a function that acts on functions. For example, $J(y(t))$ is a functional because $y$ is itself a function of time. Here $J$ is a scalar quantity derived from a function $y(t)$, that essentially consists of an infinite number of points.</p> The variational operator is to functionals, what derivatives are to functions. Similar to how a stationary point of a function can be found by setting its derivative to zero, the stationary point of a functional can be found by setting its variation to zero.</p> Please check the following links if you want to learn more:</p> https://www.youtube.com/watch?v=vqDHO2eKXcs</a></p> https://canvas.vt.edu/files/1315932/download?download_frd=1</a></p> Deriving bank angle policy</h3> </p> The goal is to find the constant bank angle $u$ that will guide the spacecraft from the perturbed starting state $\mathbf{x_0}$ to the same range as the reference trajectory. Let’s call this function $J$. Any variable with an “f” in the suffix denotes that it is evaluated at the terminal point of the trajectory and the ‘’ denotes that it is part of the reference trajectory.</p> $$ \begin{align} J = R_f &= s_f + \dot{s_f} dt_f = s_f + v_f \cos(\gamma_f) dt_f \label{eqn:J_1} \end{align} $$ </div> From the equations of motion,</p> $$ \begin{align} \dot{h_f} &= \frac{dh_f}{dt_f} \implies dt_f = \frac{dh_f}{\dot{h_f}} \label{eqn:h_f_expr} \end{align} $$ </div> Substituting $\eqref{eqn:h_f_expr}$ in $\eqref{eqn:J_1}$,</p> $$ \begin{align} J &= s_f + \frac{v_f \cos(\gamma_f) }{\dot{h_f}} dh_f \\ &= s_f + \frac{v_f \cos(\gamma_f)}{v_f \sin(\gamma_f)} dh_f \end{align} $$ </div> Assuming that the reference trajectory terminates at the ground, we get $dh_f = 0 - h_f = -h_f$</p> $$ \implies J = s_f - cot(\gamma_f) h_f = \Phi(\mathbf{x}_f) $$ </div> We want to now find a constant value of $u$ that will keep J constant at $J = R_f = R_f^$ even with perturbations. We are able to control the trajectory by influencing $u$ and are constrained by physics i.e. equations of motion, $\dot{\mathbf{x}} = \mathbf{f}(\mathbf{x},u,t)$. These constraints can be adjoined to $J$ using co-states</a> $\mathbf{\lambda}^\intercal = \left[\lambda_h\enspace\lambda_s\enspace\lambda_v\enspace\lambda_\gamma\right]$, one for each state. This is very similar to Lagrange multipliers used in function optimization. In this case, each costate is a function that has its own equation of motion which will be derived here.</p> $$ J' = \Phi(\mathbf{x}_f) + \int_{t_0}^{t_f} \mathbf{\lambda}^\intercal(t) \left\{ \mathbf{f}(\mathbf{x},u, t) - \dot{\mathbf{x}}\right\} dt $$ </div> To find the stationary point of $J$ we apply the variation operator. We also shorten $\mathbf{f}(\mathbf{x},u, t)$ to just $\mathbf{f}$.</p> $$ \begin{align} \delta J' &= \frac{\partial \Phi}{\partial \mathbf{x}}\delta \mathbf{x}\bigg\|_{t=t_f} + \delta \left[ \int_{t_0}^{t_f} \mathbf{\lambda}^\intercal(t) \left\{ \mathbf{f} - \dot{\mathbf{x}}) \right\} dt \right] \nonumber\\ &= \frac{\partial \Phi}{\partial \mathbf{x}}\delta \mathbf{x}\bigg\|_{t=t_f} + \delta \int_{t_0}^{t_f} \bigg[ \mathbf{\lambda}^\intercal(t) \mathbf{f} - \mathbf{\lambda}^\intercal(t)\dot{\mathbf{x}}\bigg] dt \nonumber\\ &= \frac{\partial \Phi}{\partial \mathbf{x}}\delta \mathbf{x}\bigg\|_{t=t_f} + \int_{t_0}^{t_f} \delta \big[ \mathbf{\lambda}^\intercal(t) \mathbf{f} \big] - \delta\big[\mathbf{\lambda}^\intercal(t)\dot{\mathbf{x}}\big] dt \nonumber\\ &= \frac{\partial \Phi}{\partial \mathbf{x}}\delta \mathbf{x}\bigg\|_{t=t_f} + \int_{t_0}^{t_f} \delta \big[ \mathbf{\lambda}^\intercal(t) \mathbf{f} \big] - \delta\big[\mathbf{\lambda}^\intercal\dot{\mathbf{x}}\big] dt \end{align} $$ </div> Applying the chain rule to the variation operator</p> $$ \begin{align} \delta J' &= \frac{\partial \Phi}{\partial \mathbf{x}}\delta \mathbf{x}\bigg\|_{t=t_f} + \int_{t_0}^{t_f} \mathbf{\lambda}^\intercal \delta \mathbf{f} + \delta\mathbf{\lambda}^\intercal \mathbf{f} - \delta\mathbf{\lambda}^\intercal(t)\dot{\mathbf{x}} - \mathbf{\lambda}^\intercal\delta\dot{\mathbf{x}} \enspace\enspace dt \label{eqn:Jprime_1} \end{align} $$ </div> Applying Leibniz Rule</a> to the first term of the integral in ${\eqref{eqn:Jprime_1}}$,</p> $$ \begin{align} \int_{t_0}^{t_f} \mathbf{\lambda}^\intercal \delta \mathbf{f}(\mathbf{x}, u, t)\enspace dt = \int_{t_0}^{t_f} \mathbf{\lambda^\intercal} \frac{\partial \mathbf{f}}{\partial \mathbf{x}} \delta\mathbf{x} + \mathbf{\lambda^\intercal} \frac{\partial \mathbf{f}}{\partial \mathbf{u}} \delta\mathbf{u}\enspace dt \label{eqn:Jprime_int_term1} \end{align} $$ </div> Integrating by parts</a>, the fourth term of the integral in ${\eqref{eqn:Jprime_1}}$,</p> $$ \begin{align} \int_{t_0}^{t_f} \mathbf{\lambda}^\intercal(t)\enspace\delta\dot{\mathbf{x}}\enspace dt &= \int_{t_0}^{t_f} \frac{d}{dt}\big( \mathbf{\lambda}^\intercal \delta \mathbf{x} \big) dt - \int_{t_0}^{t_f} \dot{\mathbf{\lambda}}(t)\enspace\delta x \enspace dt \\ &= \bigg[ {\lambda}^\intercal \delta \mathbf{x} \bigg]_{t_0}^{t_f} - \int_{t_0}^{t_f} \dot{\mathbf{\lambda}}(t)\enspace\delta x \enspace dt \label{eqn:Jprime_int_term4} \end{align} $$ </div> Substituting $\eqref{eqn:Jprime_int_term1}$ and $\eqref{eqn:Jprime_int_term4}$ in ${\eqref{eqn:Jprime_1}}$,</p> $$ \begin{align} \delta J' &= \frac{\partial \Phi}{\partial \mathbf{x}}\delta \mathbf{x}\bigg\|_{t=t_f} + \int_{t_0}^{t_f} \mathbf{\lambda^\intercal} \frac{\partial \mathbf{f}}{\partial \mathbf{x}} \delta\mathbf{x} + \mathbf{\lambda^\intercal} \frac{\partial \mathbf{f}}{\partial \mathbf{u}} \delta\mathbf{u} + \delta\mathbf{\lambda}^\intercal \overbrace{\left(\mathbf{f} - \dot{\mathbf{x}}\right)}^{= 0} \enspace dt - \bigg[ {\lambda}^\intercal \delta \mathbf{x} \bigg]_{t_0}^{t_f} + \int_{t_0}^{t_f} \dot{\mathbf{\lambda}}(t)\enspace\delta x \enspace dt \\ \delta J' &= \bigg[\bigg(\frac{\partial \Phi}{\partial \mathbf{x}} - \mathbf{\lambda}^\intercal\bigg)\delta \mathbf{x}\bigg]_{t=t_f} + \left( \mathbf{\lambda}^\intercal \delta \mathbf{x} \right)\bigg\|_{t=t_0}+ \int_{t_0}^{t_f} \delta\mathbf{x}(\mathbf{\lambda}^\intercal\frac{\partial \mathbf{f}}{\partial \mathbf{x}} + \dot{\mathbf{\lambda}}) \enspace dt + \int_{t_0}^{t_f} \mathbf{\lambda}^\intercal \frac{\partial \mathbf{f}}{\partial \mathbf{u}} \delta\mathbf{u} \enspace dt\label{eqn:Jprime_2} \end{align} $$ </div> Set $\delta J’ = 0$ to find the stationary point of $J’$. We choose co-states to have the following equations of motion so that they cancel out the third term in $\eqref{eqn:Jprime_2}$:</p> $$ \begin{align} \mathbf{\dot{\lambda}} = -\mathbf{\lambda}^\intercal\frac{\partial \mathbf{f}}{\partial \mathbf{x}} \label{eqn:costate_eom} \end{align} $$ </div> Now focusing on the first term of $\eqref{eqn:Jprime_2}$,</p> $$ \begin{align} \text{Let }\bigg[\bigg(\frac{\partial \Phi}{\partial \mathbf{x}} - \mathbf{\lambda}^\intercal\bigg)\delta \mathbf{x}\bigg]_{t=t_f} &= 0 \nonumber \\ \implies \mathbf{\lambda}^\intercal(t_f) &= \frac{\partial \Phi(t_f)}{\partial \mathbf{x}(t_f)} \label{eqn:costate_bc_vec} \end{align} $$ </div> This gives us the boundary conditions on the costates as follows:</p> $$ \begin{align} \lambda_h(t_f) &= \frac{\partial \Phi}{\partial h_f} = - \cot{\gamma_f} \\ \lambda_s(t_f) &= \frac{\partial \Phi}{\partial s_f} = 1 \\ \lambda_v(v_f) &= \frac{\partial \Phi}{\partial v_f} = 0 \\ \lambda_\gamma(t_f) &= \frac{\partial \Phi}{\partial \gamma_f} = 0 \\ \end{align} $$ </div> Therefore, assuming the conditions in $\eqref{eqn:costate_eom}$ and $\eqref{eqn:costate_bc_vec}$ hold for the costates, the condition for the stationary point of $J’$ is given by:</p> $$ \delta J' = \mathbf{\lambda}^\intercal(t_0) \delta \mathbf{x}(t_0) + \int_{t_0}^{t_f} \mathbf{\lambda^\intercal}\frac{\partial \mathbf{f}}{\partial \mathbf{u}} \delta u\enspace dt = 0\\ $$ </div> Apollo guidance assumes that the bank angle correction, $\delta u$ is constant for the whole trajectory.</p> $$ \begin{align} \mathbf{\lambda}^\intercal(t_0) \delta \mathbf{x}(t_0) &= - \delta u \int_{t_0}^{t_f} \mathbf{\lambda^\intercal}\frac{\partial \mathbf{f}}{\partial \mathbf{u}}\enspace dt \\ \delta u &= -\frac{\mathbf{\lambda}^\intercal(t_0) \delta \mathbf{x}(t_0)}{\int_{t_0}^{t_f} \mathbf{\lambda^\intercal}\frac{\partial \mathbf{f}}{\partial \mathbf{u}}\enspace dt} \label{eqn:delu_1} \end{align} $$ </div> Eq. $\eqref{eqn:delu_1}$ is giving us a “correction factor” for the bank angle $u$ that should minimize the range error at the terminal point if applied over the entire trajectory. This needs to be simplified into something that can be computed on-board the flight computers.</p> Looking at just the numerator of $\eqref{eqn:delu_1}$.</p> $$ \mathbf{\lambda}^\intercal(t_0) \delta\mathbf{x}(t_0) = \lambda_h(t_0) \delta h(t_0) + \lambda_s(t_0) \delta s(t_0) + \lambda_v(t_0) \delta v(t_0) + \lambda_\gamma(t_0) \delta \gamma(t_0) $$ </div> Since we are trying to keep $J$ stationary about the reference trajectory, all of the terms here must be evaluated w.r.t the reference trajectory (denoted by the $^$). We also change the independent variable to the velocity, $v$ as that is a better value for matching up the current state of the vehicle to the reference state (for computing the $\delta$’s).</p> $$ \begin{align} \mathbf{\lambda^}^\intercal(v_0) \delta\mathbf{x}(v_0) = \lambda_h^(v_0) \delta h(v_0) + \lambda_s^(v_0) \delta s(v_0) + \lambda_v^(v_0) \underbrace{\delta v(v_0)}_{ = 0} + \lambda_\gamma^(v_0) \delta \gamma(v_0) \label{eqn:delu_numerator} \end{align} $$ </div> Also, the altitude rate $\dot{h}$ and drag acceleration $D/m$ are more accurately estimated by sensors on board the spacecraft than the altitude or flight-path angle.</p> $$ \begin{align} \dot{h} &= v \sin{\gamma} \nonumber\\ \implies \delta \dot{h} &= \sin{\gamma} \overbrace{\delta v}^{=0} + v \cos{\gamma} \delta \gamma \nonumber\\ \implies \delta \dot{\gamma} &= \frac{\delta\dot{h}}{v \cos{\gamma}} \label{eqn:delgam_to_delhdot}\\ \end{align} $$ </div> Assuming exponential atmospheric model with scale height $H$, $$ \begin{align} \frac{D}{m} &= \frac{\rho_0 e^{-h/H} v^2 C_d A_{ref}}{2m}\nonumber\\ \delta(\frac{D}{m}) &= \frac{\rho_0 e^{-h/H} C_d A_{ref}}{2m} (v^2 \frac{\delta h}{H} + 2v\overbrace{\delta v}^{=0})\nonumber\\ \implies \delta(\frac{D}{m}) &= -\frac{(D/m)}{H} \delta h \label{eqn:delh_to_deldm} \end{align} $$ </div> </p> Substituting $\eqref{eqn:delgam_to_delhdot}$ and $\eqref{eqn:delh_to_deldm}$ into $\eqref{eqn:delu_numerator}$</p> $$ \begin{align} \mathbf{\lambda^}^\intercal(v_0) \delta\mathbf{x}^(v_0) &= \frac{-H\lambda_h^(v_0) }{\frac{D}{m}^(v_0)} \delta(\frac{D}{m} (v_0)) + \lambda_s^(v_0) \delta s(v_0) + \frac{\lambda_\gamma^(v_0)}{v_0^ \cos{(\gamma^(v_0))}}\delta\dot{h}^(v_0) \end{align} $$ </div> For denominator of $\eqref{eqn:delu_1}$, introduce new state $\lambda_u(t)$ such that</p> $$ \begin{align} \lambda_u &= \int_{t_0}^{t_f}-\frac{\partial \mathbf{f}}{\partial \mathbf{u}}^\intercal \mathbf{\lambda}\enspace dt \end{align} $$ </div> One option we have is to compute this integral on board the vehicle in every guidance cycle. However this can be very expensive (especially considering the hardware this was originally designed for). So we differentiate (34) w.r.t $t_0$ and apply Leibniz Rule to get</p> $$ \begin{align} \frac{\partial \lambda_u}{\partial t_0} &= -\frac{\partial \mathbf{f}}{\partial \mathbf{u}}^\intercal \mathbf{\lambda} \end{align} $$ </div> The boundary condition for $\lambda_u$ can be obtained as :</p> $$ \lambda_u(t_0=t_f) = \int_{t_f}^{t_f}-\frac{\partial \mathbf{f}}{\partial \mathbf{u}}^\intercal \mathbf{\lambda}\enspace dt = 0 $$ </div> Apollo Guidance Bank Angle Policy</h2> When we actually implement this guidance algorithm, $t_0$ and $\mathbf{\mathbf{x}_0}$ corresponds to the “current” time and state of the spacecraft. All the $\delta{\mathbf{x}}$ values are therefore computed by comparing the current trajectory to the reference trajectory. For example,</p> $\delta h(v_0) = h(v_0) - h^{}(v_0)$</p> where $h(v_0)$ is the current altitude and $h^(v_0)$ is the altitude on the reference trajectory corresponding to the current speed.</p> Putting it all together, $\eqref{eqn:delu_1}$ becomes</p> $$ \delta u = -\frac{\frac{-H\lambda_h^(v_0)}{(D/m)^(v_0)}\delta((D/m) (v_0)) + \lambda_s^(v_0) \delta s(v_0) + \frac{\lambda_\gamma^(v_0)}{v_0^* \cos{(\gamma(v_0))}}\delta\dot{h}(v_0)}{\lambda_u^(v_0)} $$ </div> The terms containing $$ can be pre-computed on the ground along with teh reference trajectory. These terms can therefore be substituted by:</p> $$ \begin{align} F_1(v_0) &= \frac{H \lambda_h^(v_0)}{\frac{D}{m}^(v_0)}\\ F_2(v_0) &= \frac{\lambda_\gamma^(v_0)}{v_0^ \cos{\gamma^(v_0)}} \\ F_3(v_0) &= \lambda_u^(v_0) \end{align} $$ </div> Also, it can be found that $\lambda_s$ has a constant value of 1 since $\frac{\partial \mathbf{s}}{\partial s} = 0$ and $\lambda_s(t_f) = 1$.</p> So the final expression for $\delta u$ becomes:</p> $$ \begin{align} \delta u = \frac{- \delta s(v_0) -F_1(v_0) \delta(\frac{D}{m} (v_0)) - F_2 (v_0) \delta\dot{h}(v_0)}{F_3(v_0)} \end{align} $$ </div> $\delta u$ is added to the reference bank angle $u$ to obtain the bank angle to be commanded in each guidance cycle.</p> Some Notes on Implementation</h2> One key bottleneck that I found during implementation was the data-lookup within the reference trajectory data. Right now, the reference trajectory data is stored in a 2D numpy array. In every guidance cycle, we do a lookup within this array to find the data row with the closest value of velocity to the vehicle’s current velocity. This could</em> be made much more efficient with a better data structure.</p> Conclusion</h2> The Jupyter notebooks</a> implement the algorithm as well as a Monte Carlo simulation system for testing it. I will be updating them to add more notes and details on the implementation to clarify things further.</p> References</h2> [1] R.D.Braun and R.M. Manning, Mars Exploration Entry, Descent and Landing Challenges</a></p> [2] M. Pajola, et. al., Planetary Mapping for Landing Sites Selection: The Mars Case Study</a></p> [3] L. Blackmore, Autonomous Precision Landing of Space Rockets</a>, Page 15</p> [4] C.R. Heidrich, E. Roelke, S.W. Albert and R.D. Braun, Comparative Study Of Lift And Drag Modulation Control Strategies For Aerocapture</a></p> [5] Entry System Design Considerations for Mars Landers</a>“ - includes more details about the Apollo Guidance Algorithm on Page 12</p> [6] P.D. Burkhart et. al., Mars Science Laboratory Entry, Descent, and Landing System Overview</a></p> [7] G.F. Mendeck, Mars Science Laboratory Entry Guidance</a></p> [8] D.G. Ives, D.K. Geller and G.L. Carman, Apollo-derived Mars precision lander guidance</a></p> [9] G.F. Mendeck and G.L. Carman, Guidance Design for Mars Smart Landers Using the Entry Terminal Point Controller</a></p> Publications 2020-11-13T20:10:00-05:00 Journal Articles and Conference Proceedings</h3> Rapid Indirect Trajectory Optimization on Highly Parallel Computing Architectures</a> Antony, T., and Grant, M. J. Journal of Spacecraft and Rockets</em>, Vol. 54, No. 5 (2017), pp. 1081-1091, doi:10.2514/1.A33755</a> </p> </li> Quasilinear Chebyshev-Picard Iteration Method for Indirect Trajectory Optimization</a> Antony, T. and Grant, M. J. 2019 AIAA Atmospheric Flight Mechanics Conference</em>, doi:10.2514/6.2019-0260</a> </p> </li> Path Constraint Regularization in Optimal Control Problems using Saturation Functions</a> Antony, T. and Grant, M. J. 2018 AIAA Atmospheric Flight Mechanics Conference</em>, doi:10.2514/6.2018-0018</a> </p> </li> Rapid Indirect Trajectory Optimization of a Hypothetical Long Range Weapon System</a> Grant M. J. and Antony, T. 2016 AIAA Atmospheric Flight Mechanics Conference</em>, doi:10.2514/6.2016-0276</a> </p> </li> Enabling Mars Exploration Using inflatable Purdue Aerodynamic Decelerator with Deployable Entry Systems (“iPADDLES”) Technology</a> Sparapany, M., Antony, T., Saranathan, H., Klug, L., Libben,B., Shibata, E., Williams, J., Grant, M. J. and Saikia, S. J. 2016 Big Idea Challenge</em>, NASA Langley Research Center</p> </li> Optimization of Interior Point Cost Functionals Using Indirect Methods</a> Antony, T., Grant, M. J. and Bolender, M. A. 2015 AIAA Atmospheric Flight Mechanics Conference</em>, doi:10.2514/6.2015-2399</a> </p> </li> Voyage to Troy: A Mission Concept For The Exploration Of The Trojan Asteroids</a> Saikia, S., Das, A., Laipert, F., Dapkus, C., Kendall, J., Bowling, T., Steckloff, J., Holbert, S., Graves, K., Antony, T., Bobick, R., Huang, Y., Stuart, J., Longuski, J., Minton, D. Asteroids, Comets, Meteors (ACM) 2014</em>, Helsinki, FI</p> </li> </ul> Theses and Dissertations</h3> Large Scale Constrained Trajectory Optimization using Indirect Methods</a> PhD Aeronautics and Astronautics</em>, Purdue University, May 2018</p> </li> Rapid Indirect Trajectory Optimization on Highly Parallel Computing Architectures</a> Master of Science in Aeronautics and Astronautics</em>, Purdue University, December 2014</p> </li> </ul> Patents</h3> U.S. Patent 10788835B2</a>: Safety system for autonomous operation of off-road and agricultural vehicles using machine learning for detection and identification of obstacles</em>, September 29, 2020</li> </ul> Also on Google Scholar</a>.</p> Setting up the Orbiter 2016 SDK in Visual Studio 2019 2020-08-08T12:39:52-05:00 Orbiter</a> is to space flight, what X-Plane is to aviation. Orbiter has been around since the early 2000s and it seems like some of the documentation</a> for add-on development is a bit out-dated. This post documents how to get an Orbiter 2016 addon development environment set-up on Windows 10, using tools available today (in 2020).</p> Download Orbiter 2016</h2> Download and install Orbiter following instructions at http://orbit.medphys.ucl.ac.uk/download.html</a>. “TexFilms” on Youtube has a very good video</a> detailing how to install Orbiter 2016 along with some essential add-ons. Orbiter-Forum</a> is also a great resource. The rest of the post assumes that Orbiter 2016 is installed in C:\Orbiter</strong>.</p> Download Visual Studio 2019</h2> Download the Visual Studio 2019 Community Edition web installer from Visual Studio Download Center</a>. Run the installer and you will eventually see a window with something similar to this:</p> </p> Check the option that says “Desktop Development with C++”. You may also modify the install location for the compiler. Continue with the installation and wait for it to complete.</p> Build a sample project</h2> The Orbiter SDK is installed in C:\Orbiter\OrbiterSdk</strong>. The SDK includes some sample projects including custom vehicles and Multi-Functional Displays (MFDs). Open OrbiterSdk\CustomMFD\CustomMFD.vcproj</strong> in Visual Studio 2019. You will get a prompt asking you if you want to convert the project to make it compatible.</p> </p> Click “OK” to continue. Switch to the “Property Manager” tab at the bottom of “Solution Explorer”.</p> </p> Within Property Manager, expand “CustomMFD” to show two options “Debug \| WIn32” and “Release \| Win32”. Expand both of these until you get an opton called “Orbiterroot”. Right click this and select Properties.</p> </p> Select “User Macros”. Ensure that the “OrbiterDir” variable is set to the correct Orbiter installation path. </p> Select “VC++ Directories”. Change the “Include Directories” and “Library Directories” settings as shown in the screenshow below. This will ensure that the compiler can find the Orbiter SDK header files and libraries.</p> </p> Click “OK” to close the property pages window. Right click on “CustomMFD” in Property Manager and select “Properties”. This should give you a window with an additional setting called “Debugging”. Change the settings as shown in the screenshot below. Please note that I use C:\Orbiter\Orbiter_ng.exe</strong> as the “Command” setting because I have the Orbiter D3D9Client</a> installed. If you are running a vanilla Orbiter installation, set this to C:\Orbiter\Orbiter.exe</strong> instead.</p> </p> I got this handy tip from Andrew Stokes’ video</a>. Go to C++ > Code Generation</strong> in the Property Sheet. Change Runtime Library to “Multithreaded (/MT)</strong>” for your “Release” configuration and “Multithreaded Debug (/MTd)</strong>” for your “Debug” configuration. This removes an external dependency on Visual Studio Runtime DLL.</p> </p> At this point, if you hit Build (F7), you may get an error saying:</p> RC : fatal error RC1110: could not open CustomMFD.rc </span></code></pre> If this happens, switch back to “Solution Explorer” and delete the CustomMFD.rc</strong> file. Now the project should build successfully. It should be noted that the compiler places the output in the C:\Orbiter\Modules\Plugin</strong> directory by default. This can be verified by deleting C:\Orbiter\Modules\Plugin\CustomMFD.dll</strong> and rebuilding the project. Ensure that CustomMFD.dll</strong> appears in the folder after you build the project. You can now run Orbiter as usual or have Visual Studio start it for you by hitting “Debug”. Activate the Module within Orbiter Launcher as shown below to test it in the simulator.</p> </p> Your development environment is now ready.</p> Hello World! 2019-10-16T20:47:55-05:00 8/8/2020 update</strong>: I have imported some of my older articles from Medium to this blog to consolidate everything in one spot. So this particular “hello world” appearing in the middle of other posts may look a bit weird.</p> 10/16/2019</strong>:</p> Yes. I have started a blog … again. This is probably my fourth attempt at creating a personal website. And as usual, I spent several hours looking at themes/templates before finally settling on this one.</p> The intention of this blog is to share my thoughts and ideas on programming, engineering, spaceflight, and pretty much anything that catches my fancy. To whoever is reading this, welcome!</p> About Me 2019-10-16T20:45:02-05:00 I’ll write this later. Here’s my LinkedIn for now: https://linkedin.com/in/thomasantony</a></p> Using VirtualCAN inside docker on macOS 2018-02-09T03:42:31.359+00:00 At SmartAg</a>, we use Docker to manage the development and runtime environments for our embedded software. For performing full-system integrated tests, we have built comprehensive simulators that mimic the behavior of the hardware that we automate. Since most of the hardware communication happens over CAN, VirtualCAN is a great way of faking the hardware signals.</p> </p> Until now, any code that required a CAN interface could not run on my Macbook Pro. This was primarily because the linux kernel used by Docker for Mac</a> lacks support for SocketCAN</a> or VirtualCAN. After much head-bashing</a>, I realized that a better option would be [docker-machine](https://docs.docker.com/machine/overview/)</code> , which is how docker was originally run on macOS before the official “Docker for Mac” release.</p> Setting up a CAN-enabled docker-machine VM</h3> Install Homebrew</a> if you don’t already have it.</li> Install docker</code>, docker-machine</code> and some associated software</li> </ol> brew install docker docker-compose docker-machine docker-credential-helper docker-machine-driver-xhyve</p> 3. Clone the repo from https://github.com/boot2docker/boot2docker</a></p> 4. Edit kernel_config</code> in the boot2docker</code> repo and add the following at the bottom:</p> CONFIG\_CAN=y </span>CONFIG\_CAN\_RAW=y </span>CONFIG\_CAN\_VCAN=y </span>CONFIG\_CAN\_DEV=y </span>CAN\_SLCAN=y </span>CAN\_BCM=y </span></code></pre> 5. Follow the instructions at https://github.com/boot2docker/boot2docker/blob/master/doc/BUILD.md</a> to build your custom boot2docker</code> image. This basically boils down to:</p> docker build -t boot2docker . </span>docker run --rm boot2docker > boot2docker-can.iso </span></code></pre> 6. Fix some permissions required by the xhyve</code> docker-machine driver.</p> sudo chown root:wheel $(brew --prefix)/opt/docker-machine-driver-xhyve/bin/docker-machine-driver-xhyve </span>sudo chmod u+s $(brew --prefix)/opt/docker-machine-driver-xhyve/bin/docker-machine-driver-xhyve </span></code></pre> 7. Create your new docker-machine</code> VM with the following command. Change the command appropriately to allocate the desired number of CPUs, amount of RAM and disk space to the VM.</p> docker-machine create default --driver xhyve --xhyve-experimental-nfs-share --xhyve-cpu-count=4 --xhyve-memory-size=4096 --xhyve-disk-size=40000 --xhyve-boot2docker-url boot2docker-can.iso </span></code></pre> 8. Your docker-machine</code> VM is now ready. It should already be running. If you restart your machine, you can start the VM by typing docker-machine start default</code> or stop it with docker-machine stop default</code> .</p> 9. Set the environment parameters to use docker with your new VM by running eval $(docker-machine env default)</code> . This command has to be run every time you are in a new terminal. You can also add this to your .bashrc</code> to make it automatic.</p> 10. Check that it all works:</p> docker run -it --rm --privileged alpine /bin/sh </span></code></pre> Inside the docker container, run:</p> zcat /proc/config.gz \| grep CAN </span></code></pre> The command should display the CAN flags that you set while compiling the kernel. SocketCAN/VirtualCAN is now enabled in any docker container that you start on this VM.</p> Caveats</h3> Running docker</code> using docker-machine</code> means that some things, such as port-forwarding does not work as you expect. A handy script for exposing any ports you want from your VM to localhost</code> can be found here: https://github.com/johanhaleby/docker-machine-port-forwarder</a></p> Training a neural network in real-time to control a self-driving car 2016-12-11T05:02:01.849+00:00 I was lucky enough to be accepted into the first cohort of Udacity’s Self Driving Car NanoDegree</a> program back in October. Though I have been thinking of blogging about my experience since the start, it didn’t really happen till now. I am currently wrapping up Project #3 — “Behavioral Cloning”. This one was considerably tougher than the first two. However, it has been very fulfilling to finally complete it and here I will describe the approach I used for training a neural network to drive a car (in a simulator).</p> </p> The project description makes it looks easy (relatively). In the first project, we detected lanes using some basic Computer Vision methods and in the second, we classified traffic signs from the German Traffic Signs dataset</a>. The third one seemed like an extension of the second, where instead of classifying traffic signs, we had to predict steering angles based on a camera feed, using a neural network.</p> Collecting Training Data</h3> Unlike Project#2, this time we had to collect our own training data. This was more challenging than expected. As it turned out, controlling Udacity’s SDC simulator with a keyboard is not a simple task. Feedback from other students on Slack seemed to indicate that it also gave bad, jittery steering angle data. Fortunately, I have a friend who is crazy about car racing games and owns a Logitech G27 Racing wheel.</p> Udacity’s SDC Simulator</p> For training data, I recorded data (“camera” images + steering angle and other telemetry) where I drove through the two tracks a couple of times. I also recorded data while recovering from deliberate perturbations to the sides of the lane to make sure the neural net also learned how to recover from such situations.</p> Picking the Architecture and Training the NN</h3> I spent a lot of time experimenting with different convolutional neural network architectures, with varying levels of success. I also tried taking existing trained models like VGG16 and Google’s Inception v3 and adapting them to this purpose. Eventually, I settled upon NVIDIA’s End-to-End Deep Learning architecture described in this paper</a>. It was relatively small in size and hence added very little latency when running it. I proceeded to use my gaming desktop with GTX 1070 GPU to train the model on ~32000 images.</p> What I learned is that “mean square error” was not at all a predictor of the performance of the network in the actual simulator. Another big issue was the turnaround time between collecting data, training the network and then testing it. Also, the ‘remote driving’ script provided by Udacity set the car’s throttle to a constant value with no way to control the speed.</p> That is when I came across John Chen</a>’s post on our Slack channel about how he developed an “Agile Trainer</a>” to reduce the turnaround time between data-collection and testing. His program uses PyGame and Joystick input to manually takeover control from the neural network whenever it deviated too much and also allowed to train the network at the same time.</p> I wrote my own live trainer based on this idea, which instead used keyboard input. It turned out that my keyboard based “remote driver” was able to control the simulator more reliably than the simulator’s “Training mode”.</p> Best of all, it allowed me to fine-tune the model from my bed with my Macbook Pro by “NoMachine</a>”-ing into my desktop (which would be difficult with a joystick/racing wheel).</p> How it works</strong></h3> The live trainer has a Tkinter</a>-based UI and a few simple keyboard controls.</p> SDC Live Trainer interface</p> Up/Down</strong>: Control cruise speed</p> Left/Right</strong>: Steering</p> x</strong>: Toggle between autonomous and manual override modes</p> c</strong>: Center steering (only in manual override mode)</p> z</strong>: Toggle real-time training (only in manual override mode)</p> The speed of the car is controlled by a proportional-gain controller. It modulates the throttle based on speed feedback. This rudimentary “cruise control” gets the speed within +/- 1 mph of the target speed, which is good enough in this case.</p> The arrow keys increase/decrease the steering angle. The steering also has some slow auto re-centering dynamics added by the trainer. So the steering angle will keep “decaying” towards zero if you don’t press any key. The “autonomous rating” measures what percentage of the current session was spent in fully autonomous mode.</p> Real-time training</h3> The process of training itself is pretty simple. You can do one of two things:</p> Deliberately perturb the car’s motion while in manual override and engage training mode once you have started the recovery process</li> At any spots that the model has trouble with, engage training mode while driving through the spot manually to fine-tune the model.</li> </ol> The GIF below shows an example of the first case. I purposely drive the car towards the right edge using manual override and then start training the model once I have it recovering and returning to the center of the lane.</p> Evaluating model performance</h3> My initial model had some trouble navigating a couple of turns on track#1 in the simulator. I was able to successfully tune these spots using live training and finally get this result:</p> Track 2 was a little more difficult, with more sharp gradients and curves. However, I found that decreasing the speed down to 20 mph helped it navigate that track as well!</p> The live trainer code is on Github at: thomasantony/sdc-live-trainer</strong></a></p> Possibilities</h3> A live trainer can also probably be used to perform the initial training of the network, though that would involve a lot more baby-sitting during the training process. The good thing is that you can immediately start seeing results as the model converges toward the right weights.</p> Is such an architecture extendable to real-world SDCs? It can definitely be done with scale models on scale tracks. On real cars it is probably a little more difficult (though there are probably ways to do it). NVIDIA’s paper</a> mentions using real-world data to make a simulator. A live training methodology like the one described here can possibly be incorporated into such a simulator as well!</p> Let me know if you have any comments/suggestions!</p> flybywire — Declarative GUIs for Python inspired by React 2016-09-04T05:26:46.557+00:00 by Randall Monroe Source: xkcd#970</a> by Randall Monroe</p> Python is amazing. I love the flexibility, the clean and readable syntax and its huge ecosystem of libraries. However, when it comes to making modern GUIs, it comes up sort in many ways.</p> There are libraries like PyQT</em> and Kivy</em> to create GUIs for your Python application. However, each of them come with their own problems</a>. Many modern UI solutions like Electron and React-Native looks to the web to avoid the problems of dealing with multiple platforms. After all, the web is one platform that DOES have it’s share of great (and at times awful) UIs.</p> flybywire</em></a> is my ongoing experiment to develop a declarative UI library, based off some great work by Cristian Medina</a>. So, what is flybywire</em> all about? Well, you need a bit of background before I can go into that.</p> React, ES6 and the Endless Abyss</h4> React</a> caught my interest sometime late last year when I was trying to build a desktop frontend for a Python project using Electron</a>. I was coming back to web development after a gap of nearly six years and my last experience in the field was with jQuery and PHP.</p> After finishing a basic tutorial</a>, I was really excited about the possibilities of React. However, that excitement was a little dulled once I discovered the wonderful world of node-based tools that seemed almost mandatory if you wanted to create anything serious. I found that javascript is no longer the innocent, interpreted language I knew it as. ES6, CoffeeScript, TypeScript, transpilers, webpack</em>, the endless abyss that is node-packages</strong> … it is easy to get lost just trying to get a hang of all these tools and frameworks.</p> So where am I going with all this? Well, my (mis?)adventures with React, Redux etc. can be summarized as:</p> React seems to have zeroed in on a really good way of defining UIs without much clutter. I especially loved the concept of one-way binding and views defined as pure functions of state which redraws the whole page when updated.</li> I found redux to be a great addition to the React ecosystem that provides clean and predictable state management along with some very fancy debugging features.</li> A Python programmer who wants to use React or Electron still has to navigate through the very confusing tooling (npm</em>, webpack</em>, babel</em> etc.) before they can even start to create anything useful.</li> I don’t want to deal with Javascript to design my UI.</li> </ol> There has to be a way to do all this in Python!</p> The Magic of Websockets</h4> Last week, I came across this article</a> which seemed to reflect many of the problems that I had faced when it came to Python GUIs. The article is part of a 3-part (so far) series that ends with the creation of Sofi</a> (Cheers Cristian</a>!). As described in the article, Sofi is:</p> a system that will generate the necessary HTML and JavaScript code typically needed to produce a single-page application and serve it up through WebSockets</p> </blockquote> Though it is at a very early stage in its design, Sofi seems to do what it is supposed to. It allows you to design UIs in Python while leveraging web technologies like Bootstrap to render them. One thing I did not like about Sofi was the imperative nature of the UI design which reminded me of jQuery (and maybe a bit of Java AWT). After my experience with React, I wanted something declarative and functional.</p> So, is it possible to leverage websockets to implement something that keeps the general idea behind Sofi, but is declarative and functional like React?</p> flybywire</h3> flybywire</em> is my ongoing experiment based on Sofi to create a more declarative UI library. It re-renders the page every time the state changes. It uses a virtual-dom system similar to that used by React, to only update those parts of the page that have actually changed. The coding style in flybywire</em> applications was modeled after that of React. The library includes a helper function that allows components to be defined in a syntax inspired by JSX.</p> Usage</h4> Below is a really simple demo app that is included with the library:</p> A simple counter app made using flybywire</strong></p> And this is counter.py.</strong></p> from </span>flybywire.core </span>import </span>App </span>from </span>flybywire.dom </span>import </span>h </span> </span>def </span>CounterView</span>(</span>count</span>): </span> </span>"""A simple functional stateless component.""" </span> </span>return </span>h</span>('</span>h1</span>', </span>str</span>(count)) </span> </span>class </span>CounterApp</span>(</span>App</span>): </span> </span>def </span>\</span>_\_init\_\_(self): </span> </span> """</span>Initialize the application.</span>""" </span> </span>super</span>().\</span>_\_init\_\_() </span> </span> </span>self</span>.set\</span>_initial\_state(0)</span> </span> </span>def </span>render</span>(</span>self</span>): </span> </span>"""Renders view given application state.""" </span> </span>return </span>h</span>('</span>div</span>', </span> \</span>[CounterView(count=self.state), </span> </span> </span>h</span>('</span>button</span>', '</span>+</span>', </span>onclick </span>= </span>self</span>.increment), </span> </span>h</span>('</span>button</span>', '</span>-</span>', </span>onclick </span>= </span>self</span>.decrement)\</span>] </span> </span> ) </span> </span>def </span>increment</span>(</span>self</span>, </span>e</span>): </span> </span>"""Increments counter.""" </span> </span>self</span>.set\</span>_state(self.state + 1)</span> </span> </span>def </span>decrement</span>(</span>self</span>, </span>e</span>): </span> </span>"""Decrements counter.""" </span> </span>self</span>.set\</span>_state(self.state - 1)</span> </span> </span>app = </span>CounterApp</span>() </span>app.</span>start</span>() </span></code></pre> How it Works</h4> The structure of the code above should be very familiar to anyone who has worked with React before. flybywire</em> provides a helper function for building DOM structures. It is also possible to compose the UI out of stateless, functional components (like CounterView</strong> in the above example). This DOM structure is then converted into JSON format and sent to the browser over websockets using the autobahn</a> library. The javascript part of the library parses the virtual-DOM structure out of the JSON data and patches the existing DOM wherever it has changed. Any DOM event callbacks are also setup to be passed back to the Python app over websockets.</p> Some of the core parts of this library such as the event server and event processor were directly taken from Sofi with a few modifications. Instead of Bootstrap-based widgets, flybywire</em> allows you to define your own components that can be composed to form whatever widget you need.</p> It is now possible to make some really simple apps using flybywire</em>. However, the library is at a very early stage, given that the First Commit in the repository was only three days ago!</p> What doesn’t work</h4> Here’s some things that are missing and/or acts weird:</p> Some basic manipulations of the DOM elements such as focusing a particular input box or clearing the input box after a certain action is completed are currently not possible. This will probably require putting back some of the command system from Sofi that I had removed when making flybywire</em>. This can also possibly be fixed by moving to a platform like Electron which may give greater control over the rendering process.</li> The server shuts down as soon as you close the browser window. This is done on purpose as there is currently no way to reset the application state without restarting the server. The shared state also results in weird behavior if you open multiple windows. Once we move to a platform like Electron, flybywire</em> will have hopefully have more fine control over the life cycle of the application.</li> </ul> Coming Soon</strong></h4> I will probably add a few more features over the weekend, particularly a better Component class for creating stateful components. Any suggestions/comments/ideas and constructive criticism are welcome!</p>

Thomas Antony

GPU-Agnostic Programming using CubeCL

Inner Product of Functions

Norm of a Function or Square integrable functions

Functions form a Vector Space

Inner Product Space

Hilbert Spaces

Volumetric Scene Representations

Volume Rendering

Git Worktrees

Sandwich Bread v0.1 (Sep 2025) - 129 cal per 60g slice

Equipment</h2> Stand Mixer (you could make this with a no-knead process similar to what is described by Chain Baker, but I did not do that here)</li> Scale</li> Thermometer</li> Cutting board/flat surface</li> Rolling pin</li> Loaf pan</li>

Nutrition Facts</h2> Assuming each slice is ~60g (about 0.25 inches), the macros are the following (for the particular brand of ingredients that I used):</p>

IFR Alternate Requirements

Engine start procedure for Cirrus SR22T-G6

Hot Start (Oil temp > 100F)</h2> If the engine is warm, no priming is required. Remaining procedure is the same.</p>

References</h2> [1] Cirrus IFOM - Chapter 2, Section 5 [2] Cirrus SR22T-G6 POH - Section 4-11 [3] https://www.youtube.com/watch?v=eFAb9JK–HM</p>

Cirrus SR22T: Abnormal Procedures for the Turbocharger

References</h2> https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=1072487639</li> </ul>

What Is A Schmitt Trigger?

SINDy: Sparse Identification of Nonlinear Dynamics

Fragment Shaders

Vertex Shaders

Understanding 3D Gaussian Splats by writing a software renderer

Acknowledgements</h2> The following articles/code bases were extremely helpful in teaching me about how 3D Gaussian Splats work</p>

Understanding 3D Gaussian Splats by writing a software renderer

Acknowledgements</h2> The following articles/code bases were extremely helpful in teaching me about how 3D Gaussian Splats work</p>

Hyena Hierarchy: Towards Larger Convolutional Language Models

Generalization through memorization: Nearest neighbor language models

How to send UDP packets from command line

Python extension debugging in Vscode

Troubleshooting</h2> If you get EXC_BAD_INSTRUCTION on M1 Mac, downgrade openssl from 3.1.0 to 3.0.7 (and Python to 3.10.9)</li> </ul>

How was ChatGPT trained?

References</h2> [1] https://www.youtube.com/watch?v=_MPJ3CyDokU</p> [2] “Learning to summarize from human feedback” https://arxiv.org/pdf/2009.01325.pdf</p>

Plasma

Generating music using ChatGPT

Section 3.1 : Hamilton's Equations

Section 2.12: Nonsingular Coordinates and Quaternions

Section 2.11.1: Spin-Orbit Coupling - Development of Potential Energy

Exercise 2.13: Bicycle Wheel (incomplete)

Exercise 2.12: Derivation of Euler Angle Kinematics

Exercise 2.12: Derivation of Euler Angle Kinematics</h3> Fill in the details of the derivation of equation (2.73). You may want to use the computer to help with the algebra.</strong></p>

References</h3> [1] : https://www.youtube.com/watch?v=af041z8jujU</a></p>

Exercise 2.11: Conservation of Angular Momentum

Exercise 2.11: Conservation of Angular Momentum</h3> Fill in the details of the argument that Noether’s theorem implies that vector angular momentum is conserved by the motion of the free rigid body.</strong></p> $$\require{cancel}$$</p>

Section 2.9: Euler's Equations

Section 2.8.2: Qualitative Features of Free Rigid Body Motion

Section 2.8.1: Computing the Motion of Free Rigid Bodies (incomplete)

2.8.1 Computing the Motion of Free Rigid Bodies</h2> Lagrange’s equations for the motion of a free rigid body in terms of Euler angles are quite disgusting, so we will not show them here.</p> </blockquote>

Exercise 2.10: Uniformly accelerated rigid body

Section 2.8 : Motion of a Free Rigid Body

Exercise 2.9: Euler angles

Section 2.7: Euler Angles

2.7 Euler Angles</h2> Euler Angles</em> are a set of generalized coordinates for describing the orientation of a rigid body. To quote the book:</p>

Exercise 2.6: Principal moments of inertia

Exercise 2.8: Rotational angular momentum

Exercise 2.8: Rotational angular momentum</h2> Verify that expression in Eq. (2.50) for the components of the rotational angular momentum Eq. (2.49) in terms of the inertia tensor is correct.</strong></p>

Section 2.6: Vector Angular Momentum

Section 1.8.3: Central Forces in Three Dimensions

1.8.3 Central Forces in Three Dimensions</h2> Consider the motion of a particle in a potential field $V(r)$ in three dimensions using spherical coordinates, $r, \theta, \varphi$, where $\theta$ is the colatitude and $\varphi$ is the longitude. The kinetic energy is:</p>

Exercise 2.5: A constraint on the moments of inertia

Exercise 2.4: Jupiter

Exercise 2.3: Some useful moments of inertia

Section 2.5: Principal Moments of Inertia

Exercise 2.2: Steiner's Theorem

Section 2.4: Inertia Tensor

Seam carving algorithm

Section 1.6.2: Systems with Rigid Constraints

Hot Start (Oil temp > 100F)</h2>
If the engine is warm, no priming is required. Remaining procedure is the same.</p>

References</h2>
[1] Cirrus IFOM - Chapter 2, Section 5 [2] Cirrus SR22T-G6 POH - Section 4-11 [3] https://www.youtube.com/watch?v=eFAb9JK–HM</p>

References</h2>

https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=1072487639</li> </ul>

Troubleshooting</h2>

If you get EXC_BAD_INSTRUCTION on M1 Mac, downgrade openssl from 3.1.0 to 3.0.7 (and Python to 3.10.9)</li> </ul>

References</h2>
[1] https://www.youtube.com/watch?v=_MPJ3CyDokU</p>
[2] “Learning to summarize from human feedback” https://arxiv.org/pdf/2009.01325.pdf</p>

References</h3>
[1] : https://www.youtube.com/watch?v=af041z8jujU</a></p>