#005 - The Power of Python Classes in Structural/Civil Engineering Design

Streamline Your Structural Engineering Calculations with Python Classes

Python, the versatile programming language, has become an essential tool in the engineer's toolbox. Especially in structural and civil engineering design, Python's simplicity and power can revolutionize workflows. One of Python's most powerful features is the concept of classes, which enables engineers to model real-world entities with great precision and efficiency.

Prerequisites to Classes

There are a few prerequisites to understanding how a Python class works. If you have a general grasp on the following Python topics, then you are good to go with classes!

1. Variables and Data Types: Know how to work with basic data types such as integers, floats, strings, and booleans, as well as complex data types like lists, tuples, sets, and dictionaries.

2. Control Flow: Understand how to control the execution of code using conditional statements (if, elif, else) and loops (for, while).

3. Functions: Be familiar with defining and calling functions, understanding parameters and return values, and the scope of variables.

4. Modules: Learn how to import and use modules, which are files containing Python definitions and statements intended for use in other Python programs.

5. File I/O: Know how to perform file operations to read from and write to files.

6. Python Standard Library: Have an awareness of the rich set of modules and functionalities available in the Python Standard Library.

7. Basic Scripting: Experience with writing basic Python scripts to perform tasks and automate processes.

Whether you're beginning to explore these concepts or are already familiar, the engineering examples provided below will offer practical insights into their application.

Fundamentals of Python Classes

A class in Python serves as a template for creating objects. Objects are instances of classes that embody attributes and methods, two fundamental aspects of a class.

• Attributes: These are variables that belong to a class. Attributes are used to store the state or data of an object created from a class, representing characteristics of the object. For example, in a Car class, attributes might include color, make, model, and year.

• Methods: These are functions defined within a class that describe the behaviours or actions that an object created from the class can perform. Methods operate on the attributes of the objects and can modify the object's state. Continuing the Car example, methods might include start_engine(), stop_engine(), drive(), and brake().

Attributes encapsulate data relevant to an object, while methods interact with this data to express the functionality and operations an object can perform.

This will make a little more sense when we look at an example.

class Material:
    def __init__(self, name, elasticity_modulus):
        self.name = name
        self.elasticity_modulus = elasticity_modulus

    def display_properties(self):
        print(f"Material: {self.name}")
        print(f"Elastic Modulus: {self.elasticity_modulus} Pa")

In this snippet, Material is a class that represents a structural material such as concrete, steel or timber, with two attributes: name and elasticity_modulus.

The __init__ method is a special method called a constructor, which is automatically called when a new instance of Material is created. It initializes the attributes with values that are passed in when the Material object is instantiated. The __init__ method can be thought of as the setup process for a new object, much like setting up a new piece of machinery or equipment with initial settings before it is ready to perform its intended tasks. It ensures that the object starts with all the necessary properties correctly assigned for it to operate as expected.

The display_properties method is a regular method that simply prints out the material's properties. This method can access the instance's attributes through self. The self parameter in a Python class is a reference to the current instance of the class. It is used to access variables that belong to the class. When you create a new instance of a class, self allows the methods of the class to interact with the attributes of that specific instance.

OK, so now what?

Now that we’ve reviewed the architecture of a class, let’s see it in action.

Creating an object (an instance of a Material class) might look like this:

# Creating an instance of Material with name "Steel" and an elasticity modulus of 200e9 Pascal
steel_material = Material("Steel", 200e9) # Pa

# Calling the method to display its properties
steel_material.display_properties()

Here, steel_material is an object of the Material class, instantiated with "Steel" as its name and 200e9 (representing 200 GPa) as its elasticity_modulus. When display_properties is called on this object, it will print out "Steel" and "200e9 Pa" to the console.

Using classes in Python, especially for engineering applications, allows for the modeling of complex entities with their properties and behaviors, leading to code that is more organized, modular, and easier to understand and maintain.

Application of Python Classes in Engineering

Classes come to life in engineering by encapsulating the characteristics of structures. A Beam class, for example, can include attributes like length, modulus_of_elasticity, and moment_of_inertia, while methods can calculate reactions or internal forces:

class Beam:
    def __init__(self, length, e_modulus, i_moment):
        self.length = length
        self.e_modulus = e_modulus
        self.i_moment = i_moment

    def calculate_deflection(self, force, position):
        """
        Calculation for deflection at the point of load.
        Formula: Pb(3L^2 - 4b^2) / (48 * EI) where:
        P = applied force,
        b = position of the force from the nearest support,
        L = length of the beam,
        E = modulus of elasticity,
        I = moment of inertia.
        """
        b = position  # position of the load from the nearest support
        L = self.length
        E = self.e_modulus
        I = self.i_moment
        return (force * b * (3 * L**2 - 4 * b**2)) / (48 * E * I)

The provided Python class Beam represents a physical structural element in an engineering design. This class contains:

1. An __init__ method initializes the properties of the Beam object when it is created. Here, it sets up three attributes:

   • length: The length of the beam.

   • e_modulus: The modulus of elasticity of the beam's material.

   • i_moment: The moment of inertia of the beam's cross-section.

2. A method calculate_deflection, which computes the deflection (displacement) at a specific point on the beam under a given load. This method uses an engineering formula to calculate the deflection based on the position of the applied force and the beam's properties. The formula it uses is “Pb(3L^2 - 4b^2) / (48 * EI)” where:

   • P is the force applied to the beam.

   • b is the distance from the point of force application to the nearest support.

   • L is the total length of the beam.

   • E is the modulus of elasticity.

   • I is the moment of inertia.

The calculate_deflection method applies this formula to the attributes of the Beam instance and returns the calculated deflection value. This result helps us understand how the beam would deflect under specific load conditions.

Benefits of Using Python Classes

The use of classes promotes code reusability and readability. Engineers can create a single Column class and use it for various column instances, altering just the attributes. This approach minimizes errors that can occur when recalculating for different cases manually. It also streamlines how you enter the variables for each column instance. All columns will have similar property categories but individual attributes will vary, such as length, support conditions or cross-sectional properties.

Case Study: A Simple Beam Class

Imagine you're designing a Beam class to compute bending moments and shear forces. This class simplifies repetitive tasks:

class Beam:
    def __init__(self, length, support_conditions):
        self.length = length
        self.support_conditions = support_conditions

    def calculate_moment(self, load):
        # Implement bending moment calculation here
        pass

A structural engineer can instantiate a Beam with specific length and support_conditions, then use calculate_moment method to find the bending moment for a given load.

In future posts we will dig into how we can use conditional variables like support_conditions to flesh this calculation out even further, automatically capturing fixed, pinned, cantilever and other types of beam support conditions.

Advanced Features of Python Classes

The versatility of Python extends into advanced object-oriented programming features that are particularly useful for engineering applications. In forthcoming discussions, we'll delve deeper into the power of Python classes, including:

• Inheritance: Learn how to create subclasses that inherit attributes and methods from a parent class, enabling the modelling of specialized structural elements with greater ease.

• Polymorphism: We'll explore the concept of using a single interface to represent different structural forms, simplifying code management and readability.

• Method Overriding: See how to tailor inherited methods to fit specific engineering calculations, enhancing the functionality of your structural models.

• Interoperability with Engineering Software: An overview of how Python classes can interact with engineering software like FEA programs, opening up a world of possibilities for integrated design solutions.

Learning Path and Resources

To deepen your understanding of Python classes, a structured learning path is invaluable. Online courses and interactive tutorials provide a step-by-step approach to mastering these concepts. Resources such as 'Automate the Boring Stuff with Python' and 'Python Crash Course' are excellent for beginners.

Forums like Stack Overflow and the Python community on GitHub offer ongoing support and insight from experienced developers.

And of course, if you made it this far, you are likely interested in engineering-specific learning tracks, come and visit us at flocode.dev to dive deeper down this rabbit hole and many more.

Conclusion

Embracing Python classes can significantly boost the efficiency and accuracy of your engineering design work. By automating repetitive tasks, reducing the margin for error, and facilitating complex calculations, Python empowers engineers to refine their design process.

The evolution of engineering tools continues to revolutionize our capabilities, and staying abreast of these changes is paramount. Investing time in learning Python is more than skill development—it's an investment in future-proofing your career. So, take the leap and start incorporating Python classes into your workflow; the potential benefits are too substantial to ignore.

Thanks for reading and I’ll see you in the next post!

James 🌊