Hey, Agday, back from the Tai Garden in Lincoln, Nebraska. I wanted to talk a little bit about pulse programs today on the PiPPM. Grab a chair down there, you're gonna want one. We're talking about pulse programs. The important thing here is to talk about what a DC field does. The DC magnetic field takes our polarization, our magnetic polarization. And it transitions it, it polarizes it along a new axis. So we're reorient. We feel that an AC pulse is going to take that magnetization and rotate it in a new direction. AC fields rotate magnetization. So we could take something and rotate it down on a new axis. We can rotate any which way we want. So if we go back then to the original pulse program, we have a hard transition on where we're returning polarization on. A delay and a hard off in which our polarization off. And then we acquire the data. Now, what if we wanted to do AC pulses? Now, we have a situation where we have to add an AC pulse somewhere in or change up the way that we're doing this experiment. So the answer to this lecture break is called pulse programing. The pulse program are just sequences of instructions. And they're executed on the fly by the pi-ppn. At the end of the day, we want to acquire data. But before that, maybe we'll add an AC pulse. We can extend this as much as we want, flexibly on the pi-ppn by simply adding more and more instructions. So this would be an example of a pulse program using the new scheme that pi-ppn influence where we can flexibly arrange these in sequence and run a new kind of experiment. Where we have multiple acquisitions, multiple pulses, delays, etc. And this is a much more flexible way of going about taking data from your pi-ppn. Yeah, instead of having a hard-goated pulse program, you can now ask any question you want. So this is an inherently different question that we're asking our spends in a sample than the original hard-goated sequence. With pulse programming, you can ask an infinite number of questions. That's the whole idea. So pulse programs then in Python look like lists of lists. So we have an outer list here. And inside the list, every element is its own list. It has an instruction. So we could delay, we require, we could have a pulse. And then we just give each one of these instructions different arguments. And so delays take arguments in seconds. So this would be a one-second delay. This is the number of samples. So we're taking 16k points. And 20 is the sample rate and kilo samples per sample. So each one of these has a different syntax. And what we do is we write this to the device in Python. And then it's as easy as dev.xq. The PyPPM runs our statements here. It compiles these into a bytecode instruction set. Executes it. And then gives you back the data as a traditional list of or tuple of tuples. So a few questions. Sure. How does that actually apply to protons, for instance, or spin? So we can ask different questions the sample now that we could before with the hard coded scheme. For example, we can ask about relaxation rates. So all these protons have what's called a T1 and a T2 relaxation rate. And those are intrinsic to the sample. It's used a lot of MRI to get different weighting on images. We can ask these questions for pulse programming in a flexible way that the original scheme wouldn't allow us to do. Furthermore, there are more features. And so being able to arrange these in the right way at the right time really necessitates going to this more complex language. In the end though, for the Python user, it's going to be as simple as writing lists.