xara-prism 0.0.0__tar.gz

xara_prism-0.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: xara_prism
+Version: 0.0.0
+Requires-Dist: xsection
+Requires-Dist: xara
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib

xara_prism-0.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+
+[project]
+name = "xara_prism"
+version = "0.0.0"
+dependencies = [
+    "xsection",
+    "xara",
+    "numpy",
+    "scipy",
+    "matplotlib"
+]
+
+[build-system]
+requires = [
+  "setuptools >= 52.0.2",
+]
+
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+

xara_prism-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xara_prism-0.0.0/src/xara_prism/__init__.py

@@ -0,0 +1,576 @@
+import numpy as np
+import xara
+from xara.helpers import find_node
+
+
+class BasicShape(dict):
+    materials = {}
+
+
+class Span:
+    def __init__(self, 
+                 length, 
+                 shape,
+                 shear, 
+                 loads,
+                 smax=1.0,
+                 rotate=None,
+                 units=None,
+                 # Internal
+                 _span_name=None,
+                 ):
+        self.length = length
+        self.shape = shape
+        self.shear = shear
+        self.units = units
+        self.smax = float(smax)
+
+        if not isinstance(loads, list):
+            loads = [loads]
+        self.loads = loads
+
+        self._span_name = _span_name
+
+        if rotate is None:
+            rotate = np.eye(3)
+        self._rotate = rotate
+
+    
+        self.e_long = np.array([0, 1, 0]) # Global longitudinal axis
+        self.e_tran = np.array([1, 0, 0]) # Global transverse axis
+        self.e_bend = np.array([0, 0, 1]) # Global bending axis
+
+        self.i_long = np.array([1, 0, 0])
+        self.i_tran = np.array([0, 0, 1]) # local z
+        self.i_bend = np.array([0, 1, 0]) # local y
+
+        self._elastic_section = xara.FrameSection("Elastic", self.shape)
+
+    def plane_properties(self, iv, im):
+        section = self._elastic_section
+        cnn = section.cnn()
+        cmm = section.cmm()
+        cmn = section.cmn()
+        EA  = cnn[0][0]
+        GJ  = cmm[0][0]
+        EI = float(im.T@cmm@im)
+        GA = float(iv.T@cnn@iv)
+
+        return EA, GA, EI
+
+    def solution(self, type, time=None, shear=None, **kwds):
+        if shear is None:
+            shear = self.shear
+
+        from .solutions.linear import LinearPlaneSolution
+        from .solutions.pdelta import PDelta
+
+        if type == "linear" and self._span_name in {"span1", "span2", "span3", "span4", "span5"}:
+            return LinearPlaneSolution(span=self._span_name, prism=self, shear=shear, **kwds)
+
+        elif type == "pdelta" and self._span_name in {"span1", "span2", "span3", "span4", "span5"}:
+            return PDelta(span=self._span_name, prism=self, shear=shear, **kwds)
+
+        raise NotImplementedError("Solution not implemented for this span type.")
+
+
+    def create_prism(self, ndm, 
+                     element, 
+                     transform, 
+                     section="Elastic", 
+                     ne=1,
+                     nen=2,
+                     echo_file=None,
+                     options=None):
+        model = xara.Model(ndm=ndm, echo_file=echo_file)
+        # nen = order + 1
+        nn = ne*(nen-1)+1
+        shear = self.shear
+        if options is None:
+            options = {}
+
+        if section == "Elastic":
+            section = self._elastic_section
+        else:
+            section = xara.FrameSection(section, self.shape)
+        model.section(section)
+
+        for i, x in enumerate(np.linspace(0, self.length, nn)):
+            model.node(i+1, 0, x, 0)
+        
+
+        model.geomTransf(transform, 1, (1, 0, 0))
+
+        geometry = None
+        for i in range(ne):
+            start = i * (nen - 1) + 1
+            nodes = list(range(start, start + nen))
+            model.element(element, i+1, 
+                          nodes,
+                          section=1,
+                          shear=shear,
+                          transform=1, 
+                          **options)
+        return model
+
+    def analyze(self, 
+                ndm, 
+                element, 
+                transform,
+                section="Elastic", 
+                ne=1, 
+                nen=2,
+                steps=None,
+                echo_file=None,
+                analysis_options: dict =None,
+                element_options : dict =None,
+                loading_options : dict =None):
+
+        from .analysis import AnalysisOutput
+
+        model = self._create_model(ndm, element, transform, section=section, 
+                                   ne=ne, nen=nen, 
+                                   echo_file=echo_file,
+                                   options=element_options)
+
+        if loading_options is None:
+            loading_options = {}
+
+        #
+        # 1. Analyze constant loads if present
+        #
+        if self.apply_loads(model, scale_type="constant", **loading_options) > 0:
+            model.integrator("LoadControl", 1/10)
+            model.system("BandGeneral")
+            model.test("NormUnbalance", 1e-8, 100, 0)
+            model.analysis("Static")
+            assert model.analyze(10) == 0
+            model.loadConst(time=0)
+
+        #
+        # 2. Analyze linear loads if present
+        #
+        if analysis_options is None:
+            analysis_options = {"hooks": [], "system": "BandGeneral"}
+    
+        if "integrator" not in analysis_options:
+            if steps is None:
+                steps = 10
+            dlam = self.smax/steps if steps != 0 else 1
+            analysis_options["integrator"] = ("LoadControl", dlam)
+
+        if "test" not in analysis_options:
+            analysis_options["test"] = ("NormUnbalance", 1e-8, 100, 0)
+
+        if "hooks" not in analysis_options:
+            analysis_options["hooks"] = []
+
+        if "system" not in analysis_options:
+            analysis_options["system"] = "BandGeneral"
+
+        output = AnalysisOutput(self, model, label=f"{element}/{transform}, ne={ne}, nen={nen}")
+        analysis_options["hooks"].append(output.create_hook())
+        analysis_options["hooks"][-1](model)
+        analysis = xara.StaticAnalysis(model, **analysis_options)
+        output.analysis = analysis
+        if self.apply_loads(model, scale_type="linear", **loading_options) > 0:
+            for _ in range(steps):
+                analysis.analyze(1)
+        return output
+
+
+    def _create_model(self, ndm, element, transform, section="Elastic", ne=1, nen=2, **kwds):
+        model = self.create_prism(ndm, element, transform, section=section, ne=ne, nen=nen, **kwds)
+        i_node = find_node(model, y=0)
+        j_node = find_node(model, y=self.length)
+        self._fix_nodes(model, i_node, j_node)
+        return model
+
+    def _fix_nodes(self, model, i_node: int, j_node: int):
+        raise NotImplementedError("Subclasses must implement the _fix_nodes method.")
+
+
+    def apply_loads(self, model, scale_type, **kwargs):
+        loads = []
+        n_loads = 0
+        for load in self.loads:
+            if scale_type == load._scale_type:
+                n_loads += 1
+                xara_load = load.create(self, model, **kwargs)
+                if xara_load is None:
+                    # When creating legacy opensees-type loads,
+                    # the load must be created after a pattern is created;
+                    # This will have been done entirely within load.create()
+                    continue
+                loads.append(xara_load)
+
+        if len(loads) > 0:
+            model.pattern(
+                xara.StaticPattern(loads)
+            )
+        return n_loads
+
+
+
+
+class Span1(Span):
+    # Cantilever with tip loads
+    def __init__(self, length, shape, shear, loads, smax=1.0, **kwds):
+        super().__init__(length, 
+                         shape, 
+                         shear, 
+                         loads, 
+                         smax=smax, 
+                         _span_name="span1",
+                         **kwds
+        )
+
+    def _fix_nodes(self, model, i_node, j_node):
+        model.fix(i_node, (1, 1, 1, 1, 1, 1))
+        model.fix(j_node, (0, 0, 0, 0, 0, 0))
+
+    def critical_load(self, iv, im, mode=1):
+        """
+        Positive magnitude of the cantilever Euler load for odd mode number:
+
+            Pcr_j = ((2*j - 1)*pi/2L)^2 EI,  j = 1,2,...
+
+        """
+        mode = int(mode)
+        L = self.length
+        if mode < 1:
+            raise ValueError("mode must be >= 1")
+        q = (2 * mode - 1) * np.pi / (2.0 * L)
+        _, GA, EI = self.plane_properties(iv, im)
+        return EI * q**2
+
+
+class Span2(Span):
+    # Encastre beam with transverse deflection at L
+    def __init__(self, length, shape, shear, loads, smax=1.0, **kwds):
+        super().__init__(length, 
+                         shape, 
+                         shear, 
+                         loads, 
+                         smax=smax, 
+                         _span_name="span2",
+                         **kwds
+        )
+
+    def _fix_nodes(self, model, i_node, j_node):
+        model.fix(i_node, (1, 1, 1, 1, 1, 1))
+        model.fix(j_node, (0, 0, 1, 1, 1, 1))
+
+
+class Span3(Span): 
+    # Simply supported beam
+    def __init__(self, length, shape, shear, loads, smax=1.0, **kwds):
+        super().__init__(length, 
+                         shape, 
+                         shear, 
+                         loads, 
+                         smax=smax,
+                         **kwds,
+                         _span_name="span3"
+        )
+
+    def _fix_nodes(self, model, i_node, j_node):
+        model.fix(i_node, (1, 1, 1, 1, 1, 0))
+        model.fix(j_node, (1, 0, 1, 1, 1, 0))
+
+
+class Span4(Span):
+    # Fixed-Fixed
+    def __init__(self, length, shape, shear, loads, **kwds):
+        super().__init__(length, 
+                         shape, 
+                         shear, 
+                         loads, 
+                         _span_name="span4",
+                         **kwds
+        )
+
+    def _fix_nodes(self, model, i_node, j_node):
+        model.fix(i_node, (1, 1, 1, 1, 1, 1))
+        model.fix(j_node, (1, 0, 1, 1, 1, 1))
+
+
+class Span5(Span):
+    # Propped column
+    def __init__(self, length, shape, shear, loads, **kwds):
+        super().__init__(length, 
+                         shape, 
+                         shear, 
+                         loads,
+                         _span_name="span5",
+                         **kwds
+                        )
+
+    def _fix_nodes(self, model, i_node, j_node):
+        model.fix(i_node, (1, 1, 1, 1, 1, 1))
+        model.fix(j_node, (1, 0, 1, 1, 1, 0))
+
+
+from xsection.library import from_aisc
+
+
+class AISC_360_C1(Span3):
+    def __init__(self, shear, smax=1.0):
+        import xara.units.iks as units
+        from .loading import UniformShear, AxialForce, ShearForce
+        L = 336*units.inch
+        material = xara.MultiaxialMaterial(
+            "ElasticIsotropic",
+            E=29000*units.ksi,
+            G=11200*units.ksi,
+        )
+
+        super().__init__(
+            length=L, 
+            shape=from_aisc("W14x48", material=material), 
+            shear=shear,
+            loads=[
+                UniformShear(0.2*units.kip/units.foot, scale="constant"),
+                AxialForce(-450*units.kip, x=L, scale="linear"),
+            ],
+            smax=smax,
+            units=units
+        )
+
+    def solution(self, type, time=None, shear=None):
+        if shear is None:
+            shear = self.shear
+        if type == "aisc" and not shear:
+            from .solutions.aisc25 import AISC_25_S3
+            return AISC_25_S3(self, time=time, shear=shear)
+        else:
+            return super().solution(type, time=time, shear=shear)
+
+
+class AISC_360_C2(Span1):
+    def __init__(self, shear, smax=1.0, **kwds):
+        import xara.units.iks as units
+        from .loading import AxialForce, ShearForce
+        L = 336*units.inch
+        material = xara.MultiaxialMaterial(
+            "ElasticIsotropic",
+            E=29000*units.ksi,
+            G=11200*units.ksi,
+        )
+
+        super().__init__(
+            length=L, 
+            shape=from_aisc("W14x48", material=material), 
+            shear=shear,
+            units=units,
+            loads=[
+                ShearForce(1*units.kip, x=L, scale="constant"),
+                AxialForce(-200*units.kip, x=L, scale="linear"),
+            ],
+            smax=smax,
+            **kwds
+        )
+
+    def solution(self, type, time=None, shear=None):
+        if shear is None:
+            shear = self.shear
+
+        if type == "aisc" and not shear:
+            from .solutions.aisc25 import AISC_25_S1
+            return AISC_25_S1(self, time=time, shear=shear)
+        else:
+            return super().solution(type, time=time)
+
+
+class AISC_D25_C2(Span2):
+    def __init__(self, shear, smax=1.0, **kwds):
+        import xara.units.iks as units
+        from .loading import AxialForce, ShearForce
+        L = 336*units.inch
+        material = xara.MultiaxialMaterial(
+            "ElasticIsotropic",
+            E=29000*units.ksi,
+            G=11200*units.ksi,
+        )
+
+        super().__init__(
+            length=L, 
+            shape=from_aisc("W14x48", material=material), 
+            shear=shear,
+            units=units,
+            loads=[
+                ShearForce(1*units.kip, x=L, scale="constant"),
+                AxialForce(-200*units.kip, x=L, scale="linear"),
+            ],
+            smax=smax,
+            **kwds
+        )
+
+
+def AISC_25(loads, span_type, shear=1, smax=1.0, slenderness=None, **kwds):
+
+    import xara.units.iks as units
+
+    material = xara.MultiaxialMaterial(
+        "ElasticIsotropic",
+        E=29000*units.ksi,
+        G=11200*units.ksi,
+    )
+    shape = from_aisc("W14x48", material=material)
+
+    if slenderness is None:
+        length = 336*units.inch
+    else:
+        length = slenderness * shape.d
+
+    if span_type  == "span1":
+        span = Span1
+    elif span_type == "span2":
+        span = Span2
+    elif span_type == "span3":
+        span = Span3
+    elif span_type == "span4":
+        span = Span4
+    elif span_type == "span5":
+        span = Span5
+    else:
+        raise ValueError(f"Unknown span type: {span_type}")
+
+    return span(
+        length=length, 
+        shape=shape, 
+        shear=shear,
+        units=units,
+        loads=loads,
+        smax=smax,
+        **kwds
+    )
+
+class PlotPoint:
+    def __init__(self, 
+                 prism, 
+                 x,
+                 y,
+                 loc,
+                 ax=None,
+                 time=None):
+        self.prism = prism
+        self.x_key = x
+        self.y_key = y
+        self.loc = loc
+        if time is None:
+            time = np.linspace(0, prism.smax, 100)
+        self.time = time
+        if ax is not None:
+            self.ax = ax
+            self.fig = ax.figure
+        else:
+            from matplotlib import pyplot as plt
+            self.fig, self.ax = plt.subplots()
+            self.ax.grid(True)
+
+
+    def add(self, obj, **kwds):
+        x = self._collect(obj, self.x_key)
+        y = self._collect(obj, self.y_key)
+        self.ax.plot(x, y, **kwds)
+
+    def _collect(self, obj, var):
+        if var == "time":
+            if obj.time is not None:
+                return obj.time
+            return self.time
+
+        return [
+          getattr(obj, var)(self.loc, time) for time in self._collect(obj, var="time")
+        ]
+
+class PlotSpan:
+    def __init__(self, prism,  time=1, space=None, scale=1, ax=None):
+        self.prism = prism
+        self.time = time
+        self.scale = scale
+        small = 1e-3 * prism.length
+        self._x_lim = (-small, small)
+        if space is None:
+            space = np.linspace(0, prism.length, 100)
+        self.space = space
+        import matplotlib.pyplot as plt
+        if ax is None:
+            _, self.ax = plt.subplots()
+            # self.ax.axis("equal")
+            self.ax.plot([0]*len(space), space, color="k", lw=0.5)
+        else:
+            self.ax = ax
+
+    def add(self, obj, **kwds):
+        if obj.space is None:
+            space = self.space
+        else:
+            # import pprint
+            # pprint.pprint(obj.data)
+            space = obj.space
+
+        x = [xi + self.scale*getattr(obj, "u_long")(xi, self.time) for xi in space]
+        y = [self.scale*getattr(obj, "u_tran")(x, self.time) for x in space]
+
+        e = 1.2
+        self._x_lim = (min(self._x_lim[0], min(y)*e), max(self._x_lim[1], max(y)*e))
+        self.ax.plot(y, x, **kwds)
+        # self.ax.plot(space, y, **kwds)
+
+    def finish(self):
+        self.ax.set_xlim(self._x_lim)
+
+
+def check_span(obj, sol, time=1, space=None, rtol=None, atol=None):
+    if time is None:
+        time = obj.time
+    time = map(float, np.atleast_1d(time))
+
+    if space is None:
+        space = obj.space
+
+    print(obj, sol)
+    print(f"{'time':>6} {'x':>6} │ {'u_long_out':>10}   {'u_long_sol':>10}   {'diff':>10} │ {'u_tran_out':>10}   {'u_tran_sol':>10}   {'diff':>10}")
+    print(f"{'─'*6:>6} {'─':>6} │ {'─'*10      :>10}   {'─'*10      :>10}   {'─'*10:>10}─┼ {'─'*10      :>10}   {'─'*10      :>10}   {'─'*10:>10}")
+    for t in time:
+        print(f"{t:6.3f}", end="\n" if len(space) > 1 else "")
+        pad_time = f"{' '*6:>6}" if len(space) > 1 else ""
+        for xi in space:
+            print(f"{pad_time} {xi:>6.0f}", end=" │ ")
+            for key in ["u_long", "u_tran"]:
+                u_out = getattr(obj, key)(xi, t)
+                u_sol = getattr(sol, key)(xi, t)
+                diff = u_out - u_sol
+                if atol is not None:
+                    assert abs(diff) < atol[key], f"{key} at x={xi} has absolute error {diff} > {atol[key]}"
+                if u_sol != 0:
+                    diff /= u_sol
+                if rtol is not None:
+                    assert abs(diff) < rtol[key], f"{key} at x={xi} has relative error {diff} > {rtol[key]}"
+                print(f"{u_out:>10.4f}   {u_sol:>10.4f}   {diff:>10.3e}", end=" │ ")
+            try:
+                print(f" {obj.ic(t):>6}", end="")
+            except:
+                pass
+            print()
+    print()
+
+
+if __name__ == "__main__":
+
+    p = AISC_360_C1(shear=1)
+
+    # plot = PlotPoint(p, 
+    #             x="u_tran", 
+    #             y="time",
+    #             loc=p.length
+    # )
+
+    plot = PlotSpan(p, var="u_tran", time=1, space=None)
+
+    # plot.add(p.simulation(3, "PrismFrame", ..., n=...))
+
+    plot.add(p.solution("linear"))
+    

xara_prism-0.0.0/src/xara_prism/analysis.py

@@ -0,0 +1,98 @@
+import xara
+import numpy as np
+
+class XaraAnalysis:
+    def __init__(self, span,
+                 element: str,
+                 transform: str,
+                 section: str = "ElasticFrame",
+                 element_options=None,
+                 loading_options=None,
+                 analysis_options=None,
+    ):
+        self.span = span
+        self._element = element
+        self._transform = transform
+        self._section = section
+        self._element_options = element_options or {}
+        self._loading_options = loading_options or {}
+        self._analysis_options = analysis_options or {}
+
+
+
+class AnalysisOutput:
+    def __init__(self, span, model: xara.Model, label=None, analysis=None):
+        self.prism = span
+        self.model = model
+        self.label = label
+        self.analysis = analysis
+        self.space = np.array([model.nodeCoord(node, 2) for node in model.getNodeTags()])
+
+        self.data = {
+            "u_tran": [],
+            "u_long": [],
+            "r_plan": [],
+            "ic":    [],
+            "time":  [],
+        }
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.label})"
+
+    @property
+    def time(self):
+        return np.asarray(self.data["time"], dtype=float)
+
+    def create_hook(self):
+        def hook(model):
+            self.data["time"].append(model.getTime())
+
+            self.data["u_tran"].append([
+                model.nodeDisp(node, 1)
+                for node in model.getNodeTags()
+            ])
+            self.data["u_long"].append([
+                model.nodeDisp(node, 2)
+                for node in model.getNodeTags()
+            ])
+            self.data["r_plan"].append([
+                model.nodeDisp(node, 6)
+                for node in model.getNodeTags()
+            ])
+            ic = None
+            try:
+                ic = model.getIterationCount()
+            except:
+                pass
+            self.data["ic"].append(ic)
+        return hook
+
+
+
+    @property
+    def time(self):
+        return np.asarray(self.data["time"], dtype=float)
+
+    def _response(self, key: str, x: float, time: float):
+
+        i_time  = np.argmin(np.abs(self.time - time))
+        i_space = np.argmin(np.abs(self.space - x))
+        # Check that the requested time and space are in the available data points
+        if np.abs(self.time[i_time] - time) > 1e-6:
+            raise ValueError(f"Requested time {time} is not available in the output data.")
+        if np.abs(self.space[i_space] - x) > 1e-6:
+            raise ValueError(f"Requested space {x} is not available in the output data.")
+
+        return self.data[key][i_time][i_space]
+
+    def u_tran(self, x, time):
+        return self._response("u_tran", x, time)
+    def u_long(self, x, time):
+        return self._response("u_long", x, time)
+    def r_plan(self, x, time):
+        return self._response("r_plan", x, time)
+
+    def ic(self, time):
+        i_time  = np.argmin(np.abs(self.time - time))
+        if np.abs(self.time[i_time] - time) > 1e-8:
+            raise ValueError(f"Requested time {time} is not available in the output data.")
+        return self.data["ic"][i_time]