irie 0.0.0__py3-none-any.whl

irie/apps/prediction/runners/utilities.py

@@ -0,0 +1,277 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+import json
+import fnmatch
+import numpy as np
+
+from matplotlib import pyplot as plt
+from math import pi
+from collections import defaultdict
+import quakeio
+
+try:
+    from xmlutils import read_sect_xml3 as read_sect_xml
+    from xmlutils import read_xml
+except ImportError:
+    from .xmlutils import read_sect_xml3 as read_sect_xml
+    from .xmlutils import read_xml
+
+def read_model(filename:str)->dict:
+    with open(filename, "r") as f:
+        model = json.load(f)
+    sam = model["StructuralAnalysisModel"]
+    model["sections"] = {
+        int(s["name"]): s for s in sam["properties"]["sections"]
+    }
+    model["materials"] = {
+        int(m["name"]): m for m in sam["properties"]["uniaxialMaterials"]
+    }
+    model["elements"] = {
+#       int(el["name"]): el for el in sam["geometry"]["elements"]
+        int(el["name"]): {**el, "length": None} for el in sam["geometry"]["elements"]
+    }
+    return model
+
+# --8<--------------------------------------------------------
+def damage_states(Dcol):
+    from opensees import section
+    from opensees.section import patch
+
+    cover = 2.0
+    Rcol = Dcol/2
+    coverl = cover + Rcol*(1/np.cos(np.pi/8)-1)
+    return {
+        "dsr0": {
+            "regions": [
+                # external radius    internal radius
+                section.PolygonRing(8, Rcol, Rcol-coverl/4)
+            ],
+            "material": "*concr*"
+        },
+        "dsr1": {
+            "regions": [
+                section.FiberSection(areas=[
+                    patch.circ(intRad=Rcol - cover - 2, extRad=Rcol - cover)
+                ])
+            ],
+            "material": "*steel*"
+        },
+        "dsr2" : {
+            "regions": [
+                section.PolygonRing(8, Rcol,         Rcol-coverl/4)
+            ]
+        },
+        "dsr3" : {
+            "regions": [
+                section.PolygonRing(8, Rcol-cover/2, Rcol-3*cover/4)
+            ],
+            "material": "*concr*"
+        },
+        "dsr4" : {
+            "regions": [
+                section.PolygonRing(8, Rcol-3*coverl/4, Rcol-coverl)
+            ],
+            "material": "*concr*"
+        },
+        "dsr5": {
+            "regions": [
+                section.FiberSection(areas=[
+                    patch.circ(intRad=Rcol - cover - 2, extRad=Rcol - cover)
+                ])
+            ],
+            "material": "*concr*"
+        },
+        "dsr6": {
+            "regions": [
+                section.FiberSection(areas=[
+                    patch.circ(intRad=Rcol - cover - 2, extRad=Rcol - cover)
+                ])
+            ],
+            "material": "*steel*"
+        },
+        "all": {
+            "regions": [
+                section.ConfinedPolygon(8, Rcol)
+            ]
+        }
+    }
+
+# --8<--------------------------------------------------------
+
+def iter_section_fibers(model, s, filt=None, match=None):
+    # if match is None:
+    #     test = lambda a, b: a == b 
+    # elif match == "pattern":
+    #     pass
+    if filt is not None:
+        if "material" not in filt:
+            filt["material"] = "*"
+        for fiber in s["fibers"]:
+            print(fiber)
+            print(fnmatch.fnmatch(
+                    model["materials"][fiber["material"]]["type"].lower(),
+                    filt["material"]
+                ))
+            print([fiber["coord"] in region for region in filt["regions"]])
+            if (
+                ("material" not in filt) or fnmatch.fnmatch(
+                    model["materials"][fiber["material"]]["type"].lower(),
+                    filt["material"]
+                )
+            ) and any(
+                fiber["coord"] in region for region in filt["regions"]
+            ) :
+                yield fiber
+    else:
+        yield from s["fibers"]
+
+
+def iter_elem_fibers(model:dict, elements:list, sections: list=(0,-1), filt:dict=None):
+    for tag in map(int,elements):
+        el = model["elements"][int(tag)]
+        for i in sections:
+            idx = len(el["sections"]) - 1 if i==-1 else i
+            tag = int(el["sections"][idx])
+            s = model["sections"][tag]
+            if "section" in s:
+                s = model["sections"][int(s["section"])]
+                for f in iter_section_fibers(model, s, filt):
+                    yield el,idx+1,f
+
+def fiber_strain(recorder_data, el, s, f, t=None):
+    if t is not None:
+        eps = recorder_data[int(el)][int(s)]["eps"][t]
+        kz =  recorder_data[int(el)][int(s)]["kappaZ"][t]
+        ky =  recorder_data[int(el)][int(s)]["kappaY"][t]
+    else:
+        eps = recorder_data[int(el)][int(s)]["eps"]
+        kz =  recorder_data[int(el)][int(s)]["kappaZ"]
+        ky =  recorder_data[int(el)][int(s)]["kappaY"]
+
+    return eps - kz * f["coord"][1] + ky * f["coord"][0]
+
+
+REGIONS1 = damage_states(84.0)
+REGIONS2 = damage_states(66.0)
+REGIONS3 = damage_states(48.0)
+
+def getDamageStateStrains(a, dsr, model, elems, strain_data=None):
+    if strain_data is None:
+        strain_data = {}
+
+    intFrames = 1
+
+    epsEle = []
+    for ele in elems:
+        if ele < 12000:
+            regions = REGIONS1
+        elif ele < 13000:
+            regions = REGIONS2
+        else:
+            regions = REGIONS3
+
+        # TODO!!!!!!!!!!!
+        if np.isin(ele, [2010, 2020, 12010, 12020, 12030, 13010, 13020, 14010, 14020, 14030]):
+            sec = 4
+        else:
+            sec = 1
+
+        data_file = f"eleDef{sec}.txt"
+        if data_file in strain_data:
+            strains = strain_data[data_file]
+        else:
+            strains = strain_data[data_file] = read_sect_xml(a/f"{data_file}")
+
+        print(list(iter_elem_fibers(model, [ele], [int(sec)-1], filt=regions["dsr1"])))
+
+        X,Y,epsRaw = zip(*(
+                (
+                    fib["coord"][0], fib["coord"][1],
+                    fiber_strain(strains, int(e["name"]), s, fib)
+                ) for ds in dsr
+            for e,s,fib in iter_elem_fibers(model, [ele], [int(sec)-1], filt=regions[ds])
+        ))
+
+        eps = np.array([e.T for e in epsRaw])
+        epsElei = X, Y, eps, intFrames, np.arange(eps.shape[1])
+        epsEle.append(epsElei)
+    return epsEle
+
+def get_DS(a, model, elems, strain_data):
+    dsrs = list(map(lambda x: f"dsr{x}", range(1,7)))
+    thresholds = list(reversed([0.09, -0.011, -0.005, -0.005, -0.005, 0.002]))
+    ds_by_elem = {el: {"state": 0, "time": np.nan} for el in elems}
+    for i in range(len(dsrs)):
+        dsr = dsrs[i]
+        th = thresholds[i]
+        epsEle = getDamageStateStrains(a, [dsr], model, elems, strain_data)
+        for j in range(len(elems)):
+            X, Y, eps = epsEle[j][:3]
+
+            for t in range(eps.shape[1]):
+                epst = eps[:, t]
+                if (th < 0 and any(epst <= th)) or (th > 0 and any(epst >= th)):
+                    ds_by_elem[elems[j]] = {"state": i+1, "time": t}
+                    break
+    return ds_by_elem
+
+
+def getPeakXML(file, filter="*"):
+    nodeOutputs = read_xml(file)
+    return {
+        node:
+            {resp: max(abs(nodeOutputs[node][resp])) for resp in nodeOutputs[node]} 
+            for node in nodeOutputs
+    }
+
+def getPeak(file, other=None):
+    nodeOutputs = np.loadtxt(file)
+    peakVals = np.max(np.abs(nodeOutputs), axis=0)
+    peakVals = np.append(peakVals, max(peakVals))
+    timePeakVals = np.argmax(np.abs(nodeOutputs), axis=0)
+    maxPeakCol = np.argmax(peakVals)
+    timePeakVals = np.append(timePeakVals, timePeakVals[maxPeakCol])
+    return peakVals, timePeakVals, maxPeakCol
+
+def husid(accRH, plothusid, dt, lb=0.05, ub=0.95):
+    ai = np.tril(np.ones(len(accRH)))@accRH**2
+    husid = ai/ai[-1]
+    ilb = next(x for x, val in enumerate(husid) if val > lb)
+    iub = next(x for x, val in enumerate(husid) if val > ub)
+    if plothusid:
+        fig, ax = plt.subplots()
+        if dt is not None:
+            print("duration between ", f"{100*lb}%", " and ", f"{100*ub}%", " (s): ", dt*(iub-ilb))
+            ax.plot(dt*np.arange(len(accRH)), husid)
+            ax.set_xlabel("time (s)")
+        else:
+            ax.plot(np.arange(len(accRH)), husid)
+            ax.set_xlabel("timestep")
+        ax.axhline(husid[ilb], linestyle=":", label=f"{100*lb}%")
+        ax.axhline(husid[iub], linestyle="--", label=f"{100*ub}%")
+        ax.set_title("Husid Plot")
+        ax.legend()
+    return (ilb, iub)
+
+def get_node_values(filename, channels, quant=None):
+    if quant is None:
+        quant = "accel"
+
+    event = quakeio.read(filename)
+    rotated = set()
+
+    nodes = defaultdict(dict)
+    for nm,ch in channels.items():
+        channel = event.match("l", station_channel=nm)
+        if id(channel._parent) not in rotated:
+            channel._parent.rotate(ch[2])
+            rotated.add(id(channel._parent))
+        series = getattr(channel, quant).data
+        nodes[ch[0]][ch[1]] = series
+
+    return nodes
+

irie/apps/prediction/runners/xmlutils.py

@@ -0,0 +1,232 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+import re
+import warnings
+import numpy as np
+from collections import defaultdict
+import xml.etree.ElementTree as ET
+
+re_elem_tag = re.compile(rb'eleTag="([0-9]*)"')
+re_node_tag = re.compile(rb'nodeTag="([0-9]*)"')
+re_sect_num = re.compile(rb'number="([0-9]*)"')
+resp_tag = re.compile(rb"<ResponseType>([A-z0-9]*)</ResponseType>")
+
+class ParseError(Exception): pass
+
+def getDictData(allData, curDict):
+    if isinstance(curDict, (defaultdict,dict)):
+        for key, item in curDict.items():
+            if isinstance(item, (defaultdict,dict)):
+                getDictData(allData, item)
+            elif isinstance(item, int):
+                curDict[key] = allData[:, item]
+
+
+def read_sect_xml3(filename: str)->dict:
+    data_dict = defaultdict(lambda: defaultdict(dict))
+    counter = 0
+
+    with open(filename, "rb") as f:
+        # print(f.read())
+        try:
+            for line in f:
+                if b"<ElementOutput" in line and b"/>" not in line and (elem := re_elem_tag.search(line)):
+                    elem_tag = int(elem.group(1).decode())
+                    while b"</ElementOutput>" not in line:
+                        line = next(f)
+                        if b"<GaussPointOutput" in line:
+                            sect = re_sect_num.search(line).group(1).decode()
+
+                        elif b"<ResponseType" in line:
+                            r_label =  resp_tag.search(line).group(1).decode()
+                            while r_label in data_dict[elem_tag][sect]:
+                                r_label += "_"
+                            data_dict[elem_tag][sect][r_label] = counter
+                            counter += 1
+
+
+                elif b"<Data>" in line:
+                    lines = f.read()
+                    lines = lines[:lines.find(b"</Data>")].split()
+                    data = np.fromiter(lines, dtype=np.float64, count=len(lines))
+        except StopIteration:
+            raise ParseError(f"Failed to find end tag in XML file {filename}")
+
+    getDictData(data.reshape((-1, counter)), data_dict)
+    return data_dict
+
+def read_sect_xml1(xml_file):
+    root = ET.parse(xml_file).getroot()
+
+    dataDict = {}
+    colCtr = 0
+
+    # time_output = root.find("TimeOutput")
+    # if time_output:
+    #     hdrs.append(child[0].text)
+    #     dataDict[child[0].text] = colCtr
+    #     colCtr += 1
+
+    elems = root.findall("ElementOutput")
+    for child in elems:
+
+        eleKey = child.attrib["eleTag"]
+        secKey = child[0].attrib["number"]
+
+        dataDict[eleKey] = {secKey: {}}
+
+        for respCtr in range(len(child[0][0])):
+            respKey = child[0][0][respCtr].text
+            if respKey in dataDict[eleKey][secKey].keys():
+                respKey = respKey + "_"
+            dataDict[eleKey][secKey][respKey] = colCtr
+            colCtr += 1
+                
+    data_element = root.find("Data")
+    data = np.array(data_element.text.split(), dtype=float)
+    getDictData(data.reshape((-1, colCtr)), dataDict)
+    return dataDict
+
+def read_sect_xml2(xml_file):
+    root = ET.parse(xml_file).getroot()
+
+    dataDict = {}
+    colCtr = 0
+
+    # time_output = root.find("TimeOutput")
+    # if time_output:
+    #     hdrs.append(child[0].text)
+    #     dataDict[child[0].text] = colCtr
+    #     colCtr += 1
+
+    elems = root.findall("ElementOutput")
+    for child in elems:
+
+        eleKey = child.attrib["eleTag"]
+        secKey = child[0].attrib["number"]
+
+        dataDict[eleKey] = {secKey: {}}
+
+        for respCtr in range(len(child[0][0])):
+            respKey = child[0][0][respCtr].text
+            if respKey in dataDict[eleKey][secKey].keys():
+                respKey = respKey + "_"
+            dataDict[eleKey][secKey][respKey] = colCtr
+            colCtr += 1
+                
+    data_element = root.find("Data")
+    data = np.fromiter(
+        (i for text in data_element.itertext() for i in text.split()), dtype=float,
+    ).reshape((-1, colCtr))
+    getDictData(data, dataDict)
+    return dataDict
+
+def read_sect_xml0(xml_file):
+    "Arpit Nema"
+    root = ET.parse(xml_file).getroot()
+
+    hdrs = []
+    dataDict = {}
+    colCtr = 0
+    for i, child in enumerate(root):
+        if child.tag == "TimeOutput":
+            hdrs.append(child[0].text)
+            dataDict[child[0].text] = colCtr
+            colCtr += 1
+        elif child.tag == "ElementOutput":
+            eleKey = child.attrib["eleTag"]
+            secKey = child[0].attrib["number"]
+            hdrPre = eleKey + "_" + secKey + "_" + child[0][0].attrib["secTag"]
+
+            dataDict[eleKey] = {secKey: {}}
+            for respCtr in range(len(child[0][0])):
+                hdrs.append(hdrPre + "_" + child[0][0][respCtr].text)
+                respKey = child[0][0][respCtr].text
+                if respKey in dataDict[eleKey][secKey].keys():
+                    respKey = respKey + "_"
+                dataDict[eleKey][secKey][respKey] = colCtr
+                colCtr += 1
+        elif child.tag == "Data":
+            tmp = child.text
+
+    data = np.array(tmp.replace("\n", "").split(), dtype=float)
+    
+    data = data.reshape((-1, len(hdrs)))
+    getDictData(data, dataDict)
+    return dataDict
+
+
+
+def read_nodeRH_xml(filename: str)->dict:
+    data_dict = defaultdict(lambda: defaultdict(dict))
+    counter = 0
+
+    with open(filename, "rb") as f:
+        try:
+            for line in f:
+                if b"<NodeOutput" in line and (node := re_node_tag.search(line)):
+                    node_tag = int(node.group(1).decode())
+
+                elif b"<Data>" in line:
+                    lines = f.read()
+                    lines = lines[:lines.find(b"</Data>")].split()
+                    data = np.fromiter(lines, dtype=np.float64, count=len(lines))
+        except StopIteration:
+            raise ParseError(f"Failed to find end tag in XML file {filename}")
+
+    getDictData(data.reshape((-1, counter)), data_dict)
+    return data_dict
+
+
+def read_xml(xml_file):
+    root = ET.parse(xml_file).getroot()
+
+    dataDict = {}
+    colCtr = 0
+
+    # time_output = root.find("TimeOutput")
+    # if time_output:
+    #     hdrs.append(child[0].text)
+    #     dataDict[child[0].text] = colCtr
+    #     colCtr += 1
+
+    for child in root.findall("ElementOutput"):
+
+        eleKey = child.attrib["eleTag"]
+        try:
+            secKey = child[0].attrib["number"]
+        except IndexError:
+            warnings.warn(f"Skipping element '{eleKey}'")
+            continue
+
+        dataDict[eleKey] = {secKey: {}}
+
+        for respCtr in range(len(child[0][0])):
+            respKey = child[0][0][respCtr].text
+            if respKey in dataDict[eleKey][secKey].keys():
+                respKey = respKey + "_"
+            dataDict[eleKey][secKey][respKey] = colCtr
+            colCtr += 1
+
+    for child in root.findall("NodeOutput"):
+
+        tag = int(child.attrib["nodeTag"])
+
+        dataDict[tag] = {}
+
+        for resp in child.findall("ResponseType"):
+            respKey = resp.text
+            if respKey in dataDict[tag].keys():
+                respKey = respKey + "_"
+            dataDict[tag][respKey] = colCtr
+            colCtr += 1
+
+    data_element = root.find("Data")
+    data = np.array(data_element.text.split(), dtype=float)
+    getDictData(data.reshape((-1, colCtr)), dataDict)
+    return dataDict
+

irie/apps/prediction/runners/zipped.py

@@ -0,0 +1,27 @@
+import sys
+import zipfile
+import tempfile
+import subprocess
+
+def process_zip_file(archive, main_file, temp_dir):
+    # Create a temporary directory
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Extract the zip file into the temporary directory
+        with zipfile.ZipFile(archive, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir)
+        
+        # Start a subprocess with the temporary directory as the cwd
+        process = subprocess.Popen(
+            [sys.executable, "-m", "opensees", main_file],  # Replace with the command you want to run
+            cwd=temp_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        # Wait for the process to complete and get the output
+        stdout, stderr = process.communicate()
+        
+        # Print the output for debugging purposes
+        print("STDOUT:", stdout.decode())
+        print("STDERR:", stderr.decode())
+

irie/apps/prediction/templatetags/predictor.py

@@ -0,0 +1,20 @@
+from django import template
+from django.utils.safestring import SafeString
+
+register = template.Library()
+
+@register.filter(is_safe=True)
+def display_predictor(predictor):
+    out = "" # str(predictor.__class__.__name__) #"" # f'<h6 style="display:inline">{predictor.name}</h6>  '
+    out = out + predictor.description
+    out = out + "\n".join((out, '<table class="table align-items-center"><tbody>'))
+
+    #for key, val in predictor.conf.get("config", {}).items():
+    for key, val in predictor.conf.items():
+        name = predictor.schema["properties"].get(key, {"name": key}).get("name", key)
+        out = out + f"<tr><td>{name}</td><td><code>{val}</code></td><tr>"
+
+    out = out + "</tbody></table>"
+    return SafeString(out)
+
+#register.filter("display_predictor", display_predictor)

irie/apps/prediction/urls.py

@@ -0,0 +1,19 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Author: Claudio Perez
+#
+#----------------------------------------------------------------------------#
+from django.urls import path, re_path
+from .views import new_prediction, asset_predictors, predictor_profile, predictor_upload
+
+urlpatterns = [
+    re_path("^inventory/[0-9 A-Z-]*/predictors/new",   new_prediction),
+    re_path("^inventory/[0-9 A-Z-]*/predictors/[0-9]", predictor_profile),
+    re_path("upload/", predictor_upload),
+    re_path("^inventory/[0-9 A-Z-]*/predictors/",      asset_predictors, name="asset_predictors"),
+    re_path("^inventory/[0-9 A-Z-]*/predictors/",      asset_predictors),
+]