Modeling beam structures directly inside Ansys mechanical

Vishnu

Note : No CAD tool is used here for creation of beams (its created directly in mechanical)

you could model beams using construction geometry in Ansys mechanical.

Below is an example how you could create beams directly inside mechanical having known a list of x,y,z points.

the example shows creation of below:

1. straight beams or pipes ,
2. L-shape pipes,
3. U-shape pipes,
4. Helix structures
5. simple representation of real life cases like crane machine

Vishnu

The below function would create beams based on points

def create_cir_beams_from_points(points):
    with Transaction(True):
        ExtAPI.DataModel.Project.Model.AddConstructionGeometry()
        construction_line = ExtAPI.DataModel.Project.Model.ConstructionGeometry.AddConstructionLine()

        for pointlist in points:
            points = construction_line.CreatePoints(pointlist)
            for i in range(0, len(points) - 1):
                edge = construction_line.CreateStraightLines([points[i], points[i + 1]], [(0, 1)])

        part_geo = construction_line.AddToGeometry()
        part = ExtAPI.DataModel.Project.Model.Geometry.GetPart(part_geo)
        geo_bodies = part_geo.Bodies
        treebodies = map(lambda x: ExtAPI.DataModel.Project.Model.Geometry.GetBody(x), geo_bodies)

now let us look at how you can use the above functions to create various structures

for example:

create_cir_beams_from_points([[[0,0,0],[100,0,0]],[[100,0,0],[200,0,0]]])

should create beams on a straight line(multi-body-part) like below:

lets look at another example where we create a triangle shape using 3 beams
as a single part

beam1_points = [[0,0,0],[100,0,0]]
beam2_points = [[100,0,0],[50,50,0]]
beam3_points = [[50,50,0],[0,0,0]]
create_cir_beams_from_points([beam1_points,beam2_points,beam3_points])

similarly, you could as well create triangle shape as a single beam like below:

beam1_points = [[0,0,0],[100,0,0],[50,50,0],[0,0,0]]
create_cir_beams_from_points([beam1_points])

lets look at an example of creating a U-shape pipe structure

def generate_u_bend_points(radius, length, num_points):
    points = []
    # Straight section before the bend
    points.append([0, 0, 0])
    points.append([0, length, 0])
    # Semi-circular bend
    for i in range(num_points + 1):
        angle = math.pi * i / num_points
        x = radius * (1 - math.cos(angle))
        y = length + radius * math.sin(angle)
        points.append([x, y, 0])
    # Straight section after the bend
    points.append([2 * radius, length, 0])
    points.append([2 * radius, 0, 0])
    return points
# Inputs
radius = 5
length = 10
num_points = 20  # Number of points to define the semi-circular bend
# Generate the points
points = generate_u_bend_points(radius, length, num_points)

# Create beams
create_cir_beams_from_points([points])

Let us create an L-Shape pipe now:

def generate_l_bend_points(radius, length, num_points):
    points = []
    # Straight section before the bend
    points.append([0, 0, 0])
    points.append([0, length, 0])

    # Quarter-circular bend (90 degrees)
    for i in range(num_points + 1):
        angle = (math.pi / 2) * i / num_points
        x = radius * (1 - math.cos(angle))
        y = length + radius * math.sin(angle)
        points.append([x, y, 0])
    # Straight section after the bend
    points.append([radius, length + radius, 0])
    points.append([radius + length, length + radius, 0])
    return points

# Inputs
radius = 1.0
length = 2.0
num_points = 10
points = generate_l_bend_points(radius, length, num_points)

#create beams
create_cir_beams_from_points([points])

let us look at how you can create a single helical strand or coil:

def generate_helix_points(radius, pitch, turns, num_points):
    points = []
    total_points = num_points * turns
    for i in range(total_points):
        t = i * (2 * math.pi / num_points)
        x = radius * math.cos(t)
        y = radius * math.sin(t)
        z = (pitch / (2 * math.pi)) * t
        points.append((x, y, z))
    return points

# Inputs
radius = 5
pitch = 2
turns = 10
num_points = 100

# Generate points for the helix
helix_points = generate_helix_points(radius, pitch, turns, num_points)

#Create beams
create_cir_beams_from_points([helix_points])

now let us look at an example of how you can create multiple helix , typically used in braded hoses or wires.
You can create multiple layers of this helix for multi layered helical structures

def generate_multiple_helix_points(radius, pitch, length, num_points, num_strands):
    helix_points_list = []
    angle_increment = 2 * math.pi / num_strands
    z_increment = length / num_points
    for strand in range(num_strands):
        points = []
        start_angle = strand * angle_increment

        for i in range(num_points):
            t = i * (2 * math.pi / num_points)
            x = radius * math.cos(t + start_angle)
            y = radius * math.sin(t + start_angle)
            z = i * z_increment
            points.append((x, y, z))
        helix_points_list.append(points)
    return helix_points_list
#Inputs
radius = 5
pitch = 20
length = 100
num_points = 100
num_strands = 50

# Generate points for helix
multiple_helix_points = generate_multiple_helix_points(radius, pitch, length, num_points, num_strands)

#create beams
create_cir_beams_from_points(multiple_helix_points)