About Catherine Paulson

Posts by Catherine Paulson:

Catherine Paulson

Automate Insurance Claims to Save my Mental Health

… So I’ve decided to dip my toes into some web automation.

My problem is that my mental health therapist doesn’t accept my insurance because they’re out of network. My insurance will reimburse a partial amount of my therapy bill if I submit a claim with a super-bill from my therapist. I really want my money back, but it’s a huge bummer to have to fill out a claims form every month – and honestly depression makes tasks like this very difficult.

So I want to have a script that uploads it for me.

Automating interacting with my insurance company’s website is in violation of their terms of use, so this is all very hypothetical

So let’s break down this problem. Here’s what I do when I complete this process manually

  1. My therapist emails me my superbill
  2. I download the superbill as a pdf and name it something like “Superbill_MAY2023”
  3. I log in to my insurance company’s website
  4. I navigate to their claims page
  5. I fill out the form. Some of the info is on the pdf, and some of it is the same each time I fill out the form
  6. I upload my superbill for that month
  7. I submit my form

I want to do this automatically. There are three systems I see interacting

  1. My pdf has to be downloaded to my local system from my email
  2. My local system needs to parse some data from the pdf and store it somewhere
  3. My system them needs to login to the insurance company’s website and fill in the form with the info from the pdf

I think I can use either some built-in stuff from gmail or google scripts to get the pdf to automatically download. I’m thinking I’ll then use python to extract the necessary data from the pdf. I’m not too sure how I’ll get the form to autofill, but I’ll probably use some javascript for that.

I’m going to start with the easiest part I can think of – automatic download of gmail attachments from a certain sender. 

We’ll see how I do that in the next post!

Catherine Paulson

It’s been a minute…

Hello again – I figured it’s time to dust off the old blog!

I’ve been mulling over lots of ideas and watching creative people on youtube, and I’m inspired now to get rolling on some of my projects!

That’s not to say I haven’t been working on stuff since my last post – I plan on sharing in-progress and old projects as I dust them off. My main goal right now is to update my website using my new javascript skills. I want to update the design of the website, as well as show off some smaller artistic code projects I’ve been working on.

I want to be more consistent in posting blog updates, so I’ll end with a note to my future self – they say starting is the hardest part, so you’ve already done the hard part! Don’t let perfect be the enemy of done – it’s time to show your awesome work!

Catherine Paulson

Gravity Simulation

Gravity Simulation Modeling gravitational force with MATLAB

I’ve done all types of projects, but I figured I’d save the best for first. I’ve created a gravity simulation to model planet interaction, and it’s my favorite coding project that I’ve done so far.

In this post, I’ll go through my basic design process and some of the physics and programming I used to get to a super cool simulation. Click here if you’d rather skip straight to the final simulation. Click here it you’d like to check out my code on github.

Project Background

This past summer, I was a tutor for the first ever UCLA Engineering Transfer Summer Bridge program, designed to help students transferring into UCLA’s engineering program get a head-start on their courses and get a feel for the rigor of the curriculum.

We introduced students to MATLAB, a programming language commonly used by engineers and researchers for all kinds of things, including processing data and running simulations. The final project of this two-week crash-course was to create a simulation of gravity. This simulation could be used to model all kinds of space-y things, from calculating how to launch a satellite into orbit around Mars, or modelling the formation of planets from a bunch of space dust. It also introduced students into some programming concepts like iteration and data structures.

As a tutor, I helped formulate the project idea and problem statement. I also got to build my own version of the gravity simulation as an example. I’ll go through the physics and math that drives this simulation, as well as the programming tips and tricks used in this project.

Gravity

Gravity is an attractive force between objects thats proportional to their mass and inversely proportional to the square of the distance between them. Basically, the bigger you are the more you attractive you are; the further away you are, the less attractive you are. You can read more about it here, but it’s best summed up by this equation:

F_k,j = [G*m_j*m_k / ||dx||³] * dx

||dx|| = √(dx² + dy²+ dz²)

where F_k,j is the force of attraction between body k and body j, G is the universal gravitational constant, m_k is the mass of the first object, m_j is the mass of the second object and dx is the separation vector between the two bodies. The ||…|| notation denotes the Euclidean norm of a vector; it’s a way to calculate the magnitude of the vector, which in this case, is the distance between the two objects.

Kinematics

With this equation, we know how much each object is pulling on each other. This pulling force (F) is going to make these objects move; how fast they move (acceleration a) depends on their size (mass m). This is summarized in the equation:

F = m*a

We can then find how fast the object is going (velocity v) and calculate where it will be (position x) after some given time (differential time step dt). This is summarized with the equations:

a = v* dt

v = x*dt.

Basically, we can use gravity to predict where the planets will be at some tiny amount of time in the future. But now they’ve moved, which means the gravitational force between the two is different! We need to recalculate the gravitational force between the objects, and then figure out the new acceleration, velocity and position, over and over until we’re done with our experiment.

That’s a lot of calculations to do by hand, especially if we want to add more planets. But computers are really good at doing these calculations for us. Next, I’ll go over how I wrote a program in MATLAB to create this simulation, which perform these calculations and display the results.

Collisions

Lastly we need to figure out what to do when object collide. We’re going to model our collision as an inelastic collision, where the two objects will accrete, or combine into a single object with a combined mass and new velocity. In these types of collisions, momentum of the system is conserved. We can use the equation:

m_1*v_1 + m_2*v_2 = m_new*v_new

We know that m_new = m_1 + m_2, since the new object is the combined masses of the two objects. We rearrange and solve for v_new:

v_new = (m_1*v_1 + m_2*v_2) / (m_1 + m_2)

Now we know the new object’s mass and velocity, and can treat it like any other object in our system.

*Bolded variables are vectors

Building the Program

Basics

A computer is actually pretty simple; it follows whatever instructions it is given. A set of instructions is called an algorithm. Programmers create these sets of instructions that the computer follows. These instructions are first written in human language (like English), so the human programmer can easily understand what’s going on. We call this human version of the program pseudocode. Then we convert that into code, the language the computer understands.

*From now on, I refer to objects as bodies since not everything in space is a planet (r.i.p. Pluto), but you can think of them as planets if you’d like.

Here’s the pseudocode for the gravity simulation:

Create all the bodies in the system, including their mass, starting velocity and position

Repeat what’s in {} for every instant for the duration of the simulation:

{ Check for collisions between bodies

Calculate the gravitational force between each pair of bodies

Calculate the new velocity and position of each body }

This is what we described we’d need to do earlier! You can check out my code on github to see how this is translated into MATLAB so the computer can understand.

Verification

Once we’ve written our code, it’s important to verify that it’s working the way we expect. I used a simple case of two equal-sized bodies at rest. The two bodies will attract each other until they collide and become one, stationary body, shown here:

The gravitational force between the two bodies attracts them to each other, until they collide and combine into a single body. Both bodies are the same size and are initially at rest.

This simple case verified a lot of things: the bodies moved toward each other, so I’d gotten the force calculation correct; the bodies combined into one, so I’m detecting collisions correctly; the bodies stopped moving, so I’m conserving momentum. Now that I know the basic part of my code is working, I can add more complicated features.

Special behavior: Explosions

So far, we’re modeling an inelastic collision, where the objects combine when they collide. But what happens when two big objects collide head-on? We’d expect them to explode, with pieces shooting out from the point of collision. But so far, we’ve only modeled accretion.

To model an explosion, we calculate how much energy was involved in the collision. If the collision is powerful enough, the bodies will explode instead of combining, as seen here

The gravitational force between the two bodies pulls them towards each other. When they collide, the objects explode into several fragments. The new objects also experience the gravitational attraction force of all other bodies.

Gravity Simulation Demo

I’ve picked a few interesting examples of the gravity simulation. All these demos are start with bodies randomly placed in a small area. All bodies are a similar size with small random starting velocities. The color of of the bodies depends on its mass. The smaller objects are blue and bigger objects are red.

The fragmentation feature is turned off. We can see the bodies come together into a large red body, which the remaining objects orbit around. The chaotic system becomes more organized, which is similar to how solar systems form.

You can see it’s rather satisfying to watch how the chaotic system evolves. You can also see that a simple principle can be used to create a complicated simulation.

Final Thoughts

I’ve got a few ideas for where I want to take this project. My next goal is to develop a web-based version of this simulation, so users can run a new simulation every time, with control over all the different setting. I also plan to do more research into explosions to make the fragmentation feature more realistic.

If you wanna learn to code yourself, there’s a whole bunch of stuff online to help you get started (that don’t cost money like MATLAB). I started out with Codecacdemy and recommend it to all beginners.

You can find the code for this simulation on my github; you can also check out this project and others in my portfolio.

I’ve got plenty more projects to showcase: stay tuned for more!

Recent Posts

Catherine Paulson

Welcome to the blog

Welcome Let me introduce myself

Hi there! Welcome to my blog! I’m new to this whole blogging thing, but I figured I’d introduce myself and what this blog is about.

I’m Catherine, a recent grad from UCLA; I studied bioengineering with a technical focus in computer science.

I’ve been drawn to engineering since I was young. I wasn’t really a “take apart the VCR” type of tinkerer; I was more interested in creating things that I’d never seen before, like a lamp shade made from sunglasses or a tiny robot that would sign your name as it moved. Most of the time my wild ideas never really turned into much, but I would spend hours (and multiple sticks of hot glue) trying to turn these ideas into reality.

When I got to college, I discovered programming. It honestly blew my mind— I could execute an idea with just a computer, and no splinters?? Sign me up! My childhood hobby morphed into a full grown career path. I started taking as many computer science classes I could fit into my schedule. I became a MATLAB fanatic, and I even got to help develop an intro to MATLAB course. I don’t know where I’ll end up working, but I am looking for work that lets me be creative and innovative.

In the meantime, I’m still just a weekend creative. I’m constantly dreaming up new projects in a variety of mediums; I’ve restored furniture and made jewelry; I’m learning to sew and to weld; I paint and I code; I’ve got big plans for a rescued moped, and there’s a pile of scrap lumber just begging to be turned into something cool.

As I work my way through these projects, I’m hoping to document my progress. I’ll detail the design process, the techniques used, obstacles I encountered and how I go around them (watching a project or technique evolve is pretty fascinating in my opinion). I hope these projects help inspire you with your own projects

Wish me luck!

Recent Posts