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

CivilTools/ReportGenerator/__init__.py

@@ -0,0 +1,7 @@
+from .BasicGenerator import BasicGenerator, PageSize
+from .SeismicReport import SeismicReport
+from .DocParagraph import DocParagraph
+from .DocTable import DocTable
+from .DocPicture import DocPicture
+from .UtilFunctions import add_comma_in_num_str
+from .StairCalculationReport import StairCalculationReport

CivilTools/YDBLoader/BuildingDefine/Beam/Beam.py

@@ -0,0 +1,26 @@
+from ..Section import Section,ShapeEnum
+from ..Geometry import Joint
+
+class Beam:
+    def __init__(
+        self,
+        id:int,
+        start_joint:Joint,
+        end_joint:Joint,
+        section:Section
+        ):
+        self.id = id 
+        self.start_joint = start_joint
+        self.end_joint = end_joint
+        self.section = section
+        self.std_flr_id = self.start_joint.std_flr_id
+        
+        
+    def get_data_for_plot(self):
+        return [[self.start_joint.x,self.end_joint.x],[self.start_joint.y,self.end_joint.y]]
+    
+    def __str__(self):
+        return f"Beam:{self.id}-{str(self.section)}"
+    
+    def __repr__(self):
+        return self.__str__()

CivilTools/YDBLoader/BuildingDefine/Beam/__init__.py

@@ -0,0 +1 @@
+from .Beam import Beam

CivilTools/YDBLoader/BuildingDefine/Column/Column.py

@@ -0,0 +1,16 @@
+from ..Section import Section,ShapeEnum
+from ..Geometry import Joint
+
+class Column:
+    def __init__(self,id:int,joint:Joint,section:Section):
+        self.id = id
+        self.joint = joint
+        self.std_flr_id = joint.std_flr_id
+        self.section = section
+    
+
+    def __str__(self):
+        return f"Column:{self.id}-{str(self.section)}"
+    
+    def __repr__(self):
+        return self.__str__()

CivilTools/YDBLoader/BuildingDefine/Column/__init__.py

@@ -0,0 +1 @@
+from .Column import Column

CivilTools/YDBLoader/BuildingDefine/ComponentType.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class ComponentType(Enum):
+    Beam = 1
+    Column = 2
+    Wall = 3
+    Slab = 4
+    Brace = 5
+    SlabHole = 6
+    

CivilTools/YDBLoader/BuildingDefine/Geometry/Grid.py

@@ -0,0 +1,21 @@
+
+from .Joint import Joint
+
+class Grid:
+    def __init__(
+        self,
+        id:int,
+        s_joint:Joint,
+        e_joint:Joint
+        ):
+        if s_joint.std_flr_id!= e_joint.std_flr_id:
+            raise ValueError("The standard-floor-ids of two Joints is not same! " +
+                             "Please check the data!")
+        self.id = id
+        self.start_joint = s_joint
+        self.end_joint = e_joint
+        self.std_flr_id = s_joint.std_flr_id
+        
+    def get_length(self):
+        return self.start_joint.distance_to_joint(self.end_joint)
+        

CivilTools/YDBLoader/BuildingDefine/Geometry/Joint.py

@@ -0,0 +1,25 @@
+import math
+
+class Joint:
+    def __init__(self,id:int,x:float,y:float,std_flr_id:int):
+        self.id = id
+        self.x = x
+        self.y = y
+        self.std_flr_id = std_flr_id
+
+    def distance_to_joint(self,other)-> float:
+        if not isinstance(other, Joint):
+            raise ValueError("Input should be Joint")
+        dis_square = (self.x - other.x)**2 + (self.y - other.y)**2
+        return math.sqrt(dis_square)
+    
+    def __str__(self):
+        return f"Joint(id:{self.id}):[x:{self.x:.4f},y:{self.y:.4f}]:stdFlrId:{self.std_flr_id}"
+    
+    def __repr__(self):
+        return str(self) 
+    
+    
+if __name__ == "__main__":
+    j = Joint(1,3.1,36.6513246534313)
+    print(j)

CivilTools/YDBLoader/BuildingDefine/Geometry/StandFloor.py

@@ -0,0 +1,2 @@
+class StandFloor:
+    pass

CivilTools/YDBLoader/BuildingDefine/Geometry/__init__.py

@@ -0,0 +1,3 @@
+from .Joint import Joint
+from .StandFloor import StandFloor
+from .Grid import Grid

CivilTools/YDBLoader/BuildingDefine/GlobalResult/BasicResult.py

@@ -0,0 +1,45 @@
+from typing import List
+
+class SingleMassResult:
+    def __init__(self,
+                 floor_num:int,
+                 tower_num:int,
+                 dead_load:float, 
+                 live_load:float, 
+                 slab_area:float,
+    ):
+        self.floor_num = floor_num
+        self.tower_num = tower_num
+        self.dead_load = dead_load
+        """单层恒载，没有折减"""
+        self.live_load = live_load
+        """单层活载，没有折减"""
+        self.slab_area = slab_area
+        """单层楼板面积"""
+    
+    @property
+    def mass(self):
+        """单层质量，恒+0.5活"""
+        return self.dead_load + 0.5 * self.live_load
+
+class MassResult:
+    def __init__(self, mass_list:List[SingleMassResult]):
+        self.mass_list = mass_list
+    
+    @property
+    def total_slab_area(self):
+        return sum([i.slab_area for i in self.mass_list])
+    
+    @property
+    def total_dead_load(self):
+        return sum([i.dead_load for i in self.mass_list])
+    
+    @property
+    def total_live_load(self):
+        return sum([i.live_load for i in self.mass_list])
+    
+    @property
+    def total_mass(self):
+        return sum([i.mass for i in self.mass_list])
+    
+    

CivilTools/YDBLoader/BuildingDefine/GlobalResult/SeismicResult.py

@@ -0,0 +1,128 @@
+import math
+import abc
+from typing import List
+import matplotlib.pyplot as plt
+
+class SinglePeriod:
+    """单个周期
+    """
+    def __init__(
+        self,index:int,
+        time:float, 
+        angle:float = 0,
+        coeff_x:float = 1,
+        coeff_y:float = 0,
+        coeff_z:float = 0,
+        mass_particpate_x:float = 0,
+        mass_particpate_y:float = 0,
+        mass_particpate_z:float = 0,
+    ):
+        self.index = index
+        self.time = time
+        self.angle = angle
+        assert abs(coeff_x 
+                   + coeff_y 
+                   + coeff_z-1)<0.01 ,"The sum of three participite coeff should == 1"
+        self.coeff_x = coeff_x
+        self.coeff_y = coeff_y
+        self.coeff_z = coeff_z
+        self.mass_participate_x = mass_particpate_x
+        self.mass_participate_y = mass_particpate_y
+        self.mass_participate_z = mass_particpate_z
+        
+    def __str__(self):
+        return f"T{self.index}:\t{self.time:.4f}s\t[X:{self.coeff_x*100:.1f}%;\tY:{self.coeff_y*100:.1f}%;\tZ:{self.coeff_z*100:.1f}%]"  
+    
+    def __repr__(self):
+        return str(self) 
+
+class Period:
+    def __init__(self,periods:List[SinglePeriod] , model_type = None):
+        self.periods = periods
+        
+    def __str__(self):
+        if len(self.periods)<=10:
+            return "\n".join([str(period) for period in self.periods])
+        else:
+            result = "\n".join([str(period) for period in self.periods[:9]])
+            result += "\n....\n"
+            result += str(self.periods[-1])
+            return result
+        
+    def __repr__(self):
+        return self.__str__()
+    
+class ValuePeer:
+    def __init__(self, x:float, y:float):
+        self.x = x
+        self.y = y
+    def __str__(self):
+        if self.x >500:
+            return f"X:{self.x:.1f}\tY:{self.y:.1f}"
+        elif self.x >5:
+            return f"X:{self.x:.2f}\tY:{self.y:.2f}"
+        else:
+            return f"X:{self.x:.3f}\tY:{self.y:.3f}"
+    
+class FloorSeismicResult:
+    def __init__(self,
+                 floor_num: int,
+                 tower_num: int,
+                 force:ValuePeer = None,
+                 shear:ValuePeer = None,
+                 moment:ValuePeer = None,
+                 disp:ValuePeer = None,
+                 stiffness:ValuePeer = None,
+                 shear_capacity:ValuePeer = None,
+                 ):
+        self.floor_num = floor_num
+        self.tower_num = tower_num
+        self.force = force
+        self.shear = shear
+        self.moment = moment
+        self.disp = disp
+        self.stiffness = stiffness
+        self.shear_capacity = shear_capacity
+    
+    def __str__(self):
+        return f"Flr.{self.floor_num}:Fx={self.force.x};Fy={self.force.y}"
+
+    def __repr__(self):
+        return self.__str__()
+
+class SeismicResult:
+    def __init__(self,
+                 floor_result : List[FloorSeismicResult]
+        ):
+        self.floor_result = floor_result
+    
+    @property
+    def seismic_shear_x(self):
+        return [i.shear.x for i in self.floor_result]
+    
+    @property
+    def floor_index(self):
+        return [i+1 for i in range(len(self.floor_result))]
+    
+    def plot_shear(self):
+        fig,ax = plt.subplots(figsize=(2,5))
+        ax.plot(self.seismic_shear_x,self.floor_index)
+        return fig,ax
+    
+    def __str__(self):
+        result = f"Total floor: {len(self.floor_result)}\n"
+        for temp_result in self.floor_result:
+            result += str(temp_result)
+            result += "\n"
+        return result
+    
+    def __repr__(self):
+        return self.__str__()
+    
+    
+if __name__ == "__main__":
+    p_list = []
+    for i in range(112):
+        p_list.append(SinglePeriod(i+1,i*0.1+0.1,0,1-i*0.1,i*0.1,0))
+    P = Period(p_list)
+    print(str(P))

CivilTools/YDBLoader/BuildingDefine/GlobalResult/__init__.py

@@ -0,0 +1,2 @@
+from .SeismicResult import SinglePeriod, Period, ValuePeer, FloorSeismicResult, SeismicResult
+from .BasicResult import SingleMassResult, MassResult

CivilTools/YDBLoader/BuildingDefine/Section/Section.py

@@ -0,0 +1,49 @@
+from .ShapeEnum import ShapeEnum
+from typing import List
+
+class Section:
+    def __init__(self,
+                 id:int,
+                 k:ShapeEnum,
+                 vals:List[float],
+                 mat:int = 1
+        ):
+        self.id = id
+        self.k = k
+        self.mat = mat
+        value_number = len(vals)
+        self.b = vals[0] if value_number>=1 else None
+        self.h = vals[1] if value_number>=2 else None
+        self.u = vals[2] if value_number>=3 else None
+        self.t = vals[3] if value_number>=4 else None
+        self.d = vals[4] if value_number>=5 else None
+        self.f = vals[5] if value_number>=6 else None
+        
+
+    def __str__(self):
+        '''todo:这里需要完善str方法'''
+        display_function = {
+            ShapeEnum.Rect : lambda : f"Rect-{self.b}mmx{self.h}mm",
+            ShapeEnum.HShape : lambda : f"{self.b}",
+            ShapeEnum.Circle : lambda : f"Circle-Diameter:{self.b}mm",
+            ShapeEnum.RegularPolygon : lambda : f"{self.b}",
+            ShapeEnum.Groove : lambda  : f"{self.b}",
+            ShapeEnum.Cross : lambda : f"{self.b}",
+            ShapeEnum.Box : lambda : f"{self.b}",
+            ShapeEnum.CircleTube : lambda : f"{self.b}",
+            ShapeEnum.CircleCFT : lambda : f"{self.b}",
+            ShapeEnum.HSRC : lambda : f"{self.b}",
+            ShapeEnum.BoxSRC : lambda : f"{self.b}",
+            ShapeEnum.CrossSRC : lambda : f"{self.b}",
+            
+            ShapeEnum.UnKnown : lambda : f"Unknown:{self.b}"
+        }
+        return display_function[self.k]()
+    
+    def __repr__(self):
+        return self.__str__()
+
+if __name__ == "__main__":
+    s = Section(1,ShapeEnum.Circle,[20,32])
+
+    print(s)

CivilTools/YDBLoader/BuildingDefine/Section/ShapeEnum.py

@@ -0,0 +1,42 @@
+from enum import Enum
+import warnings
+class ShapeEnum(Enum):
+    # 矩形
+    Rect = 1
+    # 工字型
+    HShape = 2
+    # 圆形
+    Circle = 3
+    # 正多边形
+    RegularPolygon = 4
+    # 槽型
+    Groove = 5
+    # 十字形
+    Cross = 6
+    # 箱形
+    Box = 7
+    # 圆管
+    CircleTube = 8
+    # 钢管混凝土
+    CircleCFT = 12
+    # 工形劲
+    HSRC = 13
+    # 箱型劲
+    BoxSRC = 14
+    # 十字劲
+    CrossSRC = 15
+    
+    # 未知截面均归于这个类别
+    UnKnown = 999
+    
+    @classmethod
+    def ConvertToShapeEnum(cls,index:int):
+        try: 
+            return (ShapeEnum)(index)
+        except ValueError:
+            warnings.warn(f"Shape kind ${index} is not supported yet. It will be converted to UnKnown.")
+            return ShapeEnum.UnKnown
+            
+    
+    
+    

CivilTools/YDBLoader/BuildingDefine/Section/__init__.py

@@ -0,0 +1,2 @@
+from .Section import Section
+from .ShapeEnum import ShapeEnum

CivilTools/YDBLoader/BuildingDefine/Slab/Slab.py

@@ -0,0 +1,2 @@
+class Slab:
+    pass

CivilTools/YDBLoader/BuildingDefine/Slab/__init__.py

@@ -0,0 +1 @@
+from .Slab import Slab

CivilTools/YDBLoader/BuildingDefine/StairPart/LoadDefine.py

@@ -0,0 +1,38 @@
+from enum import Enum
+
+class LoadParams:
+    def __init__(self):
+        self.append_dead_load = 1
+        self.live_load = 3.5
+        self.dead_load_coef = 1.3
+        self.live_load_coef = 1.5
+        self.live_load_adjust_coef = 1
+        self.live_load_permenent_coef = 0.5
+        
+class LoadType(Enum):
+    Dead = 1
+    Live = 2
+    
+class LoadCalulateType(Enum):
+    qk = 1
+    q = 2
+    qe = 3
+    
+class StairLoad:
+    def __init__(self, dead, live, load_params:LoadParams):
+        self.dead = dead
+        self.live = live
+        self.load_params = load_params
+        
+    @property
+    def qk(self):
+        return self.dead + self.live
+    
+    @property
+    def q(self):
+        return self.load_params.dead_load_coef* self.dead +self.load_params.live_load_coef* self.live
+    
+    @property
+    def qe(self):
+        return self.dead + self.load_params.live_load_permenent_coef* self.live
+

CivilTools/YDBLoader/BuildingDefine/StairPart/StairComponent.py

@@ -0,0 +1,95 @@
+import math
+import numpy as np
+
+class Component:
+    
+    def init_attr(self):
+        self.E = 30000
+        self.B = 1000
+        self.H = 150
+        self.vertical_q = 10
+        self.length = math.sqrt((self.end_point[1] - self.start_point[1])**2 + (self.end_point[0] - self.start_point[0])**2)
+        if self.start_point[0] == self.end_point[0]:
+            self.alpha = 0
+        else:
+            self.alpha = math.atan((self.end_point[1] - self.start_point[1]) / (self.end_point[0] - self.start_point[0]))
+    
+    def __init__(self,p1,p2) -> None:
+        self.start_point = p1
+        self.end_point = p2
+        self.section_kind = "Rectangle"
+        self.init_attr()
+        
+    def set_comp_attr(self,e,b,h):
+        self.E = e
+        self.B = b
+        self.H = h
+        
+    def set_vertical_q(self, q):
+        self.vertical_q = q
+    
+    def create_k(self):
+        self.calculate_section_attr()
+        K = np.zeros((6,6))
+        
+        l = self.length
+        i = self.E *self.I / l
+        B =  self.E *self.area / l
+        c_x = math.cos(self.alpha)
+        c_y = math.sin(self.alpha)
+        a1 = B * c_x * c_x + 12 * i / l / l * c_y * c_y
+        a2 = (B - 12 * i / l / l) * c_x * c_y
+        a3 = B * c_y * c_y + 12 * i / l / l * c_x * c_x
+        a4 = -6 * i / l * c_y
+        a5 = 6 * i / l * c_x
+        a6 = 4 * i
+        K[0, 0] = K[3, 3] = a1
+        K[0, 3] = K[3, 0] = -a1
+        K[1, 0] = K[4, 3] = K[0, 1] = K[3, 4] = a2
+        K[1, 3] = K[0, 4] = K[3, 1] = K[4, 0] = -a2
+        K[1, 1] = K[4, 4] = a3
+        K[1, 4] = K[4, 1] = -a3
+        K[0, 2] = K[0, 5] = K[2, 0] = K[5, 0] = a4
+        K[2, 3] = K[3, 5] = K[3, 2] = K[5, 3] = -a4
+        K[1, 2] = K[1, 5] = K[2, 1] = K[5, 1] = a5
+        K[2, 4] = K[4, 5] = K[4, 2] = K[5, 4] = -a5
+        K[2, 2] = K[5, 5] = a6
+        K[2, 5] = K[5, 2] = a6 / 2
+        return K
+    
+    def create_f(self):
+        F = np.zeros((6,1))
+        # 这里只针对竖向荷载
+        length = abs(self.end_point[0] - self.start_point[0])
+        
+        F[1,0] = -self.vertical_q * length / 2
+        F[2,0] = -self.vertical_q * length ** 2 / 12
+        F[4,0] = -self.vertical_q * length / 2
+        F[5,0] = self.vertical_q * length ** 2 / 12
+        return F
+    
+    def calculate_section_attr(self):
+        if self.section_kind == "Rectangle":
+            self.I = self.B * self.H **3 / 12
+            self.area = self.B * self.H
+            
+            
+    def set_f(self,f_1_x,f_1_y,f_2_x,f_2_y):
+        self.f_1_x = f_1_x/1e3
+        self.f_1_y = f_1_y/1e3
+        self.f_2_x = f_2_x/1e3
+        self.f_2_y = f_2_y/1e3
+        
+    def set_m(self, m_1, m_2):
+        self.m_1 = m_1/1e6
+        self.m_2 = m_2/1e6
+        
+
+    @property
+    def v1(self):
+        return self.f_1_y*np.cos(self.alpha) - self.f_1_x*np.sin(self.alpha)
+    
+    @property
+    def v2(self):
+        return -self.f_2_y*np.cos(self.alpha) + self.f_2_x*np.sin(self.alpha)
+