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