elset='elset_lines'))
# Displacements
boundary = network.leaves()
mdl.add(PinnedDisplacement(name='disp', nodes=boundary))
# Loads
mdl.add(PointLoad(name='load_weights', nodes='load_pts', z=-100))
# Steps
mdl.add([
GeneralStep(name='step_bc', displacements=['disp']),
GeneralStep(name='step_load', loads='load_weights'),
])
mdl.steps_order = ['step_bc', 'step_load']
# Summary
# mdl.summary()
# Run
exe = '/Applications/OpenSees3.2.1/OpenSees'
mdl.write_input_file('opensees', fields='u')
mdl.analyse('opensees', exe=exe, cpus=4, license='research')
mdl.extract_data('opensees', fields='u', steps='all', exe=exe)
mdl.analyse_and_extract(software='opensees', exe=exe, fields=['u'])
# print(mdl.results['step_load']['nodal']['um'][0])
#print(mdl.loads['loads'])
#print(mdl.loads['gravity'])
#print(mdl.loads['pressure'])
mdl.add([
GeneralStep(name='bc', displacements='pinned'),
GeneralStep(name='loads',
loads=['gravity', 'loads', 'pressure'],
factor=1.5),
BucklingStep(name='buckling',
modes=3,
loads=['gravity', 'loads', 'pressure'],
displacements='pinned'),
ModalStep(name='modal', modes=3),
])
mdl.steps_order = ['bc', 'loads', 'buckling', 'modal']
#print(mdl.steps['bc'])
#print(mdl.steps['loads'])
#print(mdl.steps['buckling'])
#print(mdl.steps['modal'])
#mdl.summary()
# Run
mdl.analyse_and_extract(software='abaqus', fields=['u', 's', 'rf', 'cf'])
rhino.plot_data(mdl, step='loads', field='um')
rhino.plot_data(mdl, step='loads', field='smaxp')
rhino.plot_data(mdl, step='loads', field='sminp')
# add gravity load -------------------------------------------------------------
s.add_load(GravityLoad(name='load_gravity', elements=['shell']))
# add steps --------------------------------------------------------------------
step = GeneralStep(name='gravity_step',
nlgeom=False,
displacements=['supports'],
loads=['load_gravity'],
type='static')
s.add_steps([step])
s.steps_order = ['gravity_step']
# analyse ----------------------------------------------------------------------
fields = 'all'
s.write_input_file(software='ansys', fields=fields)
s.analyse(software='ansys', cpus=4, delete=True)
s.extract_data(software='ansys', fields=fields, steps='last')
# visualise results ------------------------------------------------------------
rhino.plot_data(s,
step='gravity_step',
field='uz',
scale=100,
colorbar_size=0.3)
'y': float(rs.ObjectName(i))
}
mdl.add([
PointLoads(name='load_points', components=loads),
PrestressLoad(name='load_prestress', elements='elset_tie', sxx=50 * 10**6),
])
# Steps
mdl.add([
GeneralStep(name='step_bc', displacements=['disp_pin', 'disp_roller']),
GeneralStep(name='step_prestress', loads=['load_prestress']),
GeneralStep(name='step_load', loads=['load_points']),
])
mdl.steps_order = ['step_bc', 'step_prestress', 'step_load']
# Summary
mdl.summary()
# Run
mdl.analyse_and_extract(software='abaqus', fields=['u', 'cf', 's', 'rf'])
cbar1 = [-4 * 10**6, 0]
cbar2 = [0, 2 * 10**6]
rhino.plot_data(mdl,
step='step_prestress',
field='sminp',
# Properties
mdl.add([Properties(name='ep_concrete', material='mat_concrete', section='sec_concrete', elset='elset_concrete'),
Properties(name='ep_mass', section='sec_mass', elset='elset_mass')])
# Displacements
mdl.add(PinnedDisplacement(name='disp_pinned', nodes='nset_pins'))
# Steps
mdl.add([
GeneralStep(name='step_bc', displacements=['disp_pinned']),
ModalStep(name='step_modal', modes=5),
])
mdl.steps_order = ['step_bc', 'step_modal']
# Summary
mdl.summary()
# Run
mdl.analyse_and_extract(software='abaqus', fields=['u'])
rhino.plot_mode_shapes(mdl, step='step_modal', layer='mode-')
print(mdl.results['step_modal']['frequencies'])
print(mdl.results['step_modal']['masses'])
mdl.add(PointLoads(name='load_points', components=point_loads))
# Steps
displacements = ['disp_top', 'disp_bot']
loads = ['load_gravity', 'load_points']
mdl.add([
GeneralStep(name='step_bc', displacements=displacements),
GeneralStep(name='step_loads', loads=loads, factor=1.35),
BucklingStep(name='step_buckle',
loads=loads,
displacements=displacements,
modes=5),
])
mdl.steps_order = ['step_bc', 'step_loads', 'step_buckle']
# Summary
mdl.summary()
# Run
mdl.analyse_and_extract(software='abaqus',
fields=['u', 's'],
components=['ux', 'uy', 'uz', 'um', 'smaxp', 'sminp'])
rhino.plot_data(mdl, step='step_loads', field='uz', radius=0.01, cbar_size=0.5)
rhino.plot_data(mdl,
step='step_loads',
field='smaxp',
# Displacements
mdl.add(FixedDisplacement(name='disp_pins', nodes=[0, 2, 8, 6]))
# Loads
mdl.add(PointLoad(name='load_v', nodes=[4], z=-1000))
# Steps
mdl.add(
GeneralStep(name='step_bc_loads',
displacements=['disp_pins'],
loads=['load_v'],
nlgeom=False))
mdl.steps_order = ['step_bc_loads']
# Summary
# mdl.summary()
# Run (Abaqus)
# mdl.analyse_and_extract(software='abaqus', fields=['u', 'rf'], license='research')
# Run (Ansys)
mdl.analyse_and_extract(software='ansys', fields=['sf'], license='research')
# print(mdl.get_nodal_results(step='step_loads', field='rfm', nodes='nset_pins'))
Properties(name='ep_solid_0', material='mat_2', section='sec_solid', elset='elset_blocks_layer_0'),
Properties(name='ep_beams', material='mat_3', section='sec_rectangle', elset='elset_beams'),
Properties(name='ep_membrane', material='mat_2', section='sec_membrane', elset='elset_membranes', rebar=rebar),
])
# Displacements
mdl.add([
PinnedDisplacement(name='disp_pinned', nodes='nset_bot'),
RollerDisplacementY(name='disp_roller', nodes='nset_top'),
GeneralDisplacement(name='disp_move', nodes='nset_top', y=0.010)
])
# Steps
mdl.add([
GeneralStep(name='step_bc', displacements=['disp_pinned', 'disp_roller']),
GeneralStep(name='step_move', displacements=['disp_move']),
])
mdl.steps_order = ['step_bc', 'step_move']
# Structure
mdl.summary()
# Run
mdl.analyse_and_extract(software='abaqus', fields=['u', 's'], components=['ux', 'uy', 'uz', 'smises'])
rhino.plot_data(mdl, step='step_move', field='smises', radius=0.002)
def compute_compas_fea(file_path, load_path, fea_engine='abaqus', recompute=True):
""" Use abaqus (via compas_fea) to perform elastic FEA on the given frame
under a given load case. If no load path is specified, elemental gravity
will be assumbed to be applied.
Parameters
----------
file_path : string
full path to the frame shape's json file.
load_path : type
full path to the load case's json file.
Returns
-------
nD: dict
Reactional nodal displacement
key is the node id.
value is
(nodal_id, dx, dy, dz, theta_x, theta_y, theta_z).
fR: dict
Fixities reaction force, moment.
key is the nodal id.
value is [Fxyz, Mxyz] in the global axes.
eR: dict
Element-wise reaction force, moment (two ends).
key is the element id.
(Fxyz_1, Mxyz_1, Fxyz_2, Mxyz_2)
"""
root_dir = os.path.dirname(os.path.abspath(__file__))
temp_dir = os.path.join(root_dir, 'compas_fea-temp')
if not os.path.exists(temp_dir):
os.makedirs(temp_dir)
file_json_name = file_path.split(os.sep)[-1]
file_name = file_json_name.split('.')[0]
print('compas_fea initing: file name {}'.format(file_name))
if not recompute:
nD, fR, eR = parse_abaqus_result_json(file_name, temp_dir)
return nD, fR, eR
with open(file_path, 'r') as f:
json_data = json.loads(f.read())
load_json_data = {}
if load_path:
with open(load_path, 'r') as f:
load_json_data = json.loads(f.read())
# init an empty structure
mdl = Structure(name=file_name, path=os.path.join(temp_dir, ''))
# nodes
mdl.add_nodes(nodes=parse_frame_nodes(json_data))
# elements
elements = parse_elements(json_data)
# align local axes with conmech
sc = stiffness_checker(json_file_path=file_path, verbose=False)
e_rot_mats = sc.get_element_local2global_rot_matrices()
assert len(e_rot_mats) == len(elements)
for e, mat in zip(elements, e_rot_mats):
# compas_fea local axis convention is differrent to the one used in conmech:
# in compas_fea
# 'ex' axis represents the cross-section’s major axis
# 'ey' is the cross-section’s minor axis
# 'ez' is the axis along the element
# TODO: this numpy array to list conversion
# is essential to make compas_fea work...
ez = list(mat[0][0:3]) # conmech longitude axis
ex = list(mat[1][0:3]) # conmech cross sec major axis
ey = list(mat[2][0:3]) # conmech cross sec minor axis
mdl.add_element(nodes=e,
type='BeamElement',
axes={'ex': ex, 'ey': ey, 'ez': ez})
# print(mdl.elements[mdl.check_element_exists(nodes=e)])
assert_equal(mdl.element_count(), len(elements))
# Sets
# just convenient aliases for referring to a group of elements
mdl.add_set(name='elset_all', type='element', selection=list(range(mdl.element_count())))
mdl.add_set(name='nset_all', type='node', selection=list(range(mdl.node_count())))
fixities = parse_fixties(json_data)
mdl.add_set(name='nset_fix', type='node', selection=[f[0] for f in fixities])
if load_json_data:
pt_loads, include_sw = parse_load_case(load_json_data)
# mdl.add_set(name='nset_pt_load', type='node', selection=[l[0] for l in pt_loads])
else:
pt_loads = []
include_sw = True
if pt_loads:
mdl.add_set(name='nset_v_load_all', type='node', selection=[pl[0] for pl in pt_loads])
# Materials
# Young’s modulus E [in units of Pa]
# Poisson’s ratio v and density p [kg per cubic metre].
mat_json = json_data['material_properties']
mat_name = 'mat_' + mat_json['material_name']
E_scale = parse_pressure_scale_conversion(mat_json['youngs_modulus_unit'])
p_scale = parse_density_scale_conversion(mat_json['density_unit'])
mdl.add(ElasticIsotropic(name=mat_name,
E=E_scale * mat_json['youngs_modulus'],
v=mat_json['poisson_ratio'],
p=p_scale * mat_json['density']))
# G_scale = parse_pressure_scale_conversion(mat_json['shear_modulus_unit'])
# print('{}, {}'.format(mdl.materials['mat_' + mat_json['material_name']].G, G_scale * mat_json['shear_modulus']))
# assert_almost_equal(mdl.materials['mat_' + mat_json['material_name']].G['G'], G_scale * mat_json['shear_modulus'])
# print('-----------material')
# print(mdl.materials[mat_name])
# Sections
# SI units should be used, this includes the use of metres m for cross-section dimensions, not millimetres mm.
sec_name = 'sec_circ'
mdl.add(CircularSection(name=sec_name, r=parse_circular_cross_sec_radius(json_data)))
# print('-----------cross section')
# print(mdl.sections[sec_name])
# Properties, associate material & cross sec w/ element sets
mdl.add(Properties(name='ep_all', material=mat_name, section=sec_name, elset='elset_all'))
# Displacements
# pin supports
for i, fix in enumerate(fixities):
f_dof = []
for j in range(6):
if fix[j+1] == 1:
f_dof.append(0)
else:
f_dof.append(None)
mdl.add(GeneralDisplacement(name='disp_fix_'+str(i), nodes=[fix[0]], x=f_dof[0], y=f_dof[1], z=f_dof[2], xx=f_dof[3], yy=f_dof[4], zz=f_dof[5]))
# print('-----------fixities')
# for i in range(len(fixities)):
# print(mdl.displacements['disp_fix_'+str(i)])
# Loads
if pt_loads:
mdl.add([PointLoad(name='load_v_'+str(i), nodes=[pl[0]],
x=pl[1], y=pl[2], z=pl[3],
xx=pl[4], yy=pl[5], zz=pl[6])
for i, pl in enumerate(pt_loads)])
if include_sw:
mdl.add(GravityLoad(name='load_gravity', elements='elset_all'))
else:
mdl.add(GravityLoad(name='load_gravity', elements='elset_all'))
# print('-----------loads')
# print(mdl.loads['load_gravity'])
# for i in range(len(pt_loads)):
# print(mdl.loads['load_v_'+str(i)])
# Steps
loads_names = []
if pt_loads:
loads_names.extend(['load_v_'+str(i) for i in range(len(pt_loads))])
if include_sw:
loads_names.append('load_gravity')
mdl.add([
GeneralStep(name='step_bc', displacements=['disp_fix_'+str(i) for i in range(len(fixities))]),
GeneralStep(name='step_loads', loads=loads_names)
])
# a boundary condition step such as 'step_bc' above, should always be applied as the first step to prevent rigid body motion
mdl.steps_order = ['step_bc', 'step_loads']
# Summary
mdl.summary()
# Run
# node
# 'u': nodal displacement: ux, uy, uz, um (magnitude)
# 'ur': nodal rotation
# 'rf': reaction force
# 'cf': concentrated force (external load)
# 'cm': concentrated moment (external load)
# element
# 's': beam stress (conmech cannot compute this at
# version 0.1.1)
# For beam, the following values are evaluated
# at the "integration point" 'ip1' (middle point)
# and pts along the axis: 'sp3, sp7, sp11, sp15'
# sxx: axial
# syy: hoop
# sxy: torsion
# smises: Von Mises
# smaxp: max principal
# sminp: min principal
# 'sf': beam section force
# sf1: axial
# sf2: shear x
# sf3: shear y
if fea_engine == 'abaqus':
mdl.analyse_and_extract(software='abaqus', fields=['u', 'ur', 'rf', 'rm', 'sf'], ndof=6, output=True)
nD, fR, eR = parse_abaqus_result_json(file_name, temp_dir)
elif fea_engine == 'opensees':
mdl.analyse_and_extract(software='opensees', fields=['u'], exe=OPENSEES_PATH, ndof=6, output=True, save=True)
raise NotImplementedError('opensees from compas_fea is not fully supported at this moment...')
nD = {}
fR = {}
eR = {}
# nD = mdl.get_nodal_results(step='step_load', field='ux', nodes='nset_all')
print(mdl.results)
else:
raise NotImplementedError('FEA engine not supported!')
return nD, fR, eR
mdl.add_displacement(
GeneralDisplacement(name=name, nodes=name, y=0, z=0, xx=0))
if 'Y' in beam:
mdl.add_displacement(
GeneralDisplacement(name=name, nodes=name, x=0, z=0, yy=0))
bc.append(name)
mdl.add_displacement(
GeneralDisplacement(name='disp_lift', nodes='lift_points', z=0.250))
# Steps
mdl.add_steps([
GeneralStep(name='step_bc', displacements=bc),
GeneralStep(name='step_lift', displacements=['disp_lift'])
])
mdl.steps_order = ['step_bc', 'step_lift']
# Summary
mdl.summary()
# Run (Abaqus)
mdl.analyse_and_extract(software='abaqus', fields=['u', 'sf', 'sm'])
rhino.plot_data(mdl,
step='step_lift',
field='um',
radius=0.005,
colorbar_size=0.3)
rhino.plot_data(mdl,
# print(mdl.displacements['pinned'])
mdl.add([
PointLoad(name='pointloads', nodes='loads', y=-50000),
GravityLoad(name='gravity', elements='trusses', z=0, y=1),
])
# print(mdl.loads['pointloads'])
# print(mdl.loads['gravity'])
mdl.add([
GeneralStep(name='bc', displacements='pinned'),
GeneralStep(name='loads', loads=['pointloads', 'gravity'], factor=1.5),
])
mdl.steps_order = ['bc', 'loads']
# print(mdl.steps['bc'])
# print(mdl.steps['loads'])
mdl.summary()
mdl.analyse_and_extract(software='abaqus', fields=['u', 's', 'cf', 'rf'])
print(mdl.get_nodal_results(step='loads', field='rfm', nodes='supports'))
# load / show .inp and .odb files
# show raw data, discuss methods to extract data
rhino.plot_data(mdl,
step='loads',
