def __init__(self, dss_solver, objects_by_name, objects_by_class, options, system_paths):
if options["Logging"]["Pre-configured logging"]:
LoggerTag = __name__
else:
LoggerTag = getLoggerTag(options)
self.itr = 0
self.c_seconds = 0
self.c_seconds_old = -1
self._logger = logging.getLogger(LoggerTag)
self._options = options
self._co_convergance_error_tolerance = options['Helics']['Error tolerance']
self._co_convergance_max_iterations = options['Helics']['Max co-iterations']
self._publications = {}
self._subscriptions = {}
self._system_paths = system_paths
self._objects_by_element = objects_by_name
self._objects_by_class = objects_by_class
self._create_helics_federate()
self._dss_solver = dss_solver
self._registerFederateSubscriptions()
self._registerFederatePublications()
helics.helicsFederateEnterExecutingModeIterative(
self._PyDSSfederate,
helics.helics_iteration_request_iterate_if_needed
)
self._logger.info('Entered HELICS execution mode')
def GetSolver(settings: SimulationSettingsModel, dssInstance):
LoggerTag = getLoggerTag(settings)
pyLogger = logging.getLogger(LoggerTag)
pyLogger.info('Setting solver to %s mode.',
settings.project.simulation_type.value)
return get_solver_from_simulation_type(settings.project)
def __init__(self, SimulationSettings, dssPaths, dssObjects,
dssObjectsByClass):
if SimulationSettings["Logging"]["Pre-configured logging"]:
LoggerTag = __name__
else:
LoggerTag = getLoggerTag(SimulationSettings)
self.pyLogger = logging.getLogger(LoggerTag)
self.__dssPaths = dssPaths
self.__dssObjects = dssObjects
self.__Settings = SimulationSettings
self.__dssObjectsByClass = dssObjectsByClass
try:
MCfile = os.path.join(
self.__Settings['Project']['Active Scenario'], 'Monte_Carlo',
'MonteCarloSettings.toml')
MCfilePath = os.path.join(self.__dssPaths['Import'], MCfile)
self.pyLogger.info(
'Reading monte carlo scenario settings file from ' +
MCfilePath)
self.__MCsettingsDict = utils.load_data(MCfilePath)
except:
self.pyLogger.error(
'Failed to read Monte Carlo scenario generation file %s',
MCfilePath)
raise
return
def __init__(self, dss, run_command, SimulationSettings):
LoggerTag = getLoggerTag(SimulationSettings)
self.pyLogger = logging.getLogger(LoggerTag)
self.__dssInstance = dss
self.__dssCircuit = dss.Circuit
self.__dssElement = dss.Element
self.__dssBus = dss.Bus
self.__dssClass = dss.ActiveClass
self.__dssCommand = run_command
def __init__(self, dss, run_command, SimulationSettings):
if SimulationSettings["Logging"]["Pre-configured logging"]:
LoggerTag = __name__
else:
LoggerTag = getLoggerTag(SimulationSettings)
self.pyLogger = logging.getLogger(LoggerTag)
self.__dssInstance = dss
self.__dssCircuit = dss.Circuit
self.__dssElement = dss.Element
self.__dssBus = dss.Bus
self.__dssClass = dss.ActiveClass
self.__dssCommand = run_command
def __init__(self, Options, SystemPaths, dssObjects, dssObjectsByClass,
dssBuses, dssSolver, dssCommand):
if Options["Logging"]["Pre-configured logging"]:
LoggerTag = __name__
else:
LoggerTag = getLoggerTag(Options)
self.metadata_info = unitDefinations.unit_info
self.__dssDolver = dssSolver
self.Results = {}
self.CurrentResults = {}
self.pyLogger = logging.getLogger(LoggerTag)
self.Buses = dssBuses
self.ObjectsByElement = dssObjects
self.ObjectsByClass = dssObjectsByClass
self.SystemPaths = SystemPaths
self.__dssCommand = dssCommand
self.__Settings = Options
self.__StartDay = Options['Project']['Start Day']
self.__EndDay = Options['Project']['End Day']
self.__DateTime = []
self.__Frequency = []
self.__SimulationMode = []
self.__ExportFormat = Options['Exports']['Export Format']
self.__ExportCompression = Options['Exports']['Export Compression']
self.__publications = {}
self.__subscriptions = {}
self.ExportFolder = os.path.join(self.SystemPaths['Export'],
Options['Project']['Active Scenario'])
pathlib.Path(self.ExportFolder).mkdir(parents=True, exist_ok=True)
if self.__Settings['Exports']['Export Mode'] == 'byElement':
self.FileReader = pyER(
os.path.join(SystemPaths['ExportLists'],
'ExportMode-byElement.toml'))
self.ExportList = self.FileReader.pyControllers
self.PublicationList = self.FileReader.publicationList
self.CreateListByElement()
elif self.__Settings['Exports']['Export Mode'] == 'byClass':
self.FileReader = pyER(
os.path.join(SystemPaths['ExportLists'],
'ExportMode-byClass.toml'))
self.ExportList = self.FileReader.pyControllers
self.PublicationList = self.FileReader.publicationList
self.CreateListByClass()
if self.__Settings['Helics']['Co-simulation Mode']:
self.__createPyDSSfederate()
self.__registerFederatePublications()
self.__registerFederateSubscriptions()
h.helicsFederateEnterExecutingMode(self.__PyDSSfederate)
self.pyLogger.debug('Entered HELICS execution mode')
return
def __init__(self, dssObjects, dssSolver, options, mode="r+"):
if options["Logging"]["Pre-configured logging"]:
logger_tag = __name__
else:
logger_tag = getLoggerTag(options)
self._logger = logging.getLogger(logger_tag)
self.dssSolver = dssSolver
self.Objects = dssObjects
self.profileMapping = load_data(options['Profiles']["Profile mapping"])
filePath = options['Profiles']["Profile store path"]
if os.path.exists(filePath):
self._logger.info("Loading existing h5 store")
self.store = h5py.File(filePath, mode)
else:
self._logger.info("Creating new h5 store")
self.store = h5py.File(filePath, "w")
for profileGroup in PROFILE_TYPES.names():
self.store.create_group(profileGroup)
return
def __init__(self, dss_solver, objects_by_name, objects_by_class, options, system_paths, default=True):
if options["Logging"]["Pre-configured logging"]:
LoggerTag = __name__
else:
LoggerTag = getLoggerTag(options)
self.itr = 0
self.c_seconds = 0
self.c_seconds_old = -1
self._logger = logging.getLogger(LoggerTag)
self._options = options
self._co_convergance_error_tolerance = options['Helics']['Error tolerance']
self._co_convergance_max_iterations = options['Helics']['Max co-iterations']
self._publications = {}
self._subscriptions = {}
self._system_paths = system_paths
self._objects_by_element = objects_by_name
self._objects_by_class = objects_by_class
self._create_helics_federate()
self._dss_solver = dss_solver
if default:
self.registerPubSubTags()
def GetSolver(SimulationSettings, dssInstance):
if SimulationSettings["Logging"]["Pre-configured logging"]:
LoggerTag = __name__
else:
LoggerTag = getLoggerTag(SimulationSettings)
pyLogger = logging.getLogger(LoggerTag)
pyLogger.info('Setting solver to ' +
SimulationSettings['Project']['Simulation Type'] + ' mode.')
if SimulationSettings['Project']['Simulation Type'].lower() == 'snapshot':
return Snapshot(dssInstance=dssInstance,
SimulationSettings=SimulationSettings,
Logger=pyLogger)
elif SimulationSettings['Project']['Simulation Type'].lower() == 'qsts':
return QSTS(dssInstance=dssInstance,
SimulationSettings=SimulationSettings,
Logger=pyLogger)
elif SimulationSettings['Project']['Simulation Type'].lower() == 'dynamic':
return Dynamic(dssInstance=dssInstance,
SimulationSettings=SimulationSettings,
Logger=pyLogger)
else:
pyLogger.error('Invalid solver mode chosen')
return -1
def __init__(self,
dss_solver,
objects_by_name,
objects_by_class,
settings: SimulationSettingsModel,
system_paths,
default=True):
LoggerTag = getLoggerTag(settings)
self.itr = 0
self.c_seconds = 0
self.c_seconds_old = -1
self._logger = logging.getLogger(LoggerTag)
self._settings = settings
self._co_convergance_error_tolerance = settings.helics.error_tolerance
self._co_convergance_max_iterations = self._settings.helics.max_co_iterations
self._publications = {}
self._subscriptions = {}
self._system_paths = system_paths
self._objects_by_element = objects_by_name
self._objects_by_class = objects_by_class
self._create_helics_federate()
self._dss_solver = dss_solver
if default:
self.registerPubSubTags()
def __init__(self, settings: SimulationSettingsModel, dssPaths, dssObjects,
dssObjectsByClass):
LoggerTag = getLoggerTag(settings)
self.pyLogger = logging.getLogger(LoggerTag)
self.__dssPaths = dssPaths
self.__dssObjects = dssObjects
self._settings = settings
self.__dssObjectsByClass = dssObjectsByClass
try:
MCfile = os.path.join(self._settings.project.active_scenario,
'Monte_Carlo', 'MonteCarloSettings.toml')
MCfilePath = os.path.join(self.__dssPaths['Import'], MCfile)
self.pyLogger.info(
'Reading monte carlo scenario settings file from ' +
MCfilePath)
self.__MCsettingsDict = utils.load_data(MCfilePath)
except:
self.pyLogger.error(
'Failed to read Monte Carlo scenario generation file %s',
MCfilePath)
raise
return
def __init__(self, settings: SimulationSettingsModel):
self._dssInstance = dss
self._TempResultList = []
self._dssBuses = {}
self._dssObjects = {}
self._dssObjectsByClass = {}
self._DelFlag = 0
self._pyPlotObjects = {}
self.BokehSessionID = None
self._settings = settings
self._convergenceErrors = 0
self._convergenceErrorsOpenDSS = 0
self._maxConvergenceErrorCount = None
self._maxConvergenceError = 0.0
self._controller_iteration_counts = {}
self._simulation_range = SimulationFilteredTimeRange.from_settings(
settings)
root_path = settings.project.project_path
active_project_path = root_path / settings.project.active_project
import_path = active_project_path / 'Scenarios'
active_scenario_path = import_path / settings.project.active_scenario
self._ActiveProject = settings.project.active_project
self._dssPath = {
'root':
root_path,
'Import':
import_path,
'pyPlots':
active_scenario_path / 'pyPlotList',
'ExportLists':
active_scenario_path / 'ExportLists',
'pyControllers':
active_scenario_path / 'pyControllerList',
'Export':
active_project_path / 'Exports',
'Log':
active_project_path / 'Logs',
'dssFiles':
active_project_path / 'DSSfiles',
'dssFilePath':
active_project_path / 'DSSfiles' / settings.project.dss_file,
}
if settings.project.dss_file_absolute_path:
self._dssPath['dssFilePath'] = Path(settings.project.dss_file)
if not self._dssPath['dssFilePath'].exists():
raise InvalidConfiguration(
f"DSS file {self._dssPath['dssFilePath']} does not exist")
LoggerTag = pyLogger.getLoggerTag(settings)
self._Logger = logging.getLogger(__name__)
self._reportsLogger = pyLogger.getReportLogger(LoggerTag,
self._dssPath["Log"],
settings.logging)
self._Logger.info('An instance of OpenDSS version ' +
self._dssInstance.__version__ + ' has been created.')
for key, path in self._dssPath.items():
if path.name == "pyControllerList" and not path.exists():
# This will happen if a zipped project with no controllers is unzipped and then run.
path.mkdir()
else:
assert path.exists(), '{} path: {} does not exist!'.format(
key, path)
self._CompileModel()
#run_command('Set DefaultBaseFrequency={}'.format(settings.frequency.fundamental_frequency))
self._Logger.info('OpenDSS fundamental frequency set to : ' +
str(settings.frequency.fundamental_frequency) +
' Hz')
#run_command('Set %SeriesRL={}'.format(settings.frequency.percentage_load_in_series))
if settings.frequency.neglect_shunt_admittance:
run_command('Set NeglectLoadY=Yes')
active_scenario = self._GetActiveScenario()
if active_scenario.snapshot_time_point_selection_config.mode != SnapshotTimePointSelectionMode.NONE:
self._SetSnapshotTimePoint(active_scenario)
self._dssCircuit = self._dssInstance.Circuit
self._dssElement = self._dssInstance.Element
self._dssBus = self._dssInstance.Bus
self._dssClass = self._dssInstance.ActiveClass
self._dssCommand = run_command
self._dssSolution = self._dssInstance.Solution
self._dssSolver = SolveMode.GetSolver(settings=settings,
dssInstance=self._dssInstance)
self._Modifier = Modifier(self._dssInstance, run_command, settings)
self._dssBuses = self.CreateBusObjects()
self._dssObjects, self._dssObjectsByClass = self.CreateDssObjects(
self._dssBuses)
self._dssSolver.reSolve()
if settings.profiles.use_profile_manager:
#TODO: disable internal profiles
self._Logger.info(
'Disabling internal yearly and duty-cycle profiles.')
for m in ["Loads", "PVSystem", "Generator", "Storage"]:
run_command(f'BatchEdit {m}..* yearly=NONE duty=None')
profileSettings = self._settings.profiles.settings
profileSettings["objects"] = self._dssObjects
self.profileStore = ProfileInterface.Create(
self._dssInstance, self._dssSolver, self._settings,
self._Logger, **profileSettings)
self.ResultContainer = ResultData(settings, self._dssPath,
self._dssObjects,
self._dssObjectsByClass,
self._dssBuses, self._dssSolver,
self._dssCommand, self._dssInstance)
if settings.project.use_controller_registry:
ControllerList = read_controller_settings_from_registry(
self._dssPath['pyControllers'])
else:
pyCtrlReader = pcr(self._dssPath['pyControllers'])
ControllerList = pyCtrlReader.pyControllers
if ControllerList is not None:
self._CreateControllers(ControllerList)
if settings.plots.create_dynamic_plots:
pyPlotReader = ppr(self._dssPath['pyPlots'])
PlotList = pyPlotReader.pyPlots
self._CreatePlots(PlotList)
for Plot in self._pyPlotObjects:
self.BokehSessionID = self._pyPlotObjects[Plot].GetSessionID()
if settings.plots.open_plots_in_browser:
self._pyPlotObjects[Plot].session.show()
break
self._increment_flag = True
if settings.helics.co_simulation_mode:
self._HI = HI.helics_interface(self._dssSolver, self._dssObjects,
self._dssObjectsByClass, settings,
self._dssPath)
self._Logger.info("Simulation initialization complete")
return
def __init__(self, options, system_paths, dss_objects,
dss_objects_by_class, dss_buses, dss_solver, dss_command,
dss_instance):
if options["Logging"]["Pre-configured logging"]:
logger_tag = __name__
else:
logger_tag = getLoggerTag(options)
self._logger = logging.getLogger(logger_tag)
self._dss_solver = dss_solver
self._results = {}
self._buses = dss_buses
self._objects_by_element = dss_objects
self._objects_by_class = dss_objects_by_class
self.system_paths = system_paths
self._elements = []
self._options = options
self._dss_command = dss_command
self._dss_instance = dss_instance
self._start_day = options["Project"]["Start Day"]
self._end_day = options["Project"]["End Day"]
self._time_dataset = None
self._frequency_dataset = None
self._mode_dataset = None
self._simulation_mode = []
self._hdf_store = None
self._scenario = options["Project"]["Active Scenario"]
self._base_scenario = options["Project"]["Active Scenario"]
self._export_format = options["Exports"]["Export Format"]
self._export_compression = options["Exports"]["Export Compression"]
self._export_iteration_order = options["Exports"][
"Export Iteration Order"]
self._max_chunk_bytes = options["Exports"]["HDF Max Chunk Bytes"]
self._export_dir = os.path.join(
self.system_paths["Export"],
options["Project"]["Active Scenario"],
)
# Use / because this is used in HDFStore
self._export_relative_dir = f"Exports/" + options["Project"][
"Active Scenario"]
self._store_frequency = False
self._store_mode = False
self.CurrentResults = {}
if options["Project"]["Simulation Type"] == "Dynamic" or \
options["Frequency"]["Enable frequency sweep"]:
self._store_frequency = True
self._store_mode = True
if options["Exports"]["Export Mode"] == "byElement":
raise InvalidParameter(
"Export Mode 'byElement' is not supported by ResultData")
pathlib.Path(self._export_dir).mkdir(parents=True, exist_ok=True)
export_list_filename = os.path.join(
system_paths["ExportLists"],
"Exports.toml",
)
if not os.path.exists(export_list_filename):
export_list_filename = os.path.join(
system_paths["ExportLists"],
"ExportMode-byClass.toml",
)
self._export_list = ExportListReader(export_list_filename)
Reports.append_required_exports(self._export_list, options)
self._create_exports()
def __init__(self, params):
self._TempResultList = []
self._dssInstance = dss
self._dssBuses = {}
self._dssObjects = {}
self._dssObjectsByClass = {}
self._DelFlag = 0
self._pyPlotObjects = {}
self.BokehSessionID = None
self._Options = params
rootPath = params['Project']['Project Path']
self._ActiveProject = params['Project']['Active Project']
importPath = os.path.join(rootPath,
params['Project']['Active Project'],
'Scenarios')
self._dssPath = {
'root':
rootPath,
'Import':
importPath,
'pyPlots':
os.path.join(importPath, params['Project']['Active Scenario'],
'pyPlotList'),
'ExportLists':
os.path.join(importPath, params['Project']['Active Scenario'],
'ExportLists'),
'pyControllers':
os.path.join(importPath, params['Project']['Active Scenario'],
'pyControllerList'),
'Export':
os.path.join(rootPath, params['Project']['Active Project'],
'Exports'),
'Log':
os.path.join(rootPath, params['Project']['Active Project'],
'Logs'),
'dssFiles':
os.path.join(rootPath, params['Project']['Active Project'],
'DSSfiles'),
'dssFilePath':
os.path.join(rootPath, params['Project']['Active Project'],
'DSSfiles', params['Project']['DSS File']),
}
if params['Project']['DSS File Absolute Path']:
self._dssPath['dssFilePath'] = params['Project']['DSS File']
else:
self._dssPath['dssFilePath'] = os.path.join(
rootPath, params['Project']['Active Project'], 'DSSfiles',
params['Project']['DSS File'])
if params["Logging"]["Pre-configured logging"]:
self._Logger = logging.getLogger(__name__)
else:
LoggerTag = pyLogger.getLoggerTag(params)
self._Logger = pyLogger.getLogger(LoggerTag,
self._dssPath['Log'],
LoggerOptions=params["Logging"])
self._Logger.info('An instance of OpenDSS version ' + dss.__version__ +
' has been created.')
for key, path in self._dssPath.items():
assert (
os.path.exists(path)), '{} path: {} does not exist!'.format(
key, path)
self._dssInstance.Basic.ClearAll()
self._dssInstance.utils.run_command('Log=NO')
run_command('Clear')
self._Logger.info('Loading OpenDSS model')
try:
orig_dir = os.getcwd()
reply = run_command('compile ' + self._dssPath['dssFilePath'])
finally:
os.chdir(orig_dir)
self._Logger.info('OpenDSS: ' + reply)
assert ('error ' not in reply.lower()
), 'Error compiling OpenDSS model.\n{}'.format(reply)
run_command('Set DefaultBaseFrequency={}'.format(
params['Frequency']['Fundamental frequency']))
self._Logger.info('OpenDSS fundamental frequency set to : ' +
str(params['Frequency']['Fundamental frequency']) +
' Hz')
run_command('Set %SeriesRL={}'.format(
params['Frequency']['Percentage load in series']))
if params['Frequency']['Neglect shunt admittance']:
run_command('Set NeglectLoadY=Yes')
self._dssCircuit = dss.Circuit
self._dssElement = dss.Element
self._dssBus = dss.Bus
self._dssClass = dss.ActiveClass
self._dssCommand = run_command
self._dssSolution = dss.Solution
self._dssSolver = SolveMode.GetSolver(SimulationSettings=params,
dssInstance=self._dssInstance)
self._Modifier = Modifier(dss, run_command, params)
self._UpdateDictionary()
self._CreateBusObjects()
self._dssSolver.reSolve()
if params and params['Exports']['Log Results']:
if params['Exports']['Result Container'] == 'ResultContainer':
self.ResultContainer = RC(params, self._dssPath,
self._dssObjects,
self._dssObjectsByClass,
self._dssBuses, self._dssSolver,
self._dssCommand)
else:
self.ResultContainer = ResultData(
params, self._dssPath, self._dssObjects,
self._dssObjectsByClass, self._dssBuses, self._dssSolver,
self._dssCommand, self._dssInstance)
else:
self.ResultContainer = None
if params['Project']['Use Controller Registry']:
ControllerList = read_controller_settings_from_registry(
self._dssPath['pyControllers'])
else:
pyCtrlReader = pcr(self._dssPath['pyControllers'])
ControllerList = pyCtrlReader.pyControllers
if ControllerList is not None:
self._CreateControllers(ControllerList)
if params['Plots']['Create dynamic plots']:
pyPlotReader = ppr(self._dssPath['pyPlots'])
PlotList = pyPlotReader.pyPlots
self._CreatePlots(PlotList)
for Plot in self._pyPlotObjects:
self.BokehSessionID = self._pyPlotObjects[Plot].GetSessionID()
if params['Plots']['Open plots in browser']:
self._pyPlotObjects[Plot].session.show()
break
self._increment_flag = True
if params['Helics']["Co-simulation Mode"]:
self._HI = HI.helics_interface(self._dssSolver, self._dssObjects,
self._dssObjectsByClass, params,
self._dssPath)
return
