Aerospace Engineering Graduate from ASU
Hello, I am Robert Rodriguez. I graduated in December 2021 from Arizona State University with a
bachelor's in aeronautical engineering and started working shortly after. I have been interested in mechanical
objects since I was very young. I figured out my aerospace-related passions towards the end of high school due
to some physics classes I took. I am thankful our high school had a 3D design class as an elective; this is
where I first used SOLIDWORKS, followed shortly after by SOLIDWORKS flow simulation.
Seeing the
fluids being simulated and being able to cut a cross-section of the flow, I think it is so interesting to see
how fluids move throughout their constraints. Starting with cubes and pipes and seeing how air and water would
interact over and in those objects, I then moved to more advanced objects such as relatively simple airfoils
and vehicle profiles. At this point, I was learning almost all of my SOLIDWORKS at home on a student account
with a computer that wasn't happy about all of this new CPU stress.
I have always loved cars and
racing, especially Formula 1, so I thought going into a field closely related to aerodynamics would be fun. I
figured that if I combined my love for cars and aircraft, I would have no problem pursuing aerospace
engineering. Luckily this turned out to be true, and even in times I was struggling I still really enjoyed
every subject that I took while at Arizona State. Over the course of my education, I found out that I enjoy
more than just aerodynamics but just
about all parts of aerospace engineering, including flight planning, flight testing, orbits, and geodesy.
My capstone project was really engaging and entertaining because I really enjoyed what I was doing. The
project involved designing and simulating a space tourism aircraft capable of taking off and landing on a
runway and being able to make it above 300,000 feet. This project was a lot of fun. I was involved in most
aspects of the design as our team lead, but I single-handedly took on the flight testing and flight
simulations of our proposed aircraft. Using hundreds of different parameters, our final aircraft was able to
sustain greater than 60 seconds above 300k feet and was capable of taking 14 passengers on each trip. Each
climb would approach Mach 3.4, and I had to simulate different reentry angles to maintain relatively low
stagnation temperatures.
After beginning working, I was involved with a testing team as an intern.
I was involved with testing different GNSS receivers, and this caught my interest. I started learning Python
to code in order to do data analysis on the GNSS data. First, by scraping GGA messages, which are simple
positioning messages that consist of latitude, longitude, altitude, and a few other details. I became very
involved in coding and data analysis. I had coded using MATLAB throughout college, but once I started at this
company, my skills greatly improved, so much so that a few months after starting my internship, I became a
Test Automation Engineer, where I am currently. This position involved trying to automate the testing
procedures as much as possible. This work helped me become much more interested in geodesy and GNSS in
general.
Some other hobbies I have include working on my motorcycle in my free time, designing and
printing CAD parts, and I also love snowboarding, mountain biking and rock climbing (bouldering). Anything
really to get the blood pumping, and being outdoors while doing it is a plus.
I have added these small simulations to showcase my coding and
interests. As a disclaimer, I don't have much experience with
Javascript, and these are my first tries with it. Orbiter being my first creation and . I have always loved
games that are scientifically based, such as Kerbal Space Program or
Universe Sandbox. I have come to realize I love putting together small simulations
such as the ones below. Visualizing how physics interact I think is
amazing, and it helps me stay sharp on math from university as well as learning new concepts and most importantly,
how to implement it into code.
Also of course this entire website is always a work in progress. Please
feel free and take a look at the source code on github to see how I
created these sims.
Throughout college I enjoyed most my classes, but one of the few that really stood out for me was
orbital dynamics and space vehicle dynamics. It felt great being able to predict the delta-V requirements
for different orbital maneuvers. I enjoyed calculating entire orbits from the few Keplerian elements given.
Below is my orbits simulation. This simulation uses data from the
Earth and the Sun in order to accurately model orbits. To model the gravitation forces, Newtons universal
law
of gravitation is used. This is then converted to acceleration from
the planets mass, and then converted further into velocity and
position.
Instead of calculating the entire orbit and having the planet travel on a fixed path, I
instead
calculate the force every frame. I think that makes this a more interesting simulation, although due to the
framerate and timestep, some anomalies may occur. This can be seen in the values that should remain constant
in an orbit with no outside forces, such as eccentricity, semi-major axis, period, apoapsis, and periapsis.
We can see these values slightly deviate throughout the orbit and especially so in the high velocity areas.
If the frame rate was higher it would help immensely, but also slow down the simulation. I had to pick a
balance between perfect values and entertaining sim.
This is my third simulation. I wanted to work with physics after creating the autopilot - PID sim. I
have attempted this type of code before in Python but I am not fond of PyGame, so the attempts usually
sizzle out. The canvases in Javascript are really nice for seeing quick updates to your work. This by itself
allowed me to finish this side project. This simulator uses spatial partitioning to monitor collision
detection. Although most CPU's can handle a brute force collision detection with this amount of entities, I
want to prioritize performance.
Overall with this collision detection, there are only around 200 collision checks per frame for 25
entities, by comparison with brute force there are 300 checks. As the amount of entities increase the broad
phase collision detection shows its true colors with its performance benefits.
This script was useful for me to learn about classes in Javascript. Each ball is its own class with
many different objects inside of it, including X and Y position, speed, color, mass, radius and many
more. The major difficulties in creating this simulator were stopping balls from "morphing" into one
another. With the lower framerates, there are problems with faster moving balls. Since they move a set
amount each frame, if they move into the space where another ball is moving, the collision check will not
happen
until the frame after. This can cause problems with balls "sticking" together. This was solved by checking
if the balls have been touching for more than one frame in a row. This works well in most situations.
In my latest project, I delved into creating a radar simulation. The goal was simple: make a
realistic radar experience using ray casting techniques. This project was a great way to explore how
radar physics and raycasting come together.
The simulation's core features include the ability to adjust the number of beams and set
their maximum bounces. This not only adds a bit of complexity but also lets users get a hands-on feel
for how radar works. I've also added a "radar view" mode, which shows only the returning beams, similar
to what a real radar screen would display.
Figuring out ray casting was a key challenge in this project. It took some effort, but I
managed to get it working in about a day. This was crucial for making the simulation resemble how
real radar systems detect objects.
To keep the simulation running smoothly, I set lower default settings for beams and bounces.
Also, the rays turn off when the mouse isn't over the screen, preventing the sim from running when it's
not needed.
While working on this, I learned a lot about raycasting and the X-band radar. It was
interesting to see how these technologies work and what they're used for.
Moving forward, I have some ideas to enhance the simulation. I want to add a cross-section
view, to show a one-dimensional profile similar to what a 2D radar would detect. I'm also thinking
about adding more shapes to make the simulation more detailed and interesting. These updates should
make the simulation even more useful for understanding radar technology.
This simulation takes values of a Boeing 737 (including mass, CL,
CD, thrust, and more) and inputs it into a PID controller to keep it
both level on the target height, and in the X-center of the
window.
The coefficient of lift and drag are found by taking values from
airfoiltools.com, they are then linearly interpolated using the
angle of attack. The lift is found by using the lift equation and
plugging in the density of air, the velocity of the aircraft and the
aircrafts wing reference area (sref).
In the case of this simulation we are taking the density of
air to
be near sea-level at 1.225 kg/m3, and velocity is 200
m/s. The SREF of the Boeing 737 is about 125 m2.
This simulation also features
procedurally generated clouds. Each
cloud is created out of a random number of "lobes", and each lobe is
placed randomly around the cloud. The further out a lobe, the more
transparent it becomes. I felt like this gave the clouds a neat
digital look. Currently there is a 75% chance to spawn a cloud per
tick. I implemented a cloud slider in case they get distracting.
This simulator takes fluid dynamics equations and solves. The equations in particular are the
Navier-Stokes Equation and the Poisson Pressure Equation. This took many days and nights of studying,
especially LorenABarba's Python CFD lessons.
To use the simulator first draw a shape on the grid, click the
"Set Shape" button, and then click start run. Hopefully everything works and the solution should converge
within a second or so. After it completes there should be a heat map of X velocity. Feel free to change that
to Y velocity, total velocity, or pressure in the lower left dropdown window.
Next to this dropdown window
is the scale showing the coloring of the minimum, maximum, and the average. Another feature I added was a
particle visualizer, to use this choose the interpolation loop amount,
where the larger the loops the larger the final matrix will become. Click the particle mode to enable it,
and then you can choose how many particles you want.
This program taught and reaffirmed many things about fluid dynamics and coding for me. To ensure all
the particles can move we have to check every particle if they are in every mesh square and only change the
velocity of the particle by the value of the grid square it is in. With 200 particles on a 41x41 matrix, we
must loop 336,200 times per frame to figure out the velocities of all the particles. To fix this I
incorporated a hashmap function for each row of the array. This allowed me to bring the loops to only about
5000 per frame, and it runs must smoother.
Want to see what I am working on currently? The simulation or visualizer should be on this page. It could range from just an empty canvas to a 99% complete sim. Currently, I just finished up the CFD solver shown in the bottom right of the simulation page, go check it out! That took a lot out of me with the dozens of hours to program and debug, so I am going on a Javascript break now. I have many more ideas for simulations in the future so feel free to check back later!