civil-tools-v 0.0.1__py3-none-any.whl

CivilTools/YDBLoader/BuildingDefine/StairPart/StairPart.py

@@ -0,0 +1,206 @@
+import math
+from .StairComponent import Component
+from typing import List
+
+class Position:
+    @property
+    def lower_elevation(self):
+        return min(self.left_elevation, self.right_elevation)
+    @property
+    def higher_elevation(self):
+        return max(self.left_elevation, self.right_elevation)
+    @property
+    def total_height(self):
+        return self.higher_elevation - self.lower_elevation
+    @property
+    def left_plat_length(self):
+        return self.left_x2 - self.left_x1
+    @property
+    def right_plat_length(self):
+        return self.right_x2 - self.right_x1
+    @property
+    def main_plat_length(self):
+        return self.right_x1 - self.left_x2
+
+    def __init__(self, left_elevation, right_elevation, left_x1,left_x2
+                 , right_x1, right_x2):
+        self.left_elevation = left_elevation
+        self.right_elevation = right_elevation
+        self.left_x1 = left_x1
+        self.left_x2 = left_x2
+        self.right_x1 = right_x1
+        self.right_x2 = right_x2
+   
+class StairBeam:
+    
+    def __init__(self,width, height, offset):
+        self.width  = width
+        self.height = height
+        self.offset = offset
+
+
+class StairPart:
+    
+    @property
+    def stair_type(self):
+        left_extend = self.beam_list[1].offset + self.beam_list[1].width/2
+        right_extend = self.beam_list[2].offset + self.beam_list[2].width/2
+        if left_extend>=self.STAIR_EXTEND_LIMIT:
+            if right_extend >= self.STAIR_EXTEND_LIMIT:
+                return "DT"
+            else:
+                return "BT"
+        else:
+            if right_extend >= self.STAIR_EXTEND_LIMIT:
+                return "CT"
+            else:
+                return "AT"
+    
+    @property
+    def stair_elevation_range(self):
+        return f"{self.position.lower_elevation/1000:.3f}~{self.position.higher_elevation/1000:.3f}"
+    
+    @property
+    def total_height(self):
+        return abs(self.position.left_elevation - self.position.right_elevation)
+    
+    @property
+    def equivlent_main_slab_thick(self):
+        slope = math.atan(self.position.total_height / self.position.main_plat_length)
+        thick_1 = self.main_thick / math.cos(slope)
+        thick_2 = self.position.total_height / self.step_num / 2
+        return thick_1 + thick_2
+    
+    @property
+    def total_horizental_length(self):
+        length = self.position.right_x1 - self.position.left_x2
+        length += self.beam_list[1].offset + self.beam_list[1].width/2
+        length += self.beam_list[2].offset + self.beam_list[2].width/2
+        return length
+    @property
+    def left_extend_length(self):
+        if self.stair_type =="AT" or self.stair_type == "CT":
+            return 0
+        else:
+            return self.beam_list[1].offset + self.beam_list[1].width/2
+    
+    @property
+    def right_extend_length(self):
+        if self.stair_type =="AT" or self.stair_type == "BT":
+            return 0
+        else:
+            return self.beam_list[2].offset + self.beam_list[2].width/2
+    
+    @property 
+    def stair_length_list(self):
+        return [self.left_extend_length,self.total_horizental_length - self.left_extend_length - self.right_extend_length,self.right_extend_length]
+    
+    @property
+    def up_real_rebar_str(self):
+        return f"E{self.up_d:d}@{self.up_dis:d}"
+    
+    @property
+    def up_real_rebar_area(self):
+        return f"{(self.up_d*self.up_d * math.pi/4/self.up_dis):.3f}"
+    
+    
+    
+    
+
+    def get_calculate_moments(self)->List[float]:
+        if self.stair_type == "AT":
+            return [0,0,self.components[0].m_2,0,0]
+        elif self.stair_type == "BT":
+            return [0,self.components[0].m_2,self.components[1].m_2,0,0]
+        elif self.stair_type == "CT":
+            return [0,0,self.components[0].m_2,self.components[1].m_2,0]
+        elif self.stair_type == "DT":
+            return [0,self.components[0].m_2,self.components[1].m_2,self.components[2].m_2,0]
+        return [0,10,20,10,0]
+    
+    def get_calculate_shears(self)->List[float]:
+        if self.stair_type == "AT":
+            return [0,0,self.components[0].v1,self.components[0].v2,self.components[1].v1,self.components[1].v2,0,0]
+        elif self.stair_type == "BT":
+            return [self.components[0].v1,self.components[0].v2,self.components[1].v1,self.components[1].v2,self.components[2].v1,self.components[2].v2,0,0]
+        elif self.stair_type == "CT":
+            return [0,0,self.components[0].v1,self.components[0].v2,self.components[1].v1,self.components[1].v2,self.components[2].v1,self.components[2].v2]
+        elif self.stair_type == "DT":
+            return [self.components[0].v1,self.components[0].v2,self.components[1].v1,self.components[1].v2,self.components[2].v1,self.components[2].v2,self.components[3].v1,self.components[3].v2,]
+        return [0,0,0,10,20,10,0,0]
+    
+    def get_left_slab_table_moments(self):
+        moments = self.get_calculate_moments()
+        return [0,moments[1]*0.25,moments[1]]
+    
+    def get_main_table_moments(self):
+        moments = self.get_calculate_moments()
+        return [moments[1],moments[2],moments[3]]
+
+    def get_right_slab_table_moments(self):
+        moments = self.get_calculate_moments()
+        return [moments[3],moments[3]*0.25,0]
+ 
+  
+    def get_left_slab_table_shears(self):
+        shears = self.get_calculate_shears()
+        return [shears[0],(shears[0]+shears[1])/2,shears[1]]
+    
+    def get_main_table_shears(self):
+        shears = self.get_calculate_shears()
+        return [shears[2],(shears[2]+shears[5])/2,shears[5]]
+
+    def get_right_slab_table_shears(self):
+        shears = self.get_calculate_shears()
+        return [shears[6],(shears[6]+shears[7])/2,shears[7]]  
+    
+    def get_shear_validate(self, which_side,ft,cover_thick):
+        if which_side == "left":
+            shears = self.get_left_slab_table_shears()
+            shear_limit = 0.7*1*ft*(self.left_thick - cover_thick)*1000/1000
+        elif which_side == "right":
+            shears = self.get_right_slab_table_shears()
+            shear_limit = 0.7*1*ft*(self.right_thick - cover_thick)*1000/1000
+        else:
+            shears = self.get_main_table_shears()
+            shear_limit = 0.7*1*ft*(self.main_thick - cover_thick)*1000/1000
+        max_shear = max([abs(i) for i in shears])
+        if max_shear<=shear_limit:
+            shear_context = f"Vmax={max_shear:.2f}kN < 0.7βhftbh0={shear_limit:.2f}kN，抗剪截面满足要求！"
+        else:
+            shear_context = f"Vmax={max_shear:.2f}kN > 0.7βhftbh0={shear_limit:.2f}kN，抗剪截面不满足要求！"
+        
+        return shear_context
+    
+    
+    
+    def init_default_data(self):
+        self.stair_width = 1500
+        self.stair_well_width = 100
+        self.beam_list = [StairBeam(300,500,0),StairBeam(300,500, 0),StairBeam(300,500,0),StairBeam(300,500,0)]
+        self.set_thickness(140,140,140)
+        self.set_real_rebar(10,150,10,150)
+    
+    def __init__(self, position:Position,step_num):
+        self.position = position
+        self.step_num = step_num
+        self.init_default_data()
+        
+        self.STAIR_EXTEND_LIMIT = 200
+
+    def set_thickness(self, left_thick, main_thick,right_thick):
+        self.left_thick = left_thick
+        self.main_thick = main_thick
+        self.right_thick = right_thick
+    
+    def set_beam_offset(self, i,offset):
+        self.beam_list[i].offset = offset
+        
+    def set_real_rebar(self, up_d,up_dis,down_d,down_dis):
+        self.up_d = up_d
+        self.up_dis = up_dis
+        self.down_d = down_d
+        self.down_dis = down_dis
+        
+    def set_calculate_result(self, components:List[Component]):
+        self.components = components

CivilTools/YDBLoader/BuildingDefine/StairPart/__init__.py

@@ -0,0 +1,3 @@
+from .StairPart import StairPart, Position
+from .LoadDefine import StairLoad, LoadParams,LoadCalulateType
+from .StairComponent import Component

CivilTools/YDBLoader/BuildingDefine/__init__.py

@@ -0,0 +1,9 @@
+from .Beam import Beam
+from .Section import Section
+from .Geometry import Joint,Grid,StandFloor
+from .Column import Column
+from .Slab import Slab
+
+from .ComponentType import ComponentType
+from .GlobalResult import SingleMassResult, MassResult, Period, SinglePeriod
+from .GlobalResult import ValuePeer, FloorSeismicResult, SeismicResult

CivilTools/YDBLoader/SQLiteConnector/Connector.py

@@ -0,0 +1,80 @@
+from typing import List
+import sqlite3
+import os
+
+class Connector:
+
+    def __init__(self, file_path=None):
+        self.set_db_file(file_path)
+        self.connection = None
+        self.cursor = None
+        
+    def set_db_file(self, file_path):
+        if file_path != None and not os.path.exists(file_path):
+            raise AttributeError("The file_path is not existed, please check your file path. ")
+        self.__file_path = file_path
+
+    def connect(self):
+        """
+        建立与 SQLite 数据库的连接
+        """
+        if self.__file_path == None:
+            raise AttributeError("The file_path is None, you should set db file path before connect. Try the method [set_db_file]. ")
+        try:
+            self.connection = sqlite3.connect(self.__file_path)
+            self.cursor = self.connection.cursor()
+        except sqlite3.Error as e:
+            print(f"连接数据库时出错: {e}")
+       
+    def extract_table(self, table_name):
+        """
+        从指定的表中提取数据
+        :param table_name: 要提取数据的表名
+        :return: 表中的数据列表
+        """
+        if self.cursor is None:
+            self.connect()
+        try:
+            self.cursor.execute(f"SELECT * FROM {table_name}")
+            rows = self.cursor.fetchall()
+            return rows
+        except sqlite3.Error as e:
+            print(f"从表 {table_name} 提取数据时出错: {e}")
+            return []
+
+    def extract_table_by_columns(self, table_name, column_list:List[str]):
+        """
+        从指定的表中提取数据
+        :param table_name: 要提取数据的表名
+        :param column_list: 要提取的列名集合
+        :return: 表中的数据列表
+        """
+        if self.cursor is None:
+            self.connect()
+        try:
+            column_list_sql = ",".join(column_list)
+            self.cursor.execute(f"SELECT {column_list_sql} FROM {table_name}")
+            rows = self.cursor.fetchall()
+            return rows
+        except sqlite3.Error as e:
+            print(f"从表 {table_name} 提取数据时出错: {e}")
+            return []
+
+    def is_table_in_db(self, table_name:str):
+        
+        if self.cursor is None:
+            self.connect()
+        try:
+            self.cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+            result = self.cursor.fetchone()
+            return result
+        except sqlite3.Error as e:
+            print(f"从表 {table_name} 提取数据时出错: {e}")
+            return []
+
+    def close(self):
+        """
+        关闭数据库连接
+        """
+        if self.connection:
+            self.connection.close()

CivilTools/YDBLoader/SQLiteConnector/RowDataFactory.py

@@ -0,0 +1,45 @@
+from typing import List
+
+class RowDataFactory:
+    '''
+    This Class is used to extract data form row_data
+    '''
+    @classmethod
+    def extract_int(cls,row_data:List,index:int):
+        RowDataFactory.__list_index_check(row_data,index)
+        return RowDataFactory.convert_to_int(row_data[index])
+
+    @classmethod
+    def extract_float(cls,row_data:List,index:int):
+        RowDataFactory.__list_index_check(row_data,index)
+        return RowDataFactory.convert_to_float(row_data[index])
+    
+    @classmethod
+    def extract_list(cls, row_data:List,index:int):
+        RowDataFactory.__list_index_check(row_data,index)
+        try:
+            result = list(row_data[index].split(','))
+        except SyntaxError:
+            raise TypeError(f"Value: {row_data[index]} cannot be converted to list.")
+        return result
+
+    @classmethod
+    def convert_to_float(cls,string:"str"):
+        try:
+            result = (float)(string)
+        except SyntaxError:
+            raise TypeError(f"Value: {string} cannot be converted to float.")
+        return result
+    
+    @classmethod
+    def convert_to_int(cls,string:"str"):
+        try:
+            result = (int)(string)
+        except SyntaxError:
+            raise TypeError(f"Value: {string} cannot be converted to int.")
+        return result
+    
+    @classmethod
+    def __list_index_check(cls,row_data:List,index:int):
+        if len(row_data)<=index:
+            raise IndexError("Index out of the range.")

CivilTools/YDBLoader/SQLiteConnector/YDBTableName.py

@@ -0,0 +1,96 @@
+from enum import Enum
+ID = "ID"
+STD_FLR_ID = "StdFlrID"
+JOINT_ID = "JtID"
+JOINT_ID_1 = "Jt1ID"
+JOINT_ID_2 = "Jt2ID"
+GRID_ID = "GridID"
+SECTION_ID = "SectID"
+ECC = "Ecc"
+ECC_X = "EccX"
+ECC_Y = "EccY"
+ROTATION = "Rotation"
+
+
+FLOOR_NUM = "FlrNo"
+TOWER_NUM = "TowNo"
+
+
+class YDBTableName():
+    JOINT_TABLE_NAME = "tblJoint"
+    JOINT_TABLE_USEFUL_COLUMNS = [ID,"X","Y",STD_FLR_ID]
+    
+    GRID_TABLE_NAME = "tblGrid"
+    GRID_TABLE_USEFUL_COLUMNS = [ID,JOINT_ID_1,JOINT_ID_2]
+    """ 
+    0-ID , 
+    1-Joint1_ID , 
+    2-Joint2_ID ,
+    """
+    
+    COLUMN_SECTION_TABLE_NAME = "tblColSect"
+    BEAM_SECTION_TABLE_NAME = "tblBeamSect"
+    SECTION_TABLE_USEFUL_COLUMNS = [ID,"Mat","Kind","ShapeVal"]
+    
+    COLUMN_TABLE_NAME = "tblColSeg"
+    COLUMN_TABLE_USEFUL_COLUMNS = [ID,JOINT_ID,SECTION_ID,ECC_X,ECC_Y,ROTATION]
+    """ 
+    0-ID , 
+    1-Joint_ID , 
+    2-Section_ID ,
+    3-EccX ,
+    4-EccY ,
+    5-Rotation
+    """
+    
+    BEAM_TABLE_NAME = "tblBeamSeg"
+    BEAM_TABLE_USEFUL_COLUMNS = [ID,GRID_ID,SECTION_ID,ECC,"HDiff1","HDiff2"]
+    """ 
+    0-ID , 
+    1-Grid_ID , 
+    2-Section_ID ,
+    3-Ecc ,
+    4-HDiff1 ,
+    5-HDiff2
+    """
+
+    RESULT_PERIOD_TABLE = "calEigenInf"
+    RESULT_PERIOD_USEFUL_COLUMNS = ["ModuleID","EigenNo","Period","Angle","CoeffInf","mInf"]
+    """
+    0-moduleID
+    1-EigenNo 
+    2-Period Time
+    3-Angle
+    4-CoeffInf [unknown, xpart_ratio, ypart_ratio, zpart_ratio,
+    the sum of then should be 1]
+    5-MassInfo [unknown, xmass_participate, ymass_par, zmass_par,
+    the sum of all xmass_par should larger than 0.9]
+    """
+
+    RESULT_MASS_TABLE  = "preFlrTowProp"
+    RESULT_MASS_USEFUL_COLUMNS = [FLOOR_NUM,TOWER_NUM,"MassInf"]
+    """ 
+    0-floor_num , 
+    1-tower_num , 
+    2-mass_info, list of string, [unknown, dead_load, live_load, plus_load],
+    """
+    
+    RESULT_FLOOR_DATA_TABLE = "dsnStatFlrData"
+    """包含了大多数楼层计算结果，包括风、地震的各类外力、承载力、刚度等"""
+    RESULT_FLOOR_DATA_USEFUL_COLUMNS_SEISMIC = [
+        FLOOR_NUM,TOWER_NUM,"FlrFXInf","FlrFYInf", # 0 1 2 3
+        "FlrVXInf","FlrVYInf","FlrMXInf","FlrMYInf", # 4 5 6 7
+        ] 
+    """ 
+    0-floor_num , 
+    1-tower_num , 
+    2-X方向地震外力,
+    3-Y方向地震外力,
+    4-X方向地震层间剪力,
+    5-Y方向地震层间剪力,
+    6-X方向地震倾覆力矩,
+    7-Y方向地震倾覆力矩,
+    """
+    
+    
+    

CivilTools/YDBLoader/SQLiteConnector/__init__.py

@@ -0,0 +1,3 @@
+from .Connector import Connector
+from .YDBTableName import YDBTableName
+from .RowDataFactory import RowDataFactory

CivilTools/YDBLoader/YDBLoader.py

@@ -0,0 +1,224 @@
+from .BuildingDefine import Beam,Column,Joint,ComponentType,Grid
+from .BuildingDefine import SinglePeriod, Period, MassResult,SingleMassResult
+from .BuildingDefine import ValuePeer, FloorSeismicResult , SeismicResult
+from .BuildingDefine.Section import Section,ShapeEnum
+from .SQLiteConnector import Connector,YDBTableName,RowDataFactory
+from .YDBType import YDBType
+import os
+from typing import List, Dict
+
+class YDBLoader:
+
+    def __init__(self, file_name:str = None, ydb_type:YDBType = None):
+        # default type is ModelType
+        if not file_name.endswith(".ydb"):
+            raise ValueError("Plase use file ends with .ybd!")
+        self.connector = Connector(file_name)
+        self.ydb_type = self.__check_ydb_type()
+    
+    def get_columns(self)->List[Column]:
+        columns = []
+        sections = self.__get_sections(ComponentType.Column)
+        row_data = self.connector.extract_table_by_columns(
+            YDBTableName.COLUMN_TABLE_NAME,
+            YDBTableName.COLUMN_TABLE_USEFUL_COLUMNS
+            )
+        for temp_column in row_data:
+            temp_col_id = RowDataFactory.extract_int(temp_column,0)
+            joint_id = RowDataFactory.extract_int(temp_column,1)
+            sect_id = RowDataFactory.extract_int(temp_column,2)
+            joint = self.__find_joint_by_id(joint_id)
+            sect = [s for s in sections if s.id == sect_id][0]
+            new_column = Column(temp_col_id,joint,sect)
+            columns.append(new_column)
+        return columns
+    
+    def get_beams(self)->List[Beam]:
+        beams = []      
+        sections = self.__get_sections(ComponentType.Beam)
+        row_data = self.connector.extract_table_by_columns(
+            YDBTableName.BEAM_TABLE_NAME,
+            YDBTableName.BEAM_TABLE_USEFUL_COLUMNS
+            )
+        for temp_beam in row_data:
+            temp_beam_id = RowDataFactory.extract_int(temp_beam,0)
+            grid_id = RowDataFactory.extract_int(temp_beam,1)
+            grid = self.__find_grid_by_id(grid_id) 
+            sect_id = RowDataFactory.extract_int(temp_beam,2)
+            sect = [s for s in sections if s.id == sect_id][0]
+            new_beam = Beam(temp_beam_id,grid.start_joint,grid.end_joint,sect)
+            beams.append(new_beam)
+        return beams
+
+    def __get_sections(self,comp_type:ComponentType):
+        table_name = ""
+        table_columns = []       
+        table_names_for_different_comptype = {
+            ComponentType.Column:
+                [YDBTableName.COLUMN_SECTION_TABLE_NAME,
+                 YDBTableName.SECTION_TABLE_USEFUL_COLUMNS],
+            ComponentType.Beam:
+                [YDBTableName.BEAM_SECTION_TABLE_NAME,
+                 YDBTableName.SECTION_TABLE_USEFUL_COLUMNS],
+        }
+        if (comp_type not in table_names_for_different_comptype.keys()):
+            raise ValueError(f"{comp_type.name} is not suppported yet.")
+        # 这里根据不同的构件类型，进行不同的截面数据获取
+        table_name = table_names_for_different_comptype[comp_type][0]
+        table_columns = table_names_for_different_comptype[comp_type][1]
+        row_data = self.connector.extract_table_by_columns(table_name,table_columns)
+        sections = []
+        for temp_section in row_data:
+            temp_section_id = RowDataFactory.extract_int(temp_section,0)
+            # 这里的mat暂时没用到
+            mat = RowDataFactory.extract_int(temp_section,1)
+            kind = RowDataFactory.extract_int(temp_section,2)
+            shape_val = RowDataFactory.extract_list(temp_section,3)[1:]
+            new_section = Section(temp_section_id,ShapeEnum.ConvertToShapeEnum(kind),shape_val,mat)
+            sections.append(new_section)
+        return sections
+
+    def __get_joints(self)->Dict[int,Joint]:
+        if hasattr(self, 'joint_list'):
+            return self.joint_list
+        table_name = YDBTableName.JOINT_TABLE_NAME
+        useful_columns = YDBTableName.JOINT_TABLE_USEFUL_COLUMNS
+        row_data = self.connector.extract_table_by_columns(table_name,useful_columns)
+        joint_list = {}
+        for temp_joint in row_data:
+            temp_joint_id = RowDataFactory.extract_int(temp_joint,0)
+            x = RowDataFactory.extract_float(temp_joint,1)
+            y = RowDataFactory.extract_float(temp_joint,2)
+            std_flr_id = RowDataFactory.extract_int(temp_joint,3)
+            new_joint = Joint(temp_joint_id,x,y,std_flr_id)
+            joint_list[temp_joint_id] = new_joint
+        self.joint_list = joint_list
+        return self.joint_list
+
+    def __get_grids(self)->Dict[int,Grid]:
+        if hasattr(self, 'grid_list'):
+            return self.grid_list
+        table_name = YDBTableName.GRID_TABLE_NAME
+        useful_columns = YDBTableName.GRID_TABLE_USEFUL_COLUMNS
+        row_data = self.connector.extract_table_by_columns(table_name,useful_columns)
+        grid_list = {}
+        for temp_grid in row_data:
+            temp_grid_id = RowDataFactory.extract_int(temp_grid,0)
+            start_joint_id = RowDataFactory.extract_int(temp_grid,1)
+            end_joint_id = RowDataFactory.extract_int(temp_grid,2)
+            s_joint = self.__find_joint_by_id(start_joint_id)
+            e_joint = self.__find_joint_by_id(end_joint_id)
+            grid = Grid(temp_grid_id,s_joint, e_joint)
+            grid_list[temp_grid_id] = grid
+        self.grid_list = grid_list
+        return self.grid_list        
+        
+    def __check_ydb_type(self)->YDBType:
+        if self.connector.is_table_in_db(YDBTableName.JOINT_TABLE_NAME):
+            return YDBType.ModelYDB
+        if self.connector.is_table_in_db(YDBTableName.RESULT_PERIOD_TABLE):
+            return YDBType.ResultYDB
+        raise ValueError("This ydb database is not Model YDB neither Result YDB. Please use correct ydb file.")
+    
+    def __find_joint_by_id(self,joint_id:int)->Joint:
+        joint_list = self.__get_joints()
+        try:
+            return joint_list[joint_id]
+        except KeyError:
+            raise ValueError(f"No Joint's ID is {joint_id}.")
+    
+    def __find_grid_by_id(self,grid_id:int)->Grid:
+        grid_list = self.__get_grids()
+        try:
+            return grid_list[grid_id]
+        except KeyError:
+            raise ValueError(f"No Joint's ID is {grid_id}.")
+    
+    def __check_result_model(self, extracting_data_type):
+        if self.ydb_type != YDBType.ResultYDB:
+            raise TypeError("This model is not ResultYDB file, "+
+                            f"dont have {extracting_data_type} result, please retry.")
+    
+    def get_mass_result(self)->MassResult:
+        self.__check_result_model("mass")
+        table_name = YDBTableName.RESULT_MASS_TABLE
+        useful_columns = YDBTableName.RESULT_MASS_USEFUL_COLUMNS
+        row_data = self.connector.extract_table_by_columns(table_name,useful_columns)
+        mass_list = []
+        for temp_mass in row_data:
+            floor_num = RowDataFactory.convert_to_int(temp_mass,0)
+            tower_num = RowDataFactory.convert_to_int(temp_mass,1)
+            mass_info = RowDataFactory.extract_list(temp_mass,2)
+            dead_load = RowDataFactory.convert_to_float(mass_info[1])
+            live_load = RowDataFactory.convert_to_float(mass_info[2])
+            #  TODO: 需要计算slab的结果
+            slab_area = 10
+            single_mass = SingleMassResult(floor_num,tower_num,dead_load,live_load,slab_area)
+            mass_list.append(single_mass)      
+        return MassResult(mass_list)
+    
+    def get_period_result(self)->Period:
+        self.__check_result_model("period")
+        table_name = YDBTableName.RESULT_PERIOD_TABLE
+        useful_columns = YDBTableName.RESULT_PERIOD_USEFUL_COLUMNS
+        row_data = self.connector.extract_table_by_columns(table_name,useful_columns)
+        periods = []
+        for temp_period in row_data:
+            module_id = RowDataFactory.extract_int(temp_period,0)
+            if module_id !=1:
+                continue
+            period_index = RowDataFactory.extract_int(temp_period,1)
+            time = RowDataFactory.extract_float(temp_period,2)
+            angle = RowDataFactory.extract_float(temp_period,3)
+            coeff = RowDataFactory.extract_list(temp_period,4)
+            mass_participate = RowDataFactory.extract_list(temp_period,5)
+            period = SinglePeriod(period_index,time,angle
+                                  ,RowDataFactory.convert_to_float(coeff[1])
+                                  ,RowDataFactory.convert_to_float(coeff[2])
+                                  ,RowDataFactory.convert_to_float(coeff[-1])
+                                  ,RowDataFactory.convert_to_float(mass_participate[1])
+                                  ,RowDataFactory.convert_to_float(mass_participate[2])
+                                  ,RowDataFactory.convert_to_float(mass_participate[-1])
+                                  )
+            periods.append(period)
+        return Period(periods)
+
+    def get_seismic_result(self)->SeismicResult:
+        self.__check_result_model("seismic")
+        table_name = YDBTableName.RESULT_FLOOR_DATA_TABLE
+        useful_columns = YDBTableName.RESULT_FLOOR_DATA_USEFUL_COLUMNS_SEISMIC
+        row_data = self.connector.extract_table_by_columns(table_name,useful_columns)
+        floor_result_list = []
+        for temp_floor in row_data:
+            floor_num = RowDataFactory.extract_int(temp_floor,0)
+            tower_num = RowDataFactory.extract_int(temp_floor,1)
+            force_x = RowDataFactory.convert_to_float(
+                RowDataFactory.extract_list(temp_floor,2)[1])
+            force_y = RowDataFactory.convert_to_float(
+                RowDataFactory.extract_list(temp_floor,3)[1])
+            shear_x = RowDataFactory.convert_to_float(
+                RowDataFactory.extract_list(temp_floor,4)[1])
+            shear_y = RowDataFactory.convert_to_float(
+                RowDataFactory.extract_list(temp_floor,5)[1])
+            moment_x = RowDataFactory.convert_to_float(
+                RowDataFactory.extract_list(temp_floor,6)[1])
+            moment_y = RowDataFactory.convert_to_float(
+                RowDataFactory.extract_list(temp_floor,7)[1])
+            force = ValuePeer(force_x,force_y)
+            shear = ValuePeer(shear_x, shear_y)
+            moment = ValuePeer(moment_x,moment_y)
+            
+            temp_floor_result = FloorSeismicResult(floor_num,tower_num,force,shear,moment)
+            floor_result_list.append(temp_floor_result)
+        
+        return SeismicResult(floor_result_list)
+
+
+if __name__ == "__main__":
+    file_path = "testfiles/dtlmodel1.ydb"
+    loader = YDBLoader(file_path)
+    columns = loader.get_columns()
+
+    for col in columns:
+        print(col.section,col.joint)
+        

CivilTools/YDBLoader/YDBType.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class YDBType(Enum):
+    ModelYDB  = "dtlmodel.ydb"
+    ResultYDB = "dsnModel.ydb"

CivilTools/YDBLoader/__init__.py

@@ -0,0 +1,4 @@
+from .YDBLoader import YDBLoader
+from .YDBType import YDBType
+from .SQLiteConnector.Connector import Connector
+from . import BuildingDefine

CivilTools/__init__.py

@@ -0,0 +1 @@
+from . import YDBLoader, ReportGenerator,FigureGenerator,DXFGenerator