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

CivilTools/YDBLoader/BuildingDefine/GlobalResult/SeismicResult.py

@@ -3,78 +3,174 @@ 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: 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"
+        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
+        if coeff_x >= coeff_y and coeff_x >= coeff_z:
+            self.direction = "X"
+        elif coeff_y >= coeff_x and coeff_y >= coeff_z:
+            self.direction = "Y"
+        else:
+            self.direction = "Z"
         self.mass_participate_x = mass_particpate_x
         self.mass_participate_y = mass_particpate_y
         self.mass_participate_z = mass_particpate_z
-        
+
+    @property
+    def time_str(self):
+        return f"{self.time:.4f}"
+
+    @property
+    def movement_coeff(self):
+        return (
+            f"{self.coeff_x + self.coeff_y:.2f} ({self.coeff_x:.2f}+{self.coeff_y:.2f})"
+        )
+
+    @property
+    def rotation_coeff(self):
+        return f"{self.coeff_z:.2f}"
+
+    def get_mass_participate_x(self, last):
+        return f"{self.mass_participate_x*100:.1f} ({(self.mass_participate_x + last)*100:.1f})"
+
+    def get_mass_participate_y(self, last):
+        return f"{self.mass_participate_y*100:.1f} ({(self.mass_participate_y + last)*100:.1f})"
+
     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}%]"  
-    
+        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) 
+        return str(self)
+
 
 class Period:
-    def __init__(self,periods:List[SinglePeriod] , model_type = None):
+    def __init__(self, periods: List[SinglePeriod], model_type=None):
+        if len(periods) < 3:
+            raise ValueError("At least three periods is needed.")
         self.periods = periods
-        
+
     def __str__(self):
-        if len(self.periods)<=10:
+        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__()
-    
+
+    @classmethod
+    def mock_data(
+        cls, order: str = "xyz", num: int = 40, mass_participate: float = 0.95
+    ):
+        single_period_list = []
+        single_period_list.append(
+            SinglePeriod(
+                1,
+                2.5,
+                0,
+                order[0] == "x",
+                order[0] == "y",
+                order[0] == "z",
+                0.1,
+                0.1,
+                0.1,
+            )
+        )
+        single_period_list.append(
+            SinglePeriod(
+                2,
+                2.0,
+                0,
+                order[1] == "x",
+                order[1] == "y",
+                order[1] == "z",
+                0.2,
+                0.2,
+                0.2,
+            )
+        )
+        single_period_list.append(
+            SinglePeriod(
+                3,
+                1.5,
+                0,
+                order[2] == "x",
+                order[2] == "y",
+                order[2] == "z",
+                0.3,
+                0.3,
+                0.3,
+            )
+        )
+
+        for i in range(num - 3):
+            single_period_list.append(
+                SinglePeriod(
+                    i + 4,
+                    0.5 - 0.01 * i,
+                    0,
+                    1,
+                    0,
+                    0,
+                    mass_participate,
+                    mass_participate,
+                    mass_participate,
+                )
+            )
+        return Period(single_period_list)
+
+
 class ValuePeer:
-    def __init__(self, x:float, y:float):
+    def __init__(self, x: float, y: float):
         self.x = x
         self.y = y
+
     def __str__(self):
-        if self.x >500:
+        if self.x > 500:
             return f"X:{self.x:.1f}\tY:{self.y:.1f}"
-        elif self.x >5:
+        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,
-                 ):
+    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
@@ -83,46 +179,45 @@ class FloorSeismicResult:
         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]
-        ):
+    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))]
-    
+        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
-    
+        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_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))
+    print(str(P))

CivilTools/YDBLoader/BuildingDefine/Section/Section.py

@@ -1,49 +1,44 @@
 from .ShapeEnum import ShapeEnum
 from typing import List
 
+
 class Section:
-    def __init__(self,
-                 id:int,
-                 k:ShapeEnum,
-                 vals:List[float],
-                 mat:int = 1
-        ):
+    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
-        
+        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方法'''
+        """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}"
+            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])
+    s = Section(1, ShapeEnum.Circle, [20, 32])
 
-    print(s)
+    print(s)

CivilTools/YDBLoader/BuildingDefine/Section/ShapeEnum.py

@@ -1,5 +1,7 @@
 from enum import Enum
 import warnings
+
+
 class ShapeEnum(Enum):
     # 矩形
     Rect = 1
@@ -25,18 +27,16 @@ class ShapeEnum(Enum):
     BoxSRC = 14
     # 十字劲
     CrossSRC = 15
-    
+
     # 未知截面均归于这个类别
     UnKnown = 999
-    
+
     @classmethod
-    def ConvertToShapeEnum(cls,index:int):
-        try: 
+    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.")
+            warnings.warn(
+                f"Shape kind ${index} is not supported yet. It will be converted to UnKnown."
+            )
             return ShapeEnum.UnKnown
-            
-    
-    
-    

CivilTools/YDBLoader/BuildingDefine/Slab/Slab.py

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

CivilTools/YDBLoader/BuildingDefine/StairPart/LoadDefine.py

@@ -1,5 +1,6 @@
 from enum import Enum
 
+
 class LoadParams:
     def __init__(self):
         self.append_dead_load = 1
@@ -8,31 +9,36 @@ class LoadParams:
         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):
+    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
-    
+        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
-
+        return self.dead + self.load_params.live_load_permenent_coef * self.live

CivilTools/YDBLoader/BuildingDefine/StairPart/StairComponent.py

@@ -1,40 +1,47 @@
 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)
+        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.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):
+
+    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))
-        
+        K = np.zeros((6, 6))
+
         l = self.length
-        i = self.E *self.I / l
-        B =  self.E *self.area / l
+        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
@@ -56,40 +63,37 @@ class Component:
         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))
+        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
+
+        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.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_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
-        
+        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)
-    
+        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)
-    
+        return -self.f_2_y * np.cos(self.alpha) + self.f_2_x * np.sin(self.alpha)