xsection 0.0.0__tar.gz

xsection-0.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: xsection
+Version: 0.0.0
+Author-email: "Claudio M. Perez" <50180406+claudioperez@users.noreply.github.com>
+Project-URL: repository, http://github.com/BRACE2/xsection
+Project-URL: documentation, https://brace2.github.io/xsection
+Keywords: seismic,earthquake
+Description-Content-Type: text/markdown
+
+# `xsection`
+

xsection-0.0.0/README.md

@@ -0,0 +1,2 @@
+# `xsection`
+

xsection-0.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "xsection"
+version = "0.0.0"
+authors = [
+  {name="Claudio M. Perez", email="50180406+claudioperez@users.noreply.github.com"}
+]
+
+readme = "README.md"
+
+keywords = [
+    "seismic",
+    "earthquake",
+] 
+
+[options]
+#packages = find
+install_requires = [
+  "numpy",
+  "scipy",
+  "tqdm",
+  "quakeio",
+  "matplotlib",
+  "plotly",
+  "pandas",
+  "control",
+  "sdof",
+  "opensees",
+  "quakeio"
+]
+
+[project.urls]
+repository = "http://github.com/BRACE2/xsection"
+documentation = "https://brace2.github.io/xsection"
+
+[project.scripts]
+xsection = "xsection.__main__:main"
+
+[build-system]
+requires = [
+    "setuptools >= 52.0.2",
+]
+
+build-backend = "setuptools.build_meta"
+

xsection-0.0.0/setup.cfg

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

xsection-0.0.0/setup.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup(
+            # name="opensees",
+            # cmake_install_dir="src/opensees",
+            # cmake_args  = ["-DDependencies=Conda"],
+            # package_dir = {"": "src"},
+            # packages    = ["opensees", "opensees.emit", "opensees.units"],
+            # #packages = find_packages("src"),
+            # py_modules  = [
+            #     splitext(basename(path))[0] for path in glob("src/*.py")
+            # ] + [
+            #     splitext(basename(path))[0] for path in glob("src/units/*.py")
+            # ] + [
+            #     splitext(basename(path))[0] for path in glob("src/emit/*.py")
+            # ]
+    )
+

xsection-0.0.0/src/xsection/ExtractModes.py

@@ -0,0 +1,131 @@
+from cmath import isclose
+from numpy import pi, log, sign
+from numpy.linalg import eig
+import numpy as np
+import scipy.linalg as sl
+
+def condeig(a): # TODO: make this match matlab source code for condeig
+    """
+    vals, vecs, conds = condeig(A) Computes condition numbers for the
+    eigenvalues of a matrix. The condition numbers are the reciprocals
+    of the cosines of the angles between the left and right eigenvectors.
+    Inspired by Arno Onken's Octave code for condeig.
+
+    https://github.com/macd/rogues/blob/master/rogues/utils/condeig.py
+    """
+    m, n = a.shape
+    # eigenvalues, left and right eigenvectors
+    lamr, vl, vr = sl.eig(a, left=True, right=True)
+    vl = vl.T.conj()
+    # Normalize vectors
+    for i in range(n):
+        vl[i, :] = vl[i, :] / np.sqrt(abs(vl[i, :] ** 2).sum())
+    # Condition numbers are reciprocal of the cosines (dot products) of the
+    # left eignevectors with the right eigenvectors.
+    c = abs(1 / np.diag(np.dot(vl, vr))) 
+    return vr, lamr, c
+
+def ComposeModes(dt, A, B, C, D, debug=False, **kwds)->dict:
+    
+    n = A.shape[0]
+    m = C.shape[0]
+
+    v, d, cnd = condeig(A)  # eigenvectors (d) & eiegenvalues (v) of the matrix A
+    # kit = np.log(d)         # logarithm of the eigenvalues
+
+    # a) Determination of modal frequencies (Eqs. 3.46 & 3.39)
+    sj1 = np.log(d)/dt            # dt is the time step
+    freq1 = (np.real(sj1*np.conj(sj1))**0.5)/(2*pi)
+
+    roots = []
+
+    # selection of proper roots
+    if np.isclose(freq1[0], freq1[1]):
+        roots.append(0)
+
+    if np.isclose(freq1[n-1], freq1[n-2]):
+        roots.append(n-1)
+
+    for i in range(2, n-2):
+        if np.isclose(freq1[i], freq1[i+1]) or np.isclose(freq1[i], freq1[i-1]):
+            roots.append(i)
+ 
+
+    # b) Determination of damping ratios (Eqs. 3.46 & 3.39)
+    damp1 = -((np.real(sj1))/(2*pi*freq1))
+
+    # Represent the identified frequency & damping information
+    # of the proper roots in a matrix
+
+    # NOTE: These values are stored in one array like this for legacy reasons,
+    # but this should be cleaned and a proper data structure should be used!
+    freqdmp = np.array([
+               [freq1[i],   # first column: identified frequency
+                damp1[i],   # second column: identified damping ratio
+                cnd[i]]     # condition number of the eigenvalue
+            for i in roots
+    ])
+
+    # c) Determination of mode shapes
+    modes_raw = C@v   # mode shapes (Eq. 3.40)
+
+    modeshape = np.zeros((m,len(roots)), dtype=complex)
+
+    # extract mode shapes from mod corresponding to a frequency
+    for q,root in enumerate(roots):
+        modeshape[:m,q] = modes_raw[:m, root]
+
+    for q,root in enumerate(roots):
+        om  = np.argmax(abs(np.real(modeshape[:,q])))
+        mx  = abs(np.real(modeshape[om,q]))
+        modeshape[:,q] = np.real(modeshape[:,q])/mx*sign(np.real(modeshape[om,q]))
+
+    if debug:
+        return locals()
+    return freqdmp, modeshape, None, v, d
+
+def modes(dt, A, C):
+
+    # eigendecomp A
+    Psi,Gam,cnd = condeig(A)  # eigenvectors (Psi) & eigenvalues (Gam) of the matrix A
+
+    # get damping and frequencies from eigendecomp of A
+    Lam = (np.log(Gam))/dt
+    Omega = np.real((Lam*np.conj(Lam))**0.5)  # radians per second. taking the real part because np keeps a +0j.
+    freq = Omega/(2*pi) # cycles per second (Hz)
+    damp = -np.real(Lam)/Omega
+
+    # get modeshapes from C and eigendecomp of A
+    modeshape = C @ Psi
+
+    # nroots = int(len(freq)/2)
+    # # print(f"{freq=}")
+    # for i in range(nroots):
+    #     assert np.isclose(freq[2*i],freq[2*i+1])  # make sure we have pairs of roots
+
+    # modes = {str(i):
+    #             {'cnd': cnd[2*i],   # condition number of the eigenvalue
+    #             'freq': freq[2*i],  # identified frequency
+    #             'damp': damp[2*i],  # identified damping ratio
+    #             'modeshape': modeshape[:,2*i]
+    #             }
+    #         for i in range(nroots)
+    #         }
+
+    # return modes
+
+    # weed out unique roots: get indices of roots that only show up once, and
+    # the index of the first of each pair.
+    _, notroots = np.unique(freq.round(decimals=5), return_index=True)
+    
+    # print(notroots)
+    modes = {str(i):
+                {'cnd': cnd[i],   # condition number of the eigenvalue
+                'freq': freq[i],  # identified frequency
+                'damp': damp[i],  # identified damping ratio
+                'modeshape': modeshape[:,i]
+                }
+            for i in range(len(freq)) if i not in notroots
+            }
+
+    return modes

xsection-0.0.0/src/xsection/__init__.py

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

xsection-0.0.0/src/xsection/__main__.py

@@ -0,0 +1,190 @@
+import sys
+import json
+
+import ssid
+import ssid.modes
+import quakeio
+import numpy as np
+from .okid import parse_okid
+
+HELP = """
+ssid [-p|w <>...] <method> <event> <inputs> <outputs>
+ssid [-p|w <>...] <method> -i <inputs> -o <outputs>
+
+-i/--inputs  FILE...   Input data
+-o/--outputs FILE...   Output data
+
+Methods:
+  <method> <outputs>  <plots>
+    srim    {dftmcs}   {m}
+    okid    {dftmcs}   {m}
+    spec    {ft}       {a}
+    four    {ft}       {a}
+    test
+
+Outputs options
+-p/--plot
+    a/--accel-spect
+-w/--write
+    ABCD   system matrices
+    d      damping
+    freq   frequency
+    cycl   cyclic frequency
+    t      period
+    m      modes
+    c      condition-number
+"""
+
+class JSON_Encoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        elif isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        return json.JSONEncoder.default(self, obj)
+
+
+def parse_srim(argi, config):
+    help="""
+    SRIM -- System Identification with Information Matrix
+
+    Parameters
+    no          order of the observer Kalman ARX filter (formerly p).
+    r           size of the state-space model used for 
+                representing the system. (formerly orm/n)
+    """
+    config.update({"p"  :  5, "orm":  4})
+
+    #argi = iter(args)
+    channels = [[], []]
+    for arg in argi:
+        if arg == "--arx-order":
+            config["no"] = int(next(argi))
+
+        elif arg == "--dt":
+            config["dt"] = float(next(argi))
+
+        elif arg == "--ss-size":
+            config["r"] = int(next(argi))
+
+        elif arg in ["--help", "-h"]:
+            print(help)
+            sys.exit()
+
+        elif arg == "--inputs":
+            inputs = next(argi)[1:-1].split(",")
+            if isinstance(inputs, str):
+                channels[0] = [int(inputs)]
+            else:
+                channels[0] = list(map(int, inputs))
+
+        elif arg == "--outputs":
+            outputs = next(argi)[1:-1].split(",")
+            if isinstance(outputs, str):
+                channels[1] = [int(outputs)]
+            else:
+                channels[1] = list(map(int, outputs))
+
+        elif arg == "--":
+            continue
+
+        else:
+            config["event_file"] = arg
+
+    event = quakeio.read(config["event_file"])
+    inputs = np.array([
+        event.match("l", station_channel=f"{i}").accel.data for i in channels[0]
+    ]).T
+    outputs = np.array([
+        event.match("l", station_channel=f"{i}").accel.data for i in channels[1]
+        #event.at(file_name=f"CHAN{i:03d}.V2").accel.data for i in channels[1]
+    ]).T
+    
+    dt = event.at(station_channel=f"{channels[0][0]}").accel["time_step"]
+    config["dt"] = dt
+
+    A,B,C,D = ssid.system(input=inputs, output=outputs, full=True, **config)
+
+    ss_modes = ssid.modes.modes((A,B,C,D),dt)
+
+    output = [
+        {
+            "period":  1/mode["freq"],
+            "frequency": mode["freq"],
+            "damping":   mode["damp"]         
+        } 
+        for mode in sorted(ss_modes.values(), key=lambda item: item["freq"])
+    ]
+
+    print(json.dumps(output, cls=JSON_Encoder, indent=4))
+    return config
+
+
+def parse_args(args):
+    outputs = []
+    sub_parsers = {
+        "srim": parse_srim,
+        "test": parse_srim,
+        "okid": parse_okid,
+        "okid": parse_okid
+    }
+    config = {
+            "method": None,
+            "operation": None,
+            "protocol": None
+    }
+    config["channels"] = channels = [[], []]
+
+    argi = iter(args[1:])
+    for arg in argi:
+        if arg == "-p":
+            outputs.append(next(arg))
+
+        elif arg in ["--help", "-h"]:
+            print(HELP)
+            sys.exit()
+
+        elif arg == "--protocol":
+            config["protocol"] = next(arg)
+
+        elif arg == "--inputs":
+            inputs = next(argi)[1:-1].split(",")
+            if isinstance(inputs, str):
+                channels[0] = [int(inputs)]
+            else:
+                channels[0] = list(map(int, inputs))
+
+        elif arg == "--outputs":
+            outputs = next(argi)[1:-1].split(",")
+            if isinstance(outputs, str):
+                channels[1] = [int(outputs)]
+            else:
+                channels[1] = list(map(int, outputs))
+
+        # Positional args
+        elif config["method"] is None:
+            config["method"] = arg
+            break
+
+        # elif config["protocol"] and config["operation"] is None:
+        #     config["operation"] = arg
+
+        elif arg == "--":
+            continue
+
+        else:
+            print(HELP)
+            sys.exit()
+
+
+    return sub_parsers[config.pop("method")](argi, config), outputs
+
+
+def main():
+    parse_args(sys.argv)
+
+if __name__ == "__main__":
+    main()
+    sys.exit()

xsection-0.0.0/src/xsection/brace2/__main__.py

@@ -0,0 +1,109 @@
+from .srim import parse_srim
+from .okid import parse_okid
+
+HELP = """
+ssid [-p|w <>...] <method> <event> <inputs> <outputs>
+ssid [-p|w <>...] <method> -i <inputs> -o <outputs>
+
+-i/--inputs  FILE...   Input data
+-o/--outputs FILE...   Output data
+
+Methods:
+  <method> <outputs>  <plots>
+    srim    {dftmcs}   {m}
+    okid    {dftmcs}   {m}
+    spec    {ft}       {a}
+    four    {ft}       {a}
+    test
+
+Outputs options
+-p/--plot
+    a/--accel-spect
+-w/--write
+    ABCD   system matrices
+    d      damping
+    freq   frequency
+    cycl   cyclic frequency
+    t      period
+    m      modes
+    c      condition-number
+"""
+
+
+def parse_args(args):
+    outputs = []
+    parsers = {
+        "srim": parse_srim,
+        "test": parse_srim,
+        "okid": parse_okid
+    }
+    config = {}
+    argi = iter(args[1:])
+    for arg in argi:
+        if arg == "-p":
+            outputs.append(next(arg))
+        if arg == "--setup":
+            install_me()
+            sys.exit()
+        elif arg in ["--help", "-h"]:
+            print(HELP)
+            sys.exit()
+        else:
+            config["method"] = arg
+            return parsers[arg](argi, config), outputs
+
+if __name__ == "__main__":
+    import sys
+    import quakeio
+    import numpy as np
+    from pathlib import Path
+    channels = [[17, 3, 20], [9, 7, 4]]
+    method = None
+
+    config, out_ops = parse_args(sys.argv)
+
+    if config["method"] == "test":
+        data_dir = Path("RioDell_Petrolia_Processed_Data")
+
+        first_input = quakeio.read(data_dir/f"CHAN{channels[0][0]:03d}.V2")
+        npoints = len(first_input.accel.data)
+        inputs, outputs = np.zeros((2,npoints,len(channels[0])))
+
+        # Inputs
+        inputs[:,0] = first_input.accel.data
+        for i,inp in enumerate(channels[0][1:]):
+            inputs[:,i+1] = quakeio.read(data_dir/f"CHAN{inp:03d}.V2").accel.data
+
+        # Outputs
+        for i,inp in enumerate(channels[1]):
+            outputs[:,i] = quakeio.read(data_dir/f"CHAN{inp:03d}.V2").accel.data
+
+        dt = first_input.accel["time_step"]
+        config["dt"] = dt
+
+    elif "event_file" in config:
+        event = quakeio.read(config["event_file"])
+        inputs = np.array([
+            event.at(file_name=f"CHAN{i:03d}.V2").accel.data for i in channels[0]
+        ]).T
+        outputs = np.array([
+            event.at(file_name=f"CHAN{i:03d}.V2").accel.data for i in channels[1]
+        ]).T
+        npoints = len(inputs[:,0])
+        dt = event.at(file_name=f"CHAN{channels[0][0]:03d}.V2").accel["time_step"]
+        config["dt"] = dt
+
+    #print(config)
+
+    A,B,C,D = srim(inputs, outputs, **config)
+
+    freqdmpSRIM, modeshapeSRIM, *_ = ComposeModes(dt, A, B, C, D)
+
+    if not out_ops:
+        print(f"period: {np.real(1/freqdmpSRIM[:,0])}")
+    elif "freq" in out_ops:
+        print(f"frequency: {freqdmpSRIM[:,0]}")
+    elif "cycl" in out_ops:
+        print(f"cyclic_frequency: {2*np.pi*freqdmpSRIM[:,0]}")
+
+