Professional · Power Device Corporation
Mechanical engineering intern – Power Device Corporation
My internship at Power Device Corporation ended up covering a lot more than I expected. I started close to production, designing fixtures, 3D printing, machining, and supporting existing products, then gradually moved into R&D for new space electronics.
From there, I worked across PCB layouts, electronics packaging, chassis design, thermal analysis, manufacturing drawings, heat-transfer hardware, component footprint library work, Python automation, and fit checks as the first engineering hardware started coming together.
I helped coordinate physical models and renders for marketing, and supported the manufacturing of some of the first heat-shunt hardware for the engineering boards. Some of the products I worked on, including the SSDR and HPSC, can now be found on PDC’s website, and I made the renders shown there.
Visit Power Device Corporation
Production Support
This is one of the fixtures I worked on, and it’s a good example of the full process that went into a lot of the production-support work. The original process relied on an operator visually aligning a smaller part to the component by hand before clipping. It worked, but the setup took time and the final alignment depended heavily on the person doing it. I redesigned the setup so the fixture mechanically located both parts, meaning the alignment was built into the tooling instead of being done by eye.
The fixture went through the full design and manufacturing process. I started with the existing component drawings and built a CAD model of the part, then worked through how it needed to be constrained and located. From there, I made an initial 3D-printed prototype to check fit and positioning, revised the design based on those physical fit checks, created the CAM in Fusion 360, and machined the final production version on the CNC.
Once the fixture was put into use, setup time dropped from roughly 5 minutes to under 1 minute per component, while also making the process more repeatable and less dependent on operator alignment. Over the course of the internship, I developed and delivered 20+ fixtures for different production needs, and this one is a good example of the general cycle behind that work: understand what is happening on the floor, talk with the people doing the work, design around the problem, prototype it, test it, revise it, and then make the production version.
R&D of Next-Generation Space Electronics
I worked on four of Power Device Corporation’s next-generation space products: the High Performance Space Computer (HPSC), Solid State Data Recorder (SSDR), Power Supply Card (PSC), and a 4-card chassis designed to house them together. My level of involvement was different on each one, but I contributed to all four through some combination of mechanical design, PCB packaging, thermal analysis, drawings, manufacturing support, and hardware integration.
The HPSC is a good example of how that work came together. During the school year, I started by digging into the requirements and standards that would define the card before much of the hardware existed. Using those requirements, I helped create the mechanical layout for the main PCB, including the board outline, mounting features, keep-out areas, connector locations, and the available space for components. That information gave the electrical team a mechanical envelope to work inside as they developed the board layout.
Component placement was another big part of the process. The electrical team would often have a few possible locations for a processor, memory, or another heat-generating component, and I would help determine whether those locations actually worked mechanically and thermally. I used the packaging requirements along with ANSYS Mechanical studies to compare placement options and different heat-shunt geometries. One of the studies shown here compared several heat-shunt wall configurations, and the results helped narrow down both the component location and the heat-shunt geometry that continued into the final card design.
The design and analysis then went through Critical Design Reviews (CDRs), where I presented the results and design reasoning to the other engineers. Once the design was mature enough to build, I created manufacturing drawings for the heat shunts using GD&T, material and finish requirements, and the tolerances needed for the PCB, components, and thermal interfaces. Those drawings were released internally and sent to a machine shop to manufacture the heat shunts for the first batch of five HPSC engineering boards.
As those first boards started moving into assembly, my work shifted more toward supporting the physical hardware. I designed and 3D printed an ESD-safe PCB carrier that could safely hold both bare and populated HPSC boards while they were transported between facilities for assembly and reflow. That made the whole project feel pretty full circle because I had been involved from the early PCB layout and thermal studies, through design reviews and manufacturing drawings, and eventually into the machined heat shunts and first assembled engineering cards.
Thermal Data Extraction Automation – Overview
For the full-card thermal studies, I needed temperature data for every component on the board so junction temperatures, case temperatures, and margin to limits could be reviewed across the whole design. Doing that by hand was extremely slow. Probing each component one at a time in ANSYS could take over an hour for a single card, and I needed to do it across three cards. It also was not the most reliable method, since manually probing made it easy to miss the actual hottest point on a component.
To fix that, I wrote a Python script inside ANSYS Mechanical that automatically scanned every modeled body, pulled the maximum nodal temperature for each component, identified the node location, and exported the results into a CSV file. That gave me a much faster and more repeatable starting point for calculating junction temperatures and reviewing thermal margin, while also making it easier to communicate results to the rest of the mechanical team.
Thermal Data Extraction Automation - Code
The script begins by accessing the active ANSYS Mechanical analysis, mesh data, and the most recent solved temperature result. It also locates the Temperature result object in the solution tree so the same data can later be used for visualization.
The model bodies are then collected and processed one at a time. For each body, the script maps the geometry to its corresponding mesh region and retrieves the node IDs associated with that body.
It then reads the temperature value at each of those nodes, finds the maximum value, and identifies the node where that maximum occurs. The body name, maximum temperature, and node ID are stored together in a results list before moving to the next body.
After all bodies have been processed, the results list is written to a CSV file. The script can also use the saved node IDs to place probe labels directly on the Temperature result in ANSYS, making it easier to visually locate the hot spots in the model.
The code also includes error handling so that if a body has no valid mesh or temperature data, it skips that body and continues processing the rest of the model instead of stopping the entire script.
View code
import csv
import sys
# SETTINGS
analysis = ExtAPI.DataModel.Project.Model.Analyses[0]
# Output CSV file (CHANGE FOR WHERE YOU WANT THE FILE EXPORTED TO)
OUTPUT_FILE = r"YOUR FILE PATH\NAME OF EXCEL SHEET.csv"
# Clear old max temperature labels before making new ones
CLEAR_OLD_LABELS = True
# GET MESH AND RESULTS
mesh = analysis.MeshData
reader = analysis.GetResultsData()
# Use the last solved result set
reader.CurrentResultSet = reader.ResultSetCount
# Get temperature result
temperature = reader.GetResult("TEMP")
# GET TEMPERATURE RESULT FROM TREE
temperature_result = None
for solution_item in analysis.Solution.Children:
if solution_item.Name == "Temperature":
temperature_result = solution_item
break
# GET ALL BODIES
bodies = DataModel.GetObjectsByType(
DataModelObjectCategory.Body
)
# LOOP THROUGH EVERY BODY
results = []
for body in bodies:
# Get the mesh nodes associated with the body
try:
geo_body = body.GetGeoBody()
body_mesh = mesh.MeshRegionById(geo_body.Id)
node_ids = body_mesh.NodeIds
except Exception as e:
print("Could not get mesh for " + body.Name)
print(e)
continue
# Skip bodies with no mesh nodes
if len(node_ids) == 0:
continue
# Get temperature values for the body's nodes
try:
temp_values = temperature.GetNodeValues(node_ids)
except Exception as e:
print("Could not get temperature for " + body.Name)
print(e)
continue
# Skip if no temperature values were returned
if len(temp_values) == 0:
continue
# Find maximum temperature
max_temp = max(temp_values)
# Find the node with the maximum temperature
max_node_id = node_ids[0]
for i in range(len(temp_values)):
if temp_values[i] == max_temp:
max_node_id = node_ids[i]
break
# Save component name, maximum temperature, and node ID
results.append({
"component": body.Name,
"max_temp": max_temp,
"node_id": max_node_id
})
# WRITE CSV
with open(OUTPUT_FILE, "wb") as f:
writer = csv.writer(f)
# Header
writer.writerow([
"Component",
"Maximum Temperature (C)",
"Max Temperature Node ID"
])
# Data
for result in results:
writer.writerow([
result["component"],
result["max_temp"],
result["node_id"]
])
# ADD MAX TEMPERATURE LABELS
# Stop script if temperature result was not found
if not temperature_result:
print("Could not find Temperature result.")
sys.exit()
try:
with Transaction():
# Clear old labels
if CLEAR_OLD_LABELS:
old_labels = Graphics.LabelManager.GetObjectLabels(
temperature_result
)
Graphics.LabelManager.DeleteLabels(old_labels)
# Add label to max temperature node for every body
for result in results:
max_node_id = result["node_id"]
probe_label = Graphics.LabelManager.CreateProbeLabel(
temperature_result
)
probe_label.Scoping.Node = max_node_id
# Show temperature result
temperature_result.Activate()
print("Max temperature labels added.")
except Exception as e:
print("Could not add max temperature labels.")
print(e)
# FINISHED
print("Temperature export complete.")
print("Components exported: " + str(len(results)))
print("CSV saved to:")
print(OUTPUT_FILE)What I Took Away
I think the biggest thing I got from PDC was seeing what has to happen between a CAD model and real hardware. I worked with technicians on production problems, electrical engineers on PCB packaging and component placement, machinists and fab houses on parts that needed to be made, and outside vendors when we needed things like high-quality PolyJet models for the IEEE SMC-IT/SCC conference.
By the end of the internship, I had designed and delivered 20+ production fixture configurations, with one cutting setup time from about 5 minutes to under 1 minute, helped develop thermal and mechanical hardware for the HPSC, SSDR, and PSC, and designed the four-card chassis that brought those systems together into one assembly. I also supported the first five batches of engineering boards, created manufacturing drawings that were sent out and turned into machined heat shunts, and made renders and physical models that were used publicly for marketing and customer-facing events.
A lot of the learning came from seeing what happened after I finished the first version of something. CAD changed because electrical needed more room. Thermal results changed component placement or heat-shunt geometry. Tolerances and gap pads mattered once parts had to fit together. A fixture that looked fine on screen still needed to work for the technician using it every day. That feedback loop was probably the most useful part of the whole internship.
And probably the coolest part for me was just getting the chance to work on actual space hardware that is meant to operate reliably for years. I got to watch some of those products go from early layouts and analysis to drawings, machined parts, engineering boards, and assembled hardware, which is exactly the kind of engineering work I want to keep doing.