emtiop 1.0.0__py3-none-any.whl

emtiop/__init__.py

@@ -0,0 +1,21 @@
+"""
+Copyright 2026 3743 Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+See the LICENSE file distributed with this work for copyright and
+licensing information, the AUTHORS file for a list of copyright
+holders, and the CONTRIBUTORS file for the list of contributors.
+
+SPDX-License-Identifier: Apache-2.0"""
+from .version import __version__

emtiop/api.py

@@ -0,0 +1,126 @@
+from __future__ import absolute_import
+
+"""
+Copyright 2026 3743 Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+See the LICENSE file distributed with this work for copyright and
+licensing information, the AUTHORS file for a list of copyright
+holders, and the CONTRIBUTORS file for the list of contributors.
+
+SPDX-License-Identifier: Apache-2.0"""
+
+"""Functions intended for public access.
+
+Example:
+    To show print CIM summaries interface::
+
+        import emtiop.api as emtiop
+        emtiop.print_cim_summaries(['XfmrSat','IEEE39','IEEE118','WECC240','SMIBDLL'])
+
+Public Functions:
+    :add_ibr_plant: Add an IBR plant with attributes and a DLL interface.
+    :adhoc_sparql_dict: Load the result of a user-written SPARQL query into a Python dictionary.
+    :build_bus_lists: Order the buses (connectivity nodes) sequentially.
+    :build_system_graph: Auto-layout a diagram of the CIM network, returning a networkx graph.
+    :create_atp: Write an ATP netlist from CIM loaded into a Python dictionary.
+    :create_cim_rdf: Create RDF in TTL/XML formats from results of load_rawfile.
+    :create_cim_sql: Create SQL db from results of load_rawfile.
+    :create_matpower: Write a MATPOWER netlist from CIM loaded into a Python dictionary.
+    :extract_case: Copy example files for one case into the current directory.
+    :get_dll_interface: Returns a Python dictionary of the interface to an IEEE/Cigre DLL.
+    :get_swingbus_id: Find the CIM ConnectivityNode ID by matching the Name/Number from the original raw file.
+    :list_cases: List the names and descriptions of examples provided with the package.
+    :load_detailed_model_types: Load the library of detailed dynamic models with parameter descriptors.
+    :list_dict_table: Print the fields and attributes of a Python dictionary loaded from SPARQL.
+    :load_dynamics_defaults: Load example default settings for dynamics into a Python dictionary.
+    :load_dynamics_mapping: Load a dictionary of CIM classes and attributes corresponding to dyr file contents.
+    :load_emt_dict: Load an RDF graph into Python dictionary using packaged SPARQL queries.
+    :load_ic_dict: Load an RDF graph into Python dictionary from standalone power flow solution file.
+    :load_dyrfile: Load contents of a (PSSE) dyrfile into a Pandas dataframe.
+    :load_raw_meta: Load (PSSE) rawfile metadata into a Python dictionary.
+    :load_rawfile: Load contents of a (PSSE) rawfile into a Python dictionary.
+    :load_system_graph: Load the networkx layout (graph) from a JSON file.
+    :match_dyr_generators: Collect dyrfile models from Pandas dataframe into a Python dictionary by generator name/id.
+    :plot_system_graph: Plot the transmission system topology from a networkx layout (graph).
+    :print_cim_summaries: Print class names and counts found in list of Turtle files.
+    :print_raw_table: Print a named dictionary loaded from section of a (PSSE) rawfile.
+    :print_solution_summary: Prints a summary of solved MATPOWER case to console.
+    :read_matpower_casefile: Read a MATPOWER m file into Python dictionary.
+    :run_matpower_and_wait: Runs MATPOWER from command line on Windows, Mac, or Linux.
+    :save_system_graph: Save the networkx layout (graph) to a JSON file.
+    :summarize_casefile: Report the table sizes, total load, and total generation in a loaded MATPOWER case file.
+    :summarize_graph: Count the class instances by namespace in an RDF graph.
+    :summarize_dyrfile: Enumerate contents of a loaded (PSSE) dyrfile dataframe.
+    :write_atp_dll_interface: Netlists an ATP module that calls an IEEE/Cigre DLL.
+    :write_cim_rdf: Serialize the (possibly modified) return value from create_cim_rdf.
+    :write_most_table_indices: Writes some array column indices not included in the base MATPOWER set.
+    :CASES: Configuration data for five examples that come with this package.
+"""
+
+from .buslists import build_bus_lists
+from .buslists import get_swingbus_id
+
+from .cim_examples import CASES
+from .cim_examples import list_cases
+from .cim_examples import extract_case
+
+from .cim_sparql import adhoc_sparql_dict
+from .cim_sparql import list_dict_table
+from .cim_sparql import load_emt_dict
+from .cim_sparql import load_ic_dict
+from .cim_sparql import summarize_graph
+
+from .cim_summary import print_cim_summaries
+
+from .cim_support import load_detailed_model_types
+from .cim_support import load_dynamics_defaults
+from .cim_support import load_dynamics_mapping
+from .cim_support import load_dyrfile
+from .cim_support import load_raw_meta
+from .cim_support import load_rawfile
+from .cim_support import match_dyr_generators
+from .cim_support import print_raw_table
+from .cim_support import summarize_dyrfile
+
+from .create_atp import create_atp
+
+from .create_mpow import create_matpower
+
+from .create_rdf import add_ibr_plant
+from .create_rdf import create_cim_rdf
+from .create_rdf import write_cim_rdf
+
+from .create_sql import create_cim_sql
+
+from .dll_config import get_dll_interface
+from .dll_config import write_atp_dll_interface
+
+from .mpow_utilities import print_solution_summary
+from .mpow_utilities import read_matpower_casefile
+from .mpow_utilities import run_matpower_and_wait
+from .mpow_utilities import summarize_casefile
+from .mpow_utilities import write_most_table_indices
+
+from .plot_utils import build_system_graph
+from .plot_utils import load_system_graph
+from .plot_utils import plot_system_graph
+from .plot_utils import save_system_graph
+
+from .version import __version__ 
+from .version import __cim_schema__
+from .version import __emtiop_schema__
+from .version import __urn_cim__
+from .version import __urn_emtiop__
+

emtiop/buslists.py

@@ -0,0 +1,74 @@
+"""
+Copyright 2026 3743 Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+See the LICENSE file distributed with this work for copyright and
+licensing information, the AUTHORS file for a list of copyright
+holders, and the CONTRIBUTORS file for the list of contributors.
+
+SPDX-License-Identifier: Apache-2.0"""
+
+"""
+  Helper functions that navigate sequential bus numbers and CIM ConnectivityNode IDs.
+"""
+
+def build_bus_lists (d:dict)->tuple[dict,dict]:
+  """Order the buses (connectivity nodes) sequentially.
+
+  Creates two efficient dictionaries to access buses by their
+  sequential number, or by ConnectivityNode ID.
+
+  Args:
+    d (dict): The dictionary of CIM query results for a network.
+
+  Returns:
+    ordered_buses(dict): The *EMTBus* dictionary, re-ordered by bus number.
+    bus_numbers(dict): Reverse lookup the ConnectivityNode ID by bus number.
+  """
+  bNumeric = True
+  for key, data in d['EMTBus']['vals'].items():
+    if not data['name'].isdigit():
+      bNumeric = False
+      break
+  if bNumeric:
+    ordered_buses = dict(sorted(d['EMTBus']['vals'].items(), key=lambda x:int(x[1]['name'])))
+    print ('Numeric ordered buses')
+  else:
+    ordered_buses = d['EMTBus']['vals']
+    print ('Non-numeric ordered buses')
+  bus_numbers = {}
+  busnum = 1
+  for key, data in ordered_buses.items(): # data has name and nomv
+    bus_numbers[key] = busnum
+    busnum += 1
+  return ordered_buses, bus_numbers
+
+def get_swingbus_id (ordered_buses:dict, swingbus:str)->str:
+  """Find the CIM ConnectivityNode ID by matching the Name/Number from the original raw file.
+
+  The swing bus is used in MATPOWER or another power flow, and the Thevenin equivalent
+  source in some EMT models.
+
+  Args:
+    ordered_buses (dict): a dictionary of *EMTBus* sorted by bus number
+    swingbus (str): the swing bus number, as a string name
+
+  Returns:
+    cnid (str): the ConnectivityNode ID corresponding to the swing bus.
+  """
+  for cnid, data in ordered_buses.items():
+    if data['name'] == swingbus:
+      return cnid
+
+

emtiop/cim_examples.py

@@ -0,0 +1,161 @@
+"""
+Copyright 2026 3743 Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+See the LICENSE file distributed with this work for copyright and
+licensing information, the AUTHORS file for a list of copyright
+holders, and the CONTRIBUTORS file for the list of contributors.
+
+SPDX-License-Identifier: Apache-2.0"""
+
+import importlib.resources
+import shutil
+import sys
+import os
+
+RDIR = 'emtiop.examples'
+
+CASES = [
+  {'id': '6477751A-0472-4FD6-B3C3-3AD4945CBE56',
+   'name': 'IEEE39', 
+   'desc': '39 buses, 9 machines, 1 IBR',
+   'legend_loc': 'lower right',
+   'wind_units': [], 
+   'solar_units': ['30_1'], 
+   'hydro_units': [], 
+   'nuclear_units': [],
+   'swingbus': '31',
+   'load': 1.0, 
+   'UseXfmrSaturation': False,
+   'UseMATPOWER': True},
+  {'id': '1783D2A8-1204-4781-A0B4-7A73A2FA6038', 
+   'name': 'IEEE118', 
+   'desc': '193 buses, 56 machines, 19 IBR',
+   'legend_loc': 'best', 
+   'wind_units': ['132_W', '136_W', '138_W', '168_W', '180_W'],
+   'solar_units': ['126_S', '128_S', '130_S', '140_S', '149_S', 
+                   '151_S', '159_S', '165_S', '175_S', '179_S', 
+                   '183_S', '185_S', '188_S', '191_S'],
+   'hydro_units': [], 
+   'nuclear_units': [],   
+   'swingbus':'131', 
+   'load': 0.6748, 
+   'UseXfmrSaturation': False,
+   'UseMATPOWER': True},
+  {'id': '2540AF5C-4F83-4C0F-9577-DEE8CC73BBB3', 
+   'name': 'WECC240', 
+   'desc': '333 buses, 105 machines, 35 IBR',
+   'legend_loc': 'best',
+   'wind_units': ['10322_S', '10342_W', '13332_S', '21301_G',  '2332_S', 
+                   '2431_S',  '2434_S', '24382_RG', '24386_SW', '2439_S'],
+   'solar_units': ['2533_S', '2631_S', '32343_NW', '34331_S', '38351_NG', 
+                   '3932_S', '3933_CG', '39331_NB', '40311_H', '40312_S', 
+                   '4035_C', '40392_W', '41312_W', '42321_H', '5032_C', 
+                   '50324_W', '61322_H', '61324_W', '62351_H', '63331_W', 
+                   '64333_W', '6533_C', '65331_G', '70312_P', '70321_G'],
+   'hydro_units': ['12321_H', '13311_H', '21302_H', '2637_H', '2638_H', 
+                   '40352_H', '40391_H', '41311_H', '41321_H', '42312_H', 
+                   '50311_H', '63352_H', '65332_H', '70322_H', '8033_H', 
+                   '80341_H'],
+   'nuclear_units': ['14311_N', '41322_N'],
+   'swingbus':'3831',
+   'old_swingbus':'2438', 
+   'load': 1.02, 
+   'UseXfmrSaturation': False,
+   'UseMATPOWER': True},
+  {'id': '93EA6BF1-A569-4190-9590-98A62780489E', 
+   'name':'XfmrSat', 
+   'desc': '5 buses, load rejection with transformer saturation',
+   'legend_loc': 'best', 
+   'wind_units':[], 
+   'solar_units':[], 
+   'hydro_units':[], 
+   'nuclear_units':[],
+   'swingbus': '1', 
+   'load':1.0, 
+   'emergency_ratings': True, 
+   'UseXfmrSaturation': True,
+   'UseMATPOWER': True},
+  {'id': '62CB0930-211D-4762-B5C1-27BF73EAC7C4',
+   'name': 'SMIBDLL', 
+   'desc': '12 buses in a test harness, 1 IBR in a DLL',
+   'legend_loc': 'best', 
+   'wind_units': [], 
+   'solar_units': ['1_1'], 
+   'hydro_units': [], 
+   'nuclear_units': [],
+   'swingbus': '5', 
+   'load': 1.0, 
+   'UseXfmrSaturation': True,
+   'UseMATPOWER': False,
+   'ExtraFiles': ['create_smib_dll.py']} # 'gfm_gfl_ibr2.dll', 'gfm_gfl_ibr2.dll32' now curled from test.bat
+]
+"""A list containing example case configurations as dictionaries."""
+
+def list_cases()->None:
+  """List the names and descriptions of examples provided with the package.
+
+  Prints information to the console. Use the *Idx* as an argument to *extract_case*
+  to copy the example files for one case into the current directory.
+  """
+  print ('Idx {:8s} {:36s} {:s}'.format ('Name', 'mRID', 'Description'))
+  for i in range(len(CASES)):
+    print ('{:3d} {:8s} {:36s} {:s}'.format (i, CASES[i]['name'], CASES[i]['id'], CASES[i]['desc']))
+
+def extract_case ()->None:
+  """Copy example files for one case into the current directory.
+
+  Select the case by index, as obtained from *list_cases*. The 
+  index must be passed as an argument on the command line.
+  """
+  idx = int(sys.argv[1])
+  case = CASES[idx]
+  root = case['name']
+
+  # case-specific example files
+  for ext in ['.raw', '.dyr', '_Network.json', '_mRIDs.dat', '.atp', '.prm']:
+    src = importlib.resources.files(RDIR).joinpath('{:s}{:s}'.format(root, ext))
+    with importlib.resources.as_file(src) as fpath:
+      if os.path.isfile(fpath):
+        shutil.copy(fpath, '.')
+
+  if 'ExtraFiles' in case:
+    for fname in case['ExtraFiles']:
+      if not os.path.isfile('./{:s}'.format(fname)):
+        src = importlib.resources.files(RDIR).joinpath(fname)
+        with importlib.resources.as_file(src) as fpath:
+          if os.path.isfile(fpath):
+            shutil.copy(fpath, '.')
+
+  # MATPOWER and ATP support files
+  for fname in ['matpower_write_ic.m', 'ibr.pch', 'syncmach.pch', 'tacspv3.pch']:
+    if not os.path.isfile('./{:s}'.format(fname)):
+      src = importlib.resources.files(RDIR).joinpath(fname)
+      with importlib.resources.as_file(src) as fpath:
+        if os.path.isfile(fpath):
+          shutil.copy(fpath, '.')
+
+  # Python script files
+  for fname in ['raw_to_rdf.py', 'bps_make_mpow.py', 'mpow.py', 'ic_to_rdf.py', 
+                'cim_to_atp.py', 'atp.py', 'plot_bps.py', 'cim_summary.py',
+                'test_cim_sparql.py']:
+    if not os.path.isfile('./{:s}'.format(fname)):
+      src = importlib.resources.files(RDIR).joinpath(fname)
+      with importlib.resources.as_file(src) as fpath:
+        if os.path.isfile(fpath):
+          shutil.copy(fpath, '.')
+
+
+
+

emtiop/cim_sparql.py

@@ -0,0 +1,275 @@
+"""
+Copyright 2026 3743 Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+See the LICENSE file distributed with this work for copyright and
+licensing information, the AUTHORS file for a list of copyright
+holders, and the CONTRIBUTORS file for the list of contributors.
+
+SPDX-License-Identifier: Apache-2.0"""
+
+"""
+  Functions that read CIM into Python dictionaries using SPARQL queries.
+"""
+
+import rdflib
+import time
+import xml.etree.ElementTree as ET
+import importlib.resources
+import sys
+
+XML_QUERY_FILE = 'sparql_queries.xml'
+PREFIX = None
+DELIM = ':'
+ROOT = None
+
+def summarize_graph (g:rdflib.Graph)->None:
+  """Count the class instances by namespace in an RDF graph.
+
+  Use this function for a printed summary of the graph size.
+
+  Args:
+    g (Graph): the RDF Graph obtained from construction in memory, or loaded from a file.
+  """
+
+  q = """
+  SELECT ?class (COUNT(?class) as ?cnt) WHERE {
+    ?s a ?class .
+  } group by ?class order by ?class"""
+
+  print ('{:40s} {:40s} {:5s}'.format ('Namespace', 'Class Name', 'Count'))
+  for r in g.query(q):
+    nscls = r['class']
+    idx = nscls.find('#')
+    ns = nscls[:idx]
+    cls = nscls[idx+1:]
+    print('{:40s} {:40s} {:5d}'.format (ns, cls, int(r['cnt'])))
+
+def list_dict_table(dict:str, tag:str=None)->None:
+  """Print the fields and attributes of a Python dictionary loaded from SPARQL.
+
+  Use this function to explore the structure, size, and contents of a table loaded from SPARQL.
+
+  Args:
+    dict (dict): result from *load_emt_dict*, *load_ic_dict*, or *adhoc_sparql_dict*
+    tag (str): should be a loaded table name, 'Adhoc Query'. If it includes \\* then the table is multi-keyed.
+  """
+
+  bMultiKey = False
+  if tag is None:
+    tbl = dict
+    tag = 'Adhoc Query'
+  else:
+    if '*' in tag:
+      bMultiKey = True
+    tbl = dict[tag]
+  print ('\n{:s}: key,{:s}'.format(tag, str(tbl['columns'])))
+  if bMultiKey:
+    for key, ary in tbl['vals'].items():
+      for row in ary:
+        print ('{:s},{:s}'.format (key, ','.join(str(row[c]) for c in tbl['columns'])))
+  else:
+    for key, row in tbl['vals'].items():
+      print ('{:s},{:s}'.format (key, ','.join(str(row[c]) for c in tbl['columns'])))
+
+def build_query (prefix:str, base:str, sysid:str)->str:
+  if sysid is not None:
+    idx = base.find('WHERE {') + 8
+    return prefix + '\n' + base[:idx] + """ VALUES ?EquipmentContainer_mRID {{"{:s}"^^c:String}}\n""".format (sysid) + base[idx:]
+  return prefix + '\n' + base
+
+def query_for_values (g:rdflib.Graph, tbl:dict, sysid:str)->None:
+  bMultiKey = False
+  if '*' in tbl['keyfld']:
+    bMultiKey = True
+  keyflds = tbl['keyfld'].strip('*').split(':')
+  q = build_query (PREFIX, tbl['sparql'], sysid)
+  #print ('===================')
+  #print (q)
+  result = g.query(q)
+  #print (result)
+  vars = [str(item) for item in result.vars]
+  for akey in keyflds:
+    vars.remove (akey)
+  tbl['columns'] = vars
+  for b in result:
+    row = {}
+    key = str(b[keyflds[0]])
+    for i in range(1, len(keyflds)):
+      key = key + DELIM + str(b[keyflds[i]])
+    for fld in vars:
+      #print ('  ', key, fld, b[fld])
+      if b[fld] is None:
+        row[fld] = None
+      elif 'mRID' in fld:
+        row[fld] = str(b[fld])
+      elif '_name' in fld:
+        row[fld] = str(b[fld])
+      elif '_type' in fld:
+        row[fld] = str(b[fld])
+      elif fld in ['name', 'connectionKind', 'vectorGroup', 'inputSignalType', 'kind', 'parameterKind', 'unit']:
+        row[fld] = str(b[fld])
+      else:
+        try:
+          row[fld] = int(b[fld])
+        except ValueError:
+          try:
+            row[fld] = float(b[fld])
+          except ValueError:
+            row[fld] = str(b[fld])
+    if bMultiKey:
+      if key not in tbl['vals']:
+        tbl['vals'][key] = []
+      tbl['vals'][key].append(row)
+    else:
+      tbl['vals'][key] = row
+
+def load_root_queries(bPrint:bool=False)->None:
+  global ROOT, PREFIX
+  if ROOT is None:
+    # read the queries into dict
+    xfile = importlib.resources.files('emtiop.queries').joinpath(XML_QUERY_FILE)
+    with open (xfile, 'r', encoding='utf-8', errors='strict') as fp:
+      s = fp.read()
+    ROOT = ET.fromstring(s)
+    nsCIM = ROOT.find('nsCIM').text.strip()
+    nsRDF = ROOT.find('nsRDF').text.strip()
+    nsEMT = ROOT.find('nsEMT').text.strip()
+    PREFIX = """PREFIX r: <{:s}>\nPREFIX c: <{:s}>\nPREFIX e: <{:s}>""".format (nsRDF, nsCIM, nsEMT)
+    if bPrint:
+      print (PREFIX)
+
+def load_emt_dict (g:rdflib.Graph, sysid:str, bTiming:bool=False)->dict:
+  """Load an RDF graph into Python dictionary using packaged SPARQL queries.
+
+  This function works on a graph that might contain several transmission system datasets,
+  differentiated by *sysid*. The correct *sysid* must be supplied, even if the graph
+  contains data for only one transmission system, because *sysid* filters all queries.
+
+  Args:
+    g (Graph): an RDF graph loaded from *XML* or *TTL* file
+    sysid (str): the ID of the transmission system's *EquipmentContainer*
+    bTiming (bool): print the execution time of each packaged query
+
+  Returns:
+    dict(dict): dictionary of *EMT* tables loaded from SPARQL.
+  """
+  global ROOT
+
+  current_recursion_limit = sys.getrecursionlimit()
+  new_recursion_limit = 10000
+  if new_recursion_limit > current_recursion_limit:
+    sys.setrecursionlimit(new_recursion_limit)
+    print ('For SPARQL, changing recursion limit from {:d} to {:d}'.format (current_recursion_limit, new_recursion_limit))
+
+  start_time = time.time()
+  load_root_queries()
+  dict = {}
+  for query in ROOT.findall('query'):
+    qid = query.find('id').text.strip()
+    dict[qid] = {}
+    dict[qid]['keyfld'] = query.find('keyfld').text
+    dict[qid]['sparql'] = query.find('value').text.strip()
+    dict[qid]['columns'] = []
+    dict[qid]['vals'] = {}
+    #print (' ', qid, dict[qid]['keyfld'])
+
+  for key in ['EMTContainer', 'EMTBus', 'EMTBusXY', 'EMTBaseVoltage', 'EMTLine', 'EMTLoad',
+              'EMTCountPowerXfmrWindings', 'EMTPowerXfmrWinding', 'EMTPowerXfmrCore',
+              'EMTPowerXfmrMesh', 'EMTXfmrTap', 'EMTXfmrSaturation', 'EMTCompShunt', 'EMTCompSeries',
+              'EMTSyncMachine', 'EMTSolar', 'EMTWind',
+              'EMTDynamicsModel', 'EMTDynamicsModelType', 'EMTDynamicsParameterDescriptor', 'EMTDynamicsParameter',
+              # 'EMTGovGAST', 'EMTGovHydro1', 'EMTGovSteam0',
+              # 'EMTGovSteamSGO', 'EMTExcST1A', 'EMTExcIEEEDC1A', 'EMTExcSEXS', 'EMTPss1A',
+              # 'EMTPssIEEE1A', 'EMTWeccREGCA', 'EMTWeccREECA', 'EMTWeccREPCA',
+              # 'EMTWeccWTGTA', 'EMTWeccWTGARA',
+              'EMTEnergySource', 'EMTDisconnectingCircuitBreaker',
+              'EMTXfmrLimit', 'EMTBranchLimit', 'EMTBusVoltage', 'EMTBranchFlow', 'EMTXfmrFlow',
+              'EMTIBRPlant*', 'EMTRotatingMachinePlant*', 'EMTIEEECigreAPIParameters*',
+              'EMTIBRPlantAttributes', 'EMTCountAPIParameters', 'EMTIEEECigreAPI',
+              'EMTCountAPIInputs', 'EMTIEEECigreAPIInputs*', 'EMTCountAPIOutputs', 'EMTIEEECigreAPIOutputs*',
+              'EMTEquipmentContainer', 'EMTDCEquipmentContainer', 'EMTDCNode', 'EMTDCShunt', 'EMTDCEnergySource',
+              'EMTIEEECigreAPIInfo', 'EMTIEEECigreAPIParameterInfos*', 'EMTIEEECigreAPIInputSignalInfos*',
+              'EMTIEEECigreAPIOutputSignalInfos*']:
+    if bTiming:
+      query_start_time = time.time()
+    query_for_values (g, dict[key], sysid)
+    if bTiming:
+      print ('  Running {:40s} took {:6.3f} s for {:5d} rows'.format (key, time.time() - query_start_time, len(dict[key]['vals'])))
+  if bTiming:
+    print ('Total query time {:6.3f} s'.format (time.time() - start_time))
+  return dict
+
+def load_ic_dict (g:rdflib.Graph, bPrint:bool=False)->dict:
+  """Load an RDF graph into Python dictionary from standalone power flow solution file.
+
+  This function only runs the *EMTBusVoltageIC* and *EMTBranchFlowIC* queries
+  on data that usually comes from a power flow solver.
+
+  The *EMTXfmrFlowIC* no longer works in a standalone power flow solution file. To
+  obtain this filtering, merge the power flow solution and network model into a single
+  CIM RDF file, and then use *EMTXfmrFlow*.
+
+  Args:
+    g (Graph): an RDF graph loaded from *XML* or *TTL* file
+    bPrint (bool): print the total query time
+
+  Returns:
+    dict(dict): dictionary of *EMT* tables loaded from SPARQL.
+  """
+  global ROOT
+  start_time = time.time()
+  # read the queries into dict
+  load_root_queries()
+  dict = {}
+  for query in ROOT.findall('query'):
+    qid = query.find('id').text.strip()
+    dict[qid] = {}
+    dict[qid]['keyfld'] = query.find('keyfld').text
+    dict[qid]['sparql'] = query.find('value').text.strip()
+    dict[qid]['columns'] = []
+    dict[qid]['vals'] = {}
+    #print (' ', qid, dict[qid]['keyfld'])
+
+  for key in ['EMTBusVoltageIC', 'EMTBranchFlowIC']: # , 'EMTXfmrFlowIC']:
+    query_for_values (g, dict[key], sysid=None)
+
+  if bPrint:
+    print ('Total query time {:6.3f} s'.format (time.time() - start_time))
+  return dict
+
+def adhoc_sparql_dict (g:rdflib.Graph, q:str, key_field:str)->dict:
+  """Load the result of a user-written SPARQL query into a Python dictionary.
+
+  Use this function to run SPARQL that has been constructed at runtime. It is used
+  to work with IBR and conventional generating plants that are not rooted in raw files,
+  i.e., the plant data is constructed at runtime.
+
+  Args:
+    g (Graph): an RDF graph constructed in memory, or loaded from *XML* or *TTL* file
+    q (str): the SPARQL query text
+    key_field (str): the field to index query results on, usually a CIM *mRID*
+
+  Returns:
+    dict(dict): dictionary results from SPARQL, corresponding to a single un-named table.
+  """
+  load_root_queries()
+  dict = {}
+  dict['keyfld'] = key_field
+  dict['sparql'] = q
+  dict['columns'] = []
+  dict['vals'] = {}
+  query_for_values (g, dict, sysid=None)
+  return dict
+