def RunSimulation(self, project, scenario, MC_scenario_number=None):
startTime = time.time()
Steps, sTime, eTime = self._dssSolver.SimulationSteps()
self._Logger.info('Running simulation from {} till {}.'.format(
sTime, eTime))
self._Logger.info('Simulation time step {}.'.format(Steps))
if self._Options['Exports'][
'Result Container'] == 'ResultData' and self.ResultContainer is not None:
self.ResultContainer.InitializeDataStore(project.hdf_store, Steps,
MC_scenario_number)
postprocessors = [
pyPostprocess.Create(
project,
scenario,
ppInfo,
self._dssInstance,
self._dssSolver,
self._dssObjects,
self._dssObjectsByClass,
self._Options,
self._Logger,
) for ppInfo in scenario.post_process_infos
]
if not postprocessors:
self._Logger.info('No post processing script selected')
try:
step = 0
while step < Steps:
self.RunStep(step)
if step == 0 and self.ResultContainer is not None:
size = make_human_readable_size(
self.ResultContainer.max_num_bytes())
self._Logger.info(
'Storage requirement estimation: %s, estimated based on first time step run.',
size)
for postprocessor in postprocessors:
step = postprocessor.run(step, Steps)
if self._increment_flag:
step += 1
finally:
if self._Options and self._Options['Exports']['Log Results']:
# This is here to guarantee that DatasetBuffers aren't left
# with any data in memory.
self.ResultContainer.FlushData()
if self._Options and self._Options['Exports']['Log Results']:
self.ResultContainer.ExportResults(fileprefix="", )
self._Logger.info('Simulation completed in ' +
str(time.time() - startTime) + ' seconds')
self._Logger.info('End of simulation')
def RunSimulation(self, project, scenario, MC_scenario_number=None):
"""Yields a tuple of the results of each step.
Yields
------
tuple
is_complete, step, has_converged, results
"""
startTime = time.time()
Steps, sTime, eTime = self._dssSolver.SimulationSteps()
threshold = self._settings.project.convergence_error_percent_threshold
if threshold > 0:
self._maxConvergenceErrorCount = round(threshold * .01 * Steps)
self._maxConvergenceError = self._settings.project.max_error_tolerance
dss.Solution.Convergence(self._settings.project.error_tolerance)
self._Logger.info('Running simulation from {} till {}.'.format(
sTime, eTime))
self._Logger.info('Simulation time step {}.'.format(Steps))
self._Logger.info("Set OpenDSS convergence to %s",
dss.Solution.Convergence())
self._Logger.info('Max convergence error count {}.'.format(
self._maxConvergenceErrorCount))
self._Logger.info("initializing store")
self.ResultContainer.InitializeDataStore(project.hdf_store, Steps,
MC_scenario_number)
postprocessors = [
pyPostprocess.Create(
project,
scenario,
ppInfo,
self._dssInstance,
self._dssSolver,
self._dssObjects,
self._dssObjectsByClass,
self._settings,
self._Logger,
) for ppInfo in scenario.post_process_infos
]
if not postprocessors:
self._Logger.info('No post processing script selected')
is_complete = False
step = 0
has_converged = False
current_results = {}
try:
while step < Steps:
pydss_has_converged = True
opendss_has_converged = True
within_range = self._simulation_range.is_within_range(
self._dssSolver.GetDateTime())
if within_range:
pydss_has_converged = self.RunStep(step)
opendss_has_converged = dss.Solution.Converged()
if not opendss_has_converged:
self._Logger.error(
"OpenDSS did not converge at step=%s pydss_converged=%s",
step, pydss_has_converged)
self._HandleOpenDSSConvergenceErrorChecks(step)
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())
self._Logger.info(
'Storage requirement estimation: %s, estimated based on first time step run.',
size)
if postprocessors and within_range:
step, has_converged = self._RunPostProcessors(
step, Steps, postprocessors)
if self._increment_flag:
step += 1
# In the case of a frequency sweep, the code updates results at each frequency.
# Doing so again would cause a duplicate result.
if (
self._settings.exports.export_results and not
(self._settings.frequency.enable_frequency_sweep and \
self._settings.project.simulation_type != SimulationType.DYNAMIC)
):
store_nan = (not within_range
or (not has_converged and self._settings.
project.skip_export_on_convergence_error))
self.ResultContainer.UpdateResults(store_nan=store_nan)
if self._settings.helics.co_simulation_mode:
if self._increment_flag:
self._dssSolver.IncStep()
else:
self._dssSolver.reSolve()
else:
self._dssSolver.IncStep()
if self._settings.exports.export_results:
current_results = self.ResultContainer.CurrentResults
yield False, step, has_converged, current_results
finally:
if self._settings and self._settings.exports.export_results:
# This is here to guarantee that DatasetBuffers aren't left
# with any data in memory.
self.ResultContainer.Close()
for postprocessor in postprocessors:
postprocessor.finalize()
if self._settings and self._settings.exports.export_results:
self.ResultContainer.ExportResults()
timer_stats_collector.log_stats(clear=True)
if self._controller_iteration_counts:
data = {
"Report": "ControllerIterationCounts",
"Scenario": self._settings.project.active_scenario,
"Counts": self._controller_iteration_counts,
}
self._reportsLogger.warning(json.dumps(data))
self._Logger.info('Simulation completed in %s seconds',
time.time() - startTime)
self._Logger.info('End of simulation')
yield True, step, has_converged, current_results