Questions and discussion for this lecture live here. Fire away by hitting Reply below
Hey Sean, i’m struggeling to understand the indeces step (11’ in the video) i think my issue that i’m not visualizing what we are trying to do and I’m tripping on why we are accessing 0,1 by 0 , 2 not by 1,2 in python. i’m also not getting the arrangment for kp[ia:ib+1, ia:ib+1] = kp[ia:ib+1, ia:ib+1] +k11 on the logic of the arrangement i think this also goes back that i’m not able to visualise it
may you please help me
Hey @MarioSamaan - the good news is that once you’ve fully understood this, you’ve basically unlocked the core idea behind the direct stiffness method!
So there’s two parts to understanding what we’re doing here when we programmatically build the primary stiffness matrix:
- You need to review lecture 21 where I explain how the element stiffness matrices are ‘plugged into’ the primary stiffness matrix for the structure.
- Once you’ve understood that - it’s just a matter of understanding how we perform this exact same process in Python. This boils down to understanding how indexing works in Numpy/Python.
What catches most people out with Python indexing is:
- indexing starts at 0 (not 1)
- to index a range of values we need to include ‘one past’ the location we want.
So, for example, if I have an array of 5 numbers
array = [1,3,7,4,9] #Some array of five numbers
Now, say I want to select the first 3 elements as a subset, I would index as follows:
This selects elements 0,1,2.
Once you understand this concept, you can start to index into a 2D array (like we do in the lecture). If we want to select a subsection of a 2D array (rather than a 1D array in the example above), we index into the rows and columns - think about it as selecting the relevant rows and relevant columns for your selection - in doing so, you’re extracting all of the elements at the intersection of the rows and columns. It may help you to draw this on a sheet of paper.
Let me know if this hasn’t helped and you’re still confused - we’ll tease it out a little more.
Thank you for clarifying the Python indexing. I revisited Lecture 20, which enhanced my grasp of the Primary stiffness matrix assembly process. However, I’m still encountering difficulty understanding how we’re identifying the rows and columns of
kp in the expression: ```
kp[ia:ib+1, ia:ib+1] = kp[ia:ib+1, ia:ib+1] + k11
also in the above example you sat [0:3] should yield 0,1,2 this refer to the sequence and this hould yield 1,3,7 if i understand you correctly
Think of the process like a breadcrumb trail, i.e. one piece of info leads us to the next, and then the next, so…
addElement function we take in the node numbers for the element, i.e. the node numbers at each end of the element,
We use these to identify the horizontal and vertical degrees of freedom at each node:
ia = 2*node_i - 2 #index of horizontal DoF at node_i ib = 2*node_i - 1 #index of vertical DoF at node_i ja = 2*node_j - 2 #index of horizontal DoF at node_j jb = 2*node_j - 1 #index of vertical DoF at node_j
Note that I’m calculating the index of each degree of freedom, so DoF 1 and 2 would occupy indices (or locations) 0 and 1 in a python array/matrix…remember indexing starts at 0 in Python.
So, by calculating
jb, I’m actually calculating the location or address within the primary stiffness matrix of the degrees of freedom for the member in question.
The best way to really get this clear in your mind is to write the code for
addElement function out on paper, but put numbers in for
node_j. Then just follow the logic and it should all become alot clearer - especially when you layer it on top of revisiting lecture 20.
thanks it is clear now i had to write the full matrix down to get it i think it was not clear to me that we are identifying arrays within the matrix and once we arrive to the right array using we run our function and assemble it.