Develop cosim bug fix

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.7.0-slim
+FROM python:3.11.0-slim
 
 RUN apt-get update
 

src/pydss/SolveMode.py

@@ -10,7 +10,8 @@
 
 
 def GetSolver(settings: SimulationSettingsModel, dssInstance):
-    logger.info('Setting solver to %s mode.', settings.project.simulation_type.value)
+    # logger.info('Setting solver to %s mode.', settings.project.simulation_type.value)
+    logger.info(f'Setting solver to {settings.project.simulation_type.value} mode.')
     return get_solver_from_simulation_type(settings.project)
 
 

src/pydss/cli/run.py

@@ -5,6 +5,7 @@
 from pathlib import Path
 import ast
 import sys
+import os
 
 from loguru import logger
 import click
@@ -83,7 +84,10 @@ def run(project_path, options=None, tar_project=False, zip_project=False, verbos
 
     logger.level(console_level)
     if filename:
-        logger.add(filename)
+        if settings.logging.clear_old_log_file:
+            logger.add(filename, mode="w")
+        else:
+            logger.add(filename)
 
     logger.info(f"CLI: [{get_cli_string()}]",)
 
@@ -92,7 +96,6 @@ def run(project_path, options=None, tar_project=False, zip_project=False, verbos
         if not isinstance(options, dict):
             logger.error("options are invalid: %s", options)
             sys.exit(1)
-
     project = PyDssProject.load_project(project_path, options=options, simulation_file=simulations_file)
     project.run(tar_project=tar_project, zip_project=zip_project, dry_run=dry_run)
 

src/pydss/dataset_buffer.py

@@ -37,6 +37,7 @@ def __init__(
             max_chunk_bytes=None, attributes=None, names=None,
             column_ranges_per_name=None, data=None
         ):
+
         if max_chunk_bytes is None:
             max_chunk_bytes = DEFAULT_MAX_CHUNK_BYTES
         self._buf_index = 0

src/pydss/dssElement.py

@@ -1,5 +1,5 @@
 import ast
-
+from loguru import logger
 from opendssdirect import DSSException
 
 from pydss.dssBus import dssBus
@@ -60,9 +60,10 @@ def __init__(self, dssInstance):
         super(dssElement, self).__init__(dssInstance, name, fullName)
         self._Enabled = dssInstance.CktElement.Enabled()
         if not self._Enabled:
+            logger.debug(f"Element isn't defined: {fullName}")
             return
-
         self._Parameters = {}
+        logger.debug(fullName)
         self._NumTerminals = dssInstance.CktElement.NumTerminals()
         self._NumConductors = dssInstance.CktElement.NumConductors()
 
@@ -135,8 +136,12 @@ def DataLength(self, VarName):
             return 0, None
 
     def GetValue(self, VarName, convert=False):
+
         if self._dssInstance.Element.Name() != self._FullName:
             self.SetActiveObject()
+        fullName = self._dssInstance.Element.Name()
+        # logger.debug("123456789123456789123456789123456789123456789123456789")
+        # logger.debug(fullName)
         if VarName in self._Variables:
             VarValue = self.GetVariable(VarName, convert=convert)
         elif VarName in self._Parameters:
@@ -154,6 +159,31 @@ def SetActiveObject(self):
 
     def SetParameter(self, Param, Value):
         reply = self._dssInstance.utils.run_command(self._FullName + '.' + Param + ' = ' + str(Value))
+        logger.info(f'parameter update reply: {reply}')
+        if Param == 'IsSwitch' or Param == 'Switch':
+            self._dssInstance.Lines.Name(self._Name)
+            self._dssInstance.Lines.IsSwitch(True)
+            switch_name = self._FullName.replace('Line','SwtControl')
+            if switch_name.replace('SwtControl.','') in self._dssInstance.SwtControls.AllNames():
+                logger.info(f'{switch_name} already exists. Opening existing switch')
+                self._dssInstance.SwtControls.Name(self._Name)
+                self._dssInstance.SwtControls.Delay(0)
+                self._dssInstance.SwtControls.State(int(Value)) # 1 is open and 2 is closed
+                self._dssInstance.SwtControls.NormalState(int(Value))
+                #dss.SwtControls.Action(state_value)
+            else:
+                #if it's not already created, then create the switch and set params with one command line
+                new_switch_command = f'New SwtControl.{self._Name} Delay=0 enabled=Yes Normal=Open State=Open SwitchedObj={self._FullName}'
+                self._dssInstance.run_command(new_switch_command)
+                self._dssInstance.SwtControls.IsLocked(True)
+                #dss.SwtControls.Action(state_value)
+                logger.info(f'{switch_name} created with {new_switch_command}')
+            self._dssInstance.Lines.Name(self._Name)
+            line_status = self._dssInstance.Lines.IsSwitch()
+            self._dssInstance.SwtControls.Name(self._Name)
+            swt_status = self._dssInstance.SwtControls.State()
+            logger.info(f'{self._FullName} switch status: {line_status} and switch position: {swt_status}')
+
         if reply != "":
             raise Exception(f"SetParameter failed: {reply}")
         return self.GetParameter(Param)

src/pydss/dssInstance.py

@@ -156,7 +156,11 @@ def _compile_model(self):
     def _CreateControllers(self, ControllerDict):
         self._pyControls = {}
         self._pyControls_types = {}
+        # logger.info(f'self._dssObjects -> {self._dssObjects}')
+        # os.system("PAUSE")
         for ControllerType, ElementsDict in ControllerDict.items():
+            # logger.info(f'ControllerType -> {ControllerType}, ElementsDict -> {ElementsDict}')
+            # os.system("PAUSE")
             for ElmName, SettingsDict in ElementsDict.items():
                 Controller = pyControllers.pyController.Create(ElmName, ControllerType, SettingsDict, self._dssObjects,
                                                   self._dssInstance, self._dssSolver)
@@ -167,24 +171,47 @@ def _CreateControllers(self, ControllerDict):
                     if controller_name not in self._pyControls_types:
                         self._pyControls_types[controller_name] = class_name
                     logger.info('Created pyController -> Controller.' + ElmName)
+
+        # --- Batch MotorStall controllers ---
+        from pydss.pyControllers.Controllers.MotorStall import MotorStall
+        from pydss.pyControllers.Controllers.MotorStallBatch import MotorStallBatch
+        motor_stall_keys = [k for k, v in self._pyControls.items()
+                            if isinstance(v, MotorStall)]
+        if len(motor_stall_keys) > 0:
+            motor_stall_ctrls = [self._pyControls[k] for k in motor_stall_keys]
+            batch = MotorStallBatch(motor_stall_ctrls)
+            # Remove individual controllers, add the batch
+            for k in motor_stall_keys:
+                del self._pyControls[k]
+            self._pyControls['Controller.MotorStallBatch'] = batch
+            logger.info(f"Batched {len(motor_stall_keys)} MotorStall controllers into MotorStallBatch")
+
+        # --- Batch PvVoltageRideThru controllers ---
+        from pydss.pyControllers.Controllers.PvVoltageRideThru import PvVoltageRideThru
+        from pydss.pyControllers.Controllers.PvVoltageRideThruBatch import PvVoltageRideThruBatch
+        pv_rt_keys = [k for k, v in self._pyControls.items()
+                      if isinstance(v, PvVoltageRideThru)]
+        if len(pv_rt_keys) > 0:
+            pv_rt_ctrls = [self._pyControls[k] for k in pv_rt_keys]
+            pv_batch = PvVoltageRideThruBatch(pv_rt_ctrls)
+            for k in pv_rt_keys:
+                del self._pyControls[k]
+            self._pyControls['Controller.PvVoltageRideThruBatch'] = pv_batch
+            logger.info(f"Batched {len(pv_rt_keys)} PvVoltageRideThru controllers into PvVoltageRideThruBatch")
+
+        self._controller_list = list(self._pyControls.values())
+        self._controllers_by_priority = {p: [] for p in range(CONTROLLER_PRIORITIES)}
+        for controller in self._controller_list:
+            for p in getattr(controller, 'ACTIVE_PRIORITIES', range(CONTROLLER_PRIORITIES)):
+                self._controllers_by_priority[p].append(controller)
         return
 
     def _update_controllers(self, Priority, Time, Iteration, UpdateResults):
-        errors = []
         maxError = 0
-        _pyControls_types = set(self._pyControls_types.values())
-
-        for class_name in _pyControls_types:
-            self._dssInstance.Basic.SetActiveClass(class_name)
-            elm = self._dssInstance.ActiveClass.First()
-            while elm:
-                element_name = self._dssInstance.CktElement.Name()
-                controller_name = 'Controller.' + element_name
-                if controller_name in self._pyControls:
-                    controller = self._pyControls[controller_name]
-                    error = controller.Update(Priority, Time, UpdateResults)
-                    maxError = error if error > maxError else maxError
-                elm = self._dssInstance.ActiveClass.Next()
+        for controller in self._controllers_by_priority[Priority]:
+            error = controller.Update(Priority, Time, UpdateResults)
+            if error > maxError:
+                maxError = error
         return maxError < self._settings.project.error_tolerance, maxError
 
     @staticmethod
@@ -205,7 +232,8 @@ def CreateDssObjects(dssBuses):
         InvalidSelection = ['Settings', 'ActiveClass', 'dss', 'utils', 'PDElements', 'XYCurves', 'Bus', 'Properties']
         # TODO: this causes a segmentation fault. Aadil says it may not be needed.
         #self._dssObjectsByClass={'LoadShape': self._get_relavent_object_dict('LoadShape')}
-
+        # logger.info(f"dss.Circuit.AllElementNames()  -> {dss.Circuit.AllElementNames()}")
+        # os.system("PAUSE")
         for ElmName in dss.Circuit.AllElementNames():
             Class, Name =  ElmName.split('.', 1)
             ClassName = Class + 's'
@@ -239,13 +267,18 @@ def _get_relavent_object_dict(self, key):
 
     @track_timing(timer_stats_collector)
     def RunStep(self, step, updateObjects=None):
+
         # updating parameters before simulation run
         if self._settings.logging.log_time_step_updates:
             logger.info(f'Pydss datetime - {self._dssSolver.GetDateTime()}')
             logger.info(f'OpenDSS time [h] - {self._dssSolver.GetOpenDSSTime()}')
         if self._settings.profiles.use_profile_manager:
             self.profileStore.update()
 
+        if self._settings.helics.co_simulation_mode:
+            # self._heilcs_interface.updateHelicsPublications()
+            self._increment_flag, helics_time = self._heilcs_interface.request_time_increment()
+
         if self._settings.helics.co_simulation_mode:
             self._heilcs_interface.updateHelicsSubscriptions()
         else:
@@ -263,6 +296,7 @@ def RunStep(self, step, updateObjects=None):
                     for i in range(self._settings.project.max_control_iterations):
                         has_converged, error = self._update_controllers(priority, step, i, UpdateResults=False)
                         logger.debug('Control Loop {} convergence error: {}'.format(priority, error))
+                        logger.debug('Control Loop {} convergence @step {} '.format(priority, step))
                         if has_converged:
                             priority_has_converged = True
                             break
@@ -279,7 +313,6 @@ def RunStep(self, step, updateObjects=None):
                         logger.warning('Control Loop {} no convergence @ {} '.format(priority, step))
                         self._HandleConvergenceErrorChecks(step, error)
 
-
         if self._settings.frequency.enable_frequency_sweep and \
                 self._settings.project.simulation_type != SimulationType.DYNAMIC:
             self._dssSolver.setMode('Harmonic')
@@ -297,8 +330,10 @@ def RunStep(self, step, updateObjects=None):
 
         if self._settings.helics.co_simulation_mode:
             self._heilcs_interface.updateHelicsPublications()
-            self._increment_flag, helics_time = self._heilcs_interface.request_time_increment()
+            # if step < 1:
+            #     self._increment_flag, helics_time = self._heilcs_interface.request_time_increment_2()
 
+        # os.system("PAUSE")
         return time_step_has_converged
 
     def _HandleConvergenceErrorChecks(self, step, error):
@@ -316,7 +351,7 @@ def _HandleOpenDSSConvergenceErrorChecks(self, step):
         self._convergenceErrorsOpenDSS += 1
 
         if self._maxConvergenceErrorCount is not None and self._convergenceErrorsOpenDSS > self._maxConvergenceErrorCount:
-            logger.error("Exceeded OpenDSS convergence error count threshold at step %s", step)
+            logger.error(f"Exceeded OpenDSS convergence error count threshold at step {step}")
             raise OpenDssConvergenceErrorCountExceeded(f"{self._convergenceErrorsOpenDSS} errors occurred")
 
     def DryRunSimulation(self, project, scenario):
@@ -357,7 +392,7 @@ def RunSimulation(self, project, scenario, MC_scenario_number=None):
         dss.Solution.Convergence(self._settings.project.error_tolerance)
         logger.info('Running simulation from {} till {}.'.format(sTime, eTime))
         logger.info('Simulation time step {}.'.format(Steps))
-        logger.info("Set OpenDSS convergence to %s", dss.Solution.Convergence())
+        logger.info(f"Set OpenDSS convergence to {dss.Solution.Convergence()}")
         logger.info('Max convergence error count {}.'.format(self._maxConvergenceErrorCount))
         logger.info("initializing store")
         self.ResultContainer.InitializeDataStore(project.hdf_store, Steps, MC_scenario_number)
@@ -390,10 +425,14 @@ def RunSimulation(self, project, scenario, MC_scenario_number=None):
                     pydss_has_converged = self.RunStep(step)
                     opendss_has_converged = dss.Solution.Converged()
                     if not opendss_has_converged:
-                        logger.error("OpenDSS did not converge at step=%s pydss_converged=%s",
-                                            step, pydss_has_converged)
+                        logger.error(f"OpenDSS did not converge at step={step} pydss_converged={pydss_has_converged}")
                         self._HandleOpenDSSConvergenceErrorChecks(step)
-                has_converged = pydss_has_converged and opendss_has_converged
+
+                if pydss_has_converged:
+                    has_converged = True
+                else:
+                    has_converged = pydss_has_converged and opendss_has_converged
+
                 if step == 0 and self.ResultContainer is not None:
                     size = make_human_readable_size(self.ResultContainer.max_num_bytes())
                     logger.info('Storage requirement estimation: %s, estimated based on first time step run.', size)
@@ -426,6 +465,7 @@ def RunSimulation(self, project, scenario, MC_scenario_number=None):
 
                 if self._settings.exports.export_results:
                     current_results = self.ResultContainer.CurrentResults
+
                 yield False, step, has_converged, current_results
 
         finally: