Skip to content

Reinforcement shape definition

In ALLPLAN Python API, a reinforcement shape is represented by the BendingShape object. This object has to be defined in the first place, in order to define a placement.

Polygonal and point shape

By choosing the right constructor method, a bending shape can be defined as:

  • polygonal shape, to represent rebars arranged transversely to the placement line like e.g., the black stirrup on the image to the right
  • point shape, to represent longitudinal bars arranged parallel to the placement line like e.g., the blue corner bars on the image to the right

Info

Bar and mesh bending shape

BendingShape can represent a rebar, as well as mesh bending shape, by choosing the right constructor method.

Tip

Constructing the BendingShape using its built-in __init()__ methods can be challenging, as it requires determining the axis of the rebar by taking into account its diameter and concrete cover. Therefore, we recommend using helper classes, listed below, to simplify the definition.

To construct a bending shape, you can choose between following helpers:

  • Helper modules of the StdReinfShapeBuilder module (e.g. GeneralReinfShapeBuilder). These modules contains functions for simplified creation of the most common bending shapes. They have limited functionalities, but are easier to implement.
  • ReinforcementShapeBuilder class which offers methods to build the bending shape based of any form. Its usage is more complex, but also offers more flexibility.

Model angles

Rotation util angles

In this article we will be often talking about model angles defined with a RotationUtil object in the context of rotating a shape. This is an object containing three angles describing the rotation of the bending shape around each of the axes: X, Y and Z. These angles and their positive orientation are shown on the image to the right.

Usually, we define bending shapes in a local coordinate system. Since they are mostly flat, usually in the XY plane. However, before placing them, it is necessary to rotate the shape into the correct position.

Example

In the simple example below, the stirrup is defined in a local coordinate system in XY plane (left). It must be placed in a beam in the global YZ plane (right). Therefore, the shape must be rotated around the X axis by +90° and around the Z axis by -90°

Local to global example

The model angles must be then defined as follows:

model_angles = RotationUtil(90, 0,-90)

Standard shape builder

The standard reinforcement shape builder is a collection of modules, containing helper functions to create a BendingShape. Here is a short overview of the modules and for which use-case they suit best.

Helper module Use-case Example
GeneralReinfShapeBuilder For shapes of general usage, like straight bar with hooks or rectangular stirrups General bar shapes
CorbelReinfShapeBuilder For 3d bended rebar in the column corbel Corbel shape
IProfileReinfShapeBuilder For stirrups in I-section beams I profile shapes
ProfileReinfShapeBuilder For stirrups in elements with cross-section in the shape of any polygon
StairsReinfShapeBuilder For longitudinal bars in a stair flights
DoubleTeeBeamReinfShapeBuilder For reinforcement of double-T decks

The UML chart below shows the relationships between relevant classes when using the GeneralReinfShapeBuilder. Follow the graph from bottom to top and construct the objects in your script to get the BendingShape at the end. The GeneralReinfShapeBuilder module is shown on the graph as an example. Nevertheless, other modules from the table above will follow the same principle.

classDiagram 
direction BT

class BendingShape{
    int Diameter
    int steelGrade
    BendingShapeType bendingShapeType
    float hookLengthStart
    float hookAngleStart
    HookType hookTypeStart
    float hookLengthEnd
    float hookAngleEnd
    HookType hookTypeEnd
    VecDoubleList BendingRoller
    Polyline3D ShapePolyline
}

class GeneralReinfShapeBuilder{
    <<Module>>
    create_longitudinal_shape_with_hooks()
    create_l_shape_with_hooks()
    create_stirrup()
    create_u_link()
}

class ReinforcementShapeProperties{
    float diameter
    float bending_roller
    int steel_grade
    int concrete_grade
    BendingShapeType bending_shape_type

    rebar()
}

class ConcreteCoverProperties{
    float left
    float right
    float top
    float bottom
}

class RotationUtil{
    float angle_x
    float angle_y
    float angle_z
}

class BendingShapeType{
    <<Enumeration>>
    ColumnStirrup
    LongitudinalBar
    OpenStirrup
    Stirrup
    ...
}

GeneralReinfShapeBuilder --> BendingShape : creates
ConcreteCoverProperties --> GeneralReinfShapeBuilder : requires
RotationUtil --> GeneralReinfShapeBuilder : requires
ReinforcementShapeProperties --> GeneralReinfShapeBuilder : requires
BendingShapeType "1" --o ReinforcementShapeProperties

Example

Example stirrup shape

Let's construct a stirrup shape as shown on the image to the right. According to the graph above, first we need the BendingShapeType:

bending_shape_type = AllplanReinforcement.BendingShapeType.Stirrup

Now we can define the ReinforcementShapeProperties

shape_properties = ReinforcementShapeProperties.rebar(
    diameter           = 8, #(1)!
    bending_roller     = 4, #(2)!
    steel_grade        = -1, #(3)!
    concrete_grade     = -1, #(4)!
    bending_shape_type = bending_shape_type)
  1. The stirrup will be 8 mm in diameter
  2. The bending roller diameter is defined as 4 * rebar diameter for all bending points.
  3. We use the steel grade from the current ALLPLAN settings
  4. We use the concrete grade from the current ALLPLAN settings

The next element is the ConcreteCoverProperties:

concrete_covers = ConcreteCoverProperties(left   = 25,
                                          bottom = 25,
                                          right  = 25,
                                          top    = 25) #(1)!
  1. We weep it simple and define all the covers as 25 mm. We could also use shorter notation: ConcreteCoverProperties.all(25)

Now we have all objects required to define the shape:

shape = GeneralReinfShapeBuilder.create_stirrup(
    length               = 300, #(1)!
    width                = 500,
    model_angles         = RotationUtil(0, 0, 0), #(2)!
    shape_props          = shape_properties,
    concrete_cover_props = concrete_covers,
    stirrup_type         = AllplanReinforcement.Column, #(3)!
    hook_length          = 0)   #(4)!
  1. This is the x-dimension of the concrete cross-section. Not the length of the stirrup itself! Concrete covers will be subtracted.
  2. For the purposes of this example, we set all the angles to 0°. This will create the stirrup shape in the XY plane. Refer to this paragraph to learn how to rotate the shape for your use-case.
  3. This argument is optional. We want the hooks to be bend with 135°, that is why we define it. If it would be skipped, the hooks will be 90°.
  4. This argument is optional. 0 is the default value and means that the hook's length will be calculated automatically based on the current norm.

The created shape can be then used to create placement. Refer to this article to learn, how to do it.

To see, what kind of other shapes are possible with GeneralReinfShapeBuilder refer to the example GeneralShapeBuilder. It shows the implementation of all functions offered by the module and is located in:

  • ...\Etc\Examples\PythonParts\ReinforcementExamples\BarShapes\GeneralShapeBuilder.pyp
  • ...\Etc\PythonPartsExampleScripts\ReinforcementExamples\BarShapes\GeneralShapeBuilder.py

Tip

Bending roller pin

The bending roller can, depending on the national standards, depend on multiple factors like rebar diameter, steel grade, etc. ALLPLAN Python API already offers the BendingRollerService class that can calculate the bending roller based on the currently selected norm. It takes all relevant factors into account.

Reinforcement shape builder

The bending shape can be also created using the helper class ReinforcementShapeBuilder. Use this class especially, when your bending shape is unusual and cannot be created using modules of the StdReinfShapeBuilder.

The UML chart below shows the relationships between the relevant classes when using the ReinforcementShapeBuilder. Follow it from bottom to top and construct the objects in your script to get the BendingShape at the end.

Note

The two data structures, that describes the geometry of a shape:

Can be used alternatively. Decide, which one is more convenient to use in your case and stick to it.

classDiagram 
direction BT

class BendingShape{
    int Diameter
    int steelGrade
    BendingShapeType bendingShapeType
    float hookLengthStart
    float hookAngleStart
    HookType hookTypeStart
    float hookLengthEnd
    float hookAngleEnd
    HookType hookTypeEnd
    VecDoubleList BendingRoller
    Polyline3D ShapePolyline

    rotate(RotationUtil)
}

class RotationUtil{
    float angle_x
    float angle_y
    float angle_z
}

class ReinforcementShapeBuilder {
    AddSides(BarShapeSideDataList)
    AddPoints(BarShapePointDataList)
    SetHookStart(length,angle,HookType)
    SetHookEnd(length,angle,HookType)
    CreateShape(ShapeProps)
    CreateStirrup(ShapeProps,StirrupType)
}

class ReinforcementShapeProperties{
    float diameter
    float bending_roller
    int steel_grade
    int concrete_grade
    BendingShapeType bending_shape_type

    rebar()
}

class BarShapeSideDataList{
    <<DataClass>>
}

class BarShapePointDataList{
    <<DataClass>>
}

class BendingShapeType{
    <<Enumeration>>
    ColumnStirrup
    LongitudinalBar
    OpenStirrup
    Stirrup
    ...
}

class HookType{
    <<Enumeration>>
    eAnchorage
    eAngle
    eStirrup
}

class StirrupType{
    <<Enumeration>>
    Normal
    Column
    Torsion
    ...
}

RotationUtil <.. BendingShape : uses
ReinforcementShapeBuilder ..> BendingShape : creates
ReinforcementShapeProperties --> ReinforcementShapeBuilder : requires
BarShapeSideDataList "*" --o ReinforcementShapeBuilder
BarShapePointDataList "*" --o ReinforcementShapeBuilder
HookType ..> ReinforcementShapeBuilder
StirrupType ..> ReinforcementShapeBuilder
BendingShapeType --> ReinforcementShapeProperties : requires

Free form rebar

Before creating a rebar shape using ReinforcementShapeBuilder the geometry of the shape must be defined using one of the following objects:

Info

This paragraph is about two-dimensional bar shapes. Therefore, whenever we are talking about points or lines, we mean the Point2D or Line2D respectively. To learn about 3D reinforcement shapes, scroll down to this paragraph

Bar shape points

Using BarShapePointDataList, we can define the rebar shape by defining the vertices of the concrete cross-section polygon. To define a shape like the one shown on the right, we have to define a list with 7 elements in total: 5 points and 2 concrete covers:

shape_data = BarShapePointDataList([30, #(1)!
                                    (pnt_0, 30),
                                    (pnt_1, 30),   #(2)!
                                    (pnt_2, 30, 4),#(3)!
                                    (pnt_3, 30),
                                    (pnt_4, 30),
                                    30])

  1. The first element of the list should be the concrete cover at the start of a rebar. If we skip it, it will be set to 0.

    Concrete cover at start

  2. Further elements are two-elements tuples with the first element being the vertex of the shape's reference polyline, and the second the concrete cover.

  3. We can optionally provide third element to the tuple being the bending roller factor.

Having the list with points, we can now append it to the shape:

shape_builder = AllplanReinforcement.ReinforcementShapeBuilder()

shape_builder.AddPoints(shape_data)

Bar shape sides

Using BarShapeSideDataList we can define the rebar shape by defining the vertices of the concrete cross-section polygon. To define a shape like the one shown on the right, we have to define a list with 6 elements in total: 4 sides and 2 concrete covers:

shape_data = BarShapeSideDataList([30, #(1)!
                                   (line_0, 30), #(2)!
                                   (line_1_start,line_1_end, 30), #(3)!
                                   (line_2, 30, 4), #(4)!
                                   (line_3, 30),
                                    30]) #(5)!

  1. The first element of the list should be the concrete cover at the start of a rebar. If we skip it, it will be set to 0.

    Concrete cover at start

  2. Further elements are two-element tuples with the first element being the side (Line2D) of the shape's reference polyline, and the second the concrete cover to this side.

  3. Alternatively, instead of Line2D we can provide the side's start and end point as Point2D.
  4. Optionally, we can provide third element to the tuple being the bending roller factor.

  5. The last element is the concrete cover at the end. Just as the cover at start, we can skip it.

    Concrete cover at end

Note

Note, that in the given example, the end point of the first line and the start point of the second one do not have to coincide. This is because they don't have to. The created shape will still be a continuous rebar.

Having the list with sides, we can now append it to the shape:

shape_builder = AllplanReinforcement.ReinforcementShapeBuilder()

shape_builder.AddSides(shape_data)

Hook

Hook at start

To add a hook at the beginning and/or end of the rebar shape, we can use the methods SetHookStart or SetHookEnd.

Note

Hook in ALLPLAN is treated like a special rebar leg. It can be modified only with dedicated menu functions.

shape_builder.SetHookStart(length = 0,  #(1)!
                           angle  = 90,
                           type   = AllplanReinforcement.HookType.Anchorage)  #(2)!
  1. Setting the length to 0 will calculate the hook's length based on the norm selected in the ALLPLAN settings
  2. Setting the right HookType is particularly relevant, when the hook's length should be calculated automatically, as different rules may apply for e.g., anchorage hooks and hooks in column stirrups.

Anchorage

Anchorage at end

To anchor the bar beyond the last and/or first shape point, use the SetAnchorageEnd or SetAnchorageStart method. This methods will extend the last or first segment of the rebar beyond by the specified length, ensuring its anchorage.

shape_builder.SetAnchorageLengthEnd(500)

Tip

The calculation of the anchorage length will not be done automatically by setting the length to 0, as it is the case with hooks. However, you can use the AnchorageLengthService helper class to determine the length based on the current norm and relevant parameters, such as concrete grade or \(\frac{A_{s,req}}{A_{s,prov}}\) factor

Set length of leg

Set length at end

Using the SetSideLengthStart or SetSideLengthEnd methods will change the length of the first or last leg of the rebar to the pre-defined one. This might be particularly useful, if the first or last leg of the rebar is used solely for anchorage. The last or first point of the bending shape will then only determine the direction of the leg.

shape_builder.SetSideLengthStart(500)

After defining the shape points or sides, hooks, anchorage, etc. we are ready to create the shape:

shape = shape_builder.CreateShape(shape_properties)  #(1)!
  1. shape_properties is the ReinforcementShapeProperties object. We created it in the example in the chapter above.

Example on GitHub

To try out the possibilities of the ReinforcementShapeBuilder shown in this article, by running the example FreeFormReinforcementShapeBuilder ( PYP | PY)

Closed stirrup

To create a closed stirrup, we can use the method CreateStirrup provided by the ReinforcementShapeBuilder. It requires an additional parameter of StirrupType that defines, how the points are going to be interpreted. In the overview below shows, what kind of stirrup can be achieved with each type.

Stirrup types

Example

Example stirrup shape

Let's construct a closed stirrup, as shown on the image to the right, using the ReinforcementShapeBuilder. First, we need to define the ReinforcementShapeProperties:

shape_properties = ReinforcementShapeProperties.rebar(
    diameter           = 8,
    bending_roller     = 4,
    steel_grade        = -1,
    concrete_grade     = -1,
    bending_shape_type = AllplanReinforcement.BendingShapeType.Stirrup) #(1)!
  1. This argument does not influence the geometry of the shape, but carries the information for ALLPLAN, how to draw the rebar scheme in the bending schedule! See possible options in the API reference

In this example we will define the shape using the BarShapePointDataList object.

which will consist of pairs: point and concrete cover, that should apply to the leg between the given point and the previous one. The list will look like this:

shape_data = BarShapePointDataList(
    [(AllplanGeo.Point2D(300, 500),  0), #(1)!
     (AllplanGeo.Point2D(  0, 500), 25),
     (AllplanGeo.Point2D(  0,   0), 25), 
     (AllplanGeo.Point2D(300,   0), 25), #(2)!
     (AllplanGeo.Point2D(300, 500), 25), #(3)!
     ])
  1. We begin with the shape definition there, where the stirrup hooks should be located: in the top right corner. The concrete cover for the first point is irrelevant, as there is no previous point to refer to, so we can provide any value.
  2. Any point can be also defined with extra value overwriting the bending roller factor, like this: (AllplanGeo.Point2D(300, 0), 25, 10). This would result in this particular leg being bent with a bending roller diameter of 10 * rebar diameter, instead of the standard value of 4, defined in the shape_properties.

  3. If the concrete cover is positive, we have to define the points anticlockwise to get the shape inside the polygon.

    To create a closed stirrup, the last point do not have to be equal to the first one! Relevant here is the number of points:

    • less than 3 will not create a valid shape
    • 3 points will create an open stirrup
    • 4 or more will create a closed stirrup

To have the hooks bent in 135°, we have to define the stirrup type as AllplanReinforcement.StirrupType.Column. Knowing that, we are ready to create the bending shape:

shape_builder = AllplanReinforcement.ReinforcementShapeBuilder() #(1)!

shape_builder.AddPoints(shape_data) #(2)!

shape = shape_builder.CreateStirrup(shape_properties, #(3)!
                                    AllplanReinforcement.StirrupType.Column)
  1. The ReinforcementShapeBuilder helper class needs to be instantiated first
  2. We append the shape points defined as BarShapePointDataList using the AddPoints method.
  3. At the end, we create the stirrup shape using the CreateStirrup method

Example on GitHub

To see the entire implementation, refer to the example StirrupReinforcementShapeBuilder ( PYP | PY).

3D bar shape

3D bar shape

The definition of a 3D rebar shape, like shown on the image to the left, can be done in two ways:

Info

In in the code snippets below we will use the BarShapeSideDataList data class. However, the same principles can be applied when using the BarShapePointDataList

Corbel bar with 2D points

To construct a 3D shape using 2D points we have to assume some local coordinate system. In our example, its origin is at the bottom of the column, and the local Y-axis goes upwards along the column's axis.

We will define the sides by their start and end points. You can see them marked blue on the image on the left. The corbel rebar has 5 legs, so we need to define 5 sides. They are represented with red dashed lines and numbers with the orientation.

shape_data = BarShapeSideDataList(
    [(pnt1, pnt2, -cover, bending_roller),
     (pnt3, pnt4, -cover, bending_roller),
     (pnt4, pnt4,  cover + diameter, bending_roller, z_coord), #(1)!
     (pnt4, pnt3,  cover, bending_roller, z_coord),
     (pnt2, pnt1,  cover, bending_roller, z_coord),
     ])
  1. You can't see the third side on the image, because it goes downwards along the local Z-axis, as the z_coord is defined as -thickness + 2 * cover, so it's negative.

With the geometrical shape data defined like this, we can construct the shape:

shape_builder = AllplanReinf.ReinforcementShapeBuilder()

shape_builder.AddSides(shape_data)
shape_builder.SetSideLengthStart(side_length) #(1)!
shape_builder.SetSideLengthEnd(side_length)

shape = shape_builder.CreateShape(shape_props)

shape.Rotate(RotationUtil(90, 0, 0), AllplanGeo.Point3D())  #(2)!

  1. Here we are setting the length of the first and last leg. Corbel bar start and end leg

  2. We created the shape in a local coordinate system, where the Y-axis were parallel to the column's height. In the global system, the Z-axis is parallel to the column. We have to rotate the shape by 90° around the X-axis Local to global transformation

Tip

Instead of transforming the generated shape from the local to global coordinate system with shape.Rotate(...) method, we could have instantiated the ReinforcementBuilder with a transformation matrix, like this:

trans_mat = RotationUtil(-90, 0, 0).get_rotation_matrix()
shape_builder = AllplanReinf.ReinforcementShapeBuilder(trans_mat)

Note, that in this case the trans_mat should describe the opposite: transformation from global to local coordinate system! You can learn, how to construct a transformation matrix in this article

Corbel bar with 3D points

We can construct a 3D rebar shape using 3D points. In this case, the point coordinates will be given in the global coordinate system. Here is how we define the five legs of the 3D rebar using points as shown on the image to the left:

shape_data = BarShapeSideDataList(
    [(pnt1, pnt2, cover, bending_roller),
     (pnt2, pnt3, cover, bending_roller),
     (pnt3, pnt4, cover, bending_roller),
     (pnt4, pnt5, cover, bending_roller),
     (pnt5, pnt6, cover, bending_roller),
    ])

Corbel bar with 3D points local coordinate system

However, for the definition of the concrete covers, we have to assume a local coordinate system. The XY plane of this coordinate system will be used as offset plane for the concrete_cover defined above in the shape_data. In addition to that, we will define two concrete covers: at the front and at the back. These are the covers in the local Z-direction. In our case, the local Z axis will be the same as the global Y axis, as shown on the image to the right.

Knowing that, we can construct the ReinforcementShapeBuilder like this:

trans_mat = RotationUtil(90, 0, 0).get_rotation_matrix() #(1)!

shape_builder = AllplanReinf.ReinforcementShapeBuilder(
    shapePlaneMatrix = trans_mat,
    create3DShape    = True,
    localZCoverFront = cover, #(2)!
    localZCoverBack  = cover + diameter)

shape_builder.AddSides(shape_data)
shape_builder.SetSideLengthStart(side_length) #(3)!
shape_builder.SetSideLengthEnd(side_length)

shape = shape_builder.CreateShape(shape_props)
  1. The trans_mat describes the transformation from local to global coordinate system with a rotation by 90° around the global X axis.

  2. The concrete covers at the front and at the back are measured along the local Z axis. Here is a view from the top:

    Concrete cover at the front and at the back

  3. Here we are setting the length of the first and last leg.

    Corbel bar start and end leg

Example on GitHub

Both implementations explained above are shown in the example CorbelBar3D ( PYP | PY).

Point shape

A BendingShape can be defined as point shape. This type of shape is particularly useful in combination with certain types of placements, such as extrusion or sweeping, in order to create longitudinal bars. Such bending shape is constructed using a Point3D and a diameter, like this:

shape = AllplanReinf.BendingShape(shapePoint    = AllplanGeo.Point3D(100, 200, 300),
                                  diameter      = 10,
                                  steelGrade    = -1,
                                  concreteGrade = -1)
Placeholder