irie 0.0.0__py3-none-any.whl

irie/__main__.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+
+import os
+import sys
+
+def main():
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'core.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+if __name__ == '__main__':
+    main()

irie/apps/__init__.py

@@ -0,0 +1,5 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#

irie/apps/authentication/__init__.py

@@ -0,0 +1 @@
+

irie/apps/authentication/admin.py

@@ -0,0 +1 @@
+from django.contrib import admin

irie/apps/authentication/config.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AuthConfig(AppConfig):
+    name = "apps.auth"
+    label = "apps_auth"

irie/apps/authentication/forms.py

@@ -0,0 +1,41 @@
+from django import forms
+from django.contrib.auth.forms import UserCreationForm
+from django.contrib.auth.models import User
+
+
+class LoginForm(forms.Form):
+    username = forms.CharField(
+        widget=forms.TextInput(
+            attrs={"placeholder": "Username", "class": "form-control"}
+        )
+    )
+    password = forms.CharField(
+        widget=forms.PasswordInput(
+            attrs={"placeholder": "Password", "class": "form-control"}
+        )
+    )
+
+
+class SignUpForm(UserCreationForm):
+    username = forms.CharField(
+        widget=forms.TextInput(
+            attrs={"placeholder": "Username", "class": "form-control"}
+        )
+    )
+    email = forms.EmailField(
+        widget=forms.EmailInput(attrs={"placeholder": "Email", "class": "form-control"})
+    )
+    password1 = forms.CharField(
+        widget=forms.PasswordInput(
+            attrs={"placeholder": "Password", "class": "form-control"}
+        )
+    )
+    password2 = forms.CharField(
+        widget=forms.PasswordInput(
+            attrs={"placeholder": "Password check", "class": "form-control"}
+        )
+    )
+
+    class Meta:
+        model = User
+        fields = ("username", "email", "password1", "password2")

irie/apps/authentication/migrations/__init__.py

@@ -0,0 +1 @@
+

irie/apps/authentication/models.py

@@ -0,0 +1 @@
+from django.db import models

irie/apps/authentication/tests.py

@@ -0,0 +1 @@
+from django.test import TestCase

irie/apps/authentication/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+from .views import login_view, register_user
+from django.contrib.auth.views import LogoutView
+
+urlpatterns = [
+    path("login/", login_view, name="login"),
+    path("register/", register_user, name="register"),
+    path("logout/", LogoutView.as_view(), name="logout"),
+]

irie/apps/authentication/views.py

@@ -0,0 +1,53 @@
+from django.shortcuts import render, redirect
+from django.contrib.auth import authenticate, login
+from .forms import LoginForm, SignUpForm
+
+
+def login_view(request):
+    form = LoginForm(request.POST or None)
+
+    msg = None
+
+    if request.method == "POST":
+        if form.is_valid():
+            username = form.cleaned_data.get("username")
+            password = form.cleaned_data.get("password")
+            user = authenticate(username=username, password=password)
+            if user is not None:
+                login(request, user)
+                return redirect("/")
+            else:
+                msg = "Invalid credentials"
+        else:
+            msg = "Error validating the form"
+
+    return render(request, "accounts/login.html", {"form": form, "msg": msg})
+
+
+def register_user(request):
+    msg = None
+    success = False
+
+    if request.method == "POST":
+        form = SignUpForm(request.POST)
+        if form.is_valid():
+            form.save()
+            username = form.cleaned_data.get("username")
+            raw_password = form.cleaned_data.get("password1")
+            user = authenticate(username=username, password=raw_password)
+
+            msg = "User created successfully."
+            success = True
+
+            # return redirect("/login/")
+
+        else:
+            msg = "Form is not valid"
+    else:
+        form = SignUpForm()
+
+    return render(
+        request,
+        "accounts/register.html",
+        {"form": form, "msg": msg, "success": success},
+    )

irie/apps/config.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class AppsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps"
+    label = "apps"
+

irie/apps/context_processors.py

@@ -0,0 +1,5 @@
+from django.conf import settings
+
+
+def cfg_assets_root(request):
+    return {"ASSETS_ROOT": settings.ASSETS_ROOT}

irie/apps/documents/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class DocumentsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = 'apps.documents'
+    label = 'documents'

irie/apps/documents/documents.py

@@ -0,0 +1,61 @@
+TECHNOLOGY, MODELING, RESEARCH = range(3)
+
+DOCUMENTS = [
+# {
+#     "path": "2023-05-30 2nd Annual Report/BRACE2_2023_Annual_Report_Revised_After_Caltrans_Review.pdf",
+#     "title": "2nd Annual Report",
+#     "date": "2023-09-07",
+#     "scope": [TECHNOLOGY, MODELING, RESEARCH],
+#     "draft": False,
+#     "flags": ["new"]
+# },
+# {
+#     "path": "2023-05-30 2nd Annual Report/BRACE2_2023_Annual_Report.pdf",
+#     "title": "2nd Annual Report",
+#     "date": "2023-05-30",
+#     "scope": [TECHNOLOGY, MODELING, RESEARCH],
+#     "draft": True
+# },
+# {
+#     "path": "2021-10-27 ANNUAL Progress Report/BRACE2-Annual-Report-10-27-2021.pdf",
+#     "title": "1st Annual Report",
+#     "scope": [TECHNOLOGY, MODELING, RESEARCH],
+#     "date": "2021-10-27"
+# },
+# {
+#     "path": "2022-01-18 Progress Report 4/Update_BRACE2_1_18_2022.pdf",
+#     "title": "Progress Report 4",
+#     "scope": [MODELING, RESEARCH],
+#     "date": "2022-01-18"
+# },
+# {
+#     "path": "2022-04-21 Progress Report 5/BRACE2_Progress_Report_V_Part_I-4-21-2022.pdf",
+#     "title": "Progress Report 5",
+#     "scope": [MODELING, RESEARCH],
+#     "date": "2022-04-21"
+# },
+# {
+#     "path": "2022-06-01 NCE/BRACE2_Project_Extension_Workplan-6-1-2022.pdf",
+#     "title": "NCE/Project Extension Workplan",
+#     "scope": [MODELING, RESEARCH],
+#     "date": "2022-06-01"
+# },
+# {
+#     "path": "2022-08-11 Progress Report 6/BRACE2_Progress_Report_VI.pdf",
+#     "title": "Progress Report 6",
+#     "scope": [MODELING, RESEARCH],
+#     "date": "2022-08-11"
+# },
+# {
+#     "path": "2022-12-06 Memo Platform Guide/BRACE2_Memo_Platform_Guide_Final.pdf",
+#     "title": "Memo - Platform Guide",
+#     "scope": [MODELING],
+#     "date": "2022-12-06"
+# },
+# {
+#     "path": "2023-01-30 Platform Comment Responses/BRACE2_Memo_Platform_Comments_2-Jan-30-2023.pdf",
+#     "title": "Memo - Platform Comment Responses",
+#     "date": "2023-01-30"
+# }
+]
+

irie/apps/documents/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

irie/apps/documents/urls.py

@@ -0,0 +1,12 @@
+from django.urls import path
+from django.conf.urls.static import static
+from core import settings
+from django.contrib.staticfiles.urls import staticfiles_urlpatterns
+
+from . import views
+
+urlpatterns = [
+    path("documents/", views.document_list, name="documents"),
+    path("documents.html", views.document_list),
+] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
+

irie/apps/documents/views.py

@@ -0,0 +1,27 @@
+from django.shortcuts import render
+
+from django import template
+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponse, HttpResponseRedirect
+from django.template import loader
+
+from .documents import DOCUMENTS
+
+@login_required(login_url="/login/")
+def document_list(request):
+
+    context = {}
+    load_template = "documents.html"
+    context["documents"] = sorted(DOCUMENTS, key=lambda i: i["date"], reverse=True)
+    context["segment"] = load_template
+
+    try:
+        html_template = loader.get_template("documents/" + load_template)
+        return HttpResponse(html_template.render(context, request))
+
+    except Exception as e:
+        if "DEBUG" in os.environ and os.environ["DEBUG"]:
+            raise e
+        html_template = loader.get_template("home/page-500.html")
+        return HttpResponse(html_template.render(context, request))
+

irie/apps/evaluation/admin.py

@@ -0,0 +1,43 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Summer 2023, BRACE2 Team
+#   Berkeley, CA
+#
+#----------------------------------------------------------------------------#
+import json
+import logging
+
+from django.db.models import JSONField
+from django.contrib import admin
+from django.forms import widgets
+
+from .models import Evaluation
+
+logger = logging.getLogger(__name__)
+
+
+class PrettyJSONWidget(widgets.Textarea):
+
+    def format_value(self, value):
+        try:
+            value = json.dumps(json.loads(value), indent=2, sort_keys=True)
+            # these lines will try to adjust size of TextArea to fit to content
+            row_lengths = [len(r) for r in value.split('\n')]
+            self.attrs['rows'] = min(max(len(row_lengths) + 2, 10), 30)
+            self.attrs['cols'] = min(max(max(row_lengths) + 2, 40), 120)
+            return value
+        except Exception as e:
+            logger.warning("Error while formatting JSON: {}".format(e))
+            return super(PrettyJSONWidget, self).format_value(value)
+
+
+class JsonAdmin(admin.ModelAdmin):
+    formfield_overrides = {
+        JSONField: {'widget': PrettyJSONWidget}
+    }
+
+admin.site.register(Evaluation, JsonAdmin)

irie/apps/evaluation/apps.py

@@ -0,0 +1,18 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Summer 2023, BRACE2 Team
+#   Berkeley, CA
+#
+#----------------------------------------------------------------------------#
+from django.apps import AppConfig
+
+
+class PredictionConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.evaluation'
+    label = 'apps_evaluation'
+

irie/apps/evaluation/daemon.py

@@ -0,0 +1,107 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Summer 2023, BRACE2 Team
+#   Berkeley, CA
+#
+#----------------------------------------------------------------------------#
+import sys
+import multiprocessing.dummy
+from collections import defaultdict
+from typing import List, Iterator, Tuple, Dict, Collection
+
+from apps.prediction.predictor import RunID
+from apps.prediction.metrics import HealthMetric, METRIC_CLASSES
+
+class LiveEvaluation:
+    # TODO: Merge into models.Evaluation?
+    def __init__(self, event, predictors, evaluation):
+        self.predictors = predictors
+
+        self.metrics: Dict[str, Dict[str, HealthMetric]] = defaultdict(dict)
+        self.active_metrics: List[str] = list(METRIC_CLASSES.keys())
+
+        self._evaluation = evaluation
+
+        self.evaluation_data = defaultdict(lambda: {
+            "predictors": [],
+            "summary": {},
+            "details": {}
+        })
+
+    def update(self):
+        self._evaluation.evaluation_data = dict(self.evaluation_data)
+        self.save(["evaluation_data"])
+
+    def save(self, fields=None):
+        if fields is None:
+            self._evaluation.save()
+        else:
+            self._evaluation.save(update_fields=fields)
+
+    def runPredictor(self, args: Tuple[str, Tuple[RunID, List[HealthMetric]]]):
+        predictor_name, (run_id, metrics) = args
+        self.predictors[predictor_name].runPrediction(run_id)
+        return predictor_name, run_id
+
+    # met_tag, predictor_name
+    def addMetric(self, mname: str, pid: str, confidence_score:int=0)->HealthMetric:
+        """
+        mname: metric id
+        pid: predictor id
+        """
+        #self.metrics[metric.metric_tag][metric.predictor] = metric
+        self.evaluation_data[mname]["predictors"].append(pid)
+        self.update()
+        return mname
+
+    def setMetricData(self, mname: str, pid: str, data: dict):
+#       self.metrics[mname][pid].data = data
+#       try:
+#           self.evaluation_data[mname]["details"][pid] = data["details"]
+#       except KeyError:
+#           self.evaluation_data[mname]["details"][pid] = data
+#                   self.metrics[mname][pid].buildDetails()
+#       try:
+#           None
+#       except KeyError:
+#           self.evaluation_data[mname]["summary"][pid] = \
+#                   self.metrics[mname][pid].getSummary()
+
+        self.evaluation_data[mname]["details"][pid] = data.get("details", data)
+        self.evaluation_data[mname]["summary"][pid] = data.get("summary", data)
+        if len(self.evaluation_data[mname]["summary"]) == 1:
+            self.evaluation_data[mname]["summary"][pid]["is_primary"] = True
+
+        self.update()
+
+    def assignMetricPredictors(self, event)->Dict[str, Tuple[RunID,List[HealthMetric]]]:
+        queued_predictions : Dict[str, Tuple[RunID,List[HealthMetric]]] = {}
+
+        for mname in self.active_metrics:
+            for predictor, score in self.scorePredictors(mname, self.predictors.values(), event):
+                print(predictor, score)
+
+
+                if predictor.name not in queued_predictions and predictor.active:
+                    rid = predictor.newPrediction(event)
+                    queued_predictions[predictor.name] = (rid, [])
+
+                predictor.activateMetric(mname, queued_predictions[predictor.name][0])
+                queued_predictions[predictor.name][1].append(
+                    #self.addMetric(METRIC_CLASSES[metric](predictor.name), score)
+                    self.addMetric(mname, predictor.name, score)
+                )
+
+        return queued_predictions
+
+
+    def scorePredictors(self, metric, predictors: Collection["Predictor"], event)->Iterator[Tuple["Predictor", int]]:
+        for predictor in predictors:
+            if predictor.active and metric in predictor.getMetricList():
+                print(">>> ", predictor.name, metric, file=sys.stderr)
+                yield (predictor, 0)
+

irie/apps/evaluation/identification.py

@@ -0,0 +1,196 @@
+#===----------------------------------------------------------------------===#
+#
+#         STAIRLab -- STructural Artificial Intelligence Laboratory
+#
+#===----------------------------------------------------------------------===#
+#
+#   Summer 2023, BRACE2 Team
+#   Berkeley, CA
+#
+#----------------------------------------------------------------------------#
+"""
+0. dd = {event_id: {idx01: mode01, idx02: mode02}} // with mode0? = {node: [*ndf]}
+                                                   // or   mode0? = [*ndf] ?
+                                                   // mode = {"period", "idx", "shape"}
+1. aa = {event_id: mode}
+2. for event in aa:
+      bb[event] = 0.0
+      for other_event in aa:
+        if other_event != event :
+            if assoc(dd[event], dd[other_event])[event] == event:
+                bb[event] += 1/(len(aa)-1)
+
+"""
+import os
+import json
+from collections import defaultdict
+
+import numpy as np
+from apps.events.models import Event
+from apps.site.view_utils import raise404
+from apps.inventory.models import Asset
+
+def mkdd(asset, pid, key):
+    evaluations = list(reversed(sorted(Evaluation.objects.filter(asset=asset),
+                                  key=lambda x: x.event.motion_data["event_date"])))
+    return {
+            i_eval: {
+                idx: mode for idx,mode in \
+                     enumerate(evaluation.evaluation_data["SPECTRAL_SHIFT_IDENTIFICATION"]["summary"][pid])
+                        if key in mode and mode.get("emac", 1.0) > 0.5 and mode.get("mpc", 1.0) > 0.5
+
+            } for i_eval,evaluation in enumerate(evaluations)
+    }
+
+def _ssid_stats(asset, pid, key):
+    filtered_modes = mkdd(asset, pid, key)
+    values = [mode[key] for mode in event.values() for event in filtered_modes.values()]
+
+    mean = np.mean(values)
+    std =  np.std(values)
+
+    result = {}
+    for i_eval, event_results in filtered_modes.items():
+        idx = np.argmin(np.abs(mean - np.array([mode[key] for mode in event_results])))
+        result[i_eval] = event_results[idx]
+        result[i_eval]["idx"] = idx
+    return result
+
+#   return {
+#           i_eval: event_results[np.argmin(np.abs(mean - np.array([mode[key] for mode in event_results])))]
+#               if event_results and len(event_results) > 0 else {}
+#         for i_eval, event_results in filtered_modes.items()
+#   }
+
+
+def ff(asset, pid, key):
+    # evaluation_data 
+    dd = mkdd(asset, pid, key)
+
+    aa = _ssid_stats(asset, pid, key)
+
+    for event in aa:
+        aa[event]["bb"] = 0.0
+        for other_event in aa:
+            if other_event != event :
+                if assoc(dd[event], dd[other_event])[event] == event:
+                    aa[event]["bb"] += 1/(len(aa)-1)
+
+HELP = """
+modeID [options] <baseline> <unknown>
+
+OeventPTIONS:
+    -c<compare-mode>        compare mode, currently only 'max' supported
+
+EXAMPLES:
+
+Default compare:
+    modeID baseline.yaml unknown.yaml
+
+To use `max` compare mode:
+    modeID -cmax baseline.yaml unknown.yaml
+or
+    modeID -c max baseline.yaml unknown.yaml
+
+"""
+
+import yaml
+import numpy as np
+import sys
+
+TOL = 1e-14
+
+def _clean_modes(modes, tol=1e-14):
+    "Zero-out small values"
+    mode_array = np.array([
+        [val for node in mode.values() for val in node]
+             for mode in modes.values()
+    ])
+    mode_array[abs(mode_array) < tol] = 0.0
+    return mode_array
+
+
+def associate_modes(baseline, unidentified_dict, compare = None, verbose=True):
+    identified_keys = set()
+    identified = {}
+    _old_labels = list(unidentified_dict.keys())
+
+    if compare is None:
+        _compare = lambda errors, labels: np.argmin(errors)
+
+    elif compare == "max":
+        _compare = lambda errors, labels: np.argmax(errors[~np.isin(np.arange(len(errors)), labels)])
+
+    unidentified = _clean_modes(unidentified_dict, tol=TOL)
+
+    for key, mode in baseline.items():
+        #
+        baseline_data = np.array([*mode.values()]).flatten()
+        baseline_data[abs(baseline_data) < TOL] = 0.0
+        scale_index = np.argmax(np.absolute(baseline_data))
+        baseline_scale = baseline_data[scale_index]
+
+        errors = np.sum(abs(baseline_data - unidentified*baseline_scale/unidentified[:,scale_index][:,None]), axis=1)
+
+        # Get index of mode from <unidentified> that is closest to `mode`
+        index = _compare(errors, identified_keys)
+        old_label = _old_labels[index]
+
+        if verbose:
+            print(f"{old_label} -> {key}", file=sys.stderr)
+
+        if  old_label in identified_keys and verbose:
+            print(f"WARNING: duplicate identification of key {old_label}", file=sys.stderr)
+
+        identified_keys.add(_old_labels[index])
+        identified[key] = unidentified[index]
+
+    return identified
+
+
+if __name__ == "__main__":
+    # Parse command line
+    index = 1
+    compare_mode = None
+    if "-c" in sys.argv[1]:
+        index += 1
+        if len(sys.argv[1]) > 2:
+            compare_mode = sys.argv[1][2:]
+        else:
+            compare_mode = sys.argv[index]
+            index += 1
+
+    baseline_file, unidentified_file = sys.argv[index:]
+
+
+    # Open Files
+    with open(unidentified_file, "r") as f:
+        unidentified = yaml.load(f, Loader=yaml.Loader)
+
+    with open(baseline_file, "r") as f:
+        baseline = yaml.load(f, Loader=yaml.Loader)
+
+    for nodes in unidentified.values():
+        node_names = list(nodes.keys())
+        break
+
+    # print(yaml.dump(
+    #     {
+    #         key: {
+    #             node_name: [float(v) for v in node_vals] 
+    #               for node_name, node_vals in 
+    #                  zip(node_names, mode.reshape((-1, len(node_names))).T)
+    #         } for key, mode in 
+    #         associate_modes(baseline, unidentified, compare=compare).items()
+    #     }
+    # ))
+
+    # for k,mode in associate_modes(baseline, unidentified, compare=compare).items():
+    #     print(f"{k}:\n\t")
+    #     print("\n\t".join((f"{node_name}: [{','.join(str(v) for v in node_vals)}]"
+    #               for node_name, node_vals in 
+    #                  zip(node_names, mode.reshape((-1, len(node_names))).T)
+    #     )))
+
+    associate_modes(baseline, unidentified, compare=compare_mode)
+