2D Elasticity: Introduction to FEM

• Topic is an introduction to FEM for 2D Elasticity

2D Elasticity Problems

• Many engineering applications can be simplified to 2D elasticity problems such as thin plates and long cylinders.

Governing Equations

• Equilibrium equations are:
  • ∂σxx/∂x + ∂σxy/∂y + bx = 0
  • ∂σxy/∂x + ∂σyy/∂y + by = 0
• Constitutive equations (Hooke's law):
  • {σxx, σyy, σxy}T = D{εxx, εyy, γxy}T
• Strain-displacement relations:
  • εxx = ∂u/∂x, εyy = ∂v/∂y, γxy = ∂u/∂y + ∂v/∂x

Boundary Conditions

• Essential (Dirichlet) boundary conditions (displacement):
  • u = ū on Γu
  • v = v̄ on Γv
• Natural (Neumann) boundary conditions (traction):
  • σxx nx + σxy ny = t̄x on Γt
  • σxy nx + σyy ny = t̄y on Γt

Plane Stress

• Assumptions: thin body with thickness h where σzz = σxz = σyz = 0
• Constitutive matrix:
  • D = E / (1 - ν^2) * [[1, ν, 0], [ν, 1, 0], [0, 0, (1-ν)/2]]

Plane Strain

• Assumptions: long body with constant cross-section where εzz = εxz = εyz = 0
• Constitutive matrix:
  • D = E / ((1 + ν)(1 - 2ν)) * [[(1-ν), ν, 0], [ν, (1-ν), 0], [0, 0, (1-2ν)/2]]

Finite Element Formulation

• Displacement approximation:
  • u = N d
  • u = {u(x, y), v(x, y)}T, d = {d1, d2, ..., dn}T
• Strain-displacement matrix:
  • ε = B d
  • ε = {εxx, εyy, γxy}T
• Element stiffness matrix:
  • k = ∫V BT D B dV
• Element force vector:
  • f = ∫V NT b dV + ∫Γt NT t̄ dΓ

Example: CST Element

• Topic is about constant Strain Triangle (CST) Element

Constant Strain Triangle (CST) Element

• CST Element is a 3-node triangle element with a linear displacement field

Shape Functions

• Shape Function Formula:
  • Ni = (1 / 2A) * (ai + bi x + ci y) for i = 1, 2, 3
  • a1 = x2y3 - x3y2, b1 = y2 - y3, c1 = x3 - x2
  • a2 = x3y1 - x1y3, b2 = y3 - y1, c2 = x1 - x3
  • a3 = x1y2 - x2y1, b3 = y1 - y2, c3 = x2 - x1
  • A = (1/2) * |[1, x1, y1], [1, x2, y2], [1, x3, y3]|

Displacement Field

• Displacement field formulas:
  • u(x, y) = N1d1 + N2d3 + N3d5
  • v(x, y) = N1d2 + N2d4 + N3d6

Strain-Displacement Matrix

• Strain-Displacement Matrix Formula:
  • B = (1 / 2A) * [[b1, 0, b2, 0, b3, 0], [0, c1, 0, c2, 0, c3], [c1, b1, c2, b2, c3, b3]]

Element Stiffness Matrix

• Element Stiffness Matrix Formula:

  • k = ∫V BT D B dV = hA BT D B

• The topic is lecture 1 and course introduction

Course Goal

• Teaching algorithms, data structures, & problem-solving techniques applicable to real-world problems.
• Students will be able to implement algorithms & data structures quickly.
• Students will be able to understand algorithm design techniques.
• Students can quickly implement solutions to problems.
• Students can determine the correctness and the time complexity of their solution.

Course is Not

• It's not a programming course or a theoretical course.

Prerequisites

• Solid understanding of programming (C++ or Java), discrete mathematics (CS 205).

Textbooks

• Introduction to Algorithms, Third Edition by Cormen, Leiserson, Rivest, and Stein.
• Algorithm Design by Kleinberg and Tardos

Topics

• Course will cover Algorithm Analysis, Divide and Conquer, Sorting and Searching, Graph Algorithms, Greedy Algorithms, Dynamic Programming, String Algorithms, Computational Geometry, and NP-Completeness

Grading

• midterm Exam 30%
• final Exam 40%
• Homework 30%

Homework

• Weekly homework assignments consisting of programming problems & theoretical exercises.
• One week to complete each assignment.
• Late policy: 10% penalty for each day late; no submissions accepted after 3 days.
• All homework assignments must be done individually.

Exams

• One midterm exam and one final exam.
• Closed book and closed notes.
• The exams will cover all material taught in class.

Website

• The course website is located at: www.cs.sunysb.edu/~algorith
• The website contains the syllabus, homework assignments, and the lecture notes.

Academic Honesty

• Strictly enforced; violations result in a failing grade.
• Students are not allowed to copy code from other students or from the Internet.

Algorithm Definition and Properties

• Topic defining algorithms, and the properties they are required to have

Definition

• Well-defined computational procedure transforming input values to output values.

Properties

• Correctness: Halts with the correct output for every input instance.
• Efficiency: Solves the problem within required time bounds.
• Finiteness: Terminates after a finite number of steps.
• Unambiguity: Each step must be precisely defined.
• Generality: Should solve all problems of a particular form.

Sorting Example

• Shows what is required for an algorithm input and output

Input

• a sequence of n numbers

Output

• Reordering n numbers such that values of an array A is less than the value of an array A + 1

Insertion Sort and Implementation

• Gives descriptions of what the implementation looks like through pseudocode and Java and C+

Description

• Simple sorting algorithm where the sorted array is built by inserting elements one by one.

Pseudocode description

1 for j = 2 to A.length 2 key = A[j] 3 // Insert A[j] into the sorted sequence A[1..j-1]. 4 i = j - 1 5 while i > 0 and A[i] > key 6 A[i + 1] = A[i] 7 i = i -1 8 A[i + 1] = key

C++ Implementation

void insertionSort(int arr[], int n) {
    for (int j = 1; j < n; j++) {
        int key = arr[j];
        int i = j - 1;
        while (i >= 0 && arr[i] > key) {
            arr[i + 1] = arr[i];
            i = i - 1;
        }
        arr[i + 1] = key;
    }
}

Java Implementation

void insertionSort(int arr[]) {
    int n = arr.length;
    for (int j = 1; j < n; j++) {
        int key = arr[j];
        int i = j - 1;
        while ((i > -1) && (arr[i] > key)) {
            arr[i + 1] = arr[i];
            i--;
        }
        arr[i + 1] = key;
    }
}

### Algorithm Analysis

### Running time
- Depends on input size.
- Running time is in terms of amount of steps to complete
- Useful to define this independently of machine

### Insertion Sort

- The running time of insertion sort depends on the input.
- The worst case running time of insertion sort is O(n^2).
- The best case running time of insertion sort is O(n).
- The average case running time of insertion sort is O(n^2).

### Input size
- Sorting problem: number of items to be sorted
- Multiply two integers: the total number of bits in the two integers
- Graph problem: the number of vertices and edges

### Running time
- We are usually interested in the worst case running time.
    -   The upper bound on the running time for any input.
    -   Sometimes we are interested in the average case running time.
    -   We almost never interested in the best case running time.

### Growth rate
- We are interested in the growth rate of the running time as the input size increases.
- We use asymptotic notation to describe the growth rate of the running time.

### Asymptotic Notation
-   Θ-notation: Θ(g(n)) = { f(n)$: there exist positive constants c_1, c_2, and n_0 such that 0 ≤ c_1g(n) ≤ f(n) ≤ c_2g(n) for all n ≥ n_0 }
-   O-notation: O(g(n)) = { f(n)$: there exist positive constants c and n_0 such that 0 ≤ f(n) ≤ cg(n) for all n ≥ n_0 }
-   Ω-notation: Ω(g(n)) = { f(n)$: there exist positive constants c and n_0 such that 0 ≤ cg(n) ≤ f(n) for all n ≥ n_0 }

### Example
- n^2 + n = Θ(n^2)
- Because n^2 ≤ n^2 + n ≤ 2n^2 for all n ≥ 1

### Common Running Times
-   O(1) - constant time
-   O(log n) - logarithmic time
-   O(n) - linear time
-   O(n log n) - linearithmic time
-   O(n^2) - quadratic time
-   O(n^3) - cubic time
-   O(2^n) - exponential time
-   O(n!) - factorial time

### ROS Lab Intro
- Focuses on Linux and ROS

### Objectives
-   Familiarize students with basic Linux and ROS commands and creating simple ROS publishers.
-   And subscribers.

### Linux
- ROS runs on Linux, so it’s useful to know some basic Linux commands.
- **pwd**: Print working directory (where you are).
- **ls**: List files in the current directory.
- **ls -l**: List files with details.
- **cd**: Change directory.
- **mkdir**: Create a new directory.
- **gedit**: Open a text editor.
- **cat**: Print the file content in the terminal.
- **rm**: Remove a file.
- **rm -r**: Remove a directory.
- **cp**: Copy a file or directory.

### ROS Basic Concept

-   **Nodes**: Executable that performs a task.
-   **Messages**: ROS data type for node communication.
-   **Topics**: Nodes publish to and subscribe to topics to exchange messages.
-   **Services**: Services offered by nodes that others can call.
-   **Bags**: File format for saving and playing back ROS message data.

### ROS Basic Command

-   Source command:
    -   `source /opt/ros/noetic/setup.bash` (required for each new terminal)
-   Core ROS Commands:
    -   `roscore`: Starts the ROS master.
    -   `rosnode list`: Lists active nodes.
    -   `rosnode info <node_name>`: Provides info about a node.
    -   `rostopic list`: Lists active topics.
    -   `rostopic echo <topic_name>`: Prints topic messages.
    -   `rostopic pub <topic_name> <message_type> "<data>"`: Publishes data to a topic.
    -   `rosservice list`: Lists active services.
    -   `rosservice call <service_name> <arguments>`: Calls a service.
    -   `rosbag record <topic_name>`: Records data from a topic.
    -   `rosbag play <bag_file>`: Plays back data from a bag.

### Creating a Catkin Workspace

-   Create a catkin workspace:
    -   mkdir -p ~/catkin_ws/src AND cd ~/catkin_ws/
    -   catkin_make
    -   source devel/setup.bash
-   Create a package:
    -   cd src AND catkin_create_pkg <package_name> rospy roscpp - `<package_name>` is the name of your package. `rospy` and `roscpp` are dependencies.
-   The structure of the created package consists of:
    -   CMakeLists.txt
    -   package.xml
    -   Src
    -   Include/

### Simple Publisher and Subscriber
- Describes basic publishing and subscribing structure

1.  Create a talker.py (publisher) and listener.py (subscriber) within the src directory of your package.
2.  Make the python scripts executables using the command chmod +x <file_name>.py
3.  Modify CMakeLists.txt
    -   Add executables: add_executable(talker src/talker.py) and add_executable(listener src/listener.py)
    -   Link target libraries: target_link_libraries(talker ${catkin_LIBRARIES}) and target_link_libraries(listener ${catkin_LIBRARIES})
4.  Build the package: use the command catkin_make and source devel/setup.bash
5.  Running the Nodes requires opening 3 terminals
    -   roscore
    -   rosrun <package_name> talker.py
    -   rosrun <package_name> listener.py

### Lab Tasks

1.  Create a new ROS package called “lab1”.
2.  Create a publisher node that publishes your name to a topic called “name”.
3.  Create a subscriber node that subscribes to the “name” topic and prints the received name.

### Bonus Task
- Create a service that takes two numbers as input and returns their sum.
- Create a client node that calls the service with two numbers and prints the result.

This lesson introduces the finite element method (FEM) for solving 2D elasticity problems. It covers governing equations, boundary conditions, plane stress, and plane strain assumptions. Learn about equilibrium, constitutive relations, and strain-displacement relationships.