In the Formwork text, many of the same tables we used for wall forms are the ones we use for slab forms, starting with the Plyform span limits found in Table 9.3. Again, Table 9.3 has values for 1/2" to 1", wet, Class I Plyform, with both $C_D = 1.0$ and $C_D = 1.25$, in either the strong or weak orientation. The other sheathing tables are for other support conditions.
Tables 9.6.1 through 9.8.4, covering beams, and are similar to the sheathing tables in that they are for different support conditions, and contain values for both duration factors. This time we will be using tables starting with 9.6 for our Joist and Stringer designs. Keep in mind that these beam tables contain values found using $C_D = 1.0$, and $C_D= 1.25$ so it is important to verify the table's load duration factor.
There are no wales in slabs so we will not be using Tables 9.9.1 through 9.11.2.
Tables 9.12.1 and 2 contain allowable axial loads of a variety of species, sizes, and effective lengths. The values in this table are only for a $C_D=1.0$. This is not unreasonable since you are much more likely to be reusing shores, which means their capacity would have to be calculated using a $C_D=1.0$ anyway.
Since the procedure for slab forms is very similar to wall forms we'll move straight to an example.
Design formwork for a concrete floor slab based on the following information:
%run Older_Classes/Temp_struc_v_3_beta.py
t_concrete = 9 #in
DL_form_work = 5.5 #psf
LL = 50 #psf
DL_fw = DL_form_work
LL = LL
t = t_concrete
SlabLoad = slab_load(t,LL = LL, DL_forms = DL_fw)
P = SlabLoad
print("Uninform pressure = %.2f psf"%P.value)
Uninform pressure = 168.00 psf
SlabLoad.work
(Always remember that the minimum live load on slabs is 50 psf for workers, and 75 psf for workers with motorized buggies.)
import pandas as pd
plyform = pd.read_csv("./Wood/Plyform_1.25_strong_spans.csv",index_col=0)
plyform.loc[150:200]
1/2_in_strong | 5/8_in_strong | 3/4_in_strong | 1_in_strong | 1/2_in_weak | 5/8_in_weak | 3/4_in_weak | 1_in_weak | |
---|---|---|---|---|---|---|---|---|
P | ||||||||
150 | 17 | 19 | 22 | 26 | 12 | 14 | 18 | 23 |
175 | 16 | 19 | 21 | 25 | 11 | 13 | 17 | 22 |
200 | 16 | 18 | 20 | 24 | 11 | 13 | 17 | 22 |
table_P = min(plyform['3/4_in_strong'][plyform.index>=P.value].index)
joist_spacing = int(plyform['3/4_in_strong'][plyform.index==table_P ])
print("Read down to {} psf and over to the 3/4 in column and find s = {}".format(table_P,joist_spacing))
Read down to 175 psf and over to the 3/4 in column and find s = 21
Since the problem statement indicated a 7 day load duration factor for everything but shores, i.e. $C_D = 1.25$, we use the left hand side of Table 9.2. The concrete pressure is over $150 psf$ in the left hand column, so we have to use $175 psf$.
For $3/4"$ Class I Plyform, subjected to a $175 psf$ pressure load, with $C_D = 1.25$, orientating the Plyform in the strong direction (grain perpendicular to the supports), and supported over three or more spans, the maximum support spacing is $21\text{"}$.
As a reminder, for the purposes of preparing you for the AIC exam, use $21\text{"}$ on center.
We need to determine the new line load to calculate the spacing of the joist supports.
w = line_load(P.value,joist_spacing/12)
# w=w_['value']
w.work
stringer_df = pd.read_csv("./Wood/Table_9.6.2.csv", index_col = 0)
table_w = min(stringer_df[r'$\text{4x4 DFL}$'][stringer_df.index>=w.value].index)
stringer_spacing = int(stringer_df[r'$\text{4x4 DFL}$'][stringer_df.index==table_w ])
print("Read down to {} plf and over to the 4x4 in column and find s = {} in.".format(table_w,stringer_spacing))
Read down to 300 plf and over to the 4x4 in column and find s = 69 in.
Now we look up the allowable support spacings for the joists in Table 9.6, again because the joists are being supported over three or more spans. Since, we are using Douglass Fir-Larch and $C_D=1.25$, we need to specifically use Table 9.6.2, (if we are reusing the joists again in another form, then we would look in Table 9.6.1).
Reading down to $300 plf$ in the pressure column, and over to the 4x4 column, we find that the maximum support spacings for the joists is $69\text{"}$.
We now need to determine the line load on the stringers to calculate their support spacing.
w = line_load(P.value,stringer_spacing/12)
# w=w_['value']
w.work
# joist_df = pd.read_csv("./Wood/Table_9.6.2.csv", index_col = 0)
table_w = min(stringer_df[r'$\text{4x6 DFL}$'][stringer_df.index>=w.value].index)
shore_spacing = int(stringer_df[r'$\text{4x6 DFL}$'][stringer_df.index==table_w ])
print("Read down to {} plf and over to the 4x6 in column and find s = {} in.".format(table_w,shore_spacing))
Read down to 1000 plf and over to the 4x6 in column and find s = 56 in.
Now we look up the allowable support spacings for the 4x6 stringers in Table 9.6.2. We do this because the stringers, just like the joists, are also supported over three or more spans.
Reading down to $1,000 plf$ in the pressure column, then over to the 4x6 column, we find that the maximum support spacing for the stringers is $56\text{"}$. If it had been less than $940 plf$ We might have been able to get away with using $900 plf$, but the slab for will also be carrying personnel, and we should always err on the side of caution when there is a high risk of injury.
P_axial = shore_load(P.value,stringer_spacing,shore_spacing)
print('Stringer s = {}", Shore s = {}"'.format(stringer_spacing,shore_spacing))
Stringer s = 69", Shore s = 56"
We need to determine the actual load on a shore to compare with its allowable load.
P_axial.work
shore_df = pd.read_csv("./Wood/Table_9.12.1_DFL.csv", index_col = 0)
shore_cap = shore_df[r'$\text{4x6 S4S}$'][14]
print("4x6 S4S P_allow = {} lbs".format(shore_cap))
shore_df.loc[13:15]
4x6 S4S P_allow = 3860.0 lbs
$\text{2x4 Rough}$ | $\text{2x4 S4S}$ | $\text{3x4 Rough}$ | $\text{3x4 S4S}$ | $\text{4x4 Rough}$ | $\text{4x4 S4S}$ | $\text{4x6 Rough}$ | $\text{4x6 S4S}$ | |
---|---|---|---|---|---|---|---|---|
$L_{effective}$ | ||||||||
13 | NaN | NaN | NaN | NaN | 3260 | 2840 | 5050 | 4460 |
14 | NaN | NaN | NaN | NaN | 2830 | 2460 | 4380 | 3860 |
15 | NaN | NaN | NaN | NaN | 2470 | NaN | 3830 | NaN |
print(P_axial.value)
print(P_axial.value-shore_cap)
shore_cap/P_axial.value*shore_spacing
4508.0 648.0
47.950310559006212
To determine the allowable shore load, we turn to Table 9.12.1, and look at Douglas Fir-Larch. We look up our shore length of 14 ft, and S4S 4x6s. This is the column on the right, and it reads $3,860 lbs$. This puts over by $650 lbs$. If we had adjusted for constructibility all along then our actual load would have been reduced to a point where we would have been OK. However, as our design stands we need to reduce the shore spacing to make it work.
$$\frac{s_{allow}}{P_{allow}} = \frac{s_{shore}}{P_{actual}}$$$$s_{allow} = \frac{s_{shore}}{P_{actual}}\times P_{allow}$$$$s_{allow} = \frac{56"}{4,508 lbs}\times 3,860 lbs$$$$s_{allow} = 47 \frac{15}{16}"$$print(joist_spacing,stringer_spacing,shore_spacing)
21 69 56
With $3/4\text{"}$ Class I Plyform, space the 4x4 joists every $21\text{"}$.
The 4x6 stringers, used to support the 4x4 joists, cannot be spaced more than $69\text{"}$ on center.
The 4x6 shores need to be spaced less than $56\text{"}$ on center. (Actually around to $48\text{"}$ on center.)
Again, the reason we are covering this, is that this material will show up on the AIC exam, and you might end up going to work for someone that believes this is the fastest way to work. Either way, you need to be able to use these tables.
Class website (Use this link to if you are taking the course on e-learning.)
Github.io version of course website (Do not use this link if you are taking this course in Summer A or B.)
IPython.org (IPython is the opensource software used in the development of much of this course.)
[Complete Software List](http: bviewer.ipython.org/github/damontallen/Construction-Lectures-Fall-2014/blob/master/Resources.ipynb)