Source code for streng.phd.building_models.model2d.model_input

# import pandas as pd
# import numpy as np
# import math
from dataclasses import dataclass, field
from typing import List, Dict
from tabulate import tabulate
from ....phd.building_models.model2d.slab_loads import *
from ....codes.greek.eak2000.raw.ch2.seismic_action import spectra
from ....ppp.sections.concrete.typical_sections.rectangular_rc import SectionMaterials
from ....ppp.sections.concrete.typical_sections.rectangular_rc import RectangularConcreteSection
from ....codes.greek.kanepe.assessment.section_properties.rectangular import RectangularKanepe as RectKanepe
from ....ppp.sections.concrete.reinforcement.rectangular_reinforcement import RectangularSectionReinforcement
from ....ppp.sections.concrete.reinforcement.combos import LongReinforcementLayer, TransReinforcementLayer
from ....common.io.output import OutputExtended, OutputString
import pickle
import gzip



[docs]@dataclass class Model2d: input_data: Dict[str, pd.DataFrame] = field(default_factory=dict) misc: Dict[str, object] = field(default_factory=dict) stories_total: int = 0 storey_levels: List[float] = field(init=False, repr=False, default_factory=list) storey_heights: List[float] = field(init=False, repr=False, default_factory=list) x_levels: List[float] = field(init=False, repr=False, default_factory=list) master_nodes: List[int] = field(init=False, repr=False, default_factory=list) base_level_nodes: List[int] = field(init=False, repr=False, default_factory=list) storey_masses: List[float] = field(init=False, repr=False, default_factory=list) fist_mode: List[float] = field(init=False, repr=False, default_factory=list) periods: List[float] = field(init=False, repr=False, default_factory=list) seismic_static_forces: Dict[str, list] = field(init=False, repr=False, default_factory=dict) elastic_gravity_element_forces: Dict[int, list] = field(init=False, repr=False, default_factory=dict) reinforcement_beams: Dict[str, dict] = field(init=False, repr=False, default_factory=dict) reinforcement_beams_kanepe: Dict[str, RectKanepe] = field(init=False, repr=False, default_factory=dict) reinforcement_columns_kanepe: Dict[str, RectKanepe] = field(init=False, repr=False, default_factory=dict) logs: OutputExtended = field(init=False, repr=False, default_factory=OutputExtended)
[docs] def get_eigen(self): from .os_input import OpenSeesModel2d os = OpenSeesModel2d(self, inelastic_analysis=False) os.tcl_make = True os.tcl_filename = '' os.os_run_elastic() self.periods = os.results.elastic_periods self.fist_mode = os.results.elastic_eigenvectors[0] self.elastic_gravity_element_forces = os.results.elastic_gravity_element_forces _log = ['---------------------------------------------------------------------------------------------', '------------- Periods - Eigenvectors ------------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] _log.append(' Mode Period (sec)') for i in range(0, self.stories_total): _log.append(f'{i+1:>5} {self.periods[i]:14.4f}') _log.append('') _log.append('Mode 1 - Horizontal displacements') _log.append(' Storey si') for i in range(0, self.stories_total): _log.append(f'{i+1:>5} {self.fist_mode[i]:14.4f}') _log.append('') _log.append('') self.logs.outputStrings['eigen'] = OutputString(data=_log)
[docs] def get_seismic_static_forces(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Seismic Static Forces -------------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] T0 = self.periods[0] V0_push = 1000. storeys = range(1, self.stories_total+1) m = np.array(self.storey_masses) s = np.array(self.fist_mode) ms = m * s forces_push_modal = V0_push*ms / sum(ms) forces_push_uni = V0_push*m / sum(m) forces_eak = np.zeros(len(m)) if self.misc['EAK_α'] > 0: _eak_ground = self.misc['EAK_ground'] _eak_α = self.misc['EAK_α'] _eak_Φd = spectra.Φd(T=T0, α=_eak_α*9.81, γI=1.0, T1=spectra.T1(_eak_ground), T2=spectra.T2(_eak_ground), q=3.5, η=1.0, θ=1.0, β0=2.5) V0_eak = sum(m) * _eak_Φd if T0>1.0: VH_eak = min(0.07*T0*V0_eak, 0.25*V0_eak) else: VH_eak = 0.0 forces_eak = (V0_eak-VH_eak) * ms / sum(ms) _log.append(f'T0 = {T0:.4f}sec') _log.append(f'Φd = {_eak_Φd:.3f}m/sec2') _log.append(f'V0_eak = {V0_eak:.2f}kN') _log.append(f'VH_eak = {VH_eak:.2f}kN') _log.append('') self.seismic_static_forces['EPUSHmod'] = forces_push_modal.tolist() self.seismic_static_forces['EPUSHuni'] = forces_push_uni.tolist() self.seismic_static_forces['EXSTAT'] = forces_eak.tolist() _df = pd.DataFrame(data = {'storey': storeys, 'm': m, 's': s, 'm*s':ms, 'E_push_modal': forces_push_modal, 'E_push_uni': forces_push_uni, 'E_eak': forces_eak}) _log.append(tabulate(_df, headers='keys', tablefmt='pipe', floatfmt=".4f")) _log.append('') _log.append('') self.logs.outputStrings['seismic_static_forces'] = OutputString(data=_log)
[docs] def load_excel_single(self, input_excel_filename): # Read the excel file xls = pd.ExcelFile(input_excel_filename) # Get worksheet names for sheet_name in xls.sheet_names: self.input_data[sheet_name] = xls.parse(sheet_name).set_index(self.excel_index_column[sheet_name])
[docs] def load_excel_collection(self, input_excel_filename, building_props): # Read the excel file xls = pd.ExcelFile(input_excel_filename) # Get worksheet names for sheet_name in xls.sheet_names: self.input_data[sheet_name] = \ xls.parse(sheet_name)[xls.parse(sheet_name).Building == building_props[sheet_name]].set_index(self.excel_index_column[sheet_name])
def __post_init__(self): self.excel_index_column = dict() self.excel_index_column['Misc'] = 'Building' self.excel_index_column['Nodes'] = 'NodeID' self.excel_index_column['Slabs'] = 'SlabID' self.excel_index_column['NodeSlabConn'] = 'NodeID' self.excel_index_column['BeamSlabConn'] = 'ElementID' self.excel_index_column['Sections'] = 'SectionName' self.excel_index_column['Elements'] = 'ElementID' self.excel_index_column['Concrete'] = 'ConcID' self.excel_index_column['BeamReinforcement'] = 'ReinforcementID' self.excel_index_column['ColumnReinforcement'] = 'ReinforcementID' self.excel_index_column['ModFactors'] = 'ElementType'
[docs] def prepare(self, get_eigen_from_opensees = False): self.process_misc() self.process_joint_coordinates() self.process_sections() self.log_table_elements() self.log_table_slabs() self.log_node_slab_connectivity() self.process_node_slab_connectivity() self.log_beam_slab_connectivity() self.process_beam_slab_connectivity() self.process_storey_masses() if get_eigen_from_opensees == True: self.get_eigen() self.get_seismic_static_forces()
[docs] def prepare_Mtheta(self): self.process_beam_reinforcement() self.process_column_reinforcement()
[docs] def process_misc(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Process Misc ----------------------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] self.misc = self.input_data['Misc'].iloc[0].to_dict() for key, value in self.misc.items(): _log.append(f'{key} = {value}') _log.append('') _log.append('') self.logs.outputStrings['misc'] = OutputString(data=_log)
[docs] def process_joint_coordinates(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Process Joint Coordinates ---------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] self.stories_total = max(self.input_data['Nodes']['Storey']) self.storey_levels = self.input_data['Nodes']['Z'].unique().tolist() self.x_levels = sorted(self.input_data['Nodes']['X'].unique().tolist(), key=float) st_h = [self.storey_levels[i + 1] - self.storey_levels[i] for i in range(0, self.stories_total)] self.storey_heights = st_h self.master_nodes = [int(self.input_data['Nodes'].query(f'Z=={sl}').first_valid_index()) for sl in self.storey_levels][1:] self.base_level_nodes = self.input_data['Nodes'].query(f'Z==0').index.tolist() _log.append(f'stories total = {self.stories_total}') _log.append(f'storey levels: {self.storey_levels}') _log.append(f'x levels: {self.x_levels}') _log.append(f'storey heights: {self.storey_heights}') _log.append(f'master nodes: {self.master_nodes}') _log.append(f'base level nodes: {self.base_level_nodes}') _log.append('') _log.append('-------- Coordinates --------------------------') _log.append(' Node X Y (Z) Storey Point_Etabs') for key, value in self.input_data['Nodes'].to_dict('index').items(): _log.append(f'{key:>7} {value["X"]:9.2f} {value["Z"]:9.2f} {value["Storey"]:>9} {value["Point_Etabs"]:>12}') _log.append('') _log.append('') self.logs.outputStrings['joints'] = OutputString(data=_log)
[docs] def process_sections(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Process Sections ------------------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] # *********** Προσθήκη στήλης με συνεργαζόμενα πλάτη ************************* beffs = [] for index, row in self.input_data['Sections'].iterrows(): if row['ElementType'] == 'BEAM': bw = row['b'] hf = self.misc['hf'] if row['Frame_Loc'] == 'IN': factor = 8. else: factor = 3. beffs.append(bw + factor * hf) else: beffs.append(None) self.input_data['Sections']['beff'] = beffs _log.append(tabulate(self.input_data['Sections'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['sections'] = OutputString(data=_log)
[docs] def log_table_elements(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Elements Table --------------------------------------------------------------', '---------------------------------------------------------------------------------------------', '', tabulate(self.input_data['Elements'], headers='keys', tablefmt='pipe', floatfmt=".2f"), '', ''] self.logs.outputStrings['elements'] = OutputString(data=_log)
[docs] def log_table_slabs(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Slabs Table -----------------------------------------------------------------', '---------------------------------------------------------------------------------------------', '', tabulate(self.input_data['Slabs'], headers='keys', tablefmt='pipe', floatfmt=".2f"), '', ''] self.logs.outputStrings['slabs'] = OutputString(data=_log)
[docs] def log_node_slab_connectivity(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Node-Slab Connectivity Table ------------------------------------------------', '---------------------------------------------------------------------------------------------', '', tabulate(self.input_data['NodeSlabConn'], headers='keys', tablefmt='pipe', floatfmt=".2f"), '', ''] self.logs.outputStrings['NodeSlabConnTable'] = OutputString(data=_log)
[docs] def process_node_slab_connectivity(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Process node-slab connectivity ----------------------------------------------', '---------------------------------------------------------------------------------------------', ''] _df_input = self.input_data['NodeSlabConn'][self.input_data['NodeSlabConn'].Frame_Trans_Loc.notnull()] _df_input = _df_input.fillna(value={'SlabConΔ1': '', 'SlabConΔ2': ''}) _df_input_nodes_dict = self.input_data['Nodes'].to_dict('index') _df = pd.DataFrame(columns=['NodeID']) _slabs_dict = self.input_data['Slabs'].to_dict('index') # import misc info _building_type = self.misc['building_type'] _γσκυρ = self.misc['γσκυρ'] _gπλ = self.misc['gπλ'] _qπλ = self.misc['qπλ'] _hf = self.misc['hf'] _gτοιχ_in = self.misc['gτοιχ_in'] _gτοιχ_out = self.misc['gτοιχ_out'] _hτοιχ = self.misc['hτοιχ'] _b_beam_y = self.misc['b_beam_y'] _h_beam_y = self.misc['h_beam_y'] _L_beam_y = self.misc['L_beam_y'] _h_storey = self.misc['h_storey'] _row_data = dict # ***************************************************************** # **** Φορτία στους κόμβους που συνδέονται με εγκάρσιες δοκούς **** # ***************************************************************** for index, row in _df_input.iterrows(): row_in_nodes_table = _df_input_nodes_dict[index] # import from excel table _NodeID = index _storey = row_in_nodes_table['Storey'] _pointEtabs = row_in_nodes_table['Point_Etabs'] _frame_trans_loc = row['Frame_Trans_Loc'] _slabConnΔ1 = row['SlabConΔ1'] _slabConnΔ2 = row['SlabConΔ2'] _col_geom_name = '' # ********* Ίδιο βάρος στύλου *********************** if _storey != self.stories_total: i = self.input_data['Elements'].query( '(NodeI==@_NodeID) & ' '((ElementType=="COLUMN_EX") | (ElementType=="COLUMN_IN")' ' | (ElementType=="WALL"))').first_valid_index() if i is not None: _col_geom_name = self.input_data['Elements']['SectionName'][i] _b_col, _h_col = self.get_element_b_h(_col_geom_name) else: _col_geom_name = '' _b_col, _h_col = 0., 0. # ********* Ίδιο βάρος τοιχοπληρώσεων **************** if _frame_trans_loc == 'IN': _gτοιχ = _gτοιχ_in else: _gτοιχ = _gτοιχ_out # ********* Φορτία εγκάρσιων δοκών ******************* if _slabConnΔ1 != '': _gΔ1πλ = phd_beam_loads_from_slabs(_slabs_dict, _slabConnΔ1, _gπλ) _qΔ1 = phd_beam_loads_from_slabs(_slabs_dict, _slabConnΔ1, _qπλ) _gΔ1ΙΒ = _γσκυρ * _b_beam_y * (_h_beam_y - _hf) if _storey != self.stories_total: _gΔ1τοιχ = _gτοιχ * _hτοιχ else: _gΔ1τοιχ = 0.0 _gΔ1ολ = _gΔ1πλ + _gΔ1ΙΒ + _gΔ1τοιχ else: _gΔ1πλ = 0. _qΔ1 = 0. _gΔ1ΙΒ = 0. _gΔ1τοιχ = 0. _gΔ1ολ = 0. if _slabConnΔ2 != '': _gΔ2πλ = phd_beam_loads_from_slabs(_slabs_dict, _slabConnΔ2, _gπλ) _qΔ2 = phd_beam_loads_from_slabs(_slabs_dict, _slabConnΔ2, _qπλ) _gΔ2ΙΒ = _γσκυρ * _b_beam_y * (_h_beam_y - _hf) if _storey != self.stories_total: _gΔ2τοιχ = _gτοιχ * _hτοιχ else: _gΔ2τοιχ = 0.0 _gΔ2ολ = _gΔ2πλ + _gΔ2ΙΒ + _gΔ2τοιχ else: _gΔ2πλ = 0. _qΔ2 = 0. _gΔ2ΙΒ = 0. _gΔ2τοιχ = 0. _gΔ2ολ = 0. _G_col = _γσκυρ * _b_col * _h_col * _h_storey _G = (_gΔ1ολ + _gΔ2ολ) * _L_beam_y / 2.0 + _G_col _Q = (_qΔ1 + _qΔ2) * _L_beam_y / 2.0 _row_data = {'NodeID': _NodeID, 'Storey': _storey, 'Point_Etabs': _pointEtabs, 'ColGeom': _col_geom_name, 'gπλ': _gπλ, 'qπλ': _qπλ, 'hf': _hf, 'gτοιχ': _gτοιχ, 'hτοιχ': _hτοιχ, 'b_col': _b_col, 'h_col': _h_col, 'b_beam_y': _b_beam_y, 'h_beam_y': _h_beam_y, 'gΔ1πλ': _gΔ1πλ, 'qΔ1': _qΔ1, 'gΔ2πλ': _gΔ2πλ, 'qΔ2': _qΔ2, 'gΔ1ΙΒ': _gΔ1ΙΒ, 'gΔ1τοιχ': _gΔ1τοιχ, 'gΔ1': _gΔ1ολ, 'gΔ2ΙΒ': _gΔ2ΙΒ, 'gΔ2τοιχ': _gΔ2τοιχ, 'gΔ2': _gΔ2ολ, 'G_col': _G_col, 'G': _G, 'Q': _Q, } _df = _df.append(_row_data, ignore_index=True) # ********************************************************************************* # **** Φορτία στους κόμβους που συνδέονται με τοιχώματα. Ίδιο βάρος τουχωμάτων **** # **** Το κάνω ξεχωριστά γιατί δε συνδέονται με εγκάρσιες δοκούς όπως παραπάνω **** # ********************************************************************************* _df_wall_part = self.input_data['Elements'].query('ElementType=="WALL"') for index, row in _df_wall_part.iterrows(): _storey = row['Storey'] # Ίδιο βάρος τοιχώματος if _storey!= self.stories_total: _wall_geom_name = row['SectionName'] _node_start = row['NodeI'] _pointEtabs = _df_input_nodes_dict[_node_start]['Point_Etabs'] _b_wall, _h_wall = self.get_element_b_h(_wall_geom_name) else: _wall_geom_name = '' _b_wall, _h_wall = 0., 0. _G_wall = _γσκυρ * _b_wall * _h_wall * _h_storey _row_data = {'NodeID': _node_start, 'Storey': _storey, 'Point_Etabs': _pointEtabs, 'ColGeom': _wall_geom_name, 'gπλ': 0.0, 'qπλ': 0.0, 'hf': 0.0, 'gτοιχ': 0.0, 'hτοιχ': 0.0, 'b_col': _b_wall, 'h_col': _h_wall, 'b_beam_y': 0.0, 'h_beam_y': 0.0, 'gΔ1πλ': 0.0, 'qΔ1': 0.0, 'gΔ2πλ': 0.0, 'qΔ2': 0.0, 'gΔ1ΙΒ': 0.0, 'gΔ1τοιχ': 0.0, 'gΔ1': 0.0, 'gΔ2ΙΒ': 0.0, 'gΔ2τοιχ': 0.0, 'gΔ2': 0.0, 'G_col': _G_wall, 'G': _G_wall, 'Q': 0.0, } _df = _df.append(_row_data, ignore_index=True) self.input_data['node_loads'] = _df[_row_data.keys()] # ********* Write log *********************** _log.append(tabulate(self.input_data['node_loads'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['node-slab'] = OutputString(data = _log)
[docs] def log_beam_slab_connectivity(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Beam-Slab Connectivity Table ------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] _log.append(tabulate(self.input_data['BeamSlabConn'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['BeamSlabConnTable'] = OutputString(data=_log)
[docs] def process_beam_slab_connectivity(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Process beam-slab connectivity ----------------------------------------------', '---------------------------------------------------------------------------------------------', ''] _df_input = self.input_data['BeamSlabConn'] _df = pd.DataFrame(columns=['ElementID', 'SectionName']) # import misc info _building_type = self.misc['building_type'] _γσκυρ = self.misc['γσκυρ'] _gπλ = self.misc['gπλ'] _qπλ = self.misc['qπλ'] _qπλ = self.misc['qπλ'] _hf = self.misc['hf'] _gτοιχ_in = self.misc['gτοιχ_in'] _gτοιχ_out = self.misc['gτοιχ_out'] _hτοιχ = self.misc['hτοιχ'] _row_data = dict() for index, row in _df_input.iterrows(): _elementID = index _geom_name = row['SectionName'] _storey = row['Storey'] _lineEtabs = row['Line_Etabs'] _slabConn = row['SlabConnectivity'] _frameLoc = row['Frame_Loc'] # Φορτίο από ίδιο βάρος _b, _h = self.get_element_b_h(_geom_name) _gΔΙΒ = _γσκυρ * _b * (_h - _hf) # Φορτίο από τοιχοπληρώσεις if _frameLoc == 'IN': _gτοιχ = _gτοιχ_in else: _gτοιχ = _gτοιχ_out if _storey != self.stories_total: _gΔτοιχ = _gτοιχ * _hτοιχ else: _gΔτοιχ = 0.0 # Φορτία από πλάκες _slabs_dict = self.input_data['Slabs'].to_dict('index') _gΔπλ = phd_beam_loads_from_slabs(_slabs_dict, _slabConn, _gπλ) _qΔ = phd_beam_loads_from_slabs(_slabs_dict, _slabConn, _qπλ) # Συνολικό φορτίο _gΔολ = _gΔπλ + _gΔΙΒ + _gΔτοιχ if row['SectionName'] != 'RIGID': _row_data ={'ElementID': _elementID, 'SectionName': _geom_name, 'Storey': _storey, 'Line_Etabs': _lineEtabs, 'SlabConnectivity': _slabConn, 'gπλ': _gπλ, 'qπλ': _qπλ, 'hf': _hf, 'gτοιχ': _gτοιχ, 'hτοιχ': _hτοιχ, 'b': _b, 'h': _h, 'gΔΙΒ': _gΔΙΒ, 'gΔτοιχ': _gΔτοιχ, 'gΔπλ': _gΔπλ, 'gΔ': _gΔολ, 'qΔ': _qΔ} else: _row_data ={'ElementID': _elementID, 'SectionName': _geom_name, 'Storey': _storey, 'Line_Etabs': _lineEtabs, 'SlabConnectivity': _slabConn, 'gπλ': _gπλ, 'qπλ': _qπλ, 'hf': None, 'gτοιχ': None, 'hτοιχ': None, 'b': None, 'h': None, 'gΔΙΒ': None, 'gΔτοιχ': None, 'gΔπλ': _gΔπλ, 'gΔ': _gΔπλ, 'qΔ': _qΔ} _df = _df.append(_row_data, ignore_index=True) self.input_data['beam_loads'] = _df[_row_data.keys()] # ********* Write log *********************** _log.append(tabulate(self.input_data['beam_loads'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['beam-slab'] = OutputString(data=_log)
[docs] def process_storey_masses(self): _log = ['---------------------------------------------------------------------------------------------', '------------- Process beam-slab connectivity ----------------------------------------------', '---------------------------------------------------------------------------------------------', ''] # *********** Masses from nodes ************************** m_nodes = [] _df_input_nodal = self.input_data['node_loads'] for i in range(0, self.stories_total): _g = _df_input_nodal.query(f'Storey=={i+1}')['G'].sum() _q = _df_input_nodal.query(f'Storey=={i+1}')['Q'].sum() m_nodes.append((_g + 0.3 * _q)/9.81) # *********** Masses from beams ************************** m_beams = [] _df_input_nodal = self.input_data['beam_loads'] for i in range(0, self.stories_total): _load = 0. beams_in_storey = _df_input_nodal.query(f'Storey=={i+1}') for index, row in beams_in_storey.iterrows(): _element_id = row['ElementID'] _gbeam = row['gΔ'] _qbeam = row['qΔ'] _element_length = self.get_element_length_by_ID(_element_id) _load += (_gbeam + 0.3 * _qbeam) * _element_length m_beams.append(_load / 9.81) # *********** Total torey masses ************************* m_tot = [sum(x) for x in zip(m_nodes, m_beams)] self.storey_masses = m_tot _data = {'Storey':[i for i in range(1, self.stories_total+1)], 'mass_nodes': m_nodes, 'mass_beams': m_beams, 'mass': m_tot} self.input_data['masses'] = pd.DataFrame(data=_data).set_index('Storey') # ********* Write log *********************** _log.append(tabulate(self.input_data['masses'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['masses'] = OutputString(data=_log)
[docs] def process_column_reinforcement(self): _log = ['---------------------------------------------------------------------------------------------', '------------- ColumnReinforcement Table ----------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] _dict = self.input_data['ColumnReinforcement'].fillna({'LongSide': '0Φ0', 'SideHoopLegs':0}).to_dict('index') _dict_sections = self.input_data['Sections'].to_dict('index') _dict_concrete = self.input_data['Concrete'].to_dict('index') for key, value in _dict.items(): _reinforcementID = key _sectionID = key _b = _dict_sections[_sectionID]['b'] _h = _dict_sections[_sectionID]['h'] _cnom = float(self.misc['cnom']) _fc = _dict_concrete['CONC']['fc'] _Ec = _dict_concrete['CONC']['E'] _fy = _dict_concrete['CONC']['fy'] _fyw = _dict_concrete['CONC']['fyw'] _Es = 200.e6 _element_id = (self.input_data['Elements'].query(f'ReinforcementID=="{_reinforcementID}"')).index.tolist()[0] _element_length = self.get_element_length_by_ID(_element_id) _longMain = value["LongMain"] _longSide = value["LongSide"] _trans = value["Trans"] _sideHoopLegs = value["SideHoopLegs"] _sectionMaterials = SectionMaterials(fc=_fc, Ec=_Ec, fy=_fy, Es=_Es, fyw=_fyw) self.reinforcement_columns_kanepe[f'{_reinforcementID}'] = \ self.__get_kanepe_Mtheta (b=_b, h=_h, cnom=_cnom, length=_element_length, materials=_sectionMaterials, long1str=_longMain, long2str=_longMain, transstr=_trans, longVstr=_longSide, disdiastr='0Φ0', N=0., side_legs=_sideHoopLegs) # ********* Write log *********************** _log.append(tabulate(self.input_data['ColumnReinforcement'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['column_reinforcement'] = OutputString(data=_log)
[docs] def process_beam_reinforcement(self): _log = ['---------------------------------------------------------------------------------------------', '------------- BeamReinforcement Table ------------------------------------------------------', '---------------------------------------------------------------------------------------------', ''] _dict = self.input_data['BeamReinforcement'].to_dict('index') _dict_sections = self.input_data['Sections'].to_dict('index') _dict_concrete = self.input_data['Concrete'].to_dict('index') for key, value in _dict.items(): _reinforcementID = key _sectionID = str(_reinforcementID[:_reinforcementID.rfind('.')]) _b = _dict_sections[_sectionID]['b'] _h = _dict_sections[_sectionID]['h'] _cnom = float(self.misc['cnom']) _fc = _dict_concrete['CONC']['fc'] _Ec = _dict_concrete['CONC']['E'] _fy = _dict_concrete['CONC']['fy'] _fyw = _dict_concrete['CONC']['fyw'] _Es = 200.e6 _element_id = (self.input_data['Elements'].query(f'ReinforcementID=="{_reinforcementID}"')).index.tolist()[0] _element_length = self.get_element_length_by_ID(_element_id) _longTopLeft = value["LongTopLeft"] _longBotLeft = value["LongBotLeft"] _transLeft = value["TransLeft"] _longTopRight = value["LongTopRight"] _longBotRight = value["LongBotRight"] _transRight = value["TransRight"] _sectionMaterials = SectionMaterials(fc=_fc, Ec=_Ec, fy=_fy, Es=_Es, fyw=_fyw) self.reinforcement_beams_kanepe[f'{_reinforcementID}.L.neg'] = \ self.__get_kanepe_Mtheta (b=_b, h=_h, cnom=_cnom, length=_element_length, materials=_sectionMaterials, long1str=_longTopLeft, long2str=_longBotLeft, transstr=_transLeft) self.reinforcement_beams_kanepe[f'{_reinforcementID}.L.pos'] = \ self.__get_kanepe_Mtheta (b=_b, h=_h, cnom=_cnom, length=_element_length, materials=_sectionMaterials, long1str=_longBotLeft, long2str=_longTopLeft, transstr=_transLeft) self.reinforcement_beams_kanepe[f'{_reinforcementID}.R.neg'] = \ self.__get_kanepe_Mtheta (b=_b, h=_h, cnom=_cnom, length=_element_length, materials=_sectionMaterials, long1str=_longTopRight, long2str=_longBotRight, transstr=_transRight) self.reinforcement_beams_kanepe[f'{_reinforcementID}.R.pos'] = \ self.__get_kanepe_Mtheta (b=_b, h=_h, cnom=_cnom, length=_element_length, materials=_sectionMaterials, long1str=_longBotRight, long2str=_longTopRight, transstr=_transRight) # ********* Write log *********************** _log.append(tabulate(self.input_data['BeamReinforcement'], headers='keys', tablefmt='pipe', floatfmt=".2f")) _log.append('') _log.append('') self.logs.outputStrings['beam_reinforcement'] = OutputString(data=_log)
def __get_kanepe_Mtheta(self, b, h, cnom, length, materials, long1str, long2str, transstr, longVstr='0Φ0', disdiastr='0Φ0', N=0., side_legs=0): _reinf = RectangularSectionReinforcement( long1=LongReinforcementLayer.from_string(reinf_string=long1str, units_input='mm', units_output='m'), long2=LongReinforcementLayer.from_string(reinf_string=long2str, units_input='mm', units_output='m'), longV=LongReinforcementLayer.from_string(reinf_string=longVstr, units_input='mm', units_output='m'), disdia=LongReinforcementLayer.from_string(reinf_string=disdiastr, units_input='mm', units_output='m'), trans=TransReinforcementLayer.from_string(reinf_string=transstr, units_input='mm', units_output='m'), cnom=cnom, side_hoop_legs= side_legs) return RectKanepe( rcs = RectangularConcreteSection(b=b, h=h, materials = materials, reinforcement = _reinf), Ls = length / 2.0, N = N, calc_on_init = False )
[docs] def get_element_length_by_ID(self, elementID): _nodeI, _nodeJ = self.get_element_endpoints(elementID) _nodeI_X = self.input_data['Nodes']['X'][_nodeI] _nodeI_Y = self.input_data['Nodes']['Y'][_nodeI] _nodeI_Z = self.input_data['Nodes']['Z'][_nodeI] _nodeJ_X = self.input_data['Nodes']['X'][_nodeJ] _nodeJ_Y = self.input_data['Nodes']['Y'][_nodeJ] _nodeJ_Z = self.input_data['Nodes']['Z'][_nodeJ] return self.get_element_length(_nodeI_X, _nodeI_Y, _nodeI_Z, _nodeJ_X, _nodeJ_Y, _nodeJ_Z)
[docs] def get_element_endpoints(self, elementID): _nodeI = int(self.input_data['Elements']['NodeI'][elementID]) _nodeJ = int(self.input_data['Elements']['NodeJ'][elementID]) return _nodeI, _nodeJ
[docs] @staticmethod def get_element_length(x_start, y_start, z_start, x_end, y_end, z_end): return ((x_end - x_start)**2 + (y_end - y_start)**2 + (z_end - z_start)**2)**0.5
[docs] def get_element_b_h(self, section_name): _b = self.input_data['Sections']['b'][section_name] _h = self.input_data['Sections']['h'][section_name] return _b, _h
[docs] def save_model(self, pathfilename): f = gzip.open(pathfilename + '.model', 'wb', compresslevel=9) pickle.dump(self, f) f.close()