def extract_results(self):
'Extract results and calculated quantities from ABAQUS output'
def spoke_buckle_load(pd_data):
'Get load at which spokes start to buckle'
return pd_data.RF3[np.nonzero(pd_data.n_buckled)[0][0]]
for i in self.db.index:
print('.', end='')
j = self.db.loc[i]
w = self.wheel_from_row(j)
mm = ModeMatrix(w)
try:
# Buckling tension
Tc, nc = calc_buckling_tension(w)
self.db.at[i, 'Tc'] = Tc
self.db.at[i, 'nc'] = nc
# Get load-deflection data
if j['sim_type'] == 'exp':
pd_fname = self.out_dir + '/' + j.name + '_collapse_Pd.csv'
elif j['sim_type'] == 'riks':
pd_fname = self.out_dir + '/' + j.name + '_riks_Pd.csv'
pd_data = pd.read_csv(pd_fname)
pd_data.columns = ['Time', 'U3', 'RF3', 'n_buckled']
# Stiffness
w.apply_tension(0.01)
K_lat_0 = mm.calc_lat_stiff(smeared_spokes=True,
coupling=False)
K_rad_0 = mm.calc_rad_stiff(smeared_spokes=False,
coupling=False)
self.db.at[i, 'K_lat_0'] = K_lat_0
self.db.at[i, 'K_rad_0'] = K_rad_0
# Critical loads
self.db.at[i, 'Pc_max'] = max(pd_data.RF3)
self.db.at[i, 'Pc_spk'] = spoke_buckle_load(pd_data)
except Exception as e:
print('Error on {0:s}: {1:s}'.format(j.name, str(e)))
continue
def extract_results(self):
'Extract results and calculated quantities from ABAQUS output'
def Tc_Southwell(pd_data, T_max):
'Calculate Tc using Southwells method'
u = pd_data['U3 [m]'].values[1:]
T = pd_data['Tension [N]'].values[1:]
N = int(0.8*np.where(T >= T_max)[0][0])
p = np.polyfit(u[:N], u[:N]/T[:N], 2)
return 1. / (2*p[0]*u[N] + p[1])
def Tc_nonlin(pd_data, tol=0.02):
'Calculate Tc from departure from linearity'
# Fit straight line to first 10% of data
x, y = (pd_data['time'][:-1], pd_data['Tension [N]'][:-1])
N = int(np.max([10, np.ceil(0.10 * len(x))]))
pf = np.polyfit(x[:N], y[:N], 2)
err = (np.polyval(pf, x) - y) / np.max(y)
return y[np.argmax(np.abs(err) > tol)]
for i in self.db.index:
print('.', end='')
j = self.db.loc[i]
w = self.wheel_from_row(j)
try:
# Buckling tension
Tc, nc = calc_buckling_tension(w)
self.db.at[i, 'Tc'] = Tc
self.db.at[i, 'nc'] = nc
pd_data = pd.read_csv(self.out_dir + '/' + j.name + '_Pd.csv')
self.db.at[i, 'Tc_nonlin'] = Tc_nonlin(pd_data)
self.db.at[i, 'Tc_south'] = \
Tc_Southwell(pd_data, self.db.at[i, 'Tc_nonlin'])
except Exception as e:
print('Error on {0:s}: {1:s}'.format(j.name, str(e)))
continue
def write_input_files(self, N_batches=1):
# Open list of batch files
batchfiles = []
for b in range(N_batches):
fname = '{0:s}/_run_{1:d}.bat'.format(self.out_dir, b)
batchfiles.append(open(fname, 'w'))
pp_script = open('{0:s}/_postproc.bat'.format(self.out_dir), 'w')
b = 0
for jobname, j in self.db.iterrows():
w = self.wheel_from_row(j)
R = w.rim.radius
ns = len(w.spokes)
# Estimate buckling tension
Tc, nc = calc_buckling_tension(w)
vc = R*ns*Tc/(2*pi)/(w.rim.young_mod*w.rim.area)
w.apply_tension(Tc)
# Estimate temperature to cause buckling
deltaT = -j['sim_temp_factor']
alpha1 = (w.spokes[0].tension/w.spokes[0].EA +
vc*w.spokes[0].n[1]/w.spokes[0].length)
alpha2 = (w.spokes[1].tension/w.spokes[1].EA +
vc*w.spokes[1].n[1]/w.spokes[1].length)
if j['rim_perturb'] is None:
perturb_a = [0.00e-3, 0.01e-3, 0.01e-3]
else:
perturb_a = j['rim_perturb']
if j['spk_eltype'] == 'truss':
am = AbaqusModel(w, n_spk=1)
else:
am = AbaqusModel(w, n_spk=10)
def perturb_rim(theta):
u = 0.0
for n in range(len(perturb_a)):
u = u + perturb_a[n]*cos((n+1)*theta)
return u
# Write ABAQUS input file
with open(self.out_dir + '/' + jobname + '.inp', 'w') as f:
f.write('*Heading\n' +
'** Tension buckling with {0:s} spokes\n'.format(j['spk_eltype']) +
'**\n')
f.write(am.write_heading('Nodes'))
f.write(am.write_rim_nodes(f_perturb=perturb_rim))
f.write(am.write_spoke_nodes())
f.write(am.write_rigid_ties())
f.write(am.write_heading('Elements'))
f.write(am.write_rim_elems())
if j['spk_eltype'] == 'truss':
f.write(am.write_spoke_elems(eltype='T3D2'))
else:
f.write(am.write_spoke_elems())
f.write(am.write_heading('Sections'))
f.write(am.write_beam_sections(alpha1=alpha1, alpha2=alpha2))
f.write(am.write_heading('Boundary conditions'))
f.write(am.write_bc_fix_hub())
f.write(am.write_heading('Apply tension'))
f.write('*STEP, name=buckle, nlgeom=yes\n' +
'*STATIC\n' +
' 1.0e-3, , , 2.0e-2\n' +
'*TEMPERATURE\n' +
'nsetSpokes, {temp:e}\n'.format(temp=deltaT) +
'*OUTPUT, field, variable=PRESELECT\n' +
'*ELEMENT OUTPUT, elset=elsetSpokes\nSF\n' +
'*ELEMENT OUTPUT, elset=elsetRim\nSF\n' +
'*OUTPUT, history, variable=PRESELECT\n' +
'*END STEP\n')
# Write to batch file
bf = batchfiles[b]
bf.write('call abaqus interactive ')
bf.write('job={0:s} input={0:s}.inp\n'.format(jobname))
# Next batchfile
b = (b + 1) % N_batches
# Write entry to postprocess script
pp_script.write('call abaqus python postproc_tension.py ' +
'{0:s}.odb\n'.format(jobname))
# Close batch files
for f in batchfiles:
f.close()
def extract_results(self):
'Extract results and calculated quantities from ABAQUS output'
def buckling_load_southwell(pd_data):
'Get critical buckling load from Southwell plot'
pass
def buckling_load_nonlin(pd_data):
'Get critical buckling from departure from linearity'
# Fit straight line to first 5% of data
N = int(np.ceil(0.05 * len(pd_data)))
pf = np.polyfit(pd_data['U2'][:N], pd_data['RF2'][:N], 1)
err = (np.polyval(pf, pd_data['U2']) - pd_data['RF2']) /\
np.mean(pd_data['RF2'])
return pd_data['RF2'][np.argmax(np.abs(err) > 0.02)]
def calc_T_nb(w, K_lat_0, K_rad_0, Tc, form=1):
'Calculate minimum spoke tension for no spoke buckling'
R = w.rim.radius
EA = w.spokes[0].EA
alpha = w.spokes[0].alpha
ls = w.spokes[0].length
if form == 2:
# Quadratic approximation for K_lat(T)
x = K_rad_0 * Tc * ls / (2 * EA * K_lat_0 * R * np.cos(alpha))
return np.sqrt(1 + x**2) - x
else:
# Linear approximation for K_lat(T)
return 1.0 / (1 + K_rad_0 * ls * Tc /
(K_lat_0 * R * EA * np.cos(alpha)))
def calc_P_nb(w, K_lat_0, K_rad_0, Tc, form=1):
'Critical load at the critical no-buckling tension'
R = w.rim.radius
EA = w.spokes[0].EA
alpha = w.spokes[0].alpha
ls = w.spokes[0].length
if form == 2:
# Quadratic approximation for K_lat(T)
x = K_rad_0 * Tc * ls / (2 * EA * K_lat_0 * R * np.cos(alpha))
T_nb = np.sqrt(1 + x**2) - x
return K_lat_0 * R * (1 - T_nb**2)
else:
# Linear approximation for K_lat(T)
return K_lat_0 * R / (1 + EA / Tc * K_lat_0 / K_rad_0)
for i in self.db.index:
print('.', end='')
j = self.db.loc[i]
w = self.wheel_from_row(j)
mm = ModeMatrix(w)
try:
# Buckling tension
Tc, nc = calc_buckling_tension(w)
self.db.at[i, 'Tc'] = Tc
self.db.at[i, 'nc'] = nc
# Get load-deflection data
pd_data = pd.read_csv(self.out_dir + '/' + j.name +
'_collapse_Pd.csv')
pd_data.columns = ['Time', 'U2', 'RF2', 'U3', 'n_buckled']
# Stiffness at zero tension
w.apply_tension(0.01)
K_lat_0 = mm.calc_lat_stiff(smeared_spokes=True,
coupling=False)
K_rad_0 = mm.calc_rad_stiff(smeared_spokes=False,
coupling=False)
w.apply_tension(j['spk_T'])
K_lat = mm.calc_lat_stiff(smeared_spokes=True, coupling=False)
self.db.at[i, 'K_lat_0'] = K_lat_0
self.db.at[i, 'K_rad_0'] = K_rad_0
self.db.at[i, 'K_lat'] = K_lat
# Radial buckling load
self.db.at[i, 'Pc_max'] = max(pd_data.RF2)
self.db.at[i, 'Pc_nonlin'] = buckling_load_nonlin(pd_data)
self.db.at[i, 'T_nb'] = calc_T_nb(w, K_lat_0, K_rad_0, Tc)
self.db.at[i, 'Pc_nb'] = calc_P_nb(w, K_lat_0, K_rad_0, Tc)
self.db.at[i, 'T_nb_2'] = calc_T_nb(w,
K_lat_0,
K_rad_0,
Tc,
form=2)
self.db.at[i, 'Pc_nb_2'] = calc_P_nb(w,
K_lat_0,
K_rad_0,
Tc,
form=2)
except Exception as e:
print('Error on {0:s}: {1:s}'.format(j.name, str(e)))
continue