irie 0.0.59__py3-none-any.whl → 0.0.60__py3-none-any.whl

irie/apps/evaluation/models.py

@@ -51,6 +51,13 @@ class Evaluation(models.Model):
 #           Thread(target=evaluate, args=(event, evaluation)).start()
 
         return evaluation
+    
+    def evaluate(self):
+        """
+        Evaluate the event and update the evaluation status.
+        This method can be run in a separate thread.
+        """
+        return evaluate(self.event, self)
 
 
 def evaluate(event, evaluation)->"Evaluation":

irie/apps/events/views_events.py

@@ -84,8 +84,8 @@ def save_event(request, event, success_status):
     # RECORD ID
     rec_id = motion_data.get("record_identifier", "")
 
-    if EventRecord.objects.filter(record_identifier=rec_id).first():
-        print("\n\nSKIPPING\n\n")
+    if (evnt := EventRecord.objects.filter(record_identifier=rec_id).first()):
+        print(f"\n\nSKIPPING, {evnt.id}")
         return HttpResponse(json.dumps({"data": ""}), status=success_status)
 
     # CREATE EVENT

irie/apps/inventory/models.py

@@ -118,7 +118,7 @@ class Datum(models.Model):
 
     def __str__(self):
         return f"{self.name}"
-    
+
     def to_cardinal(self):
         """
         Create rotation matrix from datum basis to cardinal basis.

irie/apps/inventory/views.py

@@ -170,6 +170,9 @@ def asset_event_summary(request, cesmd, event):
         evaluation_data = {}
         evaluation = None
 
+    if request.method == 'POST':
+        evaluation.evaluate()
+
     try:
         for metric in evaluation_data.values():
             metric["completion"] = (
@@ -451,7 +454,10 @@ def sensor_upload(request, calid):
         "group_form": group_form,
         "formset": formset,
         "renderings": [
-            {"name": predictor.name, "glb": predictor.render_file.url}
+            {
+                "name": predictor.name,
+                "glb": predictor.render_file.url
+            }
             for predictor in PredictorModel.objects.filter(asset=asset, protocol="IRIE_PREDICTOR_V1")
             if predictor.render_file and predictor.render_file.url
         ],

irie/apps/prediction/forms/csi_upload.py

@@ -0,0 +1,68 @@
+# forms.py
+from django import forms
+from irie.apps.inventory.models import Datum
+from irie.apps.prediction.models import PredictorModel, SensorAssignment
+
+class DatumSelectForm(forms.Form):
+    """
+    Step 0 – choose an existing datum or say 'create new'.
+    The empty choice means 'I want to add a new datum'.
+    """
+    datum = forms.ModelChoiceField(
+        queryset=Datum.objects.none(),
+        required=False,
+        empty_label="-- create new datum --",
+        label="Select Datum",
+        help_text="Select an existing datum or create a new one."
+    )
+
+    def __init__(self, *args, asset=None, datum_queryset=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["datum"].queryset = datum_queryset or Datum.objects.none()
+
+class DatumCreateForm(forms.ModelForm):
+    class Meta:
+        model = Datum
+        fields = ("angle_x", "angle_y")
+
+    def __init__(self, *args, asset=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.asset = asset
+
+class PredictorForm(forms.ModelForm):
+    class Meta:
+        model = PredictorModel
+        help_text = {
+            "config_file": "File exported from CSi Bridge or SAP2000 (.b2k or .s2k).",
+        }
+        fields = "__all__"
+        exclude = [
+            "render_file", 
+            "asset", 
+            "metrics", 
+            "active",
+            "description",
+            "entry_point", 
+            "config", 
+            "protocol"
+        ]
+    def __init__(self, *args, asset=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.asset = asset
+        self.fields['name'].widget.attrs["class"] = "rounded-0"
+        self.fields['config_file'].widget.attrs["class"] = "rounded-0"
+
+class SensorForm(forms.ModelForm):
+    class Meta:
+        model = SensorAssignment
+        fields = (
+            "role",
+            "sensor"
+        )
+
+    def __init__(self, *args,  **kwargs): 
+        super().__init__(*args, **kwargs)
+
+class ConfirmForm(forms.Form):
+    # no fields – just a read-only summary screen
+    pass

irie/apps/prediction/runners/__init__.py

@@ -32,13 +32,15 @@ class Runner:
             # Create from existing PredictorModel when loaded from database.
             # This is done when running analysis
             self.id = pred.id
-            self.asset = pred.asset
+            # self.asset = pred.asset
             self.name: str = pred.name
             self.description = "" # conf.description
             self.conf = pred.config
-            self.entry_point = pred.entry_point
-            self.metrics = pred.metrics
-            self.active = pred.active
+            if pred.entry_point:
+                self.entry_point = pred.entry_point
+            if pred.metrics:
+                self.metrics = pred.metrics
+            self.active  = pred.active
 
             # NEW:
             self.predictor = pred

irie/apps/prediction/runners/opensees/__init__.py

@@ -6,6 +6,7 @@
 #
 import os.path
 import shutil
+import tqdm
 import sys, json
 import zipfile
 from pathlib import Path
@@ -54,7 +55,7 @@ def _create_excitation(model, predictor, inputs, dt):
 def _analyze_and_render(model, artist, nt, dt):
     import veux, veux.motion
     motion = veux.motion.Motion(artist)
-    for i in range(nt):
+    for i in tqdm.tqdm(range(nt)):
         if model.analyze(1, dt) != 0:
             return -1
         motion.advance(i*dt)
@@ -102,7 +103,7 @@ class OpenSeesRunner(Runner):
             with open(uploaded_file.name, 'wb+') as destination:
                 for chunk in uploaded_file.chunks():
                     destination.write(chunk)
-        
+
         # predictor.config_file = uploaded_file # data.pop("file")
         predictor.name = data.pop("name")
         predictor.config = data
@@ -227,6 +228,16 @@ class OpenSeesRunner(Runner):
                 "analysis": schemas.load("hwd_analysis.schema.json"),
             }
         }
+    
+    def render(self):
+        import veux
+        model = Job(self._csi).assemble().model
+
+        outlines = collect_outlines(self._csi, model.frame_tags)
+        artist = veux.render(model, canvas="gltf", vertical=3,
+                                reference={"frame.surface", "frame.axes"},
+                                model_config={"frame_outlines": outlines})
+        return artist
 
     def getMetricList(self):
         return [
@@ -236,6 +247,7 @@ class OpenSeesRunner(Runner):
             # "ACC_RESPONSE_HISTORY",
         ]
 
+
     def newPrediction(self, event, output_directory = None):
         """
         Create a new prediction run and return the run_id. If output_directory is None,
@@ -272,7 +284,7 @@ class OpenSeesRunner(Runner):
             if False:
                 event = event.event_file.path
                 shutil.copyfile(event, run_dir/"event.zip")
-            
+
             model_file = None
             if hasattr(self, "model_file") and self.model_file is not None:
                 shutil.copyfile(self.model_file.resolve(),
@@ -327,7 +339,6 @@ class OpenSeesRunner(Runner):
         # Create model
         import opensees.openseespy as ops
 
-        import sys
         csi = self._csi 
 
         with new_cd(self.runs[run_id]["run_output_directory"]):
@@ -445,6 +456,7 @@ class OpenSeesRunner(Runner):
             for metric in metrics:
                 metric.record(asm)
 
+
             nt = 500
             dt = 0.02
             _create_excitation(model, self.predictor, self.runs[run_id]["inputs"], dt)
@@ -496,16 +508,16 @@ class OpenSeesRunner(Runner):
         # if type == "COLUMN_STRAIN_STATES":
         #     return _clean_json(column_strain_state_metric(model, output_dir, config))
 
-        if type == "PEAK_ACCEL":
-            return _clean_json(peak_acceleration_metric(output_dir, config))
+#         if type == "PEAK_ACCEL":
+#             return _clean_json(peak_acceleration_metric(output_dir, config))
 
-        elif type == "PEAK_DRIFT":
-            return _clean_json(peak_drift_metric(model, output_dir, config))
+#         elif type == "PEAK_DRIFT":
+#             return _clean_json(peak_drift_metric(model, output_dir, config))
 
-        elif type == "ACC_RESPONSE_HISTORY":
-            # config = CONFIG
-#           return accel_response_history_plot(output_dir, config)
-            return {}
+#         elif type == "ACC_RESPONSE_HISTORY":
+#             # config = CONFIG
+# #           return accel_response_history_plot(output_dir, config)
+#             return {}
         return {}
 
     #
@@ -519,17 +531,40 @@ class OpenSeesRunner(Runner):
             try:
                 csi_file = self.predictor.config_file
                 self._csi_data = load_csi((str(line.decode()).replace("\r\n","\n") for line in csi_file.readlines()))
+
             except Exception as e:
                 import sys
                 print(f"Error loading CSiBridge file: {e}", file=sys.stderr)
-                self._csi_data = None
+                self._csi_data = {}
 
         return self._csi_data
 
 
     def structural_section(self, name):
         if (s:= create_section(self._csi, name)) is not None:
-            return {}, s._create_model(mesh_size=0.1)
+            model = s._create_model(mesh_size=0.1)
+            if model is None:
+                return [], None
+            cmm = model.cmm()
+            cnn = model.cnn()
+            cnm = model.cnm()
+            properties = [
+                {
+                    "name": "Elastic", "data": [
+                        {"name": "A",   "value": float(cnn[0,0])},
+                        {"name": "Iyy", "value": float(cmm[1,1])},
+                        {"name": "Izz", "value": float(cmm[2,2])},
+                    ],
+                },
+                {
+                    "name": "Ultimate", "data": [
+                        # {"name": "A",   "value": float(cnn[0,0])},
+                        # {"name": "Iyy", "value": float(cmm[1,1])},
+                        # {"name": "Izz", "value": float(cmm[2,2])},
+                    ]
+                }
+            ]
+            return properties, model
 
 
     def structural_sections(self):

irie/apps/prediction/urls.py

@@ -7,10 +7,10 @@
 #   Author: Claudio Perez
 #
 #----------------------------------------------------------------------------#
-from django.urls import re_path
+from django.urls import path, re_path
 from .views import (
-    asset_predictors, predictor_profile, predictor_render,
-    create_mdof, create_model, asset_map
+    asset_predictors, predictor_profile, predictor_render, predictor_table,
+    create_mdof, create_model, asset_map, CsiUpload, FORMS
 )
 
 _ROOT = "^inventory/(?P<calid>[0-9 A-Z-]*)/predictors"
@@ -18,8 +18,10 @@ _ROOT = "^inventory/(?P<calid>[0-9 A-Z-]*)/predictors"
 urlpatterns = [
     re_path(f"{_ROOT}/(?P<preid>[0-9]{{1,}})/$",        predictor_profile),
     re_path(f"{_ROOT}/(?P<preid>[0-9]{{1,}})/render/",  predictor_render),
+    re_path(f"{_ROOT}/(?P<preid>[0-9]{{1,}})/properties/",   predictor_table),
     re_path(f"{_ROOT}/create/map/$",                    asset_map),
-    re_path(f"{_ROOT}/create/model/$",                  create_model),
+    # re_path(f"{_ROOT}/create/model/$",                  create_model),
+    re_path(f"{_ROOT}/create/model/$",                  CsiUpload.as_view(FORMS), name="csi_upload"),
     re_path(f"{_ROOT}/create/v1/$",                     create_mdof),
     re_path(f"{_ROOT}/$",                               asset_predictors, name="asset_predictors")
 ]

irie/apps/prediction/views.py

@@ -16,13 +16,15 @@ import uuid
 import base64
 import hashlib
 
+from django.template.loader import render_to_string
+from django.utils.html import escape
 from django.template import loader
 from django.contrib.auth.decorators import login_required
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
 from django.shortcuts import HttpResponse, get_object_or_404
 
-from irie.apps.inventory.models import Asset
+from irie.apps.inventory.models import Asset, Datum
 from irie.apps.prediction.predictor import PREDICTOR_TYPES
 from irie.apps.prediction.models import PredictorModel
 from .forms import PredictorForm
@@ -76,25 +78,93 @@ def asset_predictors(request, calid):
 def predictor_render(request, calid, preid):
 
     predictor = get_object_or_404(PredictorModel, pk=int(preid))
+
+    canvas = None
+    
+    sname = request.GET.get("section", None)
+
+    runner = predictor.runner
+
+    if sname is None:
+        try:
+            artist = runner.render()
+            if artist is None:
+                return HttpResponse(
+                    json.dumps({"error": "No rendering available"}),
+                    content_type="application/json",
+                    status=404
+                )
+            canvas = artist.canvas
+        except Exception as e:
+            return HttpResponse(
+                json.dumps({"error": str(e)}),
+                content_type="application/json",
+                status=500
+            )
+    else:
+        try:
+            _, mesh = runner.structural_section(sname)
+
+            artist = veux.create_artist(mesh.model, canvas="gltf")
+            artist.draw_surfaces()
+            # artist.draw_outlines()
+            canvas = artist.canvas
+            # canvas = veux._create_canvas(name="gltf")
+            import numpy as np
+            R = np.array([[1, 0],
+                          [0, 1], 
+                          [0, 0]])
+            exterior = mesh.exterior()
+            exterior = np.append(exterior, np.array([[exterior[0][0], exterior[0][1]]]), axis=0)
+
+            canvas.plot_lines(exterior@R.T)
+            if (interior := mesh.interior()) is not None:
+                for i in interior:
+                    i = np.append(i, np.array([[i[0][0], i[0][1]]]), axis=0)
+                    canvas.plot_lines(i@R.T)
+            try:
+                canvas.plot_vectors(np.zeros((3,3)), 
+                                np.eye(3)*min(mesh.depth, mesh.width)/3, extrude=True)
+            except:
+                pass
+
+        except Exception as e:
+            raise e
+            return HttpResponse(
+                json.dumps({"error": "Section not found"}),
+                content_type="application/json",
+                status=404
+            )
+
+    if canvas is None:
+        return HttpResponse(
+            json.dumps({"error": "No rendering available"}),
+            content_type="application/json",
+            status=404
+        )
+
+    glb = canvas.to_glb()
+    return HttpResponse(glb, content_type="application/binary")
+
+
+@login_required(login_url="/login/")
+def predictor_table(request, calid, preid):
+
+    predictor = get_object_or_404(PredictorModel, pk=int(preid))
     
     sname = request.GET.get("section", None)
 
-    runner = PREDICTOR_TYPES[predictor.protocol](predictor) 
+    runner = predictor.runner 
 
     try:
-        _, mesh = runner.structural_section(sname)
-
-        can = veux._create_canvas(name="gltf")
-        import numpy as np
-        R = np.array([[1, 0],[0, 1], [0, 0]])
-        can.plot_lines(mesh.exterior()@R.T)
-        if (interior := mesh.interior()) is not None:
-            for i in interior:
-                can.plot_lines(i@R.T)
-        glb = can.to_glb()
-        return HttpResponse(glb, content_type="application/binary")
+        properties, _ = runner.structural_section(sname)
+
+        data = json.dumps(properties)
+        return HttpResponse(data,
+            content_type="application/json")
 
     except Exception as e:
+        print(e)
         return HttpResponse(
             json.dumps({"error": "Section not found"}),
             content_type="application/json",
@@ -102,6 +172,44 @@ def predictor_render(request, calid, preid):
         )
 
 
+@login_required(login_url="/login/")
+def predictor_analysis(request, calid, preid):
+
+    predictor = get_object_or_404(PredictorModel, pk=int(preid))
+    
+    runner = predictor.runner
+    sname = request.GET.get("section", None)
+
+    if sname is not None:
+
+        try:
+            _, mesh = runner.structural_section(sname)
+        except Exception as e:
+            return HttpResponse(
+                json.dumps({"error": "Section not found"}),
+                content_type="application/json",
+                status=404
+            )
+
+        try:
+            content = "<div></div>"
+            return HttpResponse(content)
+
+        except Exception as e:
+            return HttpResponse(
+                json.dumps({"error": str(e)}),
+                content_type="application/json",
+                status=500
+            )
+        
+    
+    return HttpResponse(
+        json.dumps({"error": str(e)}),
+        content_type="application/json",
+        status=500
+    )
+
+
 @login_required(login_url="/login/")
 def predictor_profile(request, calid, preid):
 
@@ -124,8 +232,8 @@ def predictor_profile(request, calid, preid):
 
     predictor = get_object_or_404(PredictorModel, pk=int(preid))
 
-    context["asset"] = asset
-    context["runner"] = PREDICTOR_TYPES[predictor.protocol](predictor)
+    context["asset"]     = asset
+    context["runner"]    = predictor.runner
     context["predictor"] = predictor
     context["sensors"]   = predictor.sensorassignment_set.all()
 
@@ -151,7 +259,8 @@ def predictor_profile(request, calid, preid):
         if "DEBUG" in os.environ and os.environ["DEBUG"]:
             raise e
         html_template = loader.get_template("site/page-500.html")
-        return HttpResponse(html_template.render(context, request))
+        return HttpResponse(html_template.render(context, request), status=500)
+
 
 
 @login_required(login_url="/login/")
@@ -204,7 +313,6 @@ def asset_map(request, calid):
         return HttpResponse(r200.render(context, request))
 
     except Exception as e:
-        raise e
         r500 = loader.get_template("site/page-500.html")
         return HttpResponse(r500.render({"message": str(e)}, request), status=500)
 
@@ -220,7 +328,129 @@ def create_mdof(request):
     html_template = loader.get_template("prediction/" + page_template)
     return HttpResponse(html_template.render(context, request))
 
+from formtools.wizard.views import SessionWizardView
+from .forms.csi_upload import DatumCreateForm, DatumSelectForm, PredictorForm, SensorForm, ConfirmForm
+
+FORMS = [
+    ("select datum",  DatumSelectForm),
+    ("create datum",  DatumCreateForm),
+    ("structure",     PredictorForm),
+    ("sensor",        SensorForm),
+    ("confirm",       ConfirmForm),
+]
+
+TEMPLATES = {
+    "select datum":  "prediction/upload/step.html",
+    "create datum":  "prediction/upload/step.html",
+    "structure":     "prediction/upload/step.html",
+    "sensor":        "prediction/upload/step.html",
+    "confirm":       "prediction/upload/step.html",
+}
+
+from django.shortcuts import redirect
+from django.core.files.storage import FileSystemStorage
+from django.conf import settings
+
+class CsiUpload(SessionWizardView):
+    form_list = FORMS
+    file_storage = FileSystemStorage(location=settings.MEDIA_ROOT)
+
+    condition_dict = {
+        "create datum": lambda self: (
+            self.get_cleaned_data_for_step("select datum") is None \
+            or self.get_cleaned_data_for_step("select datum").get("datum") is None
+        ),
+    }
+
+    def dispatch(self, request, *args, **kwargs):
+        self.asset = get_object_or_404(Asset, calid=kwargs["calid"])
+        self.request = request
+        return super().dispatch(request, *args, **kwargs)
+
+    def get_template_names(self):
+        return [TEMPLATES[self.steps.current]]
+
+    def get_form_kwargs(self, step=None):
+        kwargs = super().get_form_kwargs(step)
+
+        if step == "select datum":
+            kwargs["asset"] = self.asset
+            kwargs["initial"] = {"asset": self.asset.id}
+            kwargs["datum_queryset"] = Datum.objects.filter(asset=self.asset)
+        elif step == "create datum":
+            kwargs["asset"] = self.asset
+            kwargs["initial"] = {"asset": self.asset.id}
+        elif step == "structure":
+            kwargs["asset"] = self.asset
+            kwargs["initial"] = {
+                "asset": self.asset,
+                "active": False,
+                "protocol": PredictorModel.Protocol.TYPE1,
+            }
+        elif step == "sensor":
+            datum_data = self.get_cleaned_data_for_step("datum") or {}
+            kwargs["initial"] = {
+                # "datum": datum_data.get("id"),
+                "asset": self.asset.id,
+                "node": -1,
+                "predictor": self.get_cleaned_data_for_step("structure").get("id")
+            }
+        return kwargs
+
+    def get_context_data(self, form, **kwargs):
+        context = super().get_context_data(form=form, **kwargs)
+        context["asset"] = self.asset
+        context["segment"] = "assets"
+        context["step"] = self.steps.current
+
+        if self.steps.current == "confirm":
+            predictor = self.get_form("structure").save(commit=False)
+            model_file = self.get_cleaned_data_for_step("structure").get("config_file")
+
+            predictor.protocol = PredictorModel.Protocol.TYPE1
+            predictor.config_file = model_file
+            artist = predictor.runner.render()
+            glb = artist.canvas.to_glb()
+            glb64 = base64.b64encode(glb).decode("utf-8")
+
+            context["rndrdoc"] = escape(render_to_string(
+                "inventory/asset-on-map.html",
+                context={
+                    "asset": self.asset,
+                    "viewer": "three",
+                    "scale":  1/3.2808, # TODO
+                    # "offset": json.dumps(list(reversed(list(self.asset.coordinates)))),
+                    "rotate": "[0, 0, 0]",
+                    "render_glb":  f"data:application/octet-stream;base64,{glb64}",
+                    "location": json.dumps(list(reversed(list(self.asset.coordinates)))),
+                },
+                request=self.request
+            ))
+        return context 
+
+    def done(self, form_list, form_dict, **kwargs):
+        # datum comes from select step unless create step ran
+        if "select datum" in form_dict:
+            datum = form_dict["select datum"].cleaned_data["datum"]
+        elif "datum create" in form_dict:
+            datum = form_dict["datum create"].save(commit=False)
+            datum.save()
+        else:
+            datum = form_dict["select datum"].cleaned_data["datum"]
+
+        predictor = form_dict["structure"].save(commit=False)
+        sensor    = form_dict["sensor"].save(commit=False)
 
+        predictor.asset = self.asset
+        predictor.active = True
+        predictor.protocol = PredictorModel.Protocol.TYPE1
+        predictor.save()
+
+        sensor.node = -1
+        sensor.predictor = predictor
+        sensor.save()
+        return redirect("asset_predictors", calid=predictor.asset.calid)
+    
 @login_required(login_url="/login/")
 def create_model(request, calid):
 
@@ -252,6 +482,7 @@ def create_model(request, calid):
         except Exception as e:
             return HttpResponse(r400.render({"message": json.dumps({"error": str(e)})}), status=500)
 
+
         # 3) Render the model
         outlines = collect_outlines(csi, model.frame_tags)
         artist = veux.create_artist(model,

irie/apps/static/assets/css/brace.css

@@ -5577,7 +5577,7 @@ textarea.form-control-lg {
   --bs-accordion-body-padding-x: 1.25rem;
   --bs-accordion-body-padding-y: 1rem;
   --bs-accordion-active-color: rgb(27.9, 36.9, 49.5);
-  --bs-accordion-active-bg: #9CA3AF;
+  --bs-accordion-active-bg: transparent;
 }
 
 .accordion-button {