WEBVTT

1
00:00:00.000 --> 00:00:03.399
<v Speaker 1>All right, let's kick off this deep dive. Today. We're

2
00:00:03.439 --> 00:00:07.240
<v Speaker 1>diving headfirst into a challenge that's probably well, pretty familiar

3
00:00:07.280 --> 00:00:10.839
<v Speaker 1>if you're an engineer. The sheer volume of calculations, right,

4
00:00:11.000 --> 00:00:14.359
<v Speaker 1>the endless streams of data, and sometimes just feeling like

5
00:00:14.800 --> 00:00:17.519
<v Speaker 1>the tools you've always used, maybe spreadsheets, they kind of

6
00:00:17.559 --> 00:00:18.079
<v Speaker 1>hit a wall.

7
00:00:18.559 --> 00:00:22.039
<v Speaker 2>They absolutely do, especially when problems get really complex, or

8
00:00:22.320 --> 00:00:25.600
<v Speaker 2>you know, you find yourself doing the same tedious thing over.

9
00:00:25.480 --> 00:00:26.039
<v Speaker 3>And over again.

10
00:00:26.160 --> 00:00:28.640
<v Speaker 1>Yeah, exactly. Every engineer is looking for that edge. You

11
00:00:28.679 --> 00:00:33.320
<v Speaker 1>want more speed, more flexibility, and just rock solid accuracy

12
00:00:33.359 --> 00:00:34.200
<v Speaker 1>in your work.

13
00:00:34.039 --> 00:00:37.759
<v Speaker 2>And that's really where programming starts to look very appealing.

14
00:00:37.799 --> 00:00:40.039
<v Speaker 2>It offers a different way to tackle those challenges.

15
00:00:40.200 --> 00:00:43.439
<v Speaker 1>And specifically today we're doing a deep dive into Python.

16
00:00:44.039 --> 00:00:46.399
<v Speaker 1>You've probably heard the name. It's a programming language that's

17
00:00:46.560 --> 00:00:47.799
<v Speaker 1>just incredibly versatile.

18
00:00:47.880 --> 00:00:49.439
<v Speaker 3>Yeah, it's popping up everywhere, and.

19
00:00:49.399 --> 00:00:54.359
<v Speaker 1>It's rapidly becoming well, almost indispensable in civil and structural engineering.

20
00:00:54.920 --> 00:00:57.560
<v Speaker 1>We've been digging into a guide that's literally written for

21
00:00:57.840 --> 00:00:59.520
<v Speaker 1>engineers wanting to jump into this.

22
00:00:59.479 --> 00:01:02.200
<v Speaker 2>World, right, and our goal here in this deep dive

23
00:01:02.280 --> 00:01:04.439
<v Speaker 2>is to take that source material and really pull out

24
00:01:04.439 --> 00:01:07.680
<v Speaker 2>the core concepts. We want to show you how Python,

25
00:01:08.200 --> 00:01:12.000
<v Speaker 2>especially when you pair it with some really powerful specialized libraries,

26
00:01:12.400 --> 00:01:16.120
<v Speaker 2>can just fundamentally change how you work. So streamlining workflows,

27
00:01:16.159 --> 00:01:20.040
<v Speaker 2>streamlining workflows, tackling problems that may be felt impossible before

28
00:01:20.560 --> 00:01:22.920
<v Speaker 2>automating those tasks that just eat up your time.

29
00:01:23.120 --> 00:01:29.480
<v Speaker 1>Yeah yeah, So why should you our listener care? Because

30
00:01:29.840 --> 00:01:32.640
<v Speaker 1>what we learn diving into this guide, it feels like

31
00:01:32.719 --> 00:01:36.840
<v Speaker 1>it offers a genuine shortcut, a shortcut to what though,

32
00:01:36.959 --> 00:01:39.879
<v Speaker 1>a way to handle those real world engineering problems faster,

33
00:01:40.120 --> 00:01:43.319
<v Speaker 1>more efficiently, and honestly with a level of flexibility that's

34
00:01:43.480 --> 00:01:45.519
<v Speaker 1>just tough to get with the traditional methods alone.

35
00:01:45.640 --> 00:01:46.640
<v Speaker 3>Okay, let's unpack that.

36
00:01:46.680 --> 00:01:48.000
<v Speaker 1>Then where do you even begin?

37
00:01:48.359 --> 00:01:50.120
<v Speaker 2>Well, the guide we look at starts right there with

38
00:01:50.200 --> 00:01:52.879
<v Speaker 2>the motivations the why bother for an engineer to learn

39
00:01:52.920 --> 00:01:55.439
<v Speaker 2>Python right, and one of the big ones is exactly

40
00:01:55.519 --> 00:01:59.000
<v Speaker 2>what you said, moving beyond the limits of spreadsheets, especially

41
00:01:59.040 --> 00:02:02.200
<v Speaker 2>when data gets big or the calculations get intricate, you

42
00:02:02.280 --> 00:02:04.040
<v Speaker 2>need something faster, more adaptable.

43
00:02:04.079 --> 00:02:07.439
<v Speaker 1>So it's not like ditch Excel immediately. It's more like

44
00:02:07.680 --> 00:02:09.639
<v Speaker 1>adding a new powerful.

45
00:02:09.240 --> 00:02:10.560
<v Speaker 3>Tool exactly right.

46
00:02:10.800 --> 00:02:13.919
<v Speaker 2>The source material is pretty clear you can still use

47
00:02:13.960 --> 00:02:16.840
<v Speaker 2>Python in a professional setting, even when you need to

48
00:02:16.879 --> 00:02:20.719
<v Speaker 2>share data in common formats like Excel files. Okay, we'll

49
00:02:20.719 --> 00:02:23.800
<v Speaker 2>see how a library called pandas makes that surprisingly seamless.

50
00:02:23.800 --> 00:02:25.800
<v Speaker 1>Actually, and another motivation.

51
00:02:25.599 --> 00:02:29.879
<v Speaker 2>Learning practical engineering applications. This isn't just abstract coding theory.

52
00:02:29.919 --> 00:02:33.360
<v Speaker 2>It's directly applicable. We're talking about solving the kinds of

53
00:02:33.400 --> 00:02:35.960
<v Speaker 2>structural or civil problems you face day to day.

54
00:02:36.080 --> 00:02:39.840
<v Speaker 1>Yeah, and who wouldn't want to say, automate creating reports,

55
00:02:40.280 --> 00:02:44.280
<v Speaker 1>maybe getting them into professional formats like latex or PDF.

56
00:02:44.080 --> 00:02:48.840
<v Speaker 2>Or generating really sharp publication quality plots straight from your analysis.

57
00:02:48.919 --> 00:02:51.960
<v Speaker 1>Exactly. These are all things Python enables. It's not about

58
00:02:51.960 --> 00:02:53.080
<v Speaker 1>replacing everything, No.

59
00:02:53.400 --> 00:02:53.800
<v Speaker 3>Not at all.

60
00:02:53.879 --> 00:02:57.120
<v Speaker 2>It's about empowering you with this adaptable tool set that

61
00:02:57.240 --> 00:02:59.520
<v Speaker 2>really complements the skills in the software.

62
00:02:59.120 --> 00:02:59.800
<v Speaker 3>You already use.

63
00:03:00.120 --> 00:03:03.319
<v Speaker 1>Okay, so Python it is. But where do you literally start,

64
00:03:03.360 --> 00:03:06.479
<v Speaker 1>like installing it, typing the code? The guide gives us

65
00:03:06.520 --> 00:03:07.479
<v Speaker 1>those first steps.

66
00:03:07.800 --> 00:03:11.240
<v Speaker 2>Yeah, for beginners, the usual recommendation is anaconda. It's a

67
00:03:11.280 --> 00:03:16.039
<v Speaker 2>distribution basically a package okay that bundles Python itself along

68
00:03:16.080 --> 00:03:18.280
<v Speaker 2>with most of the essential libraries you'll need. It just

69
00:03:18.319 --> 00:03:20.280
<v Speaker 2>saves a ton of set up headaches right, gets you

70
00:03:20.319 --> 00:03:23.560
<v Speaker 2>going faster, and the environment for actually writing the code

71
00:03:23.919 --> 00:03:27.680
<v Speaker 2>that material mention Jupiter notebooks. Jupiter notebooks are fantastic, especially

72
00:03:27.680 --> 00:03:29.599
<v Speaker 2>for this kind of work. They let you mix things up.

73
00:03:29.680 --> 00:03:32.240
<v Speaker 2>How So you have code cells where you write and

74
00:03:32.319 --> 00:03:35.800
<v Speaker 2>run your Python code, right, Yeah, but you also have markdown.

75
00:03:35.319 --> 00:03:39.039
<v Speaker 1>Cells ah for text and explanations.

76
00:03:38.400 --> 00:03:42.639
<v Speaker 2>Exactly, write explanations, put in equations, add images, basically document

77
00:03:42.680 --> 00:03:45.879
<v Speaker 2>your whole thought process alongside the actual calculations.

78
00:03:46.080 --> 00:03:49.199
<v Speaker 1>So it's like a living document your analysis and your

79
00:03:49.240 --> 00:03:51.240
<v Speaker 1>explanation all in one place.

80
00:03:51.080 --> 00:03:54.439
<v Speaker 2>Which is just invaluable for checking your work later or

81
00:03:54.479 --> 00:03:56.960
<v Speaker 2>sharing it with colleagues. Makes things reproducible.

82
00:03:57.039 --> 00:04:01.439
<v Speaker 1>Okay, environment set up. Now, what about the absolute bedrock,

83
00:04:01.719 --> 00:04:05.039
<v Speaker 1>the foundational Python concepts an engineer needs to.

84
00:04:05.000 --> 00:04:08.080
<v Speaker 2>Get so the source runs through the core syntax pretty quickly.

85
00:04:08.599 --> 00:04:11.719
<v Speaker 2>Things like comments in your code using the hash symbol

86
00:04:11.759 --> 00:04:16.319
<v Speaker 2>hashtag for a single line or triple quotes for multiple lines.

87
00:04:16.560 --> 00:04:18.560
<v Speaker 1>Essential for clarity, absolutely essential.

88
00:04:18.680 --> 00:04:20.439
<v Speaker 2>It's not just telling the computer what to do, but

89
00:04:20.800 --> 00:04:23.759
<v Speaker 2>reminding yourself or telling others why you're doing.

90
00:04:23.680 --> 00:04:24.160
<v Speaker 3>It that way.

91
00:04:24.279 --> 00:04:27.279
<v Speaker 1>Good practice. Easy to skip when you're in a hurry, though.

92
00:04:27.360 --> 00:04:30.720
<v Speaker 2>Oh definitely. Then you've got variables obviously, and understanding the

93
00:04:30.720 --> 00:04:31.680
<v Speaker 2>basic data.

94
00:04:31.439 --> 00:04:33.879
<v Speaker 1>Types like numbers and texts right in.

95
00:04:33.959 --> 00:04:38.360
<v Speaker 2>For integers whole numbers, float for numbers with decimal points,

96
00:04:39.120 --> 00:04:42.720
<v Speaker 2>booll for true or false conditions, which are key for logic,

97
00:04:43.399 --> 00:04:46.759
<v Speaker 2>and string for text. Think of them like labeled boxes

98
00:04:46.800 --> 00:04:48.560
<v Speaker 2>for different kinds of information.

99
00:04:48.199 --> 00:04:49.240
<v Speaker 1>And grouping data.

100
00:04:49.600 --> 00:04:50.279
<v Speaker 2>Collections.

101
00:04:50.480 --> 00:04:53.040
<v Speaker 1>Yeah, Python has built in collections. The list is probably

102
00:04:53.079 --> 00:04:55.519
<v Speaker 1>the most common. It's like a flexible array or vector

103
00:04:55.680 --> 00:04:58.199
<v Speaker 1>flexible hot. It's ordered, you can change things in it,

104
00:04:58.439 --> 00:05:01.680
<v Speaker 1>and you grab elements using an index starting from zero.

105
00:05:01.720 --> 00:05:04.560
<v Speaker 1>That's important, index zero. It can even hold different types

106
00:05:04.560 --> 00:05:07.360
<v Speaker 1>of data like numbers and strings together, okay.

107
00:05:07.160 --> 00:05:10.399
<v Speaker 2>And dictionaries a dick Yeah, that's more like a lookup table.

108
00:05:11.240 --> 00:05:15.040
<v Speaker 2>It stores data as key value pairs, so you find

109
00:05:15.040 --> 00:05:18.759
<v Speaker 2>a value using its unique key, not its position like

110
00:05:18.800 --> 00:05:19.279
<v Speaker 2>in a list.

111
00:05:19.839 --> 00:05:21.920
<v Speaker 1>Un ordered gotcha and tupuls tuple.

112
00:05:22.000 --> 00:05:24.240
<v Speaker 2>It's ordered like a list, but the big difference is

113
00:05:24.279 --> 00:05:25.720
<v Speaker 2>you can't change it once you create it.

114
00:05:26.000 --> 00:05:26.639
<v Speaker 3>Immutable.

115
00:05:26.879 --> 00:05:27.399
<v Speaker 1>Why use that?

116
00:05:27.480 --> 00:05:27.680
<v Speaker 3>Then?

117
00:05:27.879 --> 00:05:31.639
<v Speaker 2>They're often used when a function needs to return multiple results.

118
00:05:31.839 --> 00:05:33.879
<v Speaker 2>You bottle them in a tuple and then you can

119
00:05:33.920 --> 00:05:35.920
<v Speaker 2>easily unpack them back into separate variables.

120
00:05:36.279 --> 00:05:40.439
<v Speaker 1>H okay, makes sense. Basic math is obvious plus velmad

121
00:05:40.560 --> 00:05:43.600
<v Speaker 1>But what about powers exponents.

122
00:05:43.120 --> 00:05:46.639
<v Speaker 2>Right, Engineers use those all the time. Python uses double asterisks,

123
00:05:47.160 --> 00:05:49.519
<v Speaker 2>so two in three is too cubed. Not the care

124
00:05:49.639 --> 00:05:50.920
<v Speaker 2>ensemble you might see elsewhere.

125
00:05:50.920 --> 00:05:51.720
<v Speaker 3>That's a common.

126
00:05:51.480 --> 00:05:53.160
<v Speaker 1>Gotcha good tip for powers.

127
00:05:53.839 --> 00:05:54.759
<v Speaker 3>Also useful are.

128
00:05:54.639 --> 00:05:57.839
<v Speaker 2>The assignment operators like plus or make just shorthand ways

129
00:05:57.839 --> 00:06:00.399
<v Speaker 2>to update of variables of value like x plus one

130
00:06:00.439 --> 00:06:01.600
<v Speaker 2>is the same as x plus one.

131
00:06:01.959 --> 00:06:03.120
<v Speaker 3>There's a bit of typing.

132
00:06:02.839 --> 00:06:04.879
<v Speaker 1>And making decisions logic flow.

133
00:06:05.000 --> 00:06:07.959
<v Speaker 2>That's your if yes, which is short for l if

134
00:06:08.000 --> 00:06:11.079
<v Speaker 2>and l statements. They work based on conditions that evaluate

135
00:06:11.120 --> 00:06:11.879
<v Speaker 2>too true or.

136
00:06:11.839 --> 00:06:15.800
<v Speaker 1>False, using comparison operators exactly for checking equality. Is this

137
00:06:15.879 --> 00:06:18.920
<v Speaker 1>equal to that? For not equal, then your standard edge.

138
00:06:18.839 --> 00:06:22.279
<v Speaker 2>A and I remember the source flag A really common mistake.

139
00:06:21.959 --> 00:06:25.160
<v Speaker 1>Here, Oh yeah, the classic versus Everyone does it at first.

140
00:06:25.480 --> 00:06:29.360
<v Speaker 1>Single equals is assignment right, x equals five, assigns five

141
00:06:29.399 --> 00:06:31.879
<v Speaker 1>to x, double equals x and equals five, so this

142
00:06:32.000 --> 00:06:34.800
<v Speaker 1>is equal to five. Huge difference in meaning. Get that

143
00:06:34.879 --> 00:06:36.600
<v Speaker 1>wrong and your logic goes haywire.

144
00:06:36.680 --> 00:06:40.439
<v Speaker 2>And you combine conditions with and or not standard logic yep.

145
00:06:40.560 --> 00:06:44.839
<v Speaker 2>No Python structure It's all about the spacing, isn't it indentation?

146
00:06:45.120 --> 00:06:49.000
<v Speaker 1>Yes, this is fundamental Python. Where other languages might use

147
00:06:49.040 --> 00:06:52.600
<v Speaker 1>curly braces or keywords like ndif to show code blocks

148
00:06:52.639 --> 00:06:55.519
<v Speaker 1>belonging to an if statement or a loop, Python uses

149
00:06:55.600 --> 00:06:57.959
<v Speaker 1>indentation consistent spacing.

150
00:06:58.240 --> 00:06:59.319
<v Speaker 3>And it's not just for looks.

151
00:06:59.480 --> 00:07:03.040
<v Speaker 1>No, it's syntactically mandatory. If your indentation is wrong, your

152
00:07:03.040 --> 00:07:05.399
<v Speaker 1>code won't run, or worse, it'll run in correctly. It

153
00:07:05.480 --> 00:07:07.879
<v Speaker 1>forces a certain level of visual clarity, which is actually

154
00:07:07.920 --> 00:07:08.360
<v Speaker 1>a good thing.

155
00:07:08.439 --> 00:07:10.279
<v Speaker 2>Okay, what about doing things repeatedly?

156
00:07:10.439 --> 00:07:10.839
<v Speaker 1>Loops?

157
00:07:11.079 --> 00:07:13.399
<v Speaker 2>Four loops are the main tool here. You use them

158
00:07:13.439 --> 00:07:16.279
<v Speaker 2>to iterate over sequences like the items in a list,

159
00:07:16.720 --> 00:07:19.199
<v Speaker 2>or to just repeat an action a specific.

160
00:07:18.800 --> 00:07:19.519
<v Speaker 3>Number of times.

161
00:07:19.560 --> 00:07:21.000
<v Speaker 1>And that range function comes up.

162
00:07:20.959 --> 00:07:23.839
<v Speaker 2>A lot very often with four loops. Dot range n

163
00:07:24.000 --> 00:07:26.560
<v Speaker 2>gives you a sequence of numbers from zero up two,

164
00:07:26.639 --> 00:07:27.680
<v Speaker 2>but not including n.

165
00:07:27.839 --> 00:07:31.480
<v Speaker 1>So range five is zero, one, two, three, four exactly.

166
00:07:31.879 --> 00:07:34.040
<v Speaker 2>That n one end point is crucial to remember.

167
00:07:34.120 --> 00:07:37.680
<v Speaker 1>Can you control the loop while it's running like stop early, yep.

168
00:07:37.720 --> 00:07:40.879
<v Speaker 2>Break, exits the loop, immediately, continue, skips the rest of

169
00:07:40.879 --> 00:07:42.879
<v Speaker 2>the current iteration, and jump straight to the next one.

170
00:07:43.360 --> 00:07:44.639
<v Speaker 2>Very handy sometimes.

171
00:07:44.319 --> 00:07:48.480
<v Speaker 1>Okay, last basic concept functions key for organization totally.

172
00:07:48.759 --> 00:07:51.480
<v Speaker 2>Think of a function as a named, reusable chunk of

173
00:07:51.480 --> 00:07:54.240
<v Speaker 2>code that does one specific job. You define it with

174
00:07:54.279 --> 00:07:57.399
<v Speaker 2>a deaf keyword, give it a name, give it inputs, right,

175
00:07:57.600 --> 00:08:01.079
<v Speaker 2>specify any inputs it needs in parentheses. Then it performs

176
00:08:01.079 --> 00:08:04.759
<v Speaker 2>its operations and usually uses the return keyword to send

177
00:08:04.800 --> 00:08:05.480
<v Speaker 2>back a result.

178
00:08:05.560 --> 00:08:08.800
<v Speaker 1>An output keeps your code cleaner, reusable.

179
00:08:08.279 --> 00:08:12.000
<v Speaker 2>Exactly avoids repeating yourself. The source also mentioned variable scope.

180
00:08:12.040 --> 00:08:15.040
<v Speaker 1>Ah, yes, local versus global important stuff.

181
00:08:15.480 --> 00:08:19.560
<v Speaker 2>Variables created inside of function are local. They only exist

182
00:08:19.600 --> 00:08:22.279
<v Speaker 2>within that function and disappear when it finishes.

183
00:08:22.000 --> 00:08:23.800
<v Speaker 1>So they don't mess with things outside.

184
00:08:24.120 --> 00:08:24.319
<v Speaker 3>Right.

185
00:08:24.639 --> 00:08:27.879
<v Speaker 2>Global variables are defined outside functions and can generally be

186
00:08:27.959 --> 00:08:32.799
<v Speaker 2>accessed from anywhere. Understanding scope helps prevent unexpected side effects.

187
00:08:32.879 --> 00:08:36.440
<v Speaker 1>The trapezoid area function example and the source was pretty clear.

188
00:08:36.639 --> 00:08:39.840
<v Speaker 2>Yeah, good, simple example. You pass in the bases in height,

189
00:08:40.320 --> 00:08:43.440
<v Speaker 2>The function calculates the area using the formula and returns

190
00:08:43.600 --> 00:08:44.759
<v Speaker 2>that single value.

191
00:08:44.879 --> 00:08:47.679
<v Speaker 1>And you mentioned tiples before for returning multiple things.

192
00:08:47.960 --> 00:08:48.240
<v Speaker 3>Yep.

193
00:08:48.399 --> 00:08:50.759
<v Speaker 2>The source showed how you can set default values for

194
00:08:50.799 --> 00:08:54.600
<v Speaker 2>function inputs, making them optional, and how returning a twopole

195
00:08:54.919 --> 00:08:58.000
<v Speaker 2>lets a function give back say both the area and perimeter,

196
00:08:58.279 --> 00:09:01.000
<v Speaker 2>which you can then easily unpack, and two separate variables

197
00:09:01.039 --> 00:09:01.559
<v Speaker 2>where you call.

198
00:09:01.440 --> 00:09:01.919
<v Speaker 3>It the function.

199
00:09:02.080 --> 00:09:05.240
<v Speaker 1>Okay, that covers the Python fundamentals. Now, the real power

200
00:09:05.279 --> 00:09:08.279
<v Speaker 1>boost for engineers comes from the libraries, right or absolutely.

201
00:09:09.000 --> 00:09:12.000
<v Speaker 2>This is where Python transforms from a general purpose language

202
00:09:12.120 --> 00:09:15.919
<v Speaker 2>into a specialized engineering powerhouse. The guide really focuses on

203
00:09:16.039 --> 00:09:18.960
<v Speaker 2>four core libraries that are well game changers.

204
00:09:19.159 --> 00:09:21.320
<v Speaker 1>Let's start with the big one for numbers, numb PI.

205
00:09:21.600 --> 00:09:22.000
<v Speaker 3>Numb PI.

206
00:09:22.120 --> 00:09:25.840
<v Speaker 2>It's fundamental if you're doing numerical work in Python, especially

207
00:09:25.840 --> 00:09:28.879
<v Speaker 2>with the rays. This is the standard. The core element

208
00:09:29.000 --> 00:09:30.679
<v Speaker 2>is the end array, the ind dimensional array.

209
00:09:30.759 --> 00:09:32.720
<v Speaker 1>How is it different from a standard Python list.

210
00:09:33.000 --> 00:09:36.679
<v Speaker 2>It's like a list, but highly optimized for math, generally

211
00:09:36.759 --> 00:09:40.559
<v Speaker 2>much faster for calculations. Crucially, all elements in a NUMBPI

212
00:09:40.639 --> 00:09:42.799
<v Speaker 2>array usually have to be the same data type, like

213
00:09:42.840 --> 00:09:44.399
<v Speaker 2>all floats or all integers.

214
00:09:44.799 --> 00:09:46.000
<v Speaker 3>Lists can mix types.

215
00:09:46.080 --> 00:09:47.399
<v Speaker 1>Got it? How do you use it?

216
00:09:47.480 --> 00:09:51.080
<v Speaker 2>Standard practice is import nump is NP. Everyone uses NP

217
00:09:51.279 --> 00:09:52.039
<v Speaker 2>as the shorthand.

218
00:09:52.080 --> 00:09:53.919
<v Speaker 1>Okay, creating a raise easy.

219
00:09:54.360 --> 00:09:57.080
<v Speaker 2>NP dot zeros makes an array full of zeros mp

220
00:09:57.159 --> 00:09:59.279
<v Speaker 2>dot range is like Python's range, but gives you an

221
00:09:59.279 --> 00:10:02.440
<v Speaker 2>actual numbpire right, and np dot lends space is super

222
00:10:02.559 --> 00:10:03.559
<v Speaker 2>useful for engineers.

223
00:10:03.639 --> 00:10:04.200
<v Speaker 1>Lends space.

224
00:10:04.279 --> 00:10:06.879
<v Speaker 2>Yeah, np dot lends space, go start stopping them. It

225
00:10:06.919 --> 00:10:10.159
<v Speaker 2>creates an array with numb evenly spaced points between start

226
00:10:10.200 --> 00:10:13.039
<v Speaker 2>and stop, including the stop point, perfect for creating X

227
00:10:13.080 --> 00:10:15.399
<v Speaker 2>coordinates along a beam or points for plotting.

228
00:10:15.679 --> 00:10:18.279
<v Speaker 1>Okay, and doing math with these arrays.

229
00:10:18.120 --> 00:10:21.279
<v Speaker 2>Numb pi shines here. You can get properties like dimensions,

230
00:10:21.360 --> 00:10:24.720
<v Speaker 2>want to be in shape, shape shape sized, data type

231
00:10:24.799 --> 00:10:28.399
<v Speaker 2>d type basic math plus a at even for powers

232
00:10:28.879 --> 00:10:32.080
<v Speaker 2>works element wisele limit wise, meaning if you have two

233
00:10:32.200 --> 00:10:35.039
<v Speaker 2>arrays A and B the same shape A plus B,

234
00:10:35.120 --> 00:10:37.000
<v Speaker 2>adds the first element of A to the first of B,

235
00:10:37.279 --> 00:10:39.279
<v Speaker 2>the second to the second, and so on same. For

236
00:10:39.399 --> 00:10:42.759
<v Speaker 2>multiplication to B, it applies the operation to corresponding elements.

237
00:10:42.799 --> 00:10:47.559
<v Speaker 1>But wait, matrix multiplication, that's different, right, crucial for structural analysis.

238
00:10:47.000 --> 00:10:48.720
<v Speaker 3>Absolutely crucial. This trists people up.

239
00:10:48.840 --> 00:10:52.720
<v Speaker 2>The standard asterisk is element wise multiplication. For true matrix

240
00:10:52.799 --> 00:10:56.279
<v Speaker 2>multiplication like you need for transformations or solving systems, use

241
00:10:56.320 --> 00:10:59.120
<v Speaker 2>the AT symbol an b okay.

242
00:10:58.840 --> 00:11:01.159
<v Speaker 1>At for matrix math element wise got it?

243
00:11:01.240 --> 00:11:02.000
<v Speaker 3>Remember at B.

244
00:11:02.919 --> 00:11:05.919
<v Speaker 2>You can also slice arrays like lists using start end

245
00:11:05.960 --> 00:11:08.559
<v Speaker 2>dot step, but it works across multiple dimensions too, and

246
00:11:08.600 --> 00:11:11.919
<v Speaker 2>you can reshape them, stack them vertically, v stack a pend,

247
00:11:12.039 --> 00:11:14.399
<v Speaker 2>or insert elements. Lots of manipulation tools.

248
00:11:14.600 --> 00:11:18.080
<v Speaker 1>The guide had a great practical example calculating moment and

249
00:11:18.120 --> 00:11:19.399
<v Speaker 1>sheer along a simple beam.

250
00:11:19.639 --> 00:11:22.519
<v Speaker 2>Yeah, that really shows the element wise power. You create

251
00:11:22.519 --> 00:11:25.399
<v Speaker 2>your X ray along the beam using np dot line space.

252
00:11:25.600 --> 00:11:28.559
<v Speaker 2>Then you just write the standard beam equations for moment

253
00:11:28.799 --> 00:11:31.679
<v Speaker 2>M and sheer V, but using the entire x ray

254
00:11:31.679 --> 00:11:31.919
<v Speaker 2>in the.

255
00:11:31.840 --> 00:11:35.159
<v Speaker 1>Formula like M equals l x two w x two

256
00:11:35.200 --> 00:11:36.039
<v Speaker 1>two exactly.

257
00:11:36.360 --> 00:11:40.440
<v Speaker 2>Numpi automatically applies that calculation to every single value in

258
00:11:40.480 --> 00:11:42.879
<v Speaker 2>the X ray all at once. You get the entire

259
00:11:43.120 --> 00:11:46.720
<v Speaker 2>M diagram or v diagram as a Numpi array instantly,

260
00:11:46.840 --> 00:11:47.559
<v Speaker 2>super efficient.

261
00:11:47.799 --> 00:11:50.639
<v Speaker 1>Wow. Okay, so numb pie handles the heavy numerical lifting.

262
00:11:50.919 --> 00:11:52.440
<v Speaker 1>What if you need to deal with the math before

263
00:11:52.440 --> 00:11:55.000
<v Speaker 1>you have numbers, like solving equations symbolically.

264
00:11:55.120 --> 00:11:57.720
<v Speaker 2>That's where simp comes in. It's a library for symbolic mathematics.

265
00:11:57.840 --> 00:11:59.879
<v Speaker 2>Think of it as a computer algebra system or see

266
00:12:00.600 --> 00:12:01.440
<v Speaker 2>right inside Python.

267
00:12:01.559 --> 00:12:03.519
<v Speaker 1>So algebra with symbols, not just numbers.

268
00:12:03.519 --> 00:12:07.360
<v Speaker 2>Percisely, you import simpsky. Then you define symbols like xsp

269
00:12:07.480 --> 00:12:11.279
<v Speaker 2>dot symbols x or maybe EI lsp dot symbols EIL

270
00:12:11.759 --> 00:12:12.840
<v Speaker 2>for engineering properties.

271
00:12:13.200 --> 00:12:14.039
<v Speaker 3>Then you can write.

272
00:12:13.799 --> 00:12:17.240
<v Speaker 2>Equations using these symbols. Simps functions like sp dot solve

273
00:12:17.240 --> 00:12:19.799
<v Speaker 2>set to solve an equation for a specific symbol, or

274
00:12:19.919 --> 00:12:22.559
<v Speaker 2>sp dot lens solve to solve systems of linear equations

275
00:12:22.600 --> 00:12:25.360
<v Speaker 2>symbolically calculus two differentiation integration.

276
00:12:25.519 --> 00:12:29.000
<v Speaker 1>The guide mentioned a display function for making it look nice.

277
00:12:29.200 --> 00:12:33.480
<v Speaker 2>Yeah, especially in Jupiter notebooks. Display your SIMP expression often

278
00:12:33.519 --> 00:12:37.960
<v Speaker 2>renders the output using latex math formatting, so complicated formulas

279
00:12:38.000 --> 00:12:40.639
<v Speaker 2>look like they do in a textbook, much easier to

280
00:12:40.679 --> 00:12:41.320
<v Speaker 2>read and check.

281
00:12:41.679 --> 00:12:44.039
<v Speaker 1>How does this help with a real problem? The source

282
00:12:44.120 --> 00:12:47.200
<v Speaker 1>used a two span beam example, again perfect case.

283
00:12:47.639 --> 00:12:51.360
<v Speaker 2>A continuous beam like that is often statically indeterminate. Basic

284
00:12:51.399 --> 00:12:54.720
<v Speaker 2>equilibrium equations aren't enough to find all the support reactions, right.

285
00:12:54.600 --> 00:12:58.720
<v Speaker 1>You need compatibility equations considering deflections or slopes Exactly.

286
00:12:59.080 --> 00:13:01.759
<v Speaker 2>With SIMP, you can say up both the equilibrium equations

287
00:13:01.799 --> 00:13:05.600
<v Speaker 2>and the compatibility equations using your defined symbols for unknown

288
00:13:05.600 --> 00:13:10.399
<v Speaker 2>reactions like va VC and maybe an unknown internal moment MX. Okay,

289
00:13:10.679 --> 00:13:13.360
<v Speaker 2>Then you use simply solvers like sp dot len solve

290
00:13:13.559 --> 00:13:16.200
<v Speaker 2>to solve that system of symbolic equations. It gives you

291
00:13:16.240 --> 00:13:20.039
<v Speaker 2>the algebraic expressions for those unknown reactions in terms of

292
00:13:20.080 --> 00:13:22.720
<v Speaker 2>the symbolic loads and lengths WL, etc.

293
00:13:23.399 --> 00:13:28.039
<v Speaker 1>So you solve the underlying indeterminate structure problem algebraically first.

294
00:13:28.080 --> 00:13:31.080
<v Speaker 2>Yes, before you even plug in a single number. It

295
00:13:31.080 --> 00:13:34.200
<v Speaker 2>helps you verify the fundamental mechanics and let simply handle

296
00:13:34.240 --> 00:13:37.039
<v Speaker 2>the messy algebra. Then you can substitute numbers into those

297
00:13:37.080 --> 00:13:39.480
<v Speaker 2>symbolic solutions later using numb pie.

298
00:13:39.519 --> 00:13:44.000
<v Speaker 1>Perhaps that's powerful. Okay, From symbolic math to data wrangling.

299
00:13:44.320 --> 00:13:47.279
<v Speaker 2>Pandas If numbpie is for a numerical arrays, PANDAS is

300
00:13:47.279 --> 00:13:52.399
<v Speaker 2>for tabular data think spreadsheets, tables with rows and columns.

301
00:13:52.559 --> 00:13:56.080
<v Speaker 2>It's built for handling potentially large structured data sets, especially

302
00:13:56.120 --> 00:13:58.399
<v Speaker 2>reading and writing common file formats.

303
00:13:58.080 --> 00:14:00.000
<v Speaker 1>Like Excel and CSV files.

304
00:13:59.639 --> 00:14:04.039
<v Speaker 2>Exactly dot xlsx, dot csv. PANDAS makes working with those

305
00:14:04.080 --> 00:14:06.440
<v Speaker 2>super easy. The core structure in PANDAS is.

306
00:14:06.440 --> 00:14:08.960
<v Speaker 1>The data frame day frame like a table.

307
00:14:08.679 --> 00:14:12.279
<v Speaker 2>Pretty much imagine a two D table, but with powerful extras.

308
00:14:12.360 --> 00:14:15.879
<v Speaker 2>It has labeled columns like spreadsheet headers, and labeled rose

309
00:14:16.080 --> 00:14:19.759
<v Speaker 2>called the index. It's designed for easily selecting, filtering, cleaning,

310
00:14:19.799 --> 00:14:21.360
<v Speaker 2>and analyzing that kind of data.

311
00:14:21.360 --> 00:14:22.799
<v Speaker 1>What kind of things can you do? Easily?

312
00:14:23.080 --> 00:14:26.919
<v Speaker 2>Create them from scratch or from numpire rays access data

313
00:14:26.919 --> 00:14:29.879
<v Speaker 2>by column name or row index, lots of data cleaning

314
00:14:29.919 --> 00:14:34.399
<v Speaker 2>tools built in sorting, sort values, renaming columns or the index, rename,

315
00:14:34.679 --> 00:14:37.879
<v Speaker 2>dropping rose or columns, drop handling missing data, resetting the

316
00:14:37.879 --> 00:14:40.440
<v Speaker 2>index if it gets messed up, reset index. You can

317
00:14:40.440 --> 00:14:42.440
<v Speaker 2>also combine data frames CONCAT.

318
00:14:42.639 --> 00:14:45.639
<v Speaker 1>The guide really highlighted working with external files. That sounds

319
00:14:45.639 --> 00:14:46.679
<v Speaker 1>incredibly useful.

320
00:14:46.759 --> 00:14:49.279
<v Speaker 2>It is probably one of the most common uses for engineers.

321
00:14:49.679 --> 00:14:53.879
<v Speaker 2>PDA dot redexl mydata dot xl sx or pd dot

322
00:14:53.919 --> 00:14:57.320
<v Speaker 2>recsv results dot csv one line and your data isn't

323
00:14:57.320 --> 00:14:57.919
<v Speaker 2>a data.

324
00:14:57.679 --> 00:15:00.360
<v Speaker 1>Frame, even if the files a bit messy like multiple

325
00:15:00.440 --> 00:15:01.080
<v Speaker 1>header rows.

326
00:15:01.159 --> 00:15:03.919
<v Speaker 2>Yeah canas has options for that. You can specify header

327
00:15:04.039 --> 00:15:06.039
<v Speaker 2>zero one if the headers pans the first two rows,

328
00:15:06.039 --> 00:15:08.720
<v Speaker 2>for example, or index col zero if the first column

329
00:15:08.799 --> 00:15:11.240
<v Speaker 2>the file should be used as the roll labels the index.

330
00:15:10.960 --> 00:15:13.559
<v Speaker 1>And cleaning that imported data, getting rid of empty rows

331
00:15:13.639 --> 00:15:14.320
<v Speaker 1>or junk.

332
00:15:14.159 --> 00:15:16.679
<v Speaker 2>PANDAS makes that much easier than doing it manually. In Excel,

333
00:15:17.120 --> 00:15:19.240
<v Speaker 2>you can drop those extra header levels that sometimes come

334
00:15:19.279 --> 00:15:22.200
<v Speaker 2>in DF dot columns DOT drop level, remove rows with

335
00:15:22.240 --> 00:15:26.080
<v Speaker 2>any missing values, DF dot drop and selectively drop rows.

336
00:15:25.919 --> 00:15:29.639
<v Speaker 1>Or columns and getting data back out to share with colleagues.

337
00:15:29.639 --> 00:15:32.559
<v Speaker 2>Maybe just as easy df dot to excel output dot

338
00:15:32.679 --> 00:15:36.480
<v Speaker 2>XLSX or df dot t s sv cleanda dot csv.

339
00:15:36.919 --> 00:15:40.039
<v Speaker 2>You can control whether the index is written and other formatting.

340
00:15:40.279 --> 00:15:42.840
<v Speaker 2>It bridges the gap between your Python analysis and standard

341
00:15:42.840 --> 00:15:43.600
<v Speaker 2>office formats.

342
00:15:43.639 --> 00:15:44.159
<v Speaker 3>Really well.

343
00:15:44.279 --> 00:15:47.639
<v Speaker 1>How did the two span beam example use pandas it.

344
00:15:47.720 --> 00:15:50.919
<v Speaker 2>Showed using a data frame to manage results from multiple

345
00:15:50.960 --> 00:15:51.600
<v Speaker 2>load cases.

346
00:15:51.759 --> 00:15:52.919
<v Speaker 3>So you use simply.

347
00:15:52.720 --> 00:15:55.600
<v Speaker 2>Numpi to calculate the M and V diagrams for dead lows,

348
00:15:55.639 --> 00:15:58.120
<v Speaker 2>live load, windload, et cetera. Okay, you can store each

349
00:15:58.279 --> 00:16:01.519
<v Speaker 2>MRA and vra as a in a Panda's data frame

350
00:16:01.600 --> 00:16:04.559
<v Speaker 2>with columns labeled maybe mddvdad, MLIV.

351
00:16:04.200 --> 00:16:04.840
<v Speaker 3>Live and so on.

352
00:16:04.960 --> 00:16:06.919
<v Speaker 1>Ah, so everything is organized together.

353
00:16:06.720 --> 00:16:09.399
<v Speaker 2>Exactly, all results in one table. Makes it super easy

354
00:16:09.399 --> 00:16:13.200
<v Speaker 2>to then compare load cases, find maximums or minimums across cases, envelopes,

355
00:16:13.440 --> 00:16:14.799
<v Speaker 2>or apply load combinations.

356
00:16:14.879 --> 00:16:19.120
<v Speaker 1>Right, Okay, we've calculated, we've solved symbolically, we've organized the data.

357
00:16:19.279 --> 00:16:22.799
<v Speaker 1>Now we need to see it visualization with matt plotlib.

358
00:16:22.879 --> 00:16:27.399
<v Speaker 2>Mat plotlib it's the workhorse. Plotting library of Python very versatile.

359
00:16:27.399 --> 00:16:30.240
<v Speaker 2>You can create anything of simple line graphs to complex

360
00:16:30.320 --> 00:16:32.240
<v Speaker 2>publication quality technical figures.

361
00:16:32.559 --> 00:16:33.399
<v Speaker 1>How do you get started?

362
00:16:33.519 --> 00:16:38.679
<v Speaker 2>The standard import is importmattplotlib dot piplot as PLT. Everyone

363
00:16:38.759 --> 00:16:42.240
<v Speaker 2>uses PLT. The key concept is the figure and axis

364
00:16:42.440 --> 00:16:43.320
<v Speaker 2>figure and axis.

365
00:16:43.480 --> 00:16:44.399
<v Speaker 3>The figure is like.

366
00:16:44.360 --> 00:16:47.320
<v Speaker 2>The overall window or canvas. The axis usually just one.

367
00:16:47.399 --> 00:16:50.120
<v Speaker 2>AX is the actual plot area within that figure where

368
00:16:50.120 --> 00:16:53.000
<v Speaker 2>your data gets drawn, the part with the xy axis,

369
00:16:53.039 --> 00:16:54.200
<v Speaker 2>the lines, the points, and.

370
00:16:54.200 --> 00:16:56.639
<v Speaker 1>The guide recommended A specific way to set this up.

371
00:16:56.559 --> 00:16:59.440
<v Speaker 2>Yeah, the object oriented approach is generally preferred for control.

372
00:17:00.039 --> 00:17:03.519
<v Speaker 2>You start with fig AX, it goes PLT dot subplots.

373
00:17:04.079 --> 00:17:07.519
<v Speaker 2>This creates both a figure FIG and a single axis.

374
00:17:07.200 --> 00:17:10.119
<v Speaker 1>Object AX, and then you plot on AX exactly.

375
00:17:10.160 --> 00:17:12.799
<v Speaker 2>You call messods directly on the AX object AC dot

376
00:17:12.839 --> 00:17:15.720
<v Speaker 2>plot x data white data for a line plot, x

377
00:17:15.759 --> 00:17:19.000
<v Speaker 2>dot scatter for scatterplots, et cetera. Then you use PLT

378
00:17:19.160 --> 00:17:21.519
<v Speaker 2>dot show at the end to actually display the figure.

379
00:17:21.640 --> 00:17:24.039
<v Speaker 1>Why that way instead of just PLT dot plot.

380
00:17:23.960 --> 00:17:26.359
<v Speaker 2>Using the AX object gives you much finer control over

381
00:17:26.400 --> 00:17:30.359
<v Speaker 2>everything on that specific plot labels, titles, ticks, legends, colors.

382
00:17:30.559 --> 00:17:32.720
<v Speaker 2>It's much more robust, especially if you end up wanting

383
00:17:32.759 --> 00:17:35.000
<v Speaker 2>multiple plots in the same figure later makes sense.

384
00:17:35.160 --> 00:17:38.559
<v Speaker 1>Customization is obviously key for engineering plots totally.

385
00:17:38.480 --> 00:17:41.519
<v Speaker 2>And map plot labelts. You customize almost anything at access

386
00:17:41.559 --> 00:17:44.839
<v Speaker 2>labels with AX dot sets label and act dot set

387
00:17:44.839 --> 00:17:47.200
<v Speaker 2>the label. Set a title with ax dot set title

388
00:17:47.519 --> 00:17:50.559
<v Speaker 2>at a legend if you have multiple lines using ax dot.

389
00:17:50.400 --> 00:17:52.279
<v Speaker 1>Legend line styles colors.

390
00:17:52.039 --> 00:17:55.319
<v Speaker 2>YEP control line styles, solid dash colors, ad markers.

391
00:17:55.359 --> 00:17:56.039
<v Speaker 3>At data points.

392
00:17:56.279 --> 00:17:58.880
<v Speaker 2>You can fill areas between curves using ax dot fill

393
00:17:58.960 --> 00:18:02.559
<v Speaker 2>between really useful for showing moment envelopes or maybe the

394
00:18:02.599 --> 00:18:05.160
<v Speaker 2>feasible region in an interaction diagram.

395
00:18:05.160 --> 00:18:07.160
<v Speaker 1>Oh nice, ticks and labels too.

396
00:18:07.119 --> 00:18:07.799
<v Speaker 3>Full control.

397
00:18:07.920 --> 00:18:10.160
<v Speaker 2>Customize the locations and labels of the tick marks on

398
00:18:10.200 --> 00:18:13.359
<v Speaker 2>both axis sex sticks set tis. You can even rotate

399
00:18:13.400 --> 00:18:17.359
<v Speaker 2>the dick labels sixtick labels rotation if they overlap essential

400
00:18:17.400 --> 00:18:18.680
<v Speaker 2>for clear technical plots.

401
00:18:18.880 --> 00:18:22.920
<v Speaker 1>Scatterplots were also mentioned for discrete points right at that'skay.

402
00:18:23.119 --> 00:18:25.319
<v Speaker 2>A cool feature there is you can color each point

403
00:18:25.440 --> 00:18:28.559
<v Speaker 2>based on a third variable using the C argument and

404
00:18:28.599 --> 00:18:30.960
<v Speaker 2>a color map. See that, then add a color bar

405
00:18:31.079 --> 00:18:32.799
<v Speaker 2>fig dot color bar to show what the colors mean.

406
00:18:32.880 --> 00:18:35.759
<v Speaker 2>Great for visualizing things like stress levels or utilization. Ratio

407
00:18:35.799 --> 00:18:36.799
<v Speaker 2>is at different points.

408
00:18:36.519 --> 00:18:39.680
<v Speaker 1>And putting multiple plots together like a dashboard.

409
00:18:39.400 --> 00:18:42.279
<v Speaker 2>Peel dot subplots PLF booze creates a grid. If you

410
00:18:42.319 --> 00:18:45.880
<v Speaker 2>do fig axs egals PLT dot subplots two two axis

411
00:18:46.000 --> 00:18:48.480
<v Speaker 2>becomes a two by two array and you can plot

412
00:18:48.519 --> 00:18:50.759
<v Speaker 2>on AXI zero zero, access rule one, et cetera.

413
00:18:51.079 --> 00:18:52.759
<v Speaker 3>To arrange four plots in one.

414
00:18:52.680 --> 00:18:55.359
<v Speaker 1>Figure and getting the plot out of Python, saving it.

415
00:18:55.559 --> 00:18:59.480
<v Speaker 2>Easy PLT dot safig, myplot, dot pdf or dot png,

416
00:18:59.599 --> 00:19:02.720
<v Speaker 2>dot s VG lots of formats saves the current figure

417
00:19:02.759 --> 00:19:05.240
<v Speaker 2>to a file ready to be included in reports.

418
00:19:05.599 --> 00:19:09.200
<v Speaker 1>So practically this ties back to visualizing those beam diagrams

419
00:19:09.240 --> 00:19:12.000
<v Speaker 1>from numb pi, or maybe plotting something complex like that

420
00:19:12.200 --> 00:19:15.119
<v Speaker 1>MN interaction domain for concrete Exactly.

421
00:19:15.480 --> 00:19:17.799
<v Speaker 2>You do the heavy lifting with NUMPI, simply manage it

422
00:19:17.839 --> 00:19:20.200
<v Speaker 2>with pandas, and then matt plotlib gives you the visual

423
00:19:20.240 --> 00:19:21.799
<v Speaker 2>insight and the communication tool.

424
00:19:21.599 --> 00:19:22.400
<v Speaker 3>It completes the picture.

425
00:19:22.519 --> 00:19:24.359
<v Speaker 1>Okay, so we've got the basics, we've got the core

426
00:19:24.440 --> 00:19:27.759
<v Speaker 1>libraries numb PI, SIMPI, panas maplotlib. The really cool part

427
00:19:27.799 --> 00:19:30.240
<v Speaker 1>is seeing them all work together on actual engineering problems.

428
00:19:30.279 --> 00:19:33.200
<v Speaker 1>The source had some great examples of this integration.

429
00:19:33.480 --> 00:19:34.920
<v Speaker 3>Yeah, this is where you see the synergy.

430
00:19:35.200 --> 00:19:38.160
<v Speaker 2>Like calculating properties for a custom steel section, maybe it

431
00:19:38.240 --> 00:19:39.319
<v Speaker 2>built up welded shape.

432
00:19:39.319 --> 00:19:40.000
<v Speaker 1>How would that work?

433
00:19:40.359 --> 00:19:43.440
<v Speaker 2>You might use SIMPI first symbolically to set up the

434
00:19:43.559 --> 00:19:47.519
<v Speaker 2>equations for finding the centroid location YG using the principle

435
00:19:47.559 --> 00:19:51.480
<v Speaker 2>of moments of area. Solve that algebraically. Okay, Then you

436
00:19:51.559 --> 00:19:54.559
<v Speaker 2>switch to Python a numb pie. You implement the standard

437
00:19:54.599 --> 00:19:57.519
<v Speaker 2>formulas for area moment of inertia like I gole sum

438
00:19:57.599 --> 00:20:00.519
<v Speaker 2>in a local plus eighty two section modulus using the

439
00:20:00.559 --> 00:20:03.599
<v Speaker 2>dimensions of the section parts may be stored in NUMPI arrays.

440
00:20:04.200 --> 00:20:08.279
<v Speaker 2>You plug the symbolic centroid result into these numerical calculations.

441
00:20:08.599 --> 00:20:12.079
<v Speaker 1>So combining the symbolic set up with the numerical calculation precisely.

442
00:20:12.240 --> 00:20:16.119
<v Speaker 2>Or take the concrete MS interaction domain. That's a complex

443
00:20:16.240 --> 00:20:17.160
<v Speaker 2>nonlinear problem.

444
00:20:17.240 --> 00:20:19.119
<v Speaker 1>Yeah, involves iterating through stream profiles.

445
00:20:19.279 --> 00:20:21.680
<v Speaker 3>Right. The guide shows how numb pi is crucial.

446
00:20:21.759 --> 00:20:21.880
<v Speaker 1>Here.

447
00:20:22.519 --> 00:20:25.319
<v Speaker 2>You use a rays to discretize the concrete section into

448
00:20:25.400 --> 00:20:28.799
<v Speaker 2>layers and to find different possible linear strain profiles across

449
00:20:28.839 --> 00:20:29.240
<v Speaker 2>the depth.

450
00:20:29.319 --> 00:20:32.599
<v Speaker 1>Then calculate forces for each strain profile exactly.

451
00:20:32.920 --> 00:20:35.759
<v Speaker 2>For each assumed strain profile, you find the stress in

452
00:20:35.799 --> 00:20:39.119
<v Speaker 2>each layer using the concrete and steel stress strain curves.

453
00:20:39.680 --> 00:20:42.480
<v Speaker 2>Then you use NUMPI functions like MP dot traps for

454
00:20:42.640 --> 00:20:45.440
<v Speaker 2>numerical integration to sum up the forces in all layers.

455
00:20:46.119 --> 00:20:49.480
<v Speaker 2>This gives you the total axial force n and bending

456
00:20:49.519 --> 00:20:51.640
<v Speaker 2>moment M for that specific.

457
00:20:51.279 --> 00:20:53.480
<v Speaker 1>Strain state, and you repeat that many times.

458
00:20:53.559 --> 00:20:54.160
<v Speaker 3>You repeat that for.

459
00:20:54.200 --> 00:20:57.680
<v Speaker 2>Many, many possible strain profiles. Each one gives you a

460
00:20:57.799 --> 00:21:01.319
<v Speaker 2>point n M on the back boundary of the interaction domain.

461
00:21:01.799 --> 00:21:03.160
<v Speaker 2>Collect all those points.

462
00:21:02.960 --> 00:21:04.480
<v Speaker 1>And plot them with matt plotlib.

463
00:21:04.640 --> 00:21:04.960
<v Speaker 3>You got it.

464
00:21:05.039 --> 00:21:07.480
<v Speaker 2>Plot all the n M pairs and maybe use fill

465
00:21:07.559 --> 00:21:10.640
<v Speaker 2>between to shade the feasible region. It shows how programming

466
00:21:10.720 --> 00:21:14.680
<v Speaker 2>lets you tackle these really fundamental iterative mechanics problems that

467
00:21:14.759 --> 00:21:16.680
<v Speaker 2>would be incredibly painful manually.

468
00:21:16.880 --> 00:21:18.599
<v Speaker 1>Yeah, impossible with just a spreadsheet.

469
00:21:18.640 --> 00:21:21.880
<v Speaker 2>Really pretty much. And it's steel column design example that

470
00:21:22.119 --> 00:21:25.599
<v Speaker 2>highlighted pandas in automation. Oh so, pannas is perfect for

471
00:21:25.680 --> 00:21:28.559
<v Speaker 2>managing potentially hundreds of load combinations in a data frame.

472
00:21:29.160 --> 00:21:31.559
<v Speaker 2>Each row could be a combo with columns for actual

473
00:21:31.640 --> 00:21:34.920
<v Speaker 2>fource moments, et cetera. Then the design checks, say calculating

474
00:21:34.960 --> 00:21:38.559
<v Speaker 2>buckling reduction factors like G and k according to eurocode

475
00:21:38.640 --> 00:21:42.400
<v Speaker 2>or another standard. You implement those checks as Python code,

476
00:21:43.039 --> 00:21:46.319
<v Speaker 2>maybe in functions, often using numb pi for the math involved.

477
00:21:46.400 --> 00:21:48.720
<v Speaker 1>And the key is applying the check systematically.

478
00:21:48.920 --> 00:21:51.759
<v Speaker 2>Yes, you write the code for the check once, then

479
00:21:51.839 --> 00:21:54.640
<v Speaker 2>you apply that function to every single row, every load

480
00:21:54.720 --> 00:21:58.359
<v Speaker 2>combination in your PANDAS data frame, maybe storing the result

481
00:21:58.839 --> 00:22:00.960
<v Speaker 2>pass fail utiless ratio.

482
00:22:01.319 --> 00:22:02.119
<v Speaker 3>In a new column.

483
00:22:02.279 --> 00:22:05.079
<v Speaker 1>Automating code compliance checks across all scenarios.

484
00:22:05.160 --> 00:22:10.240
<v Speaker 2>That's huge, massive timesaver ensure its consistency, reduces errors. It

485
00:22:10.359 --> 00:22:13.079
<v Speaker 2>automates a critical and often tedious part of design.

486
00:22:13.359 --> 00:22:16.480
<v Speaker 1>Okay, so it's not just about calculation and analysis. Engineers

487
00:22:16.559 --> 00:22:19.519
<v Speaker 1>need to communicate results. The guide finish up talking about

488
00:22:19.680 --> 00:22:21.160
<v Speaker 1>reporting and automation.

489
00:22:21.000 --> 00:22:23.279
<v Speaker 2>Right absolutely, and the Jupiter Notebook itself is a big

490
00:22:23.359 --> 00:22:25.960
<v Speaker 2>part of that story because you can mix your live code,

491
00:22:26.000 --> 00:22:28.640
<v Speaker 2>the actual output from running that code, numbers, tables the

492
00:22:28.720 --> 00:22:31.960
<v Speaker 2>plots you generated, and explanatory text using markdown, all in

493
00:22:32.039 --> 00:22:35.759
<v Speaker 2>one document. The notebook essentially becomes your working report draft.

494
00:22:36.160 --> 00:22:38.359
<v Speaker 1>Your analysis document is the report draft.

495
00:22:38.599 --> 00:22:42.000
<v Speaker 2>That's efficient, it really is, and getting results out, especially

496
00:22:42.079 --> 00:22:44.240
<v Speaker 2>tables pandas is great here too. You can take a

497
00:22:44.359 --> 00:22:47.880
<v Speaker 2>data frame, maybe your load combination result and export it

498
00:22:47.960 --> 00:22:51.519
<v Speaker 2>directly to LATEX format using DF, dot TOLA texts. Latex

499
00:22:51.640 --> 00:22:54.359
<v Speaker 2>is the standard for high quality technical documents.

500
00:22:54.519 --> 00:22:57.000
<v Speaker 1>You can format it too, yep, control things.

501
00:22:56.920 --> 00:23:01.119
<v Speaker 2>Like bolding, rows, column alignment. You can even embed LATEX

502
00:23:01.200 --> 00:23:03.880
<v Speaker 2>math symbols directly in your data frame column headers if needed,

503
00:23:04.160 --> 00:23:06.519
<v Speaker 2>and have them render correctly in the output. It connects

504
00:23:06.519 --> 00:23:09.519
<v Speaker 2>your calculations directly to professional documentation.

505
00:23:09.160 --> 00:23:12.240
<v Speaker 1>Cuts out copy pasting, reduces errors again for sure.

506
00:23:12.839 --> 00:23:15.359
<v Speaker 2>And the plots from that plotlib, yes, save them, save

507
00:23:15.440 --> 00:23:18.039
<v Speaker 2>them using PLT, dot SA, fig is, BDF or p

508
00:23:18.160 --> 00:23:20.519
<v Speaker 2>and G files and then include those image files in

509
00:23:20.599 --> 00:23:23.640
<v Speaker 2>your LATEX document or word DOOC or whatever you're using.

510
00:23:23.759 --> 00:23:26.839
<v Speaker 1>And there was a final step converting the whole notebook.

511
00:23:27.079 --> 00:23:30.319
<v Speaker 2>Yeah, the source mentioned at command line tool Jupiter andb convert.

512
00:23:30.920 --> 00:23:33.400
<v Speaker 2>You can use it to take your dot IPNB notebook

513
00:23:33.440 --> 00:23:37.119
<v Speaker 2>file and automatically convert it into different final formats like

514
00:23:37.240 --> 00:23:40.000
<v Speaker 2>dot text for LATEX, or even directly to PDF if

515
00:23:40.000 --> 00:23:42.160
<v Speaker 2>you have LATEX installed, HTML and others.

516
00:23:42.359 --> 00:23:45.880
<v Speaker 1>So it automates turning that dynamic analysis notebook into a

517
00:23:46.000 --> 00:23:48.359
<v Speaker 1>static shareable report exactly.

518
00:23:48.480 --> 00:23:49.839
<v Speaker 3>It completes the workflow loop.

519
00:23:50.000 --> 00:23:53.839
<v Speaker 1>Wow, so thinking about it, it's a whole ecosystem setting

520
00:23:53.880 --> 00:23:56.680
<v Speaker 1>up the problem using numpi and simply for the heavy math,

521
00:23:57.119 --> 00:24:01.960
<v Speaker 1>managing data and loadcases with pandas, visualizing insights with matt plotlib,

522
00:24:02.200 --> 00:24:05.559
<v Speaker 1>and then automating the report output potentially all linked together

523
00:24:05.640 --> 00:24:08.759
<v Speaker 1>in a Jupiter notebook. That is genuinely powerful.

524
00:24:08.920 --> 00:24:09.440
<v Speaker 3>It really is.

525
00:24:09.799 --> 00:24:11.759
<v Speaker 2>And I think what this deep dive into the source

526
00:24:11.799 --> 00:24:13.920
<v Speaker 2>shows is that if you're an engineer who has been

527
00:24:13.920 --> 00:24:16.480
<v Speaker 2>maybe curious about programming, this is the kind of potential

528
00:24:16.519 --> 00:24:20.000
<v Speaker 2>that's there. Those first steps getting Anaconda installed, learning the

529
00:24:20.079 --> 00:24:22.359
<v Speaker 2>core Python syntax, they're the launch pat They.

530
00:24:22.319 --> 00:24:24.400
<v Speaker 1>Open the door to all these advanced capabilities.

531
00:24:24.759 --> 00:24:28.640
<v Speaker 2>Yeah, and the guide really hammered this home practice is key.

532
00:24:28.720 --> 00:24:30.720
<v Speaker 2>You can't just read about it. You have to try

533
00:24:30.759 --> 00:24:32.920
<v Speaker 2>applying these tools to the kinds of problems.

534
00:24:32.599 --> 00:24:33.279
<v Speaker 3>You actually work on.

535
00:24:33.480 --> 00:24:35.319
<v Speaker 1>Makes sense. The more you use it, the more natural

536
00:24:35.400 --> 00:24:35.759
<v Speaker 1>it feels.

537
00:24:35.960 --> 00:24:38.920
<v Speaker 2>Exactly, it becomes more intuitive, you get faster, you start

538
00:24:39.000 --> 00:24:41.319
<v Speaker 2>seeing new ways to apply it. It's a skill that

539
00:24:41.480 --> 00:24:44.359
<v Speaker 2>just enhances everything else you do as an engineer. Boost

540
00:24:44.400 --> 00:24:49.079
<v Speaker 2>efficiency improves accuracy, lets you tackle problems that maybe felt out.

541
00:24:49.000 --> 00:24:49.720
<v Speaker 3>Of reach before.

542
00:24:49.960 --> 00:24:52.519
<v Speaker 1>So let's leave our listeners with a final thought, if

543
00:24:52.559 --> 00:24:55.920
<v Speaker 1>you can use these Python tools to, say, analyze complex

544
00:24:56.000 --> 00:24:59.759
<v Speaker 1>individual components like beams or columns, manage huge sets of

545
00:24:59.759 --> 00:25:04.920
<v Speaker 1>low cases, automate design checks, and generate reports. Where could

546
00:25:04.920 --> 00:25:06.119
<v Speaker 1>you take that next?

547
00:25:06.880 --> 00:25:08.279
<v Speaker 3>What are the bigger possibilities?

548
00:25:08.480 --> 00:25:11.599
<v Speaker 1>Could you scale these techniques up to analyze entire structural

549
00:25:11.640 --> 00:25:15.680
<v Speaker 1>systems more effectively? Could you use Python to run iterative

550
00:25:15.720 --> 00:25:19.039
<v Speaker 1>design optimizations, maybe searching for the most efficient beam size

551
00:25:19.079 --> 00:25:20.400
<v Speaker 1>or trust geometry, or what.

552
00:25:20.440 --> 00:25:24.400
<v Speaker 2>About connecting to real world data, analyzing sensor readings coming

553
00:25:24.440 --> 00:25:26.720
<v Speaker 2>off a bridge or building in near real time.

554
00:25:27.079 --> 00:25:30.839
<v Speaker 1>Exactly when you combine those fundamental engineering principles with the

555
00:25:30.960 --> 00:25:34.960
<v Speaker 1>kind of computational power and flexibility Python offers, well, the

556
00:25:35.000 --> 00:25:37.480
<v Speaker 1>possibilities start to look pretty vast, don't they
