irie 0.0.55__py3-none-any.whl → 0.0.57__py3-none-any.whl

irie/apps/inventory/models.py

@@ -96,6 +96,7 @@ class Asset(models.Model):
         ordering = ["-id"]
 
 
+
 class Vulnerability: # (models.Model):
     type    = None
     asset   = None
@@ -125,6 +126,7 @@ class SensorGroup(models.Model):
     def __str__(self):
         return f"{self.asset.calid} - {self.name} ({self.datum})"
 
+
 class Sensor(models.Model):
     # class Status:
     #     active: bool
@@ -138,12 +140,31 @@ class Sensor(models.Model):
     dy   = models.DecimalField(decimal_places=2, max_digits=10)
     dz   = models.DecimalField(decimal_places=2, max_digits=10)
 
-    group  = models.ForeignKey(SensorGroup, related_name="sensors", on_delete=models.RESTRICT)
+    group  = models.ForeignKey(SensorGroup,
+                               related_name="sensors",
+                               on_delete=models.RESTRICT)
 
     def __str__(self):
         return f"{self.group.asset.calid} - {self.name} ({self.group.name})"
 
 
+    def acceleration(self, event):
+        import quakeio
+
+        motion_data = (
+            quakeio.read(
+                event.event_file.path, input_format="csmip.zip"
+            )
+        )
+
+        series = motion_data.match("l", station_channel=f"{self.name}").accel.data
+
+        return [
+            (series*float(self.dx)).tolist(),
+            (series*float(self.dy)).tolist(),
+            (series*float(self.dz)).tolist()
+        ]
+
 
 # class Rendering:
 #     def __init__(self, url=None, units, datum):

irie/apps/inventory/urls.py

@@ -25,8 +25,11 @@ urlpatterns = [
     ),
     re_path("^inventory/(?P<calid>[0-9 A-Z-]*)/evaluations/$",  views.asset_evals,   name="asset_evals"),
     re_path("^inventory/(?P<calid>[0-9 A-Z-]*)/$",              views.asset_profile, name="asset_profile"),
+    # Sensors
     re_path("^inventory/(?P<calid>[0-9 A-Z-]*)/sensors/$",      views.asset_sensors, name="asset_sensors"),
     re_path("^inventory/(?P<calid>[0-9 A-Z-]*)/sensor_upload",  views.sensor_upload, name="sensor_upload"),
+    path("inventory/<slug:calid>/sensors/<int:group_id>/edit/", views.sensor_edit, name="sensor_edit"),
+
 
     path("inventory/map2/", views.map_inventory),
     path("california.json", views.california_json),

irie/apps/inventory/views.py

@@ -408,14 +408,16 @@ def asset_sensors(request, calid):
     asset = Asset.objects.get(calid=calid)
     context = {
         "asset": asset,
+        "segment": "assets",
         "groups": SensorGroup.objects.filter(asset=asset)
     }
     html_template = loader.get_template("inventory/asset-sensors.html")
     return HttpResponse(html_template.render(context, request))
 
+
 @login_required(login_url="/login/")
 def sensor_upload(request, calid):
-    asset = get_object_or_404(Asset, calid=calid)  # Fetch the asset using calid
+    asset = get_object_or_404(Asset, calid=calid)
     datums = Datum.objects.filter(asset=asset).values(
         'id', 'orient_x', 'locate_x', 'orient_y', 'locate_y', 'orient_z', 'locate_z'
     )
@@ -443,7 +445,8 @@ def sensor_upload(request, calid):
         formset = SensorFormSet()
 
     context = {
-        "group_form": group_form, 
+        "group_form": group_form,
+        "segment": "assets",
         "formset": formset,
         "renderings": [
             {"name": predictor.name, "glb": predictor.render_file.url}
@@ -456,6 +459,68 @@ def sensor_upload(request, calid):
     return render(request, "inventory/sensor-upload.html", context)
 
 
+@login_required(login_url="/login/")
+def sensor_edit(request, calid, group_id):
+    """
+    Edit an existing SensorGroup + its Sensors while re-using the
+    sensor-upload.html template.
+    """
+    from django.forms import modelformset_factory
+
+    asset = get_object_or_404(Asset, calid=calid)
+    sensor_group = get_object_or_404(SensorGroup, pk=group_id, asset=asset)
+
+    #
+    SensorFormSet = modelformset_factory(
+        Sensor,
+        form=SensorForm,
+        extra=0,
+        can_delete=True,
+    )
+
+    if request.method == "POST":
+        group_form = SensorGroupForm(request.POST, instance=sensor_group, asset=asset)
+        formset = SensorFormSet(request.POST, queryset=sensor_group.sensors.all())
+
+        if group_form.is_valid() and formset.is_valid():
+            # update the group fields
+            group_form.save()
+
+            # saves edits, additions (extra rows you may allow), and deletions
+            sensors = formset.save(commit=False)
+            for sensor in sensors:
+                sensor.group = sensor_group
+                sensor.save()
+
+            # any forms flagged for deletion come back in formset.deleted_objects
+            for obj in formset.deleted_objects:
+                obj.delete()
+
+            return redirect("asset_sensors", calid=calid)
+    else:
+        group_form = SensorGroupForm(instance=sensor_group, asset=asset)
+        formset = SensorFormSet(queryset=sensor_group.sensors.all())
+
+    context = {
+        "group_form": group_form,
+        "segment": "assets",
+        "formset": formset,
+        "is_edit": True,               # optional flag so the template can tweak titles/buttons
+        "renderings": [
+            {"name": p.name, "glb": p.render_file.url}
+            for p in PredictorModel.objects.filter(asset=asset, protocol="IRIE_PREDICTOR_V1")
+            if p.render_file and p.render_file.url
+        ],
+        "asset": asset,
+        "datums": list(
+            Datum.objects.filter(asset=asset).values(
+                "id", "orient_x", "locate_x", "orient_y", "locate_y", "orient_z", "locate_z"
+            )
+        ),
+    }
+    return render(request, "inventory/sensor-upload.html", context)
+
+
 def _filter_asset_table(request):
     # Copy the GET parameters and remove the 'page' parameter
     page_query = request.GET.copy()

irie/apps/prediction/models.py

@@ -34,8 +34,10 @@ class PredictorModel(models.Model):
     def __str__(self):
         return f"{self.asset.calid} - {self.name} : {self.description}"
     
-    def get_runner(self):
-        pass
+    @property
+    def runner(self):
+        from irie.apps.prediction.predictor import PREDICTOR_TYPES
+        return PREDICTOR_TYPES[self.protocol](self) 
 
     def get_artist(self):
         pass
@@ -53,9 +55,9 @@ class SensorAssignment(models.Model):
         ]
     )
 
-    orient_z  = models.FloatField()
-    orient_x  = models.FloatField()
-    orient_y  = models.FloatField()
+    # orient_z  = models.FloatField()
+    # orient_x  = models.FloatField()
+    # orient_y  = models.FloatField()
     # show_x    = models.FloatField()
     # show_y    = models.FloatField()
     # show_z    = models.FloatField()

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

@@ -10,6 +10,15 @@ import sys, json
 import zipfile
 from pathlib import Path
 import contextlib
+try:
+    from xcsi.csi import collect_outlines, load as load_csi
+    from xcsi.csi._frame.section import create_section, iter_sections
+    from xcsi.job import Job
+    from xcsi.metrics import PeakDrift
+except:
+    from openbim.csi import load as load_csi, create_model, collect_outlines
+    from openbim.csi._frame.section import create_section, iter_sections
+
 
 from irie.apps.prediction.runners import (Runner, RunID, classproperty)
 
@@ -26,6 +35,37 @@ OPENSEES = [
 ]
 
 
+def _create_excitation(model, predictor, inputs, dt):
+    import numpy as np
+    # rotation = predictor.config["orientation"]
+    rotation = np.eye(3)*150
+    i = 1
+    for sensor in predictor.sensorassignment_set.all():
+        if sensor.role == "input":
+            for dof in range(3):
+                series = sum(ai*dx
+                            for ai, dx in zip(np.array(inputs[sensor.id]["series"]), rotation[dof]))
+
+                model.timeSeries("Path", i, dt=dt, values=series.tolist())
+                model.pattern("UniformExcitation", i, dof+1, accel=i)
+                i += 1
+
+
+def _analyze_and_render(model, artist, nt, dt):
+    import veux, veux.motion
+    motion = veux.motion.Motion(artist)
+    for i in range(nt):
+        if model.analyze(1, dt) != 0:
+            return -1
+        motion.advance(i*dt)
+        motion.draw_sections(position=lambda x: [1000*u for u in model.nodeDisp(x)],
+                             rotation=model.nodeRotation)
+        
+    motion.add_to(artist.canvas)
+    return 0
+    
+    
+
 @contextlib.contextmanager
 def new_cd(x):
     d = os.getcwd()
@@ -199,10 +239,14 @@ class OpenSeesRunner(Runner):
     def newPrediction(self, event, output_directory = None):
         """
         Create a new prediction run and return the run_id. If output_directory is None,
-        the output directory will be created automatically. Otherwise, the output directory
-        will be copied to the new output directory.
+        the output directory will be created automatically.
         """
-        event = event.event_file.path
+        inputs = {}
+        for sensor in self.predictor.sensorassignment_set.all():
+            if sensor.role == "input":
+                inputs[sensor.id] = {"series": sensor.sensor.acceleration(event)}
+        
+
         if output_directory is not None:
             # this case will eventually be deleted, its just for
             # debugging metric renderers.
@@ -225,23 +269,30 @@ class OpenSeesRunner(Runner):
             run_dir.mkdir(parents=True, exist_ok=False)
 
             # Copy files to run directory
-            shutil.copyfile(event, run_dir/"event.zip")
-            shutil.copyfile(self.model_file.resolve(), run_dir/self.model_file.name)
-
-            if self.model_file.suffix == ".zip":
-                with zipfile.ZipFile(self.model_file, 'r') as zip_ref:
-                    zip_ref.extractall(run_dir)
-                model_file = (run_dir/"nonlinear.tcl").resolve()
-
-            elif self.model_file.suffix == ".b2k":
-                pass
-
-            elif self.model_file.suffix == ".tcl":
-                model_file = (run_dir/self.model_file.name).resolve()
+            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(),
+                                run_dir/self.model_file.name)
+
+                if self.model_file.suffix == ".zip":
+                    with zipfile.ZipFile(self.model_file, 'r') as zip_ref:
+                        zip_ref.extractall(run_dir)
+                    model_file = (run_dir/"nonlinear.tcl").resolve()
+
+                elif self.model_file.suffix == ".b2k":
+                    pass
+
+                elif self.model_file.suffix == ".tcl":
+                    model_file = (run_dir/self.model_file.name).resolve()
 
             self.runs[run_id] = {
                 "run_output_directory": run_dir,
-                "event_file_name": Path(event),
+                # "event_file_name": Path(event),
+                "inputs": inputs,
                 "model_file": model_file,
                 **self.conf
             }
@@ -264,56 +315,33 @@ class OpenSeesRunner(Runner):
         if run_id not in self.runs:
             self._load_config(run_id)
 
-        event_file_path = os.path.relpath(self.runs[run_id]["event_file_name"],
-                                          self.model_file.parents[0])
-        output_directory = os.path.relpath(self.runs[run_id]["run_output_directory"],
-                                           self.model_file.parents[0])
+        if False:
+            event_file_path = os.path.relpath(self.runs[run_id]["event_file_name"],
+                                            self.model_file.parents[0])
 
-        event_file_path = self.runs[run_id]["event_file_name"]
+            output_directory = os.path.relpath(self.runs[run_id]["run_output_directory"],
+                                            self.model_file.parents[0])
+
+            event_file_path = self.runs[run_id]["event_file_name"]
 
         # Create model
         import opensees.openseespy as ops
 
         import sys
-        model = ops.Model(echo_file=sys.stdout)
-        model.eval("set argv {}")
-        with new_cd(self.runs[run_id]["run_output_directory"]):
-            model.eval(f"source {self.runs[run_id]['model_file']}")
+        csi = self._csi 
 
-            model.eval(f"print -json -file modelDetails.json")
+        with new_cd(self.runs[run_id]["run_output_directory"]):
 
-            model.eval(f"set python {sys.executable}")
+            model = ops.Model(ndm=3, ndf=6, echo_file=open("model.tcl", "w"))
+            if csi is not None:
+                asm = Job(csi).assemble(model=model)
+                # model = create_model(csi, model=model)
+                sections = collect_outlines(csi, model.frame_tags)
+            else:
+                asm = None
+                sections = None
+                model.eval(f"source {self.runs[run_id]['model_file']}")
 
-            model.eval(r"""
-                proc py {args} {
-                    global python
-                    eval "[exec {*}$python {*}$args]"
-                }
-                
-                proc pt {args} {
-                    global python
-                    puts "[exec {*}$python {*}$args]"
-                }
-
-                proc write_modes {mode_file nmodes} {
-                    set fid_modes [open $mode_file w+]
-                    for {set m 1} {$m <= $nmodes} {incr m} {
-                        puts $fid_modes "$m:"
-                        foreach n [getNodeTags] {
-                        puts $fid_modes "  $n: \[[join [nodeEigenvector $n $m] {, }]\]";
-                        }
-                    }
-                    close $fid_modes
-                }
-                proc write_displacements {file_name {resp Disp}} {
-                    set fid [open "$file_name" "w+"]
-                    puts $fid "[getTime]:"
-                    foreach n [getNodeTags] {
-                        puts $fid "    $n: \[[join [node${resp} $n] {, }]\]";
-                    }
-                    close $fid;
-                }
-            """)
 
             #
             # Run gravity analysis
@@ -328,61 +356,60 @@ class OpenSeesRunner(Runner):
             system SparseGeneral;
             analysis Static;
             analyze 10;
-            #  write_displacements "dispsGrav.yaml"
             """)
 
             #
             # DAMPING
             #
-            model.eval(r"""
-            set nmodes 8; # Number of modes to analyze for modal analysis
-
-            # set wb [eigen -fullGenLapack $nmodes];
-            # puts "\tFundamental-Period After Gravity Analysis:"
-            # for {set iPd 1} {$iPd <= $nmodes} {incr iPd 1} {
-            #     set wwb [lindex $wb $iPd-1];
-            #     set Tb [expr 2*$pi/sqrt($wwb)];
-            #     puts "\tPeriod$iPd= $Tb"
+            # model.eval(r"""
+            # set nmodes 8; # Number of modes to analyze for modal analysis
+
+            # # set wb [eigen -fullGenLapack $nmodes];
+            # # puts "\tFundamental-Period After Gravity Analysis:"
+            # # for {set iPd 1} {$iPd <= $nmodes} {incr iPd 1} {
+            # #     set wwb [lindex $wb $iPd-1];
+            # #     set Tb [expr 2*$pi/sqrt($wwb)];
+            # #     puts "\tPeriod$iPd= $Tb"
+            # # }
+            # # write_modes $output_directory/modesPostG.yaml $nmodes
+            # # remove recorders
+
+            # set nmodes [tcl::mathfunc::max {*}$damping_modes $nmodes]
+            # set lambdaN [eigen  -fullGenLapack $nmodes];
+
+            # # set lambdaN [eigen $nmodes];
+            # if {$damping_type == "rayleigh"} {
+            #     set nEigenI [lindex $damping_modes 0];                  # first rayleigh damping mode
+            #     set nEigenJ [lindex $damping_modes 1];                  # second rayleigh damping mode
+            #     set iDamp   [lindex $damping_ratios 0];                 # first rayleigh damping ratio
+            #     set jDamp   [lindex $damping_ratios 1];                 # second rayleigh damping ratio
+            #     set lambdaI [lindex $lambdaN [expr $nEigenI-1]];
+            #     set lambdaJ [lindex $lambdaN [expr $nEigenJ-1]];
+            #     set omegaI [expr $lambdaI**0.5];
+            #     set omegaJ [expr $lambdaJ**0.5];
+            #     set TI [expr 2.0*$pi/$omegaI];
+            #     set TJ [expr 2.0*$pi/$omegaJ];
+            #     set alpha0 [expr 2.0*($iDamp/$omegaI-$jDamp/$omegaJ)/(1/$omegaI**2-1/$omegaJ**2)];
+            #     set alpha1 [expr 2.0*$iDamp/$omegaI-$alpha0/$omegaI**2];
+            #     puts "\tRayleigh damping parameters:"
+            #     puts "\tmodes: $nEigenI, $nEigenJ ; ratios: $iDamp, $jDamp"
+            #     puts "\tTI = $TI; TJ = $TJ"
+            #     puts "\tlambdaI = $lambdaI; lambdaJ = $lambdaJ"
+            #     puts "\tomegaI = $omegaI; omegaJ = $omegaJ"
+            #     puts "\talpha0 = $alpha0; alpha1 = $alpha1"
+            #     rayleigh $alpha0 0.0 0.0 $alpha1;
+
+            # } elseif {$damping_type == "modal"} {
+            #     # needs a bit of edit. currently assuming that the ratios are applied in order at the first modes. but should be applied at the specified damping_modes modes.
+            #     set nratios [llength $damping_ratios]
+            #     puts "\tModal damping parameters:"
+            #     puts "\tratios of $damping_ratios at the first $nratios modes"
+            #     for {set i 1} {$i <= [expr $nmodes - $nratios]} {incr i} {
+            #         lappend damping_ratios 0
+            #     }
+            #     modalDamping {*}$damping_ratios
             # }
-            # write_modes $output_directory/modesPostG.yaml $nmodes
-            # remove recorders
-
-            set nmodes [tcl::mathfunc::max {*}$damping_modes $nmodes]
-            set lambdaN [eigen  -fullGenLapack $nmodes];
-
-            # set lambdaN [eigen $nmodes];
-            if {$damping_type == "rayleigh"} {
-                set nEigenI [lindex $damping_modes 0];                  # first rayleigh damping mode
-                set nEigenJ [lindex $damping_modes 1];                  # second rayleigh damping mode
-                set iDamp   [lindex $damping_ratios 0];                 # first rayleigh damping ratio
-                set jDamp   [lindex $damping_ratios 1];                 # second rayleigh damping ratio
-                set lambdaI [lindex $lambdaN [expr $nEigenI-1]];
-                set lambdaJ [lindex $lambdaN [expr $nEigenJ-1]];
-                set omegaI [expr $lambdaI**0.5];
-                set omegaJ [expr $lambdaJ**0.5];
-                set TI [expr 2.0*$pi/$omegaI];
-                set TJ [expr 2.0*$pi/$omegaJ];
-                set alpha0 [expr 2.0*($iDamp/$omegaI-$jDamp/$omegaJ)/(1/$omegaI**2-1/$omegaJ**2)];
-                set alpha1 [expr 2.0*$iDamp/$omegaI-$alpha0/$omegaI**2];
-                puts "\tRayleigh damping parameters:"
-                puts "\tmodes: $nEigenI, $nEigenJ ; ratios: $iDamp, $jDamp"
-                puts "\tTI = $TI; TJ = $TJ"
-                puts "\tlambdaI = $lambdaI; lambdaJ = $lambdaJ"
-                puts "\tomegaI = $omegaI; omegaJ = $omegaJ"
-                puts "\talpha0 = $alpha0; alpha1 = $alpha1"
-                rayleigh $alpha0 0.0 0.0 $alpha1;
-
-            } elseif {$damping_type == "modal"} {
-                # needs a bit of edit. currently assuming that the ratios are applied in order at the first modes. but should be applied at the specified damping_modes modes.
-                set nratios [llength $damping_ratios]
-                puts "\tModal damping parameters:"
-                puts "\tratios of $damping_ratios at the first $nratios modes"
-                for {set i 1} {$i <= [expr $nmodes - $nratios]} {incr i} {
-                    lappend damping_ratios 0
-                }
-                modalDamping {*}$damping_ratios
-            }
-            """)
+            # """)
 
 
             #
@@ -390,73 +417,60 @@ class OpenSeesRunner(Runner):
             #
 
             ## COLUMN SECTION DEFORMATIONS AT TOP AND BOTTOM FOR STRAIN-BASED DAMAGE STATES
-            column_strains = tuple(k["key"] for k in self.runs[run_id]["columns"] if k["strain"])
-            if len(column_strains) > 0:
-                model.recorder("Element",  "section", 1, "deformation", xml="eleDef1.txt", ele=column_strains) # section 1 deformation]
-                model.recorder("Element",  "section", 4, "deformation", xml="eleDef4.txt", ele=column_strains) # section 4 deformation]
-
-
+            if False:
+                column_strains = tuple(k["key"] for k in self.runs[run_id]["columns"] if k["strain"])
+                if len(column_strains) > 0:
+                    model.recorder("Element",  "section", 1, "deformation", xml="eleDef1.txt", ele=column_strains) # section 1 deformation]
+                    model.recorder("Element",  "section", 4, "deformation", xml="eleDef4.txt", ele=column_strains) # section 4 deformation]
 
             #
             # Run dynamic analysis
             #
-            model.eval(f"""
-            wipeAnalysis
-            # Uniform Support Excitation
-#           lassign [pt -m  CE58658.makePattern {event_file_path} --scale $dynamic_scale_factor --node $input_location] dt steps
-#           lassign [py -m  CE58658.makePattern {event_file_path} --scale $dynamic_scale_factor --node $input_location] dt steps
-            set dt 0.1
-            set steps 3
-            """)
 
             # RESPONSE HISTORY RECORDERS
+            if False:
+                model.recorder("Node", "accel", xml="model/AA_all.txt", timeSeries=(1, 2), dof=(1, 2))
+                model.recorder("Node", "accel", xml="model/RD_all.txt", dof=(1, 2))
 
-            model.recorder("Node", "accel", xml="model/AA_all.txt", timeSeries=(1, 2), dof=(1, 2))
-            model.recorder("Node", "accel", xml="model/RD_all.txt", dof=(1, 2))
+                column_nodes = tuple(k["node"] for k in self.runs[run_id]["bents"] if k["record"])
+                model.recorder("Node", "accel", file="TopColAccel_X_txt.txt", timeSeries=1 , node=column_nodes, dof=1)
+                model.recorder("Node", "accel", file="TopColAccel_Y_txt.txt", timeSeries=2 , node=column_nodes, dof=2)
+                model.recorder("Node", "disp",  file="TopColDrift_X_txt.txt", node=column_nodes, dof=1)
+                model.recorder("Node", "disp",  file="TopColDrift_Y_txt.txt", node=column_nodes, dof=2)
 
-            column_nodes = tuple(k["node"] for k in self.runs[run_id]["bents"] if k["record"])
-            model.recorder("Node", "accel", file="TopColAccel_X_txt.txt", timeSeries=1 , node=column_nodes, dof=1)
-            model.recorder("Node", "accel", file="TopColAccel_Y_txt.txt", timeSeries=2 , node=column_nodes, dof=2)
-            model.recorder("Node", "disp",  file="TopColDrift_X_txt.txt", node=column_nodes, dof=1)
-            model.recorder("Node", "disp",  file="TopColDrift_Y_txt.txt", node=column_nodes, dof=2)
+            metrics = [
+                PeakDrift((31, 81))
+            ]
 
-            model.eval("""
-            set dtfact 1;
-            set Tol                1.0e-8;
-            set maxNumIter        100;
-            set printFlag        0;
-            set TestType        EnergyIncr;
+            for metric in metrics:
+                metric.record(asm)
+
+            nt = 500
+            dt = 0.02
+            _create_excitation(model, self.predictor, self.runs[run_id]["inputs"], dt)
+            
+            model.eval(f"print -json -file model.json")
+
+            model.eval(f"""
+            wipeAnalysis
             set NewmarkGamma    0.50;
-            set NewmarkBeta        0.25;
+            set NewmarkBeta     0.25;
             constraints Transformation;
-            numberer RCM;
-            test $TestType $Tol $maxNumIter $printFlag;
-            set algorithmType   "Newton";
-            system BandSPD;
-            integrator Newmark $NewmarkGamma $NewmarkBeta;
-
-            algorithm {*}$algorithmType;
-            analysis Transient;
-
-            set DtAnalysis         $dt;
-            set TmaxAnalysis     [expr $dt*$steps];
-            set Nsteps             $steps;
-            if {$dynamic_truncated != 0} {
-                set Nsteps             $dynamic_timesteps;
-            }
-            puts "\tGround Motion: dt= $DtAnalysis, NumPts= $Nsteps, TmaxAnalysis= $TmaxAnalysis";
-
-            puts "\tRunning dynamic ground motion analysis..."
-            set t3 [clock clicks -millisec];
-            catch {progress create $Nsteps} _
+            numberer    RCM;
+            test        EnergyIncr 1.0e-6 50 0;
+            system      Umfpack;
+            integrator  Newmark $NewmarkGamma $NewmarkBeta;
+            algorithm   Newton;
+            analysis    Transient;
+            """)
 
-            analyze 2 $DtAnalysis;
+            import veux
+            artist = veux.create_artist(model, vertical=3, model_config={
+                    "frame_outlines": sections
+            })
+            _analyze_and_render(model, artist, nt, dt)
 
-#           for {set ik 1} {$ik <= $Nsteps} {incr ik 1} {
-#               catch {progress update} _ 
-#               set ok      [analyze 1 $DtAnalysis];
-#           }
-            """)
+            artist.save("motion.glb")
 
             model.wipe()
 
@@ -477,10 +491,7 @@ class OpenSeesRunner(Runner):
         else:
             output_dir = self.out_dir/str(run_id)
 
-        # with open(output_dir/"modelDetails.json", "r") as f:
-        #     model = json.load(f)
-
-        model = read_model(output_dir/"modelDetails.json")
+        model = read_model(output_dir/"model.json")
 
         # if type == "COLUMN_STRAIN_STATES":
         #     return _clean_json(column_strain_state_metric(model, output_dir, config))
@@ -504,11 +515,10 @@ class OpenSeesRunner(Runner):
     @property
     def _csi(self):
         if not hasattr(self, "_csi_data") or self._csi_data is None:
-            from openbim.csi import load, create_model, collect_outlines
             # 1) Parse the CSI file
             try:
                 csi_file = self.predictor.config_file
-                self._csi_data = load((str(line.decode()).replace("\r\n","\n") for line in csi_file.readlines()))
+                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)
@@ -518,21 +528,13 @@ class OpenSeesRunner(Runner):
 
 
     def structural_section(self, name):
-        from openbim.csi._frame.section import create_section
-        # from openbim.csi._frame.outlines import section_mesh
         if (s:= create_section(self._csi, name)) is not None:
             return {}, s._create_model(mesh_size=0.1)
 
 
-    def structural_sections(self):        
-        from openbim.csi._frame.section import iter_sections
+    def structural_sections(self):
         yield from iter_sections(self._csi)
-        # for s, name in iter_sections(self._csi):
-        #     yield {
-        #         "name": name,
-        #         "type": "Section",
-        #         "section": name,
-        #     }
+
 
     def structural_members(self):