diff --git a/.appveyor.yml b/.appveyor.yml
index cefed267617..55eb4494e2f 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -8,7 +8,7 @@ branches:
     - appveyor
     - /devel.*/
     - /.*-avy/
-    - /.*-ci/
+    - /ci-.*/
 
 environment:
   PYTHONWARNINGS: ignore::DeprecationWarning
@@ -20,10 +20,6 @@ environment:
     EXTRA_ARGS: -m llvm
   - PYTHON: Python37
     EXTRA_ARGS: -m llvm
-  - PYTHON: Python36
-    ARCH: -x64
-  - PYTHON: Python37
-    ARCH: -x64
 
 install:
   - if not exist %GRAPHVIZ_INSTALLER% appveyor-retry curl https://graphviz.gitlab.io/_pages/Download/windows/%GRAPHVIZ_INSTALLER% -o %GRAPHVIZ_INSTALLER%
@@ -32,7 +28,9 @@ install:
   - pip install --user -U pip
   - pip --version
   # certifi upgrade is needed by pytest-profiling (it does not set the dependencies right)
-  - pip install --user -U certifi
+  # Restrict pywin32 to <226 to work around appveyor issue:
+  # https://help.appveyor.com/discussions/problems/25404-pywin32226-the-specified-module-could-not-be-found
+  - pip install --user -U certifi "pywin32<226"
   - pip install --user git+https://github.com/benureau/leabra.git@master
 
   # pytorch does not distribute windows packages over pypi. Install it directly.
diff --git a/.github/workflows/pnl-ci.yml b/.github/workflows/pnl-ci.yml
new file mode 100644
index 00000000000..ce4712561df
--- /dev/null
+++ b/.github/workflows/pnl-ci.yml
@@ -0,0 +1,61 @@
+name: PsyNeuLink CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      max-parallel: 7
+      matrix:
+        python-version: [3.6, 3.7, 3.8]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        exclude:
+          - os: windows-latest
+            python-version: 3.8
+          - os: macos-latest
+            python-version: 3.8
+
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 10
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: MacOS dependencies
+      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install graphviz
+      if: matrix.os == 'macos-latest'
+    - name: Linux dependencies
+      run: sudo apt-get install -y graphviz
+      if: matrix.os == 'ubuntu-latest'
+    - name: Windows dependencies
+      run: |
+        choco install --no-progress -y graphviz
+        python -m pip install --upgrade pip
+        pip install torch -f https://download.pytorch.org/whl/cpu/torch_stable.html
+      if: matrix.os == 'windows-latest'
+    - name: Python3.8 dependencies setup
+      run: |
+        sed -i.tmp "/torch/d" requirements.txt
+        pip install cython llvmlite==0.26
+      if: matrix.python-version == '3.8'
+      env:
+        LLVM_CONFIG: llvm-config-6.0
+    - name: Shared dependencies
+      shell: bash
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e .[dev]
+        pip install --user git+https://github.com/benureau/leabra.git@master
+    - name: Lint with flake8
+      shell: bash
+      run: |
+        pip install flake8
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --exit-zero --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: pytest
diff --git a/.idea/runConfigurations/Make_HTML.xml b/.idea/runConfigurations/Make_HTML.xml
index 68aa0f96855..e75891c18cf 100644
--- a/.idea/runConfigurations/Make_HTML.xml
+++ b/.idea/runConfigurations/Make_HTML.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" factoryName="Sphinx task" name="Make HTML" singleton="false" type="docs">
-    <module name="" />
+  <configuration default="false" name="Make HTML" type="docs" factoryName="Sphinx task" singleton="false">
+    <module name="PsyNeuLink (Dropbox)" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
-    <option name="SDK_HOME" value="" />
+    <option name="SDK_HOME" value="$USER_HOME$/anaconda/envs/python37/bin/python" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/docs" />
     <option name="IS_MODULE_SDK" value="false" />
     <option name="ADD_CONTENT_ROOTS" value="true" />
diff --git a/.idea/runConfigurations/Scratch_Pad.xml b/.idea/runConfigurations/Scratch_Pad.xml
index a7d2b7de351..ccb8a6ec5d9 100644
--- a/.idea/runConfigurations/Scratch_Pad.xml
+++ b/.idea/runConfigurations/Scratch_Pad.xml
@@ -1,9 +1,12 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" factoryName="Python" name="Scratch Pad" type="PythonConfigurationType">
-    <module name="" />
+  <configuration default="false" name="Scratch Pad" type="PythonConfigurationType" factoryName="Python">
+    <module name="PsyNeuLink (Dropbox)" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
-    <option name="SDK_HOME" value="" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />
+    </envs>
+    <option name="SDK_HOME" value="$USER_HOME$/anaconda/envs/python37/bin/python" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/Scripts" />
     <option name="IS_MODULE_SDK" value="false" />
     <option name="ADD_CONTENT_ROOTS" value="true" />
@@ -11,7 +14,7 @@
     <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
     <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Scripts/Scratch Pad.py" />
     <option name="PARAMETERS" value="-n 0" />
-    <option name="SHOW_COMMAND_LINE" value="true" />
+    <option name="SHOW_COMMAND_LINE" value="false" />
     <option name="EMULATE_TERMINAL" value="false" />
     <option name="MODULE_MODE" value="false" />
     <option name="REDIRECT_INPUT" value="false" />
diff --git a/.travis.yml b/.travis.yml
index 491184e688f..e3e192d0bd0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,6 +4,7 @@ branches:
     - devel
     - /devel-.*/
     - /travis.*/
+    - /ci-.*/
 
 language: shell
 
@@ -13,7 +14,8 @@ os:
 dist: bionic
 
 env:
-  matrix:
+  jobs:
+    - PYTHON=3.8.0
     - PYTHON=3.7.5
     - PYTHON=3.6.8
   global:
@@ -21,6 +23,11 @@ env:
     - PIP_PROGRESS_BAR="off"
     - COVERALLS_PARALLEL=true
 
+jobs:
+  exclude:
+    - env: PYTHON=3.8.0
+      os: osx
+
 # Cache downloaded(built) python packages
 # and homebrew downloads
 cache:
@@ -59,7 +66,20 @@ before_install:
   - |
     # Install venv on Linux using Ubuntu distributed python
     if [ "$TRAVIS_OS_NAME" == "linux" ]; then
-      sudo apt-get install -y python${PYTHON%.*}-dev python${PYTHON%.*}-venv
+      if [ ${PYTHON%.*} == "3.8" ]; then
+        # There are a lot fewer wheels distributed for python3.8.
+        # We end up building a lot of them locally. Install the dev packages
+        EXTRA_PKGS="gfortran llvm-8-dev liblapack-dev python3.8-distutils"
+        sudo apt-add-repository -y ppa:deadsnakes/ppa
+        sudo apt-get update
+        export LLVM_CONFIG=llvm-config-8
+        export CXXFLAGS=-fPIC
+        # Drop torch for now
+        sed -i '/torch/d' requirements.txt
+        # Cython is needed to build scikit-learn
+        EXTRA_PIP="cython"
+      fi
+      sudo apt-get install -y python${PYTHON%.*}-dev python${PYTHON%.*}-venv $EXTRA_PKGS
       python${PYTHON%.*} -m venv $HOME/venv
       # Provide fake xdg-open
       echo "#!/bin/sh" > $HOME/venv/bin/xdg-open
@@ -70,6 +90,11 @@ before_install:
   - python --version
   - pip install -U pip
   - pip --version
+  - |
+    # Install undeclared dependencies
+    if [ "x$EXTRA_PIP" != "x" ]; then
+      pip install $EXTRA_PIP
+    fi
 
 install:
   - pip install coveralls
diff --git a/Scripts/Examples/Composition/StabilityFlexibility.py b/Scripts/Examples/Composition/StabilityFlexibility.py
index 37cb1177ede..92e46a3d268 100644
--- a/Scripts/Examples/Composition/StabilityFlexibility.py
+++ b/Scripts/Examples/Composition/StabilityFlexibility.py
@@ -169,10 +169,6 @@ def computeAccuracy(variable):
                            intensity_cost_function=pnl.Linear(slope=0.),
                            allocation_samples=search_range)
 
-
-
-
-
 objective_mech = pnl.ObjectiveMechanism(monitor=[inputLayer, stimulusInfo,
                                                  (pnl.PROBABILITY_UPPER_THRESHOLD, decisionMaker),
                                                  (pnl.PROBABILITY_LOWER_THRESHOLD, decisionMaker)],
@@ -187,15 +183,15 @@ def computeAccuracy(variable):
                                                    control_signals=[signal])
 
 inputs = {inputLayer: INPUT, stimulusInfo: stimulusInput}
-stabilityFlexibility.add_model_based_optimizer(meta_controller)
+stabilityFlexibility.add_controller(meta_controller)
 stabilityFlexibility.enable_model_based_optimizer = True
 
 print("Beginning of Run")
 
-for i in range(1, len(stabilityFlexibility.model_based_optimizer.input_ports)):
-    stabilityFlexibility.model_based_optimizer.input_ports[i].function.reinitialize()
+for i in range(1, len(stabilityFlexibility.controller.input_ports)):
+    stabilityFlexibility.controller.input_ports[i].function.reinitialize()
 
-stabilityFlexibility.show_graph(show_model_based_optimizer=True)
+# stabilityFlexibility.show_graph(show_controller=True)
 
 # stabilityFlexibility.run(inputs)
 # print(stabilityFlexibility.results)
diff --git a/Scripts/Examples/System/Leabra-Demo.py b/Scripts/Examples/System/Leabra-Demo.py
index 3769b18ac0e..4b52125a476 100644
--- a/Scripts/Examples/System/Leabra-Demo.py
+++ b/Scripts/Examples/System/Leabra-Demo.py
@@ -46,7 +46,7 @@
 # The leabra network and LeabraMechanism experience this bug equally.
 
 # NOTE: The reason TransferMechanisms are used below is because there is currently a bug where LeabraMechanism
-# (and other `Mechanism`s with multiple input ports) cannot be used as origin Mechanisms for a System. If you desire
+# (and other `Mechanism` with multiple input ports) cannot be used as origin Mechanisms for a System. If you desire
 # to use a LeabraMechanism as an origin Mechanism, you can work around this bug by creating two `TransferMechanism`s
 # as origin Mechanisms instead, and have these two TransferMechanisms pass their output to the InputPorts of
 # the LeabraMechanism.
diff --git a/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model.py b/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model.py
index e0ea012893e..6df618d7c00 100644
--- a/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model.py	
+++ b/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model.py	
@@ -68,8 +68,8 @@ def objective_function(v):
     name='Task Decision',
     # function=pnl.NavarroAndFuss,
     output_ports=[
-        pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD,
-        pnl.DDM_OUTPUT.PROBABILITY_LOWER_THRESHOLD
+        pnl.PROBABILITY_UPPER_THRESHOLD,
+        pnl.PROBABILITY_LOWER_THRESHOLD
     ]
 )
 
diff --git a/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model_VZ.py b/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model_VZ.py
index 6c924dda62e..2a840a1c6a7 100644
--- a/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model_VZ.py	
+++ b/Scripts/Models (Under Development)/Bustamante_Stroop_XOR_LVOC_Model_VZ.py	
@@ -96,9 +96,9 @@ def adj_cost_fct(v):
                 t0=.4
         ),
         output_ports=[
-            pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD,
-            pnl.DDM_OUTPUT.PROBABILITY_LOWER_THRESHOLD,
-            pnl.DDM_OUTPUT.RESPONSE_TIME
+            pnl.PROBABILITY_UPPER_THRESHOLD,
+            pnl.PROBABILITY_LOWER_THRESHOLD,
+            pnl.RESPONSE_TIME
         ]
 )
 
diff --git a/Scripts/Models (Under Development)/ColorMotionTask_FULL.py b/Scripts/Models (Under Development)/ColorMotionTask_FULL.py
index 3415b06b8a2..8c9f79c5e85 100644
--- a/Scripts/Models (Under Development)/ColorMotionTask_FULL.py	
+++ b/Scripts/Models (Under Development)/ColorMotionTask_FULL.py	
@@ -126,7 +126,7 @@ def incongruent(colorResponse, motionResponse):
                        noise=0.5,
                        t0=0.2,
                        threshold=0.45),
-               output_ports=[DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD, DDM_OUTPUT.RESPONSE_TIME],
+               output_ports=[PROBABILITY_UPPER_THRESHOLD, RESPONSE_TIME],
                )
 
 c = Composition(name='ColorMotion Task')
diff --git a/Scripts/Models (Under Development)/ColorMotionTask_SIMPLE.py b/Scripts/Models (Under Development)/ColorMotionTask_SIMPLE.py
index 70e895b18b7..58f220b2738 100644
--- a/Scripts/Models (Under Development)/ColorMotionTask_SIMPLE.py	
+++ b/Scripts/Models (Under Development)/ColorMotionTask_SIMPLE.py	
@@ -13,7 +13,7 @@
                        noise=0.5,
                        t0=0.2,
                        threshold=0.45),
-               output_ports=[DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD, DDM_OUTPUT.RESPONSE_TIME],
+               output_ports=[PROBABILITY_UPPER_THRESHOLD, RESPONSE_TIME],
                )
 
 c = Composition(name='ColorMotion Task')
diff --git a/Scripts/Models (Under Development)/Predator-Prey Model DEMO.py b/Scripts/Models (Under Development)/Predator-Prey Model DEMO.py
index bff77247a9c..37ba976adb5 100644
--- a/Scripts/Models (Under Development)/Predator-Prey Model DEMO.py	
+++ b/Scripts/Models (Under Development)/Predator-Prey Model DEMO.py	
@@ -186,13 +186,13 @@ def objective_function(variable):
 agent_comp.enable_controller = True
 agent_comp.controller_mode = BEFORE
 
-if SHOW_GRAPH is 'SIMPLE':
+if SHOW_GRAPH == 'SIMPLE':
     agent_comp.show_graph(show_cim=True)
-if SHOW_GRAPH is 'CONTROL':
+if SHOW_GRAPH == 'CONTROL':
     agent_comp.show_graph(show_model_based_optimizer=True, show_cim=True)
-if SHOW_GRAPH is 'NODE STRUCTURE':
+if SHOW_GRAPH == 'NODE STRUCTURE':
     agent_comp.show_graph(show_model_based_optimizer=True, show_node_structure=True, show_cim=True)
-if SHOW_GRAPH is 'FULL':
+if SHOW_GRAPH == 'FULL':
     agent_comp.show_graph(show_model_based_optimizer=True,
                           show_cim=True,
                           show_node_structure=ALL,
diff --git a/dev_requirements.txt b/dev_requirements.txt
index c44894786d5..e1ed92bee56 100644
--- a/dev_requirements.txt
+++ b/dev_requirements.txt
@@ -8,6 +8,6 @@ pytest-helpers-namespace
 pytest-xdist
 jupyter
 sphinx
-sphinx_rtd_theme
+psyneulink-sphinx-theme
 ipykernel
 ipython
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 5cc2247083d..73ff1fd0453 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -131,10 +131,10 @@
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-import sphinx_rtd_theme
-html_theme = "sphinx_rtd_theme"
+import psyneulink_sphinx_theme
+html_theme = "psyneulink_sphinx_theme"
 # Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+html_theme_path = [psyneulink_sphinx_theme.get_html_theme_path()]
 html_theme_options = {
     'navigation_depth': 5
 }
@@ -168,7 +168,7 @@
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
-html_css_files = ['css/custom.css']
+
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
 # directly to the root of the documentation.
diff --git a/psyneulink/core/components/component.py b/psyneulink/core/components/component.py
index cbaf7dde948..0cce78cfb36 100644
--- a/psyneulink/core/components/component.py
+++ b/psyneulink/core/components/component.py
@@ -1123,7 +1123,7 @@ def __init__(self,
             self.componentName = self.componentType
 
         # ENFORCE REGISRY
-        if self.__class__.__bases__[0].__bases__[0].__bases__[0].__name__ is 'ShellClass':
+        if self.__class__.__bases__[0].__bases__[0].__bases__[0].__name__ == 'ShellClass':
             try:
                 self.__class__.__bases__[0].registry
             except AttributeError:
@@ -2846,7 +2846,7 @@ def _get_param_value_from_tuple(self, param_spec):
         ALLOWABLE_TUPLE_SPEC_CLASSES = (ModulatoryProjection_Base, ModulatorySignal, ModulatoryMechanism_Base)
 
         # If the 2nd item is a CONTROL or LEARNING SPEC, return the first item as the value
-        if (isinstance(param_spec, tuple) and len(param_spec) is 2 and
+        if (isinstance(param_spec, tuple) and len(param_spec) == 2 and
                 not isinstance(param_spec[1], (dict, list, np.ndarray)) and
                 (param_spec[1] in ALLOWABLE_TUPLE_SPEC_KEYWORDS or
                  isinstance(param_spec[1], ALLOWABLE_TUPLE_SPEC_CLASSES) or
diff --git a/psyneulink/core/components/functions/function.py b/psyneulink/core/components/functions/function.py
index 21c9eb887eb..482ae49229a 100644
--- a/psyneulink/core/components/functions/function.py
+++ b/psyneulink/core/components/functions/function.py
@@ -154,7 +154,7 @@
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set, REPORT_OUTPUT_PREF
 from psyneulink.core.globals.preferences.preferenceset import PreferenceEntry, PreferenceLevel
 from psyneulink.core.globals.registry import register_category
-from psyneulink.core.globals.utilities import object_has_single_value, parameter_spec, safe_len
+from psyneulink.core.globals.utilities import object_has_single_value, parameter_spec, safe_len, get_global_seed
 
 __all__ = [
     'ArgumentTherapy', 'EPSILON', 'Function_Base', 'function_keywords', 'FunctionError', 'FunctionOutputType',
@@ -521,6 +521,11 @@ def __deepcopy__(self, memo):
         new = super().__deepcopy__(memo)
         # ensure copy does not have identical name
         register_category(new, Function_Base, new.name, FunctionRegistry)
+        try:
+            # HACK: Make sure any copies are re-seeded to avoid dependent RNG.
+            new.random_state.seed([get_global_seed()])
+        except:
+            pass
         return new
 
     @handle_external_context()
diff --git a/psyneulink/core/components/functions/learningfunctions.py b/psyneulink/core/components/functions/learningfunctions.py
index e63ef206b4b..926fd8bb5da 100644
--- a/psyneulink/core/components/functions/learningfunctions.py
+++ b/psyneulink/core/components/functions/learningfunctions.py
@@ -930,8 +930,8 @@ class Hebbian(LearningFunction):  # --------------------------------------------
 
     COMMENT:
     activation_function : Function or function : SoftMax
-        specifies the `function <Mechanism_Base.function>` of the `Mechanism` that generated the array of activations
-        in `variable <Hebbian.variable>`.
+        specifies the `function <Mechanism_Base.function>` of the `Mechanism <Mechanism>` that generated the array of
+        activations in `variable <Hebbian.variable>`.
     COMMENT
 
     learning_rate : scalar or list, 1d or 2d array, or np.matrix of numeric values: default default_learning_rate
@@ -961,8 +961,8 @@ class Hebbian(LearningFunction):  # --------------------------------------------
 
     COMMENT:
     activation_function : Function or function : SoftMax
-        the `function <Mechanism_Base.function>` of the `Mechanism` that generated the array of activations in
-        `variable <Hebbian.variable>`.
+        the `function <Mechanism_Base.function>` of the `Mechanism <Mechanism>` that generated the array of activations
+        in `variable <Hebbian.variable>`.
     COMMENT
 
     learning_rate : float, 1d or 2d array
@@ -1168,8 +1168,8 @@ class ContrastiveHebbian(LearningFunction):  # ---------------------------------
 
     COMMENT:
     activation_function : Function or function : SoftMax
-        specifies the `function <Mechanism_Base.function>` of the `Mechanism` that generated the array of activations
-        in `variable <ContrastiveHebbian.variable>`.
+        specifies the `function <Mechanism_Base.function>` of the `Mechanism <Mechanism>` that generated the array of
+        activations in `variable <ContrastiveHebbian.variable>`.
     COMMENT
 
     learning_rate : scalar or list, 1d or 2d array, or np.matrix of numeric values: default default_learning_rate
@@ -1199,8 +1199,8 @@ class ContrastiveHebbian(LearningFunction):  # ---------------------------------
 
     COMMENT:
     activation_function : Function or function : SoftMax
-        the `function <Mechanism_Base.function>` of the `Mechanism` that generated the array of activations in
-        `variable <ContrastiveHebbian.variable>`.
+        the `function <Mechanism_Base.function>` of the `Mechanism <Mechanism>` that generated the array of activations
+        in `variable <ContrastiveHebbian.variable>`.
     COMMENT
 
     learning_rate : float, 1d or 2d array
diff --git a/psyneulink/core/components/functions/objectivefunctions.py b/psyneulink/core/components/functions/objectivefunctions.py
index 846cd0eef49..6545f23a229 100644
--- a/psyneulink/core/components/functions/objectivefunctions.py
+++ b/psyneulink/core/components/functions/objectivefunctions.py
@@ -408,11 +408,11 @@ def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
 
         input_length = ctx.int32_ty(arg_in.type.pointee.count)
         output_length = ctx.int32_ty(arg_in.type.pointee.count)
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm")
         builder.call(builtin, [vec_in, matrix, input_length, output_length, vec_out])
 
         # Prepare metric function
-        metric_fun = ctx.get_llvm_function(self.metric_fct)
+        metric_fun = ctx.import_llvm_function(self.metric_fct)
         metric_in = builder.alloca(metric_fun.args[2].type.pointee)
 
         # Transfer Function if configured
diff --git a/psyneulink/core/components/functions/optimizationfunctions.py b/psyneulink/core/components/functions/optimizationfunctions.py
index 2a492539468..8a56cf292e9 100644
--- a/psyneulink/core/components/functions/optimizationfunctions.py
+++ b/psyneulink/core/components/functions/optimizationfunctions.py
@@ -1071,7 +1071,7 @@ def _convergence_condition(self, variable, value, iteration, context=None):
         previous_variable = self.parameters.previous_variable._get(context)
         previous_value = self.parameters.previous_value._get(context)
 
-        if iteration is 0:
+        if iteration == 0:
             # self._convergence_metric = self.convergence_threshold + EPSILON
             self.parameters.previous_variable._set(variable, context)
             self.parameters.previous_value._set(value, context)
@@ -1471,12 +1471,12 @@ def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
         ocm = getattr(self.objective_function, '__self__', None)
         if ocm is not None:
             assert ocm.function is self
-            obj_func = ctx.get_llvm_function(ocm._gen_llvm_evaluate_function().name)
+            obj_func = ctx.import_llvm_function(ocm._gen_llvm_evaluate_function().name)
             sample_t = ocm._get_evaluate_alloc_struct_type(ctx)
             value_t = ocm._get_evaluate_output_struct_type(ctx)
             extra_args = [arg_in] + list(builder.function.args[-3:])
         else:
-            obj_func = ctx.get_llvm_function(self.objective_function)
+            obj_func = ctx.import_llvm_function(self.objective_function)
             sample_t = obj_func.args[2].type.pointee
             value_t = obj_func.args[3].type.pointee
             extra_args = []
@@ -1556,7 +1556,7 @@ def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
                         prob = b.fdiv(opt_count.type(1), opt_count)
                         # reuse opt_count location. it will be overwritten later anyway
                         res_ptr = opt_count_ptr
-                        rand_f = ctx.get_llvm_function("__pnl_builtin_mt_rand_double")
+                        rand_f = ctx.import_llvm_function("__pnl_builtin_mt_rand_double")
                         b.call(rand_f, [random_state, res_ptr])
                         res = b.load(res_ptr)
                         b.store(opt_count, opt_count_ptr)
diff --git a/psyneulink/core/components/functions/selectionfunctions.py b/psyneulink/core/components/functions/selectionfunctions.py
index a3467d1c5f4..34a63130df9 100644
--- a/psyneulink/core/components/functions/selectionfunctions.py
+++ b/psyneulink/core/components/functions/selectionfunctions.py
@@ -31,11 +31,9 @@
 from psyneulink.core.components.component import DefaultsFlexibility
 from psyneulink.core.components.functions.function import Function, Function_Base, FunctionError
 from psyneulink.core.globals.keywords import \
-    ADDITIVE_PARAM, MULTIPLICATIVE_PARAM, MAX_VAL, MAX_ABS_VAL, MAX_INDICATOR, MAX_ABS_INDICATOR, \
-    MIN_VAL, MIN_ABS_VAL, MIN_INDICATOR, MIN_ABS_INDICATOR, \
+    MAX_VAL, MAX_ABS_VAL, MAX_INDICATOR, MAX_ABS_INDICATOR, MIN_VAL, MIN_ABS_VAL, MIN_INDICATOR, MIN_ABS_INDICATOR, \
     MODE, ONE_HOT_FUNCTION, PARAMETER_PORT_PARAMS, PROB, PROB_INDICATOR, SELECTION_FUNCTION_TYPE, PREFERENCE_SET_NAME
 from psyneulink.core.globals.parameters import Parameter
-from psyneulink.core.globals.context import ContextFlags
 from psyneulink.core.globals.preferences.basepreferenceset import \
     REPORT_OUTPUT_PREF, PreferenceEntry, PreferenceLevel, is_pref_set
 from psyneulink.core.globals.utilities import get_global_seed
@@ -107,26 +105,27 @@ class OneHot(SelectionFunction):
     .. _OneHot:
 
     `function <Selection.function>` returns an array the same length as the first item in `variable <OneHot.variable>`,
-    with all of its values zeroed except one as specified by `mode <OneHot.mode>`:
+    with all of its values zeroed except one identified in first item `variable <OneHot.variable>` as specified by
+    `mode <OneHot.mode>`:
+
+        * *MAX_VAL*: signed value of the element with the maximum signed value;
+
+        * *MAX_ABS_VAL*: absolute value of the element with the maximum absolute value;
 
-        * *MAX_VAL*: element with the maximum signed value in first item of `variable <OneHot.variable>`;
-        ..
-        * *MAX_ABS_VAL*: element with the maximum absolute value;
-        ..
         * *MAX_INDICATOR*: 1 in place of the element with the maximum signed value;
-        ..
+
         * *MAX_ABS_INDICATOR*: 1 in place of the element with the maximum absolute value;
-        ..
-        * *MIN_VAL*: element with the minimum signed value in first item of `variable <OneHot.variable>`;
-        ..
-        * *MIN_ABS_VAL*: element with the minimum absolute value;
-        ..
+
+        * *MIN_VAL*: signed value of the element with the minimum signed value;
+
+        * *MIN_ABS_VAL*: absolute value of element with the minimum absolute value;
+
         * *MIN_INDICATOR*: 1 in place of the element with the minimum signed value;
-        ..
+
         * *MIN_ABS_INDICATOR*: 1 in place of the element with the minimum absolute value;
-        ..
-        * *PROB*: probabilistically chosen element based on probabilities passed in second item of variable;
-        ..
+
+        * *PROB*: value of probabilistically chosen element based on probabilities passed in second item of variable;
+
         * *PROB_INDICATOR*: same as *PROB* but chosen item is assigned a value of 1.
 
 
@@ -297,7 +296,7 @@ def _gen_llvm_function_body(self, ctx, builder, _, state, arg_in, arg_out):
         builder.store(ctx.int32_ty(0), idx_ptr)
 
         if self.mode in {PROB, PROB_INDICATOR}:
-            rng_f = ctx.get_llvm_function("__pnl_builtin_mt_rand_double")
+            rng_f = ctx.import_llvm_function("__pnl_builtin_mt_rand_double")
             dice_ptr = builder.alloca(ctx.float_ty)
             mt_state_ptr = ctx.get_state_ptr(self, builder, state, "random_state")
             builder.call(rng_f, [mt_state_ptr, dice_ptr])
@@ -419,11 +418,11 @@ def _function(self,
 
         if self.mode is MAX_VAL:
             max_value = np.max(variable)
-            result = np.where(variable == max_value, max_value, 0)
+            result = np.where(variable == max_value, variable, 0)
 
         elif self.mode is MAX_ABS_VAL:
             max_value = np.max(np.absolute(variable))
-            result = np.where(variable == max_value, max_value, 0)
+            result = np.where(np.absolute(variable)==max_value, np.absolute(variable), 0)
 
         elif self.mode is MAX_INDICATOR:
             max_value = np.max(variable)
@@ -431,7 +430,7 @@ def _function(self,
 
         elif self.mode is MAX_ABS_INDICATOR:
             max_value = np.max(np.absolute(variable))
-            result = np.where(variable == max_value, 1, 0)
+            result = np.where(np.absolute(variable) == max_value, 1, 0)
 
         if self.mode is MIN_VAL:
             min_value = np.min(variable)
@@ -439,7 +438,7 @@ def _function(self,
 
         elif self.mode is MIN_ABS_VAL:
             min_value = np.min(np.absolute(variable))
-            result = np.where(variable == min_value, min_value, 0)
+            result = np.where(np.absolute(variable) == min_value, np.absolute(variable), 0)
 
         elif self.mode is MIN_INDICATOR:
             min_value = np.min(variable)
@@ -447,7 +446,7 @@ def _function(self,
 
         elif self.mode is MIN_ABS_INDICATOR:
             min_value = np.min(np.absolute(variable))
-            result = np.where(variable == min_value, 1, 0)
+            result = np.where(np.absolute(variable) == min_value, 1, 0)
 
         elif self.mode in {PROB, PROB_INDICATOR}:
             # 1st item of variable should be data, and 2nd a probability distribution for choosing
diff --git a/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py b/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py
index 5a40e01c03b..5134e50a8f5 100644
--- a/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py
+++ b/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py
@@ -2345,9 +2345,9 @@ class DriftDiffusionIntegrator(IntegratorFunction):  # -------------------------
         positive or negative value of threshold (see hint).
 
         .. hint::
-           To terminate execution of the `Mechanism` to which the `function <DriftDiffusionIntegrator.function>` is
-           assigned, the Mechanism just belong to a `Composition` with a `scheduler <Composition.scheduler>` that
-           applies the `WhenFinished` `Condition` to that Mechanism.
+           To terminate execution of the `Mechanism <Mechanism>` to which the `function
+           <DriftDiffusionIntegrator.function>` is assigned, a `WhenFinished` `Condition` should be assigned for that
+           Mechanism to `scheduler <Composition.scheduler>` of the `Composition` to which the Mechanism belongs.
 
     time_step_size : float
         determines the timing precision of the integration process and is used to scale the `noise
@@ -2954,7 +2954,7 @@ class LeakyCompetingIntegrator(IntegratorFunction):  # -------------------------
         (see `offset <LeakyCompetingIntegrator.offset>` for details).
 
     time_step_size : float : default 0.0
-        determines the timing precision of the integration process (see `time_step_size
+        specifies the timing precision of the integration process (see `time_step_size
         <LeakyCompetingIntegrator.time_step_size>` for details.
 
     initializer : float, list or 1d array : default 0.0
diff --git a/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py b/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py
index b49a17e2c1e..3ac916effb3 100644
--- a/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py
+++ b/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py
@@ -783,7 +783,7 @@ def _get_state_initializer(self, context):
     def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
         # PRNG
         rand_struct = ctx.get_state_ptr(self, builder, state, "random_state")
-        uniform_f = ctx.get_llvm_function("__pnl_builtin_mt_rand_double")
+        uniform_f = ctx.import_llvm_function("__pnl_builtin_mt_rand_double")
 
         # Ring buffer
         buffer_ptr = ctx.get_state_ptr(self, builder, state, "previous_value")
@@ -831,7 +831,7 @@ def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
         retr = builder.load(retr_ptr)
         with builder.if_then(retr, likely=True):
             # Determine distances
-            distance_f = ctx.get_llvm_function(self.distance_function)
+            distance_f = ctx.import_llvm_function(self.distance_function)
             distance_params = ctx.get_param_ptr(self, builder, params, "distance_function")
             distance_state = ctx.get_state_ptr(self, builder, state, "distance_function")
             distance_arg_in = builder.alloca(distance_f.args[2].type.pointee)
@@ -847,7 +847,7 @@ def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
                 b.call(distance_f, [distance_params, distance_state,
                                     distance_arg_in, distance_arg_out])
 
-            selection_f = ctx.get_llvm_function(self.selection_function)
+            selection_f = ctx.import_llvm_function(self.selection_function)
             selection_params = ctx.get_param_ptr(self, builder, params, "selection_function")
             selection_state = ctx.get_state_ptr(self, builder, state, "selection_function")
             selection_arg_out = builder.alloca(selection_f.args[3].type.pointee)
diff --git a/psyneulink/core/components/functions/transferfunctions.py b/psyneulink/core/components/functions/transferfunctions.py
index d5c9f1986da..4bc6f3e1c7a 100644
--- a/psyneulink/core/components/functions/transferfunctions.py
+++ b/psyneulink/core/components/functions/transferfunctions.py
@@ -2058,7 +2058,7 @@ def _gen_llvm_transfer(self, builder, index, ctx, vi, vo, params, state):
 
         rvalp = builder.alloca(ptri.type.pointee)
         rand_state_ptr = ctx.get_state_ptr(self, builder, state, "random_state")
-        normal_f = ctx.get_llvm_function("__pnl_builtin_mt_rand_normal")
+        normal_f = ctx.import_llvm_function("__pnl_builtin_mt_rand_normal")
         builder.call(normal_f, [rand_state_ptr, rvalp])
 
         rval = builder.load(rvalp)
@@ -2609,7 +2609,7 @@ class LinearMatrix(TransferFunction):  # ---------------------------------------
 
             - a matrix keyword specification generates a matrix based on the sender and receiver shapes
 
-        When LinearMatrix is instantiated on its own, or as the function of `Mechanism` or `Port`:
+        When LinearMatrix is instantiated on its own, or as the function of a `Mechanism <Mechanism>` or `Port`:
 
             - the matrix specification must be compatible with the function's own `variable <LinearMatrix.variable>`
 
@@ -3017,7 +3017,7 @@ def _gen_llvm_function_body(self, ctx, builder, params, _, arg_in, arg_out):
 
         input_length = ctx.int32_ty(arg_in.type.pointee.count)
         output_length = ctx.int32_ty(arg_out.type.pointee.count)
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm")
         builder.call(builtin, [vec_in, matrix, input_length, output_length, vec_out])
         return builder
 
@@ -3440,7 +3440,7 @@ class TransferWithCosts(TransferFunction):
     The `multiplicative_param <Function_Modulatory_Params>` and `additive_param <Function_Modulatory_Params>` of each
     cost function is assigned as a parameter of the TransferWIthCost `Function`.  This makes them accessible for
     `modulation <ModulatorySignal_Modulation>` when the Function is assigned to a `Port` (e.g., as the default
-    `function <ControlSignal.function>` of a `ControlSignal`), or a `Mechanism`.
+    `function <ControlSignal.function>` of a `ControlSignal`), or a `Mechanism <Mechanism>`.
 
     For example, the following scripts shows how modulate the `intensity_cost_function
     <ControlSignal.intensity_cost_function>` of a `ControlSignal`::
@@ -4179,7 +4179,7 @@ def toggle_cost_function(self, cost_function_name:tc.any(str, CostFunctions),
     def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
         # Run transfer function first
         transfer_f = self.parameters.transfer_fct
-        trans_f = ctx.get_llvm_function(transfer_f.get())
+        trans_f = ctx.import_llvm_function(transfer_f.get())
         trans_p = ctx.get_param_ptr(self, builder, params, transfer_f.name)
         trans_s = ctx.get_state_ptr(self, builder, state, transfer_f.name)
         trans_in = arg_in
diff --git a/psyneulink/core/components/functions/userdefinedfunction.py b/psyneulink/core/components/functions/userdefinedfunction.py
index 78645749f8a..9a713e99e7f 100644
--- a/psyneulink/core/components/functions/userdefinedfunction.py
+++ b/psyneulink/core/components/functions/userdefinedfunction.py
@@ -56,13 +56,13 @@ class UserDefinedFunction(Function_Base):
     * It may have have **any number of additional arguments** (positional and/or keyword);  these are treated as
       parameters of the UDF, and can be modulated by `ModulatorySignals <ModulatorySignal>` like the parameters of
       ordinary PsyNeuLink `Functions <Function>`.  If the UDF is assigned to (or automatically created for) a
-      `Mechanism` or `Projection <Projection>`, these parameters are each automatically assigned a `ParameterPort`
-      so that they can be modulated by `ControlSignals <ControlSignal>` or `LearningSignals <LearningSignal>`,
-      respectively.  If the UDF is assigned to (or automatically created for) an `InputPort` or `OutputPort`,
-      and any of the parameters are specified as `Function_Modulatory_Params` (see `below <UDF_Modulatory_Params>`),
-      then they can be modulated by `GatingSignals <GatingSignal>`. The function or method wrapped by the UDF is called
-      with these parameters by their name and with their current values (i.e., as determined by any
-      `ModulatorySignals <ModulatorySignal>` assigned to them).
+      `Mechanism <Mechanism>` or `Projection <Projection>`, these parameters are each automatically assigned a
+      `ParameterPort` so that they can be modulated by `ControlSignals <ControlSignal>` or `LearningSignals
+      <LearningSignal>`, respectively.  If the UDF is assigned to (or automatically created for) an `InputPort` or
+      `OutputPort`, and any of the parameters are specified as `Function_Modulatory_Params` (see `below
+      <UDF_Modulatory_Params>`), then they can be modulated by `GatingSignals <GatingSignal>`. The function or method
+      wrapped by the UDF is called with these parameters by their name and with their current values (i.e.,
+      as determined by any `ModulatorySignals <ModulatorySignal>` assigned to them).
     ..
     .. _UDF_Params_Context:
 
diff --git a/psyneulink/core/components/mechanisms/mechanism.py b/psyneulink/core/components/mechanisms/mechanism.py
index ea820a836c8..e007233aab6 100644
--- a/psyneulink/core/components/mechanisms/mechanism.py
+++ b/psyneulink/core/components/mechanisms/mechanism.py
@@ -950,7 +950,6 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
 from psyneulink.core.components.component import Component, function_type, method_type
 from psyneulink.core.components.functions.function import FunctionOutputType
 from psyneulink.core.components.functions.transferfunctions import Linear
-from psyneulink.core.components.functions.selectionfunctions import OneHot
 from psyneulink.core.components.shellclasses import Function, Mechanism, Projection, Port
 from psyneulink.core.components.ports.inputport import DEFER_VARIABLE_SPEC_TO_MECH_MSG, InputPort
 from psyneulink.core.components.ports.modulatorysignals.modulatorysignal import _is_modulatory_spec
@@ -962,12 +961,11 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
     ADDITIVE_PARAM, EXECUTION_PHASE, EXPONENT, FUNCTION, FUNCTION_PARAMS, \
     INITIALIZING, INIT_EXECUTE_METHOD_ONLY, INIT_FUNCTION_METHOD_ONLY, \
     INPUT_LABELS_DICT, INPUT_PORT, INPUT_PORTS, INPUT_PORT_VARIABLES, \
-    MAX_ABS_INDICATOR, MAX_ABS_VAL, MAX_INDICATOR, MAX_VAL, MEAN, MECHANISM, MECHANISM_VALUE, \
-    MECHANISM_COMPONENT_CATEGORY, MEDIAN, MODEL_SPEC_ID_INPUT_PORTS, MODEL_SPEC_ID_OUTPUT_PORTS, \
+    MECHANISM, MECHANISM_VALUE, MECHANISM_COMPONENT_CATEGORY, MODEL_SPEC_ID_INPUT_PORTS, MODEL_SPEC_ID_OUTPUT_PORTS, \
     MONITOR_FOR_CONTROL, MONITOR_FOR_LEARNING, MULTIPLICATIVE_PARAM, \
     NAME, OUTPUT_LABELS_DICT, OUTPUT_PORT, OUTPUT_PORTS, OWNER_EXECUTION_COUNT, OWNER_EXECUTION_TIME, OWNER_VALUE, \
-    PARAMETER_PORT, PARAMETER_PORTS, PREVIOUS_VALUE, PROB, PROJECTIONS, REFERENCE_VALUE, RESULT, \
-    STANDARD_DEVIATION, TARGET_LABELS_DICT, VALUE, VARIABLE, VARIANCE, WEIGHT
+    PARAMETER_PORT, PARAMETER_PORTS, PREVIOUS_VALUE, PROJECTIONS, REFERENCE_VALUE, RESULT, \
+    TARGET_LABELS_DICT, VALUE, VARIABLE, WEIGHT
 
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.scheduling.condition import Condition
@@ -1219,39 +1217,22 @@ class Mechanism_Base(Mechanism):
         of an OutputPort does not have a corresponding label, then its numeric value is used instead.
 
     standard_output_ports : list[dict]
-        list of the dictionary specifications for `StandardOutputPorts <StandardOutputPort>` that can
-        be assigned as `OutputPorts <OutputPort>`; subclasses may extend this list to include
-         (the type for the `value <OutputPort.value>` of each is listed
-        next to its name):
+        list of the dictionary specifications for `StandardOutputPorts <OutputPort_Standard>` that can be assigned as
+        `OutputPorts <OutputPort>`; subclasses may extend this list to include additional ones.
 
         *RESULT* : 1d np.array
           first item in the outermost dimension (axis 0) of the Mechanism's `value <Mechanism_Base.value>`.
 
-        *MEAN* : float
-          mean of the elements in the first item of Mechanism's `value <Mechanism_Base.value>`.
-
-        *MEDIAN* : float
-          median of the elements in the first item of Mechanism's `value <Mechanism_Base.value>`.
-
-        *STANDARD_DEVIATION* : float
-          standard deviation of the elements in the first item of Mechanism's `value <Mechanism_Base.value>`.
-
-        *VARIANCE* : float
-          variance of the elements in the first item of Mechanism's `output_port.value`.
-
-        *MECHANISM_VALUE* : list
+        *OWNER_VALUE* : list
           Full ndarray of Mechanism's `value <Mechanism_Base.value>`.
 
-        COMMENT:
-        *COMBINE* : scalar or numpy array
-          linear combination of the `value <Mechanism_Base.value>` of all items of the TransferMechanism's `value
-          <Mechanism_Base.value>` (requires that they all have the same dimensionality).
-        COMMENT
+        *MECHANISM_VALUE* : list
+          Synonym for *OWNER_VALUE*.
 
     standard_output_port_names : list[str]
         list of the names of the `standard_output_ports <Mechanism_Base.standard_output_ports>` that can be used to
-        specify a `StandardOutputPort` in the **output_ports** argument of the Mechanism's constructor, and to
-        reference it in Mechanism's list of `output_ports <Mechanism_Base.output_ports>`.
+        specify a `StandardOutputPort <OutputPort_Standard>` in the **output_ports** argument of the Mechanism's
+        constructor, and to reference it in Mechanism's list of `output_ports <Mechanism_Base.output_ports>`.
 
     ports : ContentAddressableList
         a list of all of the Mechanism's `Ports <Port>`, composed from its `input_ports
@@ -1397,28 +1378,10 @@ def _loggable_items(self):
         })
 
     standard_output_ports = [{NAME: RESULT},
-                             {NAME:MEAN,
-                              FUNCTION:lambda x: np.mean(x)},
-                             {NAME: MEDIAN,
-                              FUNCTION:lambda x: np.median(x)},
-                             {NAME: STANDARD_DEVIATION,
-                              FUNCTION:lambda x: np.std(x)},
-                             {NAME: VARIANCE,
-                              FUNCTION:lambda x: np.var(x)},
                              {NAME: MECHANISM_VALUE,
                               VARIABLE: OWNER_VALUE},
                              {NAME: OWNER_VALUE,
-                              VARIABLE: OWNER_VALUE},
-                             {NAME: MAX_VAL,
-                              FUNCTION: OneHot(mode=MAX_VAL).function},
-                             {NAME: MAX_ABS_VAL,
-                              FUNCTION: OneHot(mode=MAX_ABS_VAL).function},
-                             {NAME: MAX_INDICATOR,
-                              FUNCTION: OneHot(mode=MAX_INDICATOR).function},
-                             {NAME: MAX_ABS_INDICATOR,
-                              FUNCTION: OneHot(mode=MAX_ABS_INDICATOR).function},
-                             {NAME: PROB,
-                              FUNCTION: OneHot(mode=PROB).function}]
+                              VARIABLE: OWNER_VALUE}]
     standard_output_port_names = [i['name'] for i in standard_output_ports]
 
     class Parameters(Mechanism.Parameters):
@@ -2766,7 +2729,7 @@ def _gen_llvm_ports(self, ctx, builder, ports,
         all_ports = self.ports
         mod_afferents = self.mod_afferents
         for i, port in enumerate(ports):
-            s_function = ctx.get_llvm_function(port)
+            s_function = ctx.import_llvm_function(port)
 
             # Find output location
             builder, p_output = get_output_ptr(builder, i)
@@ -2805,7 +2768,7 @@ def _gen_llvm_input_ports(self, ctx, builder,
         # of InputPort results should match the main function input.
         is_output_list = []
         for port in self.input_ports:
-            is_function = ctx.get_llvm_function(port)
+            is_function = ctx.import_llvm_function(port)
             is_output_list.append(is_function.args[3].type.pointee)
 
         # Check if all elements are the same. Function input will be array type if yes.
@@ -2894,7 +2857,7 @@ def _fill_input(b, s_input, i):
         return builder
 
     def _gen_llvm_invoke_function(self, ctx, builder, function, params, state, variable):
-        fun = ctx.get_llvm_function(function)
+        fun = ctx.import_llvm_function(function)
         fun_in, builder = self._gen_llvm_function_input_parse(builder, ctx, fun, variable)
         fun_out = builder.alloca(fun.args[3].type.pointee)
 
diff --git a/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py b/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py
index 56f047598f1..ce45e761eec 100644
--- a/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py
@@ -807,7 +807,7 @@ class ControlMechanism(ModulatoryMechanism_Base):
     system : System_Base
         The `System` for which the ControlMechanism is a `controller <System>`.  Note that this is distinct from
         a Mechanism's `systems <Mechanism_Base.systems>` attribute, which lists all of the Systems to which a
-        `Mechanism` belongs -- a ControlMechanism can belong to but not be the `controller of a System
+        `Mechanism <Mechanism>` belongs -- a ControlMechanism can belong to but not be the `controller of a System
         <ControlMechanism_Composition_Controller>`.
 
     objective_mechanism : ObjectiveMechanism
@@ -1622,7 +1622,7 @@ def add_to_monitor(self, monitor_specs, context=None):
         <ControlMechanism.objective_mechanism>`.
 
         **monitored_output_ports** can be any of the following:
-            - `Mechanism`;
+            - `Mechanism <Mechanism>`;
             - `OutputPort`;
             - `tuple specification <InputPort_Tuple_Specification>`;
             - `Port specification dictionary <InputPort_Specification_Dictionary>`;
diff --git a/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py b/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py
index 6d06e56e957..a797a99a4f7 100644
--- a/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py
@@ -28,10 +28,10 @@
 --------
 
 A GatingMechanism is a subclass of `ControlMechanism` that is restricted to using only `GatingSignals <GatingSignal>`,
-which modulate the `input <Mechanism_InputPorts>` or `output <Mechanism_InputPorts>` of a `Mechanism`, but not the
-paramaters of its `function <Mechanism_Base.function>`.  Accordingly, its constructor has a **gate** argument in place
-of a **control** argument.  It also lacks several attributes related to control, including those related to costs
-and net_outcome.  In all other respects it is identical to its parent class, ControlMechanism.
+which modulate the `input <Mechanism_InputPorts>` or `output <Mechanism_InputPorts>` of a `Mechanism <Mechanism>`,
+but not the paramaters of its `function <Mechanism_Base.function>`.  Accordingly, its constructor has a **gate**
+argument in place of a **control** argument.  It also lacks several attributes related to control, including those
+related to costs and net_outcome.  In all other respects it is identical to its parent class, ControlMechanism.
 
 .. _GatingMechanism_Creation:
 
diff --git a/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py b/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py
index 1fee38dfaf0..ac31494c89e 100644
--- a/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py
@@ -205,8 +205,8 @@
   created on the OptimziationControlMechanism for each feature, that receives a `Projection` paralleling
   the input to be shadowed.
 ..
-* *Output Features* -- these are the `value <OutputPort.value>` of an `OutputPort` of some other `Mechanism` in
-  the Composition.  These too are specified in the **features** argument of the OptimizationControlMechanism's
+* *Output Features* -- these are the `value <OutputPort.value>` of an `OutputPort` of some other `Mechanism <Mechanism>`
+  in the Composition.  These too are specified in the **features** argument of the OptimizationControlMechanism's
   constructor (see `OptimizationControlMechanism_Creation`), and each is assigned a `Projection` from the specified
   OutputPort(s) to the InputPort of the OptimizationControlMechanism for that feature.
 
@@ -1031,7 +1031,7 @@ def _gen_llvm_net_outcome_function(self, ctx):
             # FIXME: Add support for other cost types
             assert os.cost_options == CostFunctions.INTENSITY
 
-            func = ctx.get_llvm_function(os.intensity_cost_function)
+            func = ctx.import_llvm_function(os.intensity_cost_function)
             func_params = builder.gep(params, [ctx.int32_ty(0), ctx.int32_ty(0), ctx.int32_ty(i)])
             func_state = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(0), ctx.int32_ty(i)])
             func_out = builder.alloca(func.args[3].type.pointee)
@@ -1082,7 +1082,7 @@ def _gen_llvm_evaluate_function(self):
 
             params, state, allocation_sample, arg_out, arg_in, comp_params, base_comp_state, base_comp_data = llvm_func.args
 
-            sim_f = ctx.get_llvm_function(self.agent_rep._llvm_sim_run.name)
+            sim_f = ctx.import_llvm_function(self.agent_rep._llvm_sim_run.name)
 
             # Create a simulation copy of composition state
             comp_state = builder.alloca(base_comp_state.type.pointee, name="state_copy")
@@ -1178,7 +1178,7 @@ def _gen_llvm_function(self):
         return f
 
     def _gen_llvm_invoke_function(self, ctx, builder, function, params, context, variable):
-        fun = ctx.get_llvm_function(function)
+        fun = ctx.import_llvm_function(function)
         fun_in, builder = self._gen_llvm_function_input_parse(builder, ctx, fun, variable)
         fun_out = builder.alloca(fun.args[3].type.pointee)
 
diff --git a/psyneulink/core/components/mechanisms/modulatory/learning/learningmechanism.py b/psyneulink/core/components/mechanisms/modulatory/learning/learningmechanism.py
index 2c2702843b5..8a3410d576f 100644
--- a/psyneulink/core/components/mechanisms/modulatory/learning/learningmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/learning/learningmechanism.py
@@ -603,7 +603,7 @@ class LearningTiming(Enum):
     EXECUTION_PHASE
         LearningMechanism (and associated `LearningProjections(s) <LearningProjection>`) executed during the
         `execution phase <System_Execution>` of the System to which they belong, usually immediately after execution of
-        the `Mechanism` that receives the `primary_learned_projection`
+        the `Mechanism <Mechanism>` that receives the `primary_learned_projection`
 
     LEARNING_PHASE
         LearningMechanism (and associated `LearningProjections(s) <LearningProjection>`) executed during the
diff --git a/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py b/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py
index 5d30e5f4e4c..43611321cfe 100644
--- a/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py
@@ -34,8 +34,8 @@
 There are two primary types of ModulatoryMechanism:
 
 * `ControlMechanism`
-    modulates the `value <Port_Base.value>` of a `Port` of a `Mechanism`.  Takes an evaluative signal (generally
-    received from an `ObjectiveMechanism`) and generates a `control_allocation
+    modulates the `value <Port_Base.value>` of a `Port` of a `Mechanism <Mechanism>`.  Takes an evaluative signal
+    (generally received from an `ObjectiveMechanism`) and generates a `control_allocation
     <ControlMechanism.control_allocation>`, each item of which is assigned to one of its `ControlSignals
     <ControlSignal>`;  each of those generates a `control_signal <ControlSignal.control_signal>` that is used by its
     `ControlProjection(s) <ControlProjection>` to modulate the parameter of a `function <Port_Base.function>` (and
@@ -49,8 +49,8 @@
 COMMENT:
 ..
 * `GatingMechanism`
-    a subclsass of `ModulatoryMechanism` that is specialized for modulating the input to or ouput from a `Mechanism`;
-    it takes an evaluative signal (generally received from an `ObjectiveMechanism`) and generates a
+    a subclsass of `ModulatoryMechanism` that is specialized for modulating the input to or output from a `Mechanism
+    <Mechanism>`; it takes an evaluative signal (generally received from an `ObjectiveMechanism`) and generates a
     `gating_allocation <GatingMechanism.gating_allocation>`, each item of which is assigned to one of its
     `GatingSignals <ControlSignal>`;  each of those generates a `gating_signal <ControlSignal.control_signal>`
     that is used by its `GatingProjection(s) <ControlProjection>` to modulate the parameter of a `function
diff --git a/psyneulink/core/components/mechanisms/processing/objectivemechanism.py b/psyneulink/core/components/mechanisms/processing/objectivemechanism.py
index ed5a765b5f4..7befc8084f2 100644
--- a/psyneulink/core/components/mechanisms/processing/objectivemechanism.py
+++ b/psyneulink/core/components/mechanisms/processing/objectivemechanism.py
@@ -374,23 +374,22 @@
 from psyneulink.core.components.functions.combinationfunctions import LinearCombination
 from psyneulink.core.components.mechanisms.mechanism import Mechanism_Base
 from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
-from psyneulink.core.components.ports.outputport import OutputPort, PRIMARY
+from psyneulink.core.components.ports.outputport import OutputPort
 from psyneulink.core.components.ports.inputport import InputPort, INPUT_PORT
 from psyneulink.core.components.ports.port import _parse_port_spec
 from psyneulink.core.globals.context import ContextFlags
 from psyneulink.core.globals.keywords import \
-    CONTEXT, CONTROL, EXPONENT, EXPONENTS, FUNCTION, LEARNING, MATRIX, NAME, \
-    OBJECTIVE_MECHANISM, OUTCOME, PARAMS, PROJECTION, PROJECTIONS, PORT_TYPE, VARIABLE, WEIGHT, WEIGHTS, \
-    PREFERENCE_SET_NAME
+    CONTROL, EXPONENT, EXPONENTS, FUNCTION, LEARNING, MATRIX, NAME, OBJECTIVE_MECHANISM, OUTCOME, OWNER_VALUE, \
+    PARAMS, PREFERENCE_SET_NAME, PROJECTION, PROJECTIONS, PORT_TYPE, VARIABLE, WEIGHT, WEIGHTS
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set, REPORT_OUTPUT_PREF
 from psyneulink.core.globals.preferences.preferenceset import PreferenceEntry, PreferenceLevel
-from psyneulink.core.globals.utilities import ContentAddressableList, type_match
+from psyneulink.core.globals.utilities import ContentAddressableList
 
 __all__ = [
     'DEFAULT_MONITORED_PORT_WEIGHT', 'DEFAULT_MONITORED_PORT_EXPONENT', 'DEFAULT_MONITORED_PORT_MATRIX',
     'MONITOR', 'MONITOR_SUFFIX', 'MONITORED_OUTPUT_PORT_NAME_SUFFIX', 'MONITORED_OUTPUT_PORTS',
-    'OBJECTIVE_OUTPUT', 'ObjectiveMechanism', 'ObjectiveMechanismError', 'OUTCOME', 'ROLE'
+    'ObjectiveMechanism', 'ObjectiveMechanismError', 'OUTCOME', 'ROLE'
 ]
 
 ROLE = 'role'
@@ -403,22 +402,6 @@
 DEFAULT_MONITORED_PORT_EXPONENT = None
 DEFAULT_MONITORED_PORT_MATRIX = None
 
-# This is a convenience class that provides list of standard_output_port names in IDE
-class OBJECTIVE_OUTPUT():
-    """
-    .. _ObjectiveMechanism_Standard_OutputPorts:
-
-    `Standard OutputPorts <OutputPort_Standard>` for `ObjectiveMechanism`:
-
-    .. _OBJECTIVE_MECHANISM_OUTCOME
-
-    *OUTCOME* : 1d np.array
-        the value of the objective or "loss" function computed based on the
-        ObjectiveMechanism's `function <ObjectiveMechanism.function>`
-
-    """
-    OUTCOME=OUTCOME
-
 
 class ObjectiveMechanismError(Exception):
     def __init__(self, error_value):
@@ -503,6 +486,16 @@ class ObjectiveMechanism(ProcessingMechanism_Base):
     output_values : 2d np.array
         contains one item that is the value of the *OUTCOME* `OutputPort <ObjectiveMechanism_Output>`.
 
+    standard_output_ports : list[str]
+        list of `Standard OutputPort <OutputPort_Standard>` that includes the following in addition to
+        the `standard_output_ports <Mechanism_Base.standard_output_ports>` of a `Mechanism <Mechanism>`:
+
+        .. _OBJECTIVE_MECHANISM_OUTCOME
+
+        *OUTCOME* : 1d np.array
+            the value of the objective or "loss" function computed by the
+            ObjectiveMechanism's `function <ObjectiveMechanism.function>`
+
     """
 
     componentType = OBJECTIVE_MECHANISM
@@ -547,6 +540,9 @@ class Parameters(ProcessingMechanism_Base.Parameters):
         })
 
     standard_output_ports = ProcessingMechanism_Base.standard_output_ports.copy()
+    standard_output_ports.extend([{NAME:OUTCOME, VARIABLE:(OWNER_VALUE, 0)}])
+    standard_output_port_names = ProcessingMechanism_Base.standard_output_ports.copy()
+    standard_output_port_names.extend([OUTCOME])
 
     # FIX:  TYPECHECK MONITOR TO LIST OR ZIP OBJECT
     @tc.typecheck
@@ -668,7 +664,7 @@ def add_to_monitor(self, monitor_specs, context=None):
         Used by other Components to add a `Port` or list of Ports to be monitored by the ObjectiveMechanism.
         The **monitor_spec** can be any of the following:
         - MonitoredOutputPortTuple
-        - `Mechanism`;
+        - `Mechanism <Mechanism>`;
         - `OutputPort`;
         - `tuple specification <InputPort_Tuple_Specification>`;
         - `Port specification dictionary <InputPort_Specification_Dictionary>`;
diff --git a/psyneulink/core/components/mechanisms/processing/processingmechanism.py b/psyneulink/core/components/mechanisms/processing/processingmechanism.py
index 185ea4bfdae..739507ce79c 100644
--- a/psyneulink/core/components/mechanisms/processing/processingmechanism.py
+++ b/psyneulink/core/components/mechanisms/processing/processingmechanism.py
@@ -17,6 +17,7 @@
   * `ProcessingMechanism_Creation`
   * `ProcessingMechanism_Structure`
   * `ProcessingMechanism_Execution`
+  * `ProcessingMechanism_Class_Reference`
 
 
 .. _ProcessingMechanism_Overview:
@@ -64,8 +65,11 @@
 Structure
 ---------
 
-A ProcessingMechanism has the same basic structure as a `Mechanism <Mechanism>`.  See the documentation for
-individual subtypes of ProcessingMechanism for more specific information about their structure.
+A ProcessingMechanism has the same structure as a `Mechanism <Mechanism>`, with the addition of several
+`StandardOutputPorts <OutputPort_Standard>` to its `standard_output_ports
+<ProcessingMechanism.standard_output_ports>` attribute.
+
+See documentation for individual subtypes of ProcessingMechanism for more specific information about their structure.
 
 .. _ProcessingMechanism_Execution:
 
@@ -92,6 +96,11 @@
 This option is intended for testing and debugging purposes.  More commonly, a mechanism is executed when the
 `Composition` to which it belongs is `run <Composition_Run>`.
 
+.. _ProcessingMechanism_Class_Reference:
+
+Class Reference
+---------------
+
 """
 
 from collections.abc import Iterable
@@ -99,9 +108,12 @@
 import typecheck as tc
 import numpy as np
 
-from psyneulink.core.components.functions.transferfunctions import Linear
+from psyneulink.core.components.functions.transferfunctions import Linear, SoftMax
+from psyneulink.core.components.functions.selectionfunctions import OneHot
 from psyneulink.core.components.mechanisms.mechanism import Mechanism_Base
-from psyneulink.core.globals.keywords import PROCESSING_MECHANISM, PREFERENCE_SET_NAME
+from psyneulink.core.globals.keywords import \
+    FUNCTION, MAX_ABS_INDICATOR, MAX_ABS_ONE_HOT, MAX_ABS_VAL, MAX_INDICATOR, MAX_ONE_HOT, MAX_VAL, MEAN, MEDIAN, \
+    NAME, PROB, PROCESSING_MECHANISM, PREFERENCE_SET_NAME, STANDARD_DEVIATION, VARIANCE
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set, REPORT_OUTPUT_PREF
 from psyneulink.core.globals.preferences.preferenceset import PreferenceEntry, PreferenceLevel
 
@@ -109,31 +121,29 @@
     'ProcessingMechanismError',
 ]
 
-# ControlMechanismRegistry = {}
-
 
 class ProcessingMechanismError(Exception):
     def __init__(self, error_value):
         self.error_value = error_value
 
 
-
 # # These are defined here because STANDARD_DEVIATION AND VARIANCE
 # #    are already defined in Keywords in lower case (used as arg for Functions).
 # STD_DEV_OUTPUT_PORT_NAME = 'STANDARD_DEVIATION'
-# VARIANCE_OUTPUT_PORT_NAME = 'variance'
+# VARIANCE_OUTPUT_PORT_NAME = 'VARIANCE'
 
 
 class ProcessingMechanism_Base(Mechanism_Base):
-    # DOCUMENTATION: this is a TYPE and subclasses are SUBTYPES
-    #                primary purpose is to implement TYPE level preferences for all processing mechanisms
-    #                inherits all attributes and methods of Mechanism -- see Mechanism for documentation
-    """Subclass of `Mechanism <Mechanism>` that implements processing in a `Pathway`.
+    """Subclass of `Mechanism <Mechanism>`.
+
+    This is a TYPE and subclasses are SUBTYPES.  its primary purpose is to implement TYPE level preferences for all
+    processing mechanisms.
 
     .. note::
        ProcessingMechanism_Base is an abstract class and should *never* be instantiated by a call to its constructor.
        It should be instantiated using the constructor for `ProcessingMechanism` or one of its  `subclasses
        <ProcessingMechanism_Subtypes>`.
+
    """
 
     componentType = "ProcessingMechanism"
@@ -150,7 +160,29 @@ class ProcessingMechanism_Base(Mechanism_Base):
     paramClassDefaults = Mechanism_Base.paramClassDefaults.copy()
 
     standard_output_ports = Mechanism_Base.standard_output_ports.copy()
-    standard_output_port_names = Mechanism_Base.standard_output_port_names.copy()
+    standard_output_ports.extend([{NAME:MEAN,
+                                   FUNCTION:lambda x: np.mean(x)},
+                                  {NAME: MEDIAN,
+                                   FUNCTION:lambda x: np.median(x)},
+                                  {NAME: STANDARD_DEVIATION,
+                                   FUNCTION:lambda x: np.std(x)},
+                                  {NAME: VARIANCE,
+                                   FUNCTION:lambda x: np.var(x)},
+                                  {NAME: MAX_VAL,
+                                   FUNCTION:lambda x: np.max(x)},
+                                  {NAME: MAX_ABS_VAL,
+                                   FUNCTION:lambda x: np.max(np.absolute(x))},
+                                  {NAME: MAX_ONE_HOT,
+                                   FUNCTION: OneHot(mode=MAX_VAL).function},
+                                  {NAME: MAX_ABS_ONE_HOT,
+                                   FUNCTION: OneHot(mode=MAX_ABS_VAL).function},
+                                  {NAME: MAX_INDICATOR,
+                                   FUNCTION: OneHot(mode=MAX_INDICATOR).function},
+                                  {NAME: MAX_ABS_INDICATOR,
+                                   FUNCTION: OneHot(mode=MAX_ABS_INDICATOR).function},
+                                  {NAME: PROB,
+                                   FUNCTION: SoftMax(output=PROB).function}])
+    standard_output_port_names = [i['name'] for i in standard_output_ports]
 
     def __init__(self,
                  default_variable=None,
@@ -209,8 +241,54 @@ def __str__(self):
 
 class ProcessingMechanism(ProcessingMechanism_Base):
     """
-    Subclass of `ProcessingMechanism <ProcessingMechanism>` that does not have any specialized features.
-    See Mechanism `Mechanism_Class_Reference` for arguments of constructor and attributes.
+    Implements instance of `ProcessingMechanism_Base <ProcessingMechanism>` subclass of `Mechanism <Mechanism>`.
+    See `Mechanism <Mechanism_Class_Reference>` and `subclasses <ProcessingMechanism_Subtypes>` of ProcessingMechanism
+    for arguments and additional attributes.
+
+    Attributes
+    ----------
+
+    standard_output_ports : list[dict]
+      list of the dictionary specifications for `StandardOutputPorts <OutputPort_Standard>` that can be assigned as
+      `OutputPorts <OutputPort>`, in addition to the `standard_output_ports <Mechanism_Base.standard_output_ports>`
+      of a `Mechanism <Mechanism>`; each assigns as the `value <OutputPort.value>` of the OutputPort a quantity
+      calculated over the elements of the first item in the outermost dimension (axis 0) of the Mechanism`s `value
+      <Mechanism_Base.value>`. `Subclasses <ProcessingMechanism_Subtypes>` of ProcessingMechanism may extend this
+      list to include additional `StandardOutputPorts <OutputPort_Standard>`.
+
+     *MEAN* : float
+       mean of the elements.
+
+     *MEDIAN* : float
+       median of the elements.
+
+     *STANDARD_DEVIATION* : float
+       standard deviation of the elements.
+
+     *VARIANCE* : float
+       variance of the elements.
+
+     *MAX_VAL* : float
+       greatest signed value of the elements.
+
+     *MAX_ABS_VAL* : float
+       greatest absolute value of the elements.
+
+     *MAX_ONE_HOT* : float
+       element with the greatest signed value is assigned that value, all others are assigned 0.
+
+     *MAX_ABS_ONE_HOT* : float
+       element with the greatest absolute value is assigned that value, all others are assigned 0.
+
+     *MAX_INDICATOR* : 1d array
+       element with the greatest signed value is assigned 1, all others are assigned 0.
+
+     *MAX_ABS_INDICATOR* : 1d array
+       element with the greatest absolute value is assigned 1, all others are assigned 0.
+
+     *PROB* : float
+       element chosen probabilistically based on softmax distribution is assigned its value, all others are assigned 0.
+
     """
 
     componentType = PROCESSING_MECHANISM
diff --git a/psyneulink/core/components/mechanisms/processing/transfermechanism.py b/psyneulink/core/components/mechanisms/processing/transfermechanism.py
index 66e6d7b0ee7..b2acb055523 100644
--- a/psyneulink/core/components/mechanisms/processing/transfermechanism.py
+++ b/psyneulink/core/components/mechanisms/processing/transfermechanism.py
@@ -191,7 +191,7 @@
 more than one item in `value <Mechanism_Base.value>`, then an OuputPort is assigned for each;  the name of the first
 is *RESULT-0*, and the names of the subsequent ones are suffixed with an integer that is incremented for each successive
 one (e.g., *RESULT-1*, *RESULT-2*, etc.).  Additional OutputPorts can be assigned using the TransferMechanism's
-`Standard OutputPorts <TransferMechanism_Standard_OutputPorts>` (see `OutputPort_Standard`) or by creating `custom
+`standard_output_ports <TransferMechanism.standard_output_ports>` (see `OutputPort_Standard`) or by creating `custom
 OutputPorts <OutputPort_Customization>` (but see note below).   Like any OutputPorts, the `value <OutputPort.value>` of
 any or all of these can be modulated by one or more `ControlSignals <ControlSignal_Modulation>` or `GatingSignals
 <GatingSignal_Modulation>`.
@@ -472,16 +472,17 @@
 from psyneulink.core.components.functions.objectivefunctions import Distance
 from psyneulink.core.components.functions.selectionfunctions import SelectionFunction
 from psyneulink.core.components.functions.transferfunctions import Linear, Logistic, TransferFunction
+from psyneulink.core.components.functions.combinationfunctions import LinearCombination, SUM
 from psyneulink.core.components.functions.userdefinedfunction import UserDefinedFunction
 from psyneulink.core.components.mechanisms.modulatory.control.controlmechanism import _is_control_spec
 from psyneulink.core.components.mechanisms.mechanism import Mechanism, MechanismError
 from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
 from psyneulink.core.components.ports.inputport import InputPort
-from psyneulink.core.components.ports.outputport import OutputPort, StandardOutputPorts
+from psyneulink.core.components.ports.outputport import OutputPort
 from psyneulink.core.globals.context import ContextFlags, handle_external_context
 from psyneulink.core.globals.keywords import \
-    comparison_operators, FUNCTION, INITIALIZER, INSTANTANEOUS_MODE_VALUE, LESS_THAN_OR_EQUAL, \
-    MAX_ABS_DIFF, NAME, NOISE, OUTPUT_PORT, OWNER_VALUE, RATE, REINITIALIZE, RESULT, RESULTS, SELECTION_FUNCTION_TYPE, \
+    COMBINE, comparison_operators, FUNCTION, INITIALIZER, INSTANTANEOUS_MODE_VALUE, LESS_THAN_OR_EQUAL, \
+    MAX_ABS_DIFF, NAME, NOISE, OWNER_VALUE, RATE, REINITIALIZE, RESULT, RESULTS, SELECTION_FUNCTION_TYPE, \
     TRANSFER_FUNCTION_TYPE, TRANSFER_MECHANISM, VARIABLE
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set
@@ -768,6 +769,17 @@ class TransferMechanism(ProcessingMechanism_Base):
         `termination_threshold <TransferMechanism.termination_threshold>` to determine when execution of
         TransferMechanism is complete if `execute_until_finished <Component.execute_until_finished>` is True.
 
+    standard_output_ports : list[dict]
+        list of `Standard OutputPort <OutputPort_Standard>` that includes the following in addition to the
+        `standard_output_ports <ProcessingMechanism.standard_output_ports>` of a
+        `ProcessingMechanism <ProcessingMechanism>`:
+
+        .. _COMBINE:
+
+        *COMBINE* : 1d array
+          Element-wise (Hadamard) sum of all items of the TransferMechanism's `value <Mechanism_Base.value>`
+          (requires that they all have the same dimensionality).
+
     Returns
     -------
     instance of TransferMechanism : TransferMechanism
@@ -788,8 +800,11 @@ class TransferMechanism(ProcessingMechanism_Base):
     paramClassDefaults.update({NOISE: None})
 
     standard_output_ports = ProcessingMechanism_Base.standard_output_ports.copy()
+    standard_output_ports.extend([{NAME: COMBINE,
+                                   VARIABLE: OWNER_VALUE,
+                                   FUNCTION: LinearCombination(operation=SUM).function}])
     standard_output_port_names = ProcessingMechanism_Base.standard_output_port_names.copy()
-
+    standard_output_port_names.extend([COMBINE])
 
     class Parameters(ProcessingMechanism_Base.Parameters):
         """
@@ -963,18 +978,15 @@ def __init__(self,
         # to True after initialization
         self._needs_integrator_function_init = False
 
-        super(TransferMechanism, self).__init__(
-                default_variable=default_variable,
-                size=size,
-                input_ports=input_ports,
-                output_ports=output_ports,
-                function=function,
-                params=params,
-                name=name,
-                prefs=prefs,
-
-                **kwargs
-        )
+        super(TransferMechanism, self).__init__(default_variable=default_variable,
+                                                size=size,
+                                                input_ports=input_ports,
+                                                output_ports=output_ports,
+                                                function=function,
+                                                params=params,
+                                                name=name,
+                                                prefs=prefs,
+                                                **kwargs)
 
     def _parse_arg_initial_value(self, initial_value):
         return self._parse_arg_variable(initial_value)
diff --git a/psyneulink/core/components/ports/inputport.py b/psyneulink/core/components/ports/inputport.py
index c809507479f..d3e6af702a8 100644
--- a/psyneulink/core/components/ports/inputport.py
+++ b/psyneulink/core/components/ports/inputport.py
@@ -34,9 +34,9 @@
 Overview
 --------
 
-The purpose of an InputPort is to receive and combine inputs to a `Mechanism`, allow them to be modified, and provide
-them to the Mechanism's `function <Mechanism_Base.function>`. An InputPort receives input to a `Mechanism`
-provided by the `Projections <Projection>` to that Mechanism from others in a `Process` or `System`.  If the
+The purpose of an InputPort is to receive and combine inputs to a `Mechanism <Mechanism>`, allow them to be modified,
+and provide them to the Mechanism's `function <Mechanism_Base.function>`. An InputPort receives input to a Mechanism
+provided by the `Projections <Projection>` to that Mechanism from others in a `Composition`.  If the
 InputPort belongs to an `ORIGIN` Mechanism (see `role of Mechanisms in Processes and Systems
 <Mechanism_Role_In_Processes_And_Systems>`), then it receives the input specified when that Process or System is
 `run <Run>`.  The `PathwayProjections <PathWayProjection>` received by an InputPort are listed in its `path_afferents
@@ -53,12 +53,12 @@
 Creating an InputPort
 ----------------------
 
-An InputPort can be created by calling its constructor, but in general this is not necessary as a `Mechanism` can
-usually automatically create the InputPort(s) it needs when it is created.  For example, if the Mechanism is
-being created within the `pathway <Process.pathway>` of a `Process`, its InputPort is created and  assigned as the
-`receiver <MappingProjection.receiver>` of a `MappingProjection` from the  preceding Mechanism in the `pathway
-<Process.pathway>`.  InputPorts can also be specified in the **input_ports** argument of a Mechanism's
-constructor (see `below <InputPort_Specification>`).
+An InputPort can be created by calling its constructor, but in general this is not necessary as a `Mechanism
+<Mechanism>` can usually automatically create the InputPort(s) it needs when it is created.  For example, if the
+Mechanism isbeing created within the `pathway <Process.pathway>` of a `Process`, its InputPort is created and assigned
+as the `receiver <MappingProjection.receiver>` of a `MappingProjection` from the  preceding Mechanism in the `pathway
+<Process.pathway>`.  InputPorts can also be specified in the **input_ports** argument of a Mechanism's constructor
+(see `below <InputPort_Specification>`).
 
 The `variable <InputPort.variable>` of an InputPort can be specified using the **variable** or **size** arguments of
 its constructor.  It can also be specified using the **projections** argument, if neither **variable** nor **size** is
diff --git a/psyneulink/core/components/ports/modulatorysignals/modulatorysignal.py b/psyneulink/core/components/ports/modulatorysignals/modulatorysignal.py
index e8216c43e84..da8ebf9d9fd 100644
--- a/psyneulink/core/components/ports/modulatorysignals/modulatorysignal.py
+++ b/psyneulink/core/components/ports/modulatorysignals/modulatorysignal.py
@@ -153,12 +153,12 @@
 There are three broad categories of modulation that serve different purposes, and differ according to the
 ModulatorySignals used and the type of Port modulated:
 
-  * **modulation of a** `Mechanism`\\s <function <Mechanism_Base.function> -- a `ControlSignal` must be used; this
-    modulates the `ParameterPort` for a parameter of the Mechanism's `function <Mechanism_Base.function>` which,
-    in turn, determines how it computes the Mechanism's `value <Mechanism_Base.value>`;
+  * **modulation of a** `Mechanism  <Mechanism>`\\s <function <Mechanism_Base.function> -- a `ControlSignal` must be
+    used; this modulates the `ParameterPort` for a parameter of the Mechanism's `function <Mechanism_Base.function>`
+    which, in turn, determines how it computes the Mechanism's `value <Mechanism_Base.value>`;
 
-  * **modulation of a** `Mechanism`\\s input or output -- a `GatingSignal` is specialized for this purpose, though a
-    `ControlSignal` can also be used;  these modulate an `InputPort` of the Mechanism, that determines the
+  * **modulation of a** `Mechanism <Mechanism>`\\s input or output -- a `GatingSignal` is specialized for this purpose,
+    though a `ControlSignal` can also be used;  these modulate an `InputPort` of the Mechanism, that determines the
     Mechanism's `variable <Mechanism_Base.variable>` used as the input to its `function <Mechanism_Base.function>`,
     or an `OutputPort` of the Mechanism, that determines how the `value <Mechanism_Base.value>` of the Mechanism
     (i.e., the result of its `function <Mechanism_Base.function>`) is used to generate the output of the Mechanism.
@@ -196,8 +196,8 @@
 Colors listed are those used in the `figure <ModulatorySignal_Anatomy_Figure>` below.
 
 It is important to emphasize that, although the purpose of a ModulatorySignal is to modify the functioning of a
-`Mechanism` or a `MappingProjection`, it does this indirectly by modifying a Port that determines the input or
-output of a Mechanism, or the parameters of a Mechanism or Projection's `function`, rather than directly modifying
+`Mechanism <Mechanism>` or a `MappingProjection`, it does this indirectly by modifying a Port that determines the input
+or output of a Mechanism, or the parameters of a Mechanism or Projection's `function`, rather than directly modifying
 the function of the Mechanism or Projection itself.  This is shown in the following figure, and described in greater
 detail under `ModulatorySignal_Implementation`.
 
@@ -274,8 +274,8 @@
 Implementation of Modulation
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Although the `purpose of a ModulatorySignal <ModulatorySignal_Uses>` is to modify the operation of
-a `Mechanism` or `MappingProjection`, it does not do this *directly*; rather, it does it by way of a `Port` that
+Although the `purpose of a ModulatorySignal <ModulatorySignal_Uses>` is to modify the operation of a `Mechanism
+<Mechanism>` or `MappingProjection`, it does not do this *directly*; rather, it does it by way of a `Port` that
 modulates the input, function parameter, or output of the Mechanism or MappingProjeciton to be regulated. More
 specifically, a ModulatorySignal modulates the `function <Port_Base.function>` of a *Port* responsible for
 generating those values, by modifying a parameter of that Port's `function <Port_Base.function>`.  This is shown
diff --git a/psyneulink/core/components/ports/outputport.py b/psyneulink/core/components/ports/outputport.py
index 81335a53c39..eec81ca7e75 100644
--- a/psyneulink/core/components/ports/outputport.py
+++ b/psyneulink/core/components/ports/outputport.py
@@ -374,15 +374,16 @@
 Standard OutputPorts
 ^^^^^^^^^^^^^^^^^^^^^
 
+# FIX: 11/9/19: REPLACE RECURRENTTRANSFERMECHNISM EXAMPLE WITH TRANSFERMECHANISM
 Mechanisms have a `standard_output_ports <Mechanism_Base.standard_output_ports>` attribute, that contains a list of
-`StandardOutputPorts`:  predefined OutputPorts that can be assigned as `output_ports <Mechanism_Base.output_ports>`.
-Every Mechanism has a base set of StandardOutputPorts. Subclasses of Mechanisms may add ones that are specific to
-that type of Mechanism (for example, the `RecurrentTransferMechanism` class has `standard_output_ports
-<RecurrentTransferMechanism.standard_output_ports>` for calculating the energy and entropy of its `value
-<Mechanism_Base.value>`.  The names of the `standard_output_ports` are listed in the Mechanism's
-`standard_output_port_names <Mechanism_Base.standard_output_port_names>` attribute. These can be used to specify the
-`output_ports <Mechanism_Base.output_ports>` of a Mechanism, as in the following example for a
-`ProcessingMechanism <ProcessingMechanism>`::
+`StandardOutputPorts`: `OutputPort specification dictionaries <OutputPort_Specification_Dictionary>` that can be
+assigned as `output_ports <Mechanism_Base.output_ports>`. There is a base set of StandardOutputPorts for all
+Mechanisms. Subclasses of Mechanisms may add ones that are specific to that type of Mechanism (for example, the
+`RecurrentTransferMechanism` class has `standard_output_ports <RecurrentTransferMechanism.standard_output_ports>`
+for calculating the energy and entropy of its `value <Mechanism_Base.value>`.  The names of the `standard_output_ports`
+are listed in the Mechanism's `standard_output_port_names <Mechanism_Base.standard_output_port_names>` attribute.
+These can be used to specify the `output_ports <Mechanism_Base.output_ports>` of a Mechanism, as in the following
+example for a `ProcessingMechanism <ProcessingMechanism>`::
 
     >>> import psyneulink as pnl
     >>> my_mech = pnl.ProcessingMechanism(default_variable=[0,0],
@@ -469,8 +470,8 @@
 COMMENT
 
     >>> my_mech = pnl.DDM(function=pnl.DriftDiffusionAnalytical(),
-    ...                   output_ports=[pnl.DDM_OUTPUT.DECISION_VARIABLE,
-    ...                                  pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD,
+    ...                   output_ports=[pnl.DECISION_VARIABLE,
+    ...                                  pnl.PROBABILITY_UPPER_THRESHOLD,
     ...                                  {pnl.NAME: 'DECISION ENTROPY',
     ...                                   pnl.VARIABLE: (pnl.OWNER_VALUE, 2),
     ...                                   pnl.FUNCTION: pnl.Stability(metric=pnl.ENTROPY) }])
@@ -500,8 +501,8 @@
 and then assigned either as::
 
     >>> my_mech = pnl.DDM(function=pnl.DriftDiffusionAnalytical(),
-    ...                   output_ports=[pnl.DDM_OUTPUT.DECISION_VARIABLE,
-    ...                                  pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD,
+    ...                   output_ports=[pnl.DECISION_VARIABLE,
+    ...                                  pnl.PROBABILITY_UPPER_THRESHOLD,
     ...                                  decision_entropy_output_port])
 
 or::
@@ -510,8 +511,8 @@
     ...                                                variable=(OWNER_VALUE, 2),
     ...                                                function=pnl.Stability(metric=pnl.ENTROPY))
     >>> my_mech2 = pnl.DDM(function=pnl.DriftDiffusionAnalytical(),
-    ...                    output_ports=[pnl.DDM_OUTPUT.DECISION_VARIABLE,
-    ...                                   pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD])
+    ...                    output_ports=[pnl.DECISION_VARIABLE,
+    ...                                   pnl.PROBABILITY_UPPER_THRESHOLD])
 
     >>> my_mech2.add_ports(another_decision_entropy_output_port) # doctest: +SKIP
 
@@ -1365,12 +1366,8 @@ def _instantiate_output_ports(owner, output_ports=None, context=None):
                 if output_port.initialization_status == ContextFlags.DEFERRED_INIT:
                     try:
                         output_port_value = OutputPort._get_port_function_value(owner,
-                                                                                  # MODIFIED 9/22/19 OLD:
-                                                                                  # output_port.function,
-                                                                                  # MODIFIED 9/22/19 NEW: [JDC]
-                                                                                  output_port._init_args[FUNCTION],
-                                                                                  # MODIFIED 9/22/19 END
-                                                                                  output_port._init_args[VARIABLE])
+                                                                                output_port._init_args[FUNCTION],
+                                                                                output_port._init_args[VARIABLE])
                     # For backward compatibility with INDEX and ASSIGN
                     except AttributeError:
                         index = output_port.index
diff --git a/psyneulink/core/components/ports/parameterport.py b/psyneulink/core/components/ports/parameterport.py
index edcb6cb366d..574c9ed2c96 100644
--- a/psyneulink/core/components/ports/parameterport.py
+++ b/psyneulink/core/components/ports/parameterport.py
@@ -61,11 +61,11 @@
 -------------------------
 
 ParameterPorts are created automatically when the `Mechanism <Mechanism>` or `Projection <Projection>` to which they
-belong is created.  The `owner <Port.owner>` of a ParameterPort must be a `Mechanism` or `MappingProjection` (the
-initialization of a ParameterPort cannot be `deferred <Port_Deferred_Initialization>`). One ParameterPort is created
-for each configurable parameter of its owner, as well as for each configurable parameter of the owner's `function
-<Component.function>` (the `configurable parameters <ParameterPort_Configurable_Parameters>` of a Component are
-listed in its `user_params <Component.user_params>` and function_params <Component.function_params>` dictionaries.
+belong is created.  The `owner <Port.owner>` of a ParameterPort must be a `Mechanism <Mechanism>` or `MappingProjection`
+(the initialization of a ParameterPort cannot be `deferred <Port_Deferred_Initialization>`). One ParameterPort is
+created for each configurable parameter of its owner, as well as for each configurable parameter of the owner's
+`function <Component.function>` (the `configurable parameters <ParameterPort_Configurable_Parameters>` of a Component
+are listed in its `user_params <Component.user_params>` and function_params <Component.function_params>` dictionaries.
 Each ParameterPort is created using the value specified for the corresponding parameter, as described below.  The
 ParameterPorts for the parameters of a Mechanism or Projection are listed in its `parameter_ports` attribute.
 
diff --git a/psyneulink/core/components/ports/port.py b/psyneulink/core/components/ports/port.py
index 8196ab6792c..364b845d0bc 100644
--- a/psyneulink/core/components/ports/port.py
+++ b/psyneulink/core/components/ports/port.py
@@ -2218,7 +2218,7 @@ def _get_compilation_state(self):
         return [self.parameters.function]
 
     def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
-        state_f = ctx.get_llvm_function(self.function)
+        state_f = ctx.import_llvm_function(self.function)
 
         # Create a local copy of the function parameters
         base_params = ctx.get_param_ptr(self, builder, params, self.parameters.function.name)
diff --git a/psyneulink/core/components/process.py b/psyneulink/core/components/process.py
index eee553561aa..23aa7ce3c93 100644
--- a/psyneulink/core/components/process.py
+++ b/psyneulink/core/components/process.py
@@ -2374,7 +2374,7 @@ def _execute_learning(self, context=None, target=None):
 
                     # Not all Projection subclasses instantiate ParameterPorts
                     except AttributeError as e:
-                        if e.args[0] is '_parameter_ports':
+                        if e.args[0] == '_parameter_ports':
                             pass
                         else:
                             raise ProcessError("PROGRAM ERROR: unrecognized attribute (\'{}\') encountered "
diff --git a/psyneulink/core/components/projections/pathway/mappingprojection.py b/psyneulink/core/components/projections/pathway/mappingprojection.py
index 14a5fef5bcd..5f8bfeb2d32 100644
--- a/psyneulink/core/components/projections/pathway/mappingprojection.py
+++ b/psyneulink/core/components/projections/pathway/mappingprojection.py
@@ -328,9 +328,9 @@ class MappingProjection(PathwayProjection_Base):
         receiver=None,         \
         matrix=DEFAULT_MATRIX)
 
-    Subclass of `Projection` that transmits the `value <OutputPort.value>` of the `OutputPort` of one `Mechanism`
-    to the `InputPort` of another (or possibly itself).  See `Projection <Projection_Class_Reference>` for additional
-    arguments and attributes.
+    Subclass of `Projection` that transmits the `value <OutputPort.value>` of the `OutputPort` of one `Mechanism
+    <Mechanism>` to the `InputPort` of another (or possibly itself).  See `Projection <Projection_Class_Reference>`
+    for additional arguments and attributes.
 
     Arguments
     ---------
@@ -637,7 +637,7 @@ def _matrix_spec(self, value):
         # *LEARNING* or *LEARNING_PROJECTION* keyword, LearningProjection subclass, or instance of a LearningPojection
         from psyneulink.core.components.projections.modulatory.learningprojection import LearningProjection
         if (isinstance(self.paramsCurrent[FUNCTION_PARAMS][MATRIX], tuple) and
-                    len(self.paramsCurrent[FUNCTION_PARAMS][MATRIX]) is 2 and
+                    len(self.paramsCurrent[FUNCTION_PARAMS][MATRIX]) == 2 and
                 (self.paramsCurrent[FUNCTION_PARAMS][MATRIX][1] in {LEARNING, LEARNING_PROJECTION}
                  or isinstance(self.paramsCurrent[FUNCTION_PARAMS][MATRIX][1], LearningProjection) or
                      (inspect.isclass(self.paramsCurrent[FUNCTION_PARAMS][MATRIX][1]) and
diff --git a/psyneulink/core/components/projections/projection.py b/psyneulink/core/components/projections/projection.py
index 24f3f2bb965..790e1652fc2 100644
--- a/psyneulink/core/components/projections/projection.py
+++ b/psyneulink/core/components/projections/projection.py
@@ -996,7 +996,7 @@ def parameter_ports(self, value):
     def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
         mf_state = ctx.get_state_ptr(self, builder, state, self.parameters.function.name)
         mf_params = ctx.get_param_ptr(self, builder, params, self.parameters.function.name)
-        main_function = ctx.get_llvm_function(self.function)
+        main_function = ctx.import_llvm_function(self.function)
         builder.call(main_function, [mf_params, mf_state, arg_in, arg_out])
 
         return builder
diff --git a/psyneulink/core/components/system.py b/psyneulink/core/components/system.py
index d6c62acaae5..90c551f632e 100644
--- a/psyneulink/core/components/system.py
+++ b/psyneulink/core/components/system.py
@@ -3876,8 +3876,8 @@ def show_graph(self,
             Processes;  these represent intersections of Processes within the System.
 
         show_mechanism_structure : bool, VALUES, FUNCTIONS or ALL : default False
-            specifies whether or not to show a detailed representation of each `Mechanism` in the graph, including its
-            `Ports`;  can have the following settings:
+            specifies whether or not to show a detailed representation of each `Mechanism <Mechanism>` in the graph,
+            including its `Ports`;  can have the following settings:
 
             * `True` -- shows Ports of Mechanism, but not information about the `value
               <Component.value>` or `function <Component.function>` of the Mechanism or its Ports.
@@ -3953,8 +3953,8 @@ def show_graph(self,
             specifies whether or not to show dimensions of Mechanisms (and/or MappingProjections when show_learning
             is `True`);  can have the following settings:
 
-            * *MECHANISMS* -- shows `Mechanism` input and output dimensions.  Input dimensions are shown in parentheses
-              below the name of the Mechanism; each number represents the dimension of the `variable
+            * *MECHANISMS* -- shows `Mechanism <Mechanism>` input and output dimensions.  Input dimensions are shown
+              in parentheses below the name of the Mechanism; each number represents the dimension of the `variable
               <InputPort.variable>` for each `InputPort` of the Mechanism; Output dimensions are shown above
               the name of the Mechanism; each number represents the dimension for `value <OutputPort.value>` of each
               of `OutputPort` of the Mechanism.
diff --git a/psyneulink/core/compositions/composition.py b/psyneulink/core/compositions/composition.py
index 10755c3f143..bced433f1d3 100644
--- a/psyneulink/core/compositions/composition.py
+++ b/psyneulink/core/compositions/composition.py
@@ -988,11 +988,11 @@ def input_function(env, result):
 =====================================
 
 If execution efficiency is critical and the `AutodiffComposition` is too restrictive, a function from any Python
-environment that supports learning can be assigned as the `function <Mechanism_Base.function>` of a `Mechanism`,
-in which case it is automatically  wrapped as `UserDefinedFunction`.  For example, the `forward and backward methods
-<https://pytorch.org/docs/master/notes/extending.html>`_ of a PyTorch object can be assigned in this way.  The
-advanatage of this approach is that it can be applied to any Python function that adheres to the requirements of a
-`UserDefinedFunction`.  The disadvantage is that it can't be `compiled`, so efficiency may be compromised.  It must
+environment that supports learning can be assigned as the `function <Mechanism_Base.function>` of a `Mechanism
+<Mechanism>`, in which case it is automatically  wrapped as `UserDefinedFunction`.  For example, the `forward and
+backward methods <https://pytorch.org/docs/master/notes/extending.html>`_ of a PyTorch object can be assigned in this
+way.  The advanatage of this approach is that it can be applied to any Python function that adheres to the requirements
+of a `UserDefinedFunction`.  The disadvantage is that it can't be `compiled`, so efficiency may be compromised.  It must
 also be carefully coordinated with the execution of other learning-related Components in the Composition, to insure
 that each function is called at the appropriate times during execution.  Furthermore, as with an `AutodiffComposition`,
 the internal constituents of the object (e.g., intermediates layers of a neural network model) are not accessible to
@@ -1912,12 +1912,12 @@ def _analyze_consideration_queue(self, q, objective_mechanism):
 
     def add_node(self, node, required_roles=None, context=None):
         """
-            Add a Composition Node (`Mechanism` or `Composition`) to the Composition, if it is not already added
+            Add a Composition Node (`Mechanism <Mechanism>` or `Composition`) to Composition, if it is not already added
 
             Arguments
             ---------
 
-            node : `Mechanism` or `Composition`
+            node : `Mechanism <Mechanism>` or `Composition`
                 the node to be added to the Composition
 
             required_roles : `NodeRole` or list of NodeRoles
@@ -2052,13 +2052,13 @@ def add_node(self, node, required_roles=None, context=None):
 
     def add_nodes(self, nodes, required_roles=None):
         """
-            Add a list of Composition Nodes (`Mechanism` or `Composition`) to the Composition,
+            Add a list of Composition Nodes (`Mechanism <Mechanism>` or `Composition`) to the Composition,
 
             Arguments
             ---------
 
             nodes : list
-                the nodes to be added to the Composition.  Each item of the list must be a `Mechanism`,
+                the nodes to be added to the Composition.  Each item of the list must be a `Mechanism <Mechanism>`,
                 a `Composition` or a role-specification tuple with a Mechanism or Composition as the first item,
                 and a `NodeRole` or list of those as the second item;  any NodeRoles in a role-specification tuple
                 are applied in addition to those specified in the **required_roles** argument.
@@ -2148,7 +2148,7 @@ def get_nodes_by_role(self, role):
             List of Composition Nodes with `NodeRole` *role* : List(`Mechanisms <Mechanism>` and
             `Compositions <Composition>`)
         """
-        if role not in NodeRole:
+        if role is None or role not in NodeRole:
             raise CompositionError('Invalid NodeRole: {0}'.format(role))
 
         try:
@@ -4700,8 +4700,8 @@ def show_graph(self,
 
         show_node_structure : bool, VALUES, LABELS, FUNCTIONS, MECH_FUNCTION_PARAMS, STATE_FUNCTION_PARAMS, ROLES, \
         or ALL : default False
-            show a detailed representation of each `Mechanism` in the graph, including its `Ports <Port>`;  can
-            have any of the following settings alone or in a list:
+            show a detailed representation of each `Mechanism <Mechanism>` in the graph, including its `Ports <Port>`;
+            can have any of the following settings alone or in a list:
 
             * `True` -- show Ports of Mechanism, but not information about the `value
               <Component.value>` or `function <Component.function>` of the Mechanism or its Ports.
@@ -4769,8 +4769,8 @@ def show_graph(self,
             <Component.value>` of each Component in the graph (and/or MappingProjections when show_learning
             is `True`);  can have the following settings:
 
-            * *MECHANISMS* -- shows `Mechanism` input and output dimensions.  Input dimensions are shown in parentheses
-              below the name of the Mechanism; each number represents the dimension of the `variable
+            * *MECHANISMS* -- shows `Mechanism <Mechanism>` input and output dimensions.  Input dimensions are shown
+              in parentheses below the name of the Mechanism; each number represents the dimension of the `variable
               <InputPort.variable>` for each `InputPort` of the Mechanism; Output dimensions are shown above
               the name of the Mechanism; each number represents the dimension for `value <OutputPort.value>` of each
               of `OutputPort` of the Mechanism.
@@ -7572,7 +7572,7 @@ def __gen_node_wrapper(self, node):
             context, params, comp_in, data_in, data_out = llvm_func.args[:5]
             cond_ptr = llvm_func.args[-1]
 
-            m_function = ctx.get_llvm_function(node)
+            m_function = ctx.import_llvm_function(node)
 
             if node is self.input_CIM:
                 # if there are incoming modulatory projections,
@@ -7662,7 +7662,7 @@ def __gen_node_wrapper(self, node):
                 # Projections are listed second in param and state structure
                 proj_params = builder.gep(params, [ctx.int32_ty(0), ctx.int32_ty(1), ctx.int32_ty(proj_idx)])
                 proj_context = builder.gep(context, [ctx.int32_ty(0), ctx.int32_ty(1), ctx.int32_ty(proj_idx)])
-                proj_function = ctx.get_llvm_function(proj)
+                proj_function = ctx.import_llvm_function(proj)
 
                 if proj_out.type != proj_function.args[3].type:
                     warnings.warn("Shape mismatch: Projection ({}) results does not match the receiver state({}) input: {} vs. {}".format(proj, proj.receiver, proj.defaults.value, proj.receiver.defaults.variable))
diff --git a/psyneulink/core/globals/keywords.py b/psyneulink/core/globals/keywords.py
index 76f42188469..c43609cb8b4 100644
--- a/psyneulink/core/globals/keywords.py
+++ b/psyneulink/core/globals/keywords.py
@@ -68,12 +68,13 @@
     'LINEAR_MATRIX_FUNCTION', 'LOG_ENTRIES', 'LOGISTIC_FUNCTION', 'LOW', 'LVOC_CONTROL_MECHANISM', 'L0', 'L1',
     'MAKE_DEFAULT_GATING_MECHANISM', 'MAPPING_PROJECTION', 'MAPPING_PROJECTION_PARAMS', 'MASKED_MAPPING_PROJECTION',
     'MATRIX', 'MATRIX_KEYWORD_NAMES', 'MATRIX_KEYWORD_SET', 'MATRIX_KEYWORD_VALUES', 'MATRIX_KEYWORDS','MatrixKeywords',
-    'MAX_ABS_VAL', 'MAX_ABS_INDICATOR', 'MAX_ABS_DIFF', 'MAX_EXECUTIONS_BEFORE_FINISHED', 'MAX_INDICATOR', 'MAX_VAL',
-    'MAYBE', 'MEAN', 'MECHANISM', 'MECHANISM_COMPONENT_CATEGORY', 'MECHANISM_DEFAULT', 'MECHANISM_DEFAULTInputValue',
+    'MAX_ABS_DIFF', 'MAX_ABS_INDICATOR', 'MAX_ONE_HOT', 'MAX_ABS_ONE_HOT', 'MAX_ABS_VAL',
+    'MAX_EXECUTIONS_BEFORE_FINISHED', 'MAX_INDICATOR', 'MAX_VAL', 'MAYBE', 'MEAN',
+    'MECHANISM', 'MECHANISM_COMPONENT_CATEGORY', 'MECHANISM_DEFAULT', 'MECHANISM_DEFAULTInputValue',
     'MECHANISM_DEFAULTParams', 'MECHANISM_EXECUTED_LOG_ENTRY', 'MECHANISM_NAME', 'MECHANISM_PARAM_VALUE',
-    'MECHANISM_TYPE', 'MECHANISM_VALUE', 'MEDIAN',
-    'METRIC', 'MIN_VAL', 'MODE', 'MODULATES','MODULATION', 'MODULATORY_PROJECTION', 'MODULATORY_SIGNAL',
-    'MODULATORY_SIGNALS', 'MONITOR', 'MONITOR_FOR_CONTROL', 'MONITOR_FOR_LEARNING', 'MONITOR_FOR_MODULATION',
+    'MECHANISM_TYPE', 'MECHANISM_VALUE', 'MEDIAN', 'METRIC', 'MIN_VAL', 'MIN_ABS_VAL', 'MIN_ABS_INDICATOR', 'MODE',
+    'MODULATES','MODULATION', 'MODULATORY_PROJECTION', 'MODULATORY_SIGNAL', 'MODULATORY_SIGNALS',
+    'MONITOR', 'MONITOR_FOR_CONTROL', 'MONITOR_FOR_LEARNING', 'MONITOR_FOR_MODULATION',
     'MODEL_SPEC_ID_GENERIC', 'MODEL_SPEC_ID_INPUT_PORTS', 'MODEL_SPEC_ID_OUTPUT_PORTS', 'MODEL_SPEC_ID_PSYNEULINK',
     'MODEL_SPEC_ID_SENDER_MECH', 'MODEL_SPEC_ID_SENDER_PORT', 'MODEL_SPEC_ID_RECEIVER_MECH',
     'MODEL_SPEC_ID_RECEIVER_PORT',
@@ -1000,6 +1001,8 @@ def _is_metric(metric):
 # Note:  These are used only as names of StandardOutputPorts (hence upper case)
 MAX_VAL = 'MAX_VAL'
 MAX_ABS_VAL = 'MAX_ABS_VAL'
+MAX_ONE_HOT = 'MAX_ONE_HOT'
+MAX_ABS_ONE_HOT = 'MAX_ABS_ONE_HOT'
 MAX_INDICATOR = 'MAX_INDICATOR'
 MAX_ABS_INDICATOR = 'MAX_ABS_INDICATOR'
 MIN_VAL = 'MIN_VAL'
diff --git a/psyneulink/core/globals/log.py b/psyneulink/core/globals/log.py
index 53ceae7bf0f..65286e95f35 100644
--- a/psyneulink/core/globals/log.py
+++ b/psyneulink/core/globals/log.py
@@ -327,7 +327,7 @@
 
 Entry values are added by the setter method for the attribute being logged.
 
-The following entries are automatically included in the `loggable_items` of a `Mechanism` object:
+The following entries are automatically included in the `loggable_items` of a `Mechanism <Mechanism>` object:
     - the `value <Mechanism_Base.value>` of the Mechanism;
     - the value attribute of every Port for which the Mechanism is an owner
     - value of every projection that sends to those Ports]
diff --git a/psyneulink/core/globals/parameters.py b/psyneulink/core/globals/parameters.py
index 42cf908c124..66c4f99fc62 100644
--- a/psyneulink/core/globals/parameters.py
+++ b/psyneulink/core/globals/parameters.py
@@ -352,7 +352,7 @@ def __iter__(self):
         return iter([getattr(self, k) for k in self.values(show_all=True).keys()])
 
     def _is_parameter(self, param_name):
-        if param_name[0] is '_':
+        if param_name[0] == '_':
             return False
         else:
             try:
@@ -484,8 +484,8 @@ class Parameter(types.SimpleNamespace):
             :default: True
 
         modulable
-            if True, the parameter can be modulated; if the Parameter belongs to a `Mechanism` or `Projection`,
-            it is assigned a `ParameterPort`.
+            if True, the parameter can be modulated; if the Parameter belongs to a `Mechanism <Mechanism>` or
+            `Projection <Projection>`, it is assigned a `ParameterPort`.
 
             :default: False
 
diff --git a/psyneulink/core/globals/preferences/preferenceset.py b/psyneulink/core/globals/preferences/preferenceset.py
index 958d7a6c2e2..5717e6423fa 100644
--- a/psyneulink/core/globals/preferences/preferenceset.py
+++ b/psyneulink/core/globals/preferences/preferenceset.py
@@ -641,7 +641,8 @@ def validate_log(self, candidate_log_item, pref_set):
                 if OK:
                     continue
                 # Skip validation of value of these, as they may differ for different LogEntry classes
-                elif (log_entry_attribute is 'ALL' or log_entry_attribute is 'DEFAULTS'):
+                elif (log_entry_attribute == 'ALL' or
+                      log_entry_attribute == 'DEFAULTS'):
                     continue
                 else:
                     # Value of attribute from candidate's LogEntry does not match the value in Globals.Log.LogEntry
diff --git a/psyneulink/core/globals/utilities.py b/psyneulink/core/globals/utilities.py
index 9e8a857e285..3797b7a9f87 100644
--- a/psyneulink/core/globals/utilities.py
+++ b/psyneulink/core/globals/utilities.py
@@ -157,12 +157,12 @@ def is_modulation_operation(val):
     return get_modulationOperation_name(val)
 
 def get_modulationOperation_name(operation):
-        x = operation(1,2)
-        if x is 1:
+        x = operation(1, 2)
+        if x == 1:
             return MODULATION_OVERRIDE
-        elif x is 2:
+        elif x == 2:
             return MODULATION_MULTIPLY
-        elif x is 3:
+        elif x == 3:
             return MODULATION_ADD
         else:
             return False
@@ -914,7 +914,7 @@ def convert_to_np_array(value, dimension):
     if value is None:
         return None
 
-    if dimension is 1:
+    if dimension == 1:
         # KAM 6/28/18: added for cases when even np does not recognize the shape/dtype
         # Needed this specifically for the following shape: variable = [[0.0], [0.0], np.array([[0.0, 0.0]])]
         # Which is due to a custom OutputPort variable that includes an owner value, owner param, and owner input
@@ -931,7 +931,7 @@ def convert_to_np_array(value, dimension):
         except ValueError:
             return value
 
-    elif dimension is 2:
+    elif dimension == 2:
         from numpy import ndarray
         # if isinstance(value, ndarray) and value.dtype==object and len(value) == 2:
         value = np.array(value)
@@ -1071,8 +1071,8 @@ class ContentAddressableList(UserList):
 
     The key with which it is created is also assigned as a property of the class, that returns a list
     with the keyed attribute of its entries.  For example, the `output_ports <Mechanism_Base.output_ports>` attribute
-    of a `Mechanism` is a ContentAddressableList of the Mechanism's `OutputPorts <OutputPort>`, keyed by their
-    names.  Therefore, ``my_mech.output_ports.names`` returns the names of all of the Mechanism's OutputPorts::
+    of a `Mechanism <Mechanism>` is a ContentAddressableList of the Mechanism's `OutputPorts <OutputPort>`, keyed by
+    their names.  Therefore, ``my_mech.output_ports.names`` returns the names of all of the Mechanism's OutputPorts::
 
         >>> import psyneulink as pnl
         >>> print(pnl.DDM().output_ports.names)
@@ -1493,10 +1493,11 @@ def flatten_list(l):
     return [item for sublist in l for item in sublist]
 
 
-_seed = int(time.monotonic())
+_seed = np.int32((time.time() * 1000) % 2**31)
 def get_global_seed(offset=1):
     global _seed
     _seed += offset
+    _seed %= 2**31
     return _seed - offset
 
 
diff --git a/psyneulink/core/llvm/__init__.py b/psyneulink/core/llvm/__init__.py
index 38edb2bf3f3..980786ab16b 100644
--- a/psyneulink/core/llvm/__init__.py
+++ b/psyneulink/core/llvm/__init__.py
@@ -11,6 +11,7 @@
 import ctypes
 import functools
 import numpy as np
+from typing import Set
 
 from llvmlite import ir
 
@@ -25,7 +26,7 @@
 __all__ = ['LLVMBuilderContext']
 
 
-_compiled_modules = set()
+_compiled_modules: Set[ir.Module] = set()
 _binary_generation = 0
 
 
@@ -49,63 +50,37 @@ def _llvm_build(target_generation=_binary_generation + 1):
 
 
 class LLVMBinaryFunction:
-    def __init__(self, name):
+    def __init__(self, name: str):
         self.name = name
 
         self.__c_func = None
-        self.__c_func_type = None
-        self.__byref_arg_types = None
-
         self.__cuda_kernel = None
 
-    def _init_host_func_type(self):
         # Function signature
         f = _find_llvm_function(self.name, _compiled_modules)
 
+        # Create ctype function instance
         return_type = _convert_llvm_ir_to_ctype(f.return_value.type)
-        params = []
-        self.__byref_arg_types = []
-        for a in f.args:
-            param_type = _convert_llvm_ir_to_ctype(a.type)
-            if type(a.type) is ir.PointerType:
-                # remember pointee type for easier initialization
-                byref_type = _convert_llvm_ir_to_ctype(a.type.pointee)
-            else:
-                byref_type = None
-
-            self.__byref_arg_types.append(byref_type)
-            params.append(param_type)
+        params = [_convert_llvm_ir_to_ctype(a.type) for a in f.args]
         self.__c_func_type = ctypes.CFUNCTYPE(return_type, *params)
 
-    def __call__(self, *args, **kwargs):
-        return self.c_func(*args, **kwargs)
-
-    def wrap_call(self, *pargs):
-        #print(pargs)
-        cpargs = (ctypes.byref(p) if p is not None else None for p in pargs)
-        args = zip(cpargs, self.byref_arg_types)
-        cargs = (ctypes.cast(p, ctypes.POINTER(t)) for p, t in args)
-        self(*tuple(cargs))
-
-    @property
-    def byref_arg_types(self):
-        if self.__byref_arg_types is None:
-            self._init_host_func_type()
-        return self.__byref_arg_types
-
-    @property
-    def _c_func_type(self):
-        if self.__c_func_type is None:
-            self._init_host_func_type()
-        return self.__c_func_type
+        self.byref_arg_types = [p._type_ for p in params]
 
     @property
     def c_func(self):
         if self.__c_func is None:
             ptr = _cpu_engine._engine.get_function_address(self.name)
-            self.__c_func = self._c_func_type(ptr)
+            self.__c_func = self.__c_func_type(ptr)
         return self.__c_func
 
+    def __call__(self, *args, **kwargs):
+        return self.c_func(*args, **kwargs)
+
+    def wrap_call(self, *pargs):
+        cpargs = (ctypes.byref(p) if p is not None else None for p in pargs)
+        args = zip(cpargs, self.c_func.argtypes)
+        self(*(ctypes.cast(p, t) for p, t in args))
+
     @property
     def _cuda_kernel(self):
         if self.__cuda_kernel is None:
@@ -127,7 +102,7 @@ def from_obj(obj):
 
     @staticmethod
     @functools.lru_cache(maxsize=32)
-    def get(name):
+    def get(name: str):
         _llvm_build(LLVMBuilderContext._llvm_generation)
         return LLVMBinaryFunction(name)
 
diff --git a/psyneulink/core/llvm/builder_context.py b/psyneulink/core/llvm/builder_context.py
index 4064eabfc8a..83657b2e491 100644
--- a/psyneulink/core/llvm/builder_context.py
+++ b/psyneulink/core/llvm/builder_context.py
@@ -18,6 +18,7 @@
 import numpy as np
 import os
 import re
+from typing import Set
 import weakref
 try:
     import torch
@@ -35,8 +36,8 @@
 __all__ = ['LLVMBuilderContext', '_modules', '_find_llvm_function']
 
 
-_modules = set()
-_all_modules = set()
+_modules: Set[ir.Module] = set()
+_all_modules: Set[ir.Module] = set()
 _struct_count = 0
 
 
@@ -47,24 +48,22 @@ def module_count():
         print("Total structures generated: ", _struct_count)
 
 
-# TODO: Should this be selectable?
-_int32_ty = ir.IntType(32)
-_float_ty = ir.DoubleType()
-_global_context = None
-
 _BUILTIN_PREFIX = "__pnl_builtin_"
 _builtin_intrinsics = frozenset(('pow', 'log', 'exp', 'printf'))
 
+
 class LLVMBuilderContext:
-    uniq_counter = 0
+    __global_context = None
+    __uniq_counter = 0
     _llvm_generation = 0
+    int32_ty = ir.IntType(32)
+    float_ty = ir.DoubleType()
 
     def __init__(self):
-        self.int32_ty = _int32_ty
-        self.float_ty = _float_ty
         self._modules = []
         self._cache = weakref.WeakKeyDictionary()
         self._learningcache = weakref.WeakKeyDictionary()
+
     def __enter__(self):
         module = ir.Module(name="PsyNeuLinkModule-" + str(LLVMBuilderContext._llvm_generation))
         self._modules.append(module)
@@ -82,21 +81,21 @@ def module(self):
         assert len(self._modules) > 0
         return self._modules[-1]
 
-    @staticmethod
-    def get_global():
-        global _global_context
-        if _global_context is None:
-            _global_context = LLVMBuilderContext()
-        return _global_context
-
-    def get_unique_name(self, name: str):
-        LLVMBuilderContext.uniq_counter += 1
+    @classmethod
+    def get_global(cls):
+        if cls.__global_context is None:
+            cls.__global_context = LLVMBuilderContext()
+        return cls.__global_context
+
+    @classmethod
+    def get_unique_name(cls, name: str):
+        cls.__uniq_counter += 1
         name = re.sub(r"[- ()\[\]]", "_", name)
-        return name + '_' + str(LLVMBuilderContext.uniq_counter)
+        return name + '_' + str(cls.__uniq_counter)
 
     def get_builtin(self, name: str, args=[], function_type=None):
         if name in _builtin_intrinsics:
-            return self.get_llvm_function(_BUILTIN_PREFIX + name)
+            return self.import_llvm_function(_BUILTIN_PREFIX + name)
         if name in ('maxnum'):
             function_type = pnlvm.ir.FunctionType(args[0], [args[0], args[0]])
         return self.module.declare_intrinsic("llvm." + name, args, function_type)
@@ -125,7 +124,7 @@ def create_llvm_function(self, args, component, name=None, return_type=ir.VoidTy
 
         return builder
 
-    def gen_llvm_function(self, obj):
+    def gen_llvm_function(self, obj) -> ir.Function:
         cache = self._cache
         try:
             # HACK: allows for learning bin func and non-learning to differ
@@ -133,12 +132,16 @@ def gen_llvm_function(self, obj):
                 cache = self._learningcache
         except AttributeError as e:
             pass
-            
+
         if obj not in cache:
             cache[obj] = obj._gen_llvm_function()
         return cache[obj]
 
-    def get_llvm_function(self, name):
+    def import_llvm_function(self, name) -> ir.Function:
+        """
+        Get function handle if function exists in current modele.
+        Create function declaration if it exists in a older module.
+        """
         try:
             f = self.gen_llvm_function(name)
         except AttributeError:
@@ -267,14 +270,13 @@ def inject_printf(self, builder, fmt, *args, override_debug=False):
 
         builder.call(stack_restore, [old_stack])
 
-
     def inject_printf_float_array(self, builder, array, prefix="", suffix="\n", override_debug=False):
-        self.inject_printf(builder,prefix,override_debug=override_debug)
+        self.inject_printf(builder, prefix, override_debug=override_debug)
 
         with pnlvm.helpers.array_ptr_loop(builder, array, "print_array_loop") as (b1, i):
             self.inject_printf(b1, "%f ", b1.load(b1.gep(array, [self.int32_ty(0), i])), override_debug=override_debug)
 
-        self.inject_printf(builder,suffix,override_debug=override_debug)
+        self.inject_printf(builder, suffix, override_debug=override_debug)
 
     @contextmanager
     def _gen_composition_exec_context(self, composition, simulation=False, suffix=""):
@@ -322,18 +324,17 @@ def gen_autodiffcomp_learning_exec(self, composition, simulation=False):
         pytorch_model = composition.parameters.pytorch_representation.get(composition.default_execution_id)
         with self._gen_composition_exec_context(composition, simulation, "_learning") as (builder, data, params, cond_gen):
             state, _, comp_in, _, cond = builder.function.args
-        
+
             pytorch_model._gen_llvm_training_function_body(self, builder, state,
                                                            params, comp_in, data)
             # Call output CIM
             output_cim_w = composition._get_node_wrapper(composition.output_CIM)
-            output_cim_f = self.get_llvm_function(output_cim_w)
+            output_cim_f = self.import_llvm_function(output_cim_w)
             builder.block.name = "invoke_" + output_cim_f.name
             builder.call(output_cim_f, [state, params, comp_in, data, data])
 
             return builder.function
 
-
     def gen_autodiffcomp_exec(self, composition, simulation=False):
         """Creates llvm bin execute for autodiffcomp"""
         assert composition.controller is None
@@ -343,7 +344,7 @@ def gen_autodiffcomp_exec(self, composition, simulation=False):
             state, _, comp_in, _, cond = builder.function.args
             # Call input CIM
             input_cim_w = composition._get_node_wrapper(composition.input_CIM)
-            input_cim_f = self.get_llvm_function(input_cim_w)
+            input_cim_f = self.import_llvm_function(input_cim_w)
 
             builder.call(input_cim_f, [state, params, comp_in, data, data])
 
@@ -359,13 +360,13 @@ def gen_autodiffcomp_exec(self, composition, simulation=False):
                                              self.int32_ty(input_cim_idx)])
             model_output = builder.gep(data, [self.int32_ty(0)])
 
-            pytorch_forward_func = self.get_llvm_function(pytorch_model)
+            pytorch_forward_func = self.import_llvm_function(pytorch_model)
             builder.call(pytorch_forward_func, [state, model_params,
                                                 model_input, model_output])
 
             # Call output CIM
             output_cim_w = composition._get_node_wrapper(composition.output_CIM)
-            output_cim_f = self.get_llvm_function(output_cim_w)
+            output_cim_f = self.import_llvm_function(output_cim_w)
             builder.block.name = "invoke_" + output_cim_f.name
             builder.call(output_cim_f, [state, params, comp_in, data, data])
 
@@ -376,19 +377,19 @@ def gen_composition_exec(self, composition, simulation=False):
             state, _, comp_in, _, cond = builder.function.args
             # Call input CIM
             input_cim_w = composition._get_node_wrapper(composition.input_CIM)
-            input_cim_f = self.get_llvm_function(input_cim_w)
+            input_cim_f = self.import_llvm_function(input_cim_w)
             builder.call(input_cim_f, [state, params, comp_in, data, data])
 
             # Call parameter CIM
             param_cim_w = composition._get_node_wrapper(composition.parameter_CIM)
-            param_cim_f = self.get_llvm_function(param_cim_w)
+            param_cim_f = self.import_llvm_function(param_cim_w)
             builder.call(param_cim_f, [state, params, comp_in, data, data])
 
             if simulation is False and composition.enable_controller and \
                composition.controller_mode == BEFORE:
                 assert composition.controller is not None
                 controller = composition._get_node_wrapper(composition.controller)
-                controller_f = self.get_llvm_function(controller)
+                controller_f = self.import_llvm_function(controller)
                 builder.call(controller_f, [state, params, comp_in, data, data])
 
             # Allocate run set structure
@@ -407,9 +408,9 @@ def gen_composition_exec(self, composition, simulation=False):
 
             # Generate a while not 'end condition' loop
             builder.position_at_end(loop_condition)
-            run_cond = cond_gen.generate_sched_condition(builder,
-                            composition.termination_processing[TimeScale.TRIAL],
-                            cond, None)
+            run_cond = cond_gen.generate_sched_condition(
+                builder, composition.termination_processing[TimeScale.TRIAL],
+                cond, None)
             run_cond = builder.not_(run_cond, name="not_run_cond")
 
             loop_body = builder.append_basic_block(name="scheduling_loop_body")
@@ -427,9 +428,9 @@ def gen_composition_exec(self, composition, simulation=False):
                 run_set_mech_ptr = builder.gep(run_set_ptr,
                                                [zero, self.int32_ty(idx)],
                                                name="run_cond_ptr_" + mech.name)
-                mech_cond = cond_gen.generate_sched_condition(builder,
-                                composition._get_processing_condition_set(mech),
-                                cond, mech)
+                mech_cond = cond_gen.generate_sched_condition(
+                    builder, composition._get_processing_condition_set(mech),
+                    cond, mech)
                 ran = cond_gen.generate_ran_this_pass(builder, cond, mech)
                 mech_cond = builder.and_(mech_cond, builder.not_(ran),
                                          name="run_cond_" + mech.name)
@@ -441,7 +442,7 @@ def gen_composition_exec(self, composition, simulation=False):
                 mech_cond = builder.load(run_set_mech_ptr, name="mech_" + mech.name + "_should_run")
                 with builder.if_then(mech_cond):
                     mech_w = composition._get_node_wrapper(mech)
-                    mech_f = self.get_llvm_function(mech_w)
+                    mech_f = self.import_llvm_function(mech_w)
                     builder.block.name = "invoke_" + mech_f.name
                     # Wrappers do proper indexing of all structures
                     if len(mech_f.args) == 5:  # Mechanism wrappers have 5 inputs
@@ -492,12 +493,12 @@ def gen_composition_exec(self, composition, simulation=False):
                composition.controller_mode == AFTER:
                 assert composition.controller is not None
                 controller = composition._get_node_wrapper(composition.controller)
-                controller_f = self.get_llvm_function(controller)
+                controller_f = self.import_llvm_function(controller)
                 builder.call(controller_f, [state, params, comp_in, data, data])
 
             # Call output CIM
             output_cim_w = composition._get_node_wrapper(composition.output_CIM)
-            output_cim_f = self.get_llvm_function(output_cim_w)
+            output_cim_f = self.import_llvm_function(output_cim_w)
             builder.block.name = "invoke_" + output_cim_f.name
             builder.call(output_cim_f, [state, params, comp_in, data, data])
 
@@ -556,7 +557,7 @@ def gen_composition_run(self, composition, simulation=False, learning=False):
         if learning:
             # Call training function
             data_in_ptr = builder.gep(data_in, [self.int32_ty(0)])
-            exec_learning_f = self.get_llvm_function(composition)
+            exec_learning_f = self.import_llvm_function(composition)
             builder.call(exec_learning_f, [state, params, data_in_ptr, data, cond])
 
         runs = builder.load(runs_ptr, "runs")
@@ -564,14 +565,14 @@ def gen_composition_run(self, composition, simulation=False, learning=False):
             # Get the right input stimulus
             input_idx = b.urem(iters, b.load(inputs_ptr))
             data_in_ptr = b.gep(data_in, [input_idx])
-        
+
             # Call execution
             if learning:
                 composition.learning_enabled = False
             if simulation:
-                exec_f = self.get_llvm_function(composition._llvm_simulation.name)
+                exec_f = self.import_llvm_function(composition._llvm_simulation.name)
             else:
-                exec_f = self.get_llvm_function(composition)
+                exec_f = self.import_llvm_function(composition)
             if learning:
                 composition.learning_enabled = True
             b.call(exec_f, [state, params, data_in_ptr, data, cond])
@@ -608,7 +609,6 @@ def gen_multirun_wrapper(self, function: ir.Function) -> ir.Function:
             runs_count = builder.load(multirun_f.args[5])
             input_count = builder.load(multirun_f.args[6])
 
-
         with pnlvm.helpers.for_loop_zero_inc(builder, multi_runs, "multi_run_loop") as (b, index):
             # Index all pointer arguments
             indexed_args = []
@@ -650,7 +650,7 @@ def convert_python_struct_to_llvm_ir(self, t):
             return ir.LiteralStructType([])
         elif isinstance(t, np.random.RandomState):
             return pnlvm.builtins.get_mersenne_twister_state_struct(self)
-        elif torch_available and isinstance(t,torch.Tensor):
+        elif torch_available and isinstance(t, torch.Tensor):
             return self.convert_python_struct_to_llvm_ir(t.numpy())
         assert False, "Don't know how to convert {}".format(type(t))
 
@@ -718,7 +718,7 @@ def _gen_cuda_kernel_wrapper_module(function):
 
 
 @functools.lru_cache(maxsize=128)
-def _convert_llvm_ir_to_ctype(t):
+def _convert_llvm_ir_to_ctype(t: ir.Type):
     type_t = type(t)
 
     if type_t is ir.VoidType:
@@ -735,7 +735,6 @@ def _convert_llvm_ir_to_ctype(t):
     elif type_t is ir.FloatType:
         return ctypes.c_float
     elif type_t is ir.PointerType:
-        # FIXME: Can this handle void*? Do we care?
         pointee = _convert_llvm_ir_to_ctype(t.pointee)
         ret_t = ctypes.POINTER(pointee)
     elif type_t is ir.ArrayType:
diff --git a/psyneulink/core/llvm/builtins.py b/psyneulink/core/llvm/builtins.py
index 2328269196f..2b57bc830e0 100644
--- a/psyneulink/core/llvm/builtins.py
+++ b/psyneulink/core/llvm/builtins.py
@@ -39,7 +39,6 @@ def setup_vxm(ctx):
     builder = _setup_builtin_func_builder(ctx, "vxm", (double_ptr_ty, double_ptr_ty, ctx.int32_ty, ctx.int32_ty, double_ptr_ty))
     v, m, x, y, o = builder.function.args
 
-
     # zero the output array
     with helpers.for_loop_zero_inc(builder, y, "zero") as (b1, index):
         ptr = b1.gep(o, [index])
@@ -87,7 +86,7 @@ def setup_vxm_transposed(ctx):
     # Multiplication
     with helpers.for_loop_zero_inc(builder, x, "trans_vxm_outer") as (b1, index_j):
         with helpers.for_loop_zero_inc(b1, y, "trans_vxm_inner") as (b2, index_i):
-            
+
             # Multiplication and accumulation
             vector_ptr = builder.gep(v, [index_i])
             matrix_index = builder.mul(index_j, y)
@@ -109,9 +108,9 @@ def setup_vxm_transposed(ctx):
 
 # Setup vector addition builtin
 def setup_vec_add(ctx):
-     # Setup types
+    # Setup types
     double_ptr_ty = ctx.float_ty.as_pointer()
-    
+
     # builtin vector addition func
     # param1: ptr to vector 1
     # param2: ptr to vector 2
@@ -127,8 +126,8 @@ def setup_vec_add(ctx):
         o_ptr = b1.gep(o, [index])
         u_val = b1.load(u_ptr)
         v_val = b1.load(v_ptr)
-        
-        u_v_sum = b1.fadd(u_val,v_val)
+
+        u_v_sum = b1.fadd(u_val, v_val)
         b1.store(u_v_sum, o_ptr)
 
     builder.ret_void()
@@ -136,9 +135,9 @@ def setup_vec_add(ctx):
 
 # Setup vector copy builtin
 def setup_vec_copy(ctx):
-     # Setup types
+    # Setup types
     double_ptr_ty = ctx.float_ty.as_pointer()
-    
+
     # builtin vector copy func
     # param1: ptr to vector 1
     # param2: sizeof vector
@@ -151,7 +150,7 @@ def setup_vec_copy(ctx):
         u_ptr = b1.gep(u, [index])
         o_ptr = b1.gep(o, [index])
         u_val = b1.load(u_ptr)
-        
+
         b1.store(u_val, o_ptr)
 
     builder.ret_void()
@@ -161,7 +160,7 @@ def setup_vec_copy(ctx):
 def setup_vec_sub(ctx):
     # Setup types
     double_ptr_ty = ctx.float_ty.as_pointer()
-   
+
     # builtin vector addition func
     # param1: ptr to vector 1
     # param2: ptr to vector 2
@@ -177,8 +176,8 @@ def setup_vec_sub(ctx):
         o_ptr = b1.gep(o, [index])
         u_val = b1.load(u_ptr)
         v_val = b1.load(v_ptr)
-       
-        u_v_sum = b1.fsub(u_val,v_val)
+
+        u_v_sum = b1.fsub(u_val, v_val)
         b1.store(u_v_sum, o_ptr)
 
     builder.ret_void()
@@ -188,7 +187,7 @@ def setup_vec_sub(ctx):
 def setup_vec_hadamard(ctx):
     # Setup types
     double_ptr_ty = ctx.float_ty.as_pointer()
-   
+
     # builtin vector addition func
     # param1: ptr to vector 1
     # param2: ptr to vector 2
@@ -199,13 +198,13 @@ def setup_vec_hadamard(ctx):
 
     # Hadamard
     with helpers.for_loop_zero_inc(builder, x, "mult") as (b1, index):
-        u_ptr = b1.gep(u,[index])
-        v_ptr = b1.gep(v,[index])
+        u_ptr = b1.gep(u, [index])
+        v_ptr = b1.gep(v, [index])
         o_ptr = b1.gep(o, [index])
         u_val = b1.load(u_ptr)
         v_val = b1.load(v_ptr)
-       
-        u_v_product = b1.fmul(u_val,v_val)
+
+        u_v_product = b1.fmul(u_val, v_val)
         b1.store(u_v_product, o_ptr)
 
     builder.ret_void()
@@ -214,25 +213,25 @@ def setup_vec_hadamard(ctx):
 # vec multiply by scalar constant
 def setup_vec_scalar_mult(ctx):
     # Setup types
-   double_ptr_ty = ctx.float_ty.as_pointer()
-   
-   # builtin vector addition func
-   # param1: ptr to vector 1
-   # param2: scalar to multiply by
-   # param3: sizeof vectors (must be the same)
-   # param4: ptr to output vector (make sure this is same size as param3)
-   builder = _setup_builtin_func_builder(ctx, "vec_scalar_mult", (double_ptr_ty, ctx.float_ty, ctx.int32_ty, double_ptr_ty))
-   u, s, x, o = builder.function.args
-
-   # mult
-   with helpers.for_loop_zero_inc(builder, x, "scalar_mult_loop") as (b1, index):
-       u_ptr = b1.gep(u, [index])
-       o_ptr = b1.gep(o, [index])
-       u_val = b1.load(u_ptr)
-       u_product = b1.fmul(u_val, s)
-       b1.store(u_product, o_ptr)
-
-   builder.ret_void()
+    double_ptr_ty = ctx.float_ty.as_pointer()
+
+    # builtin vector addition func
+    # param1: ptr to vector 1
+    # param2: scalar to multiply by
+    # param3: sizeof vectors (must be the same)
+    # param4: ptr to output vector (make sure this is same size as param3)
+    builder = _setup_builtin_func_builder(ctx, "vec_scalar_mult", (double_ptr_ty, ctx.float_ty, ctx.int32_ty, double_ptr_ty))
+    u, s, x, o = builder.function.args
+
+    # mult
+    with helpers.for_loop_zero_inc(builder, x, "scalar_mult_loop") as (b1, index):
+        u_ptr = b1.gep(u, [index])
+        o_ptr = b1.gep(o, [index])
+        u_val = b1.load(u_ptr)
+        u_product = b1.fmul(u_val, s)
+        b1.store(u_product, o_ptr)
+
+    builder.ret_void()
 
 
 # hadamard multiplication for matrices
@@ -247,20 +246,20 @@ def setup_mat_scalar_mult(ctx):
     # param4: dim_y of matrix
     # param5: output ptr
     builder = _setup_builtin_func_builder(ctx, "mat_scalar_mult", (double_ptr_ty, ctx.float_ty, ctx.int32_ty, ctx.int32_ty, double_ptr_ty))
-    m1, s, dim_x, dim_y, o  = builder.function.args
+    m1, s, dim_x, dim_y, o = builder.function.args
 
     with helpers.for_loop_zero_inc(builder, dim_x, "zero") as (b1, x):
         with helpers.for_loop_zero_inc(b1, dim_y, "zero_inner") as (b2, y):
             matrix_index = b2.mul(x, dim_y)
             matrix_index = b2.add(matrix_index, y)
-            
+
             m1_ptr = b2.gep(m1, [matrix_index])
             o_ptr = b2.gep(o, [matrix_index])
-            
+
             m1_val = b2.load(m1_ptr)
-            o_val = b2.fmul(s,m1_val)
+            o_val = b2.fmul(s, m1_val)
 
-            b2.store(o_val,o_ptr)
+            b2.store(o_val, o_ptr)
 
     builder.ret_void()
 
@@ -277,20 +276,20 @@ def setup_mat_scalar_add(ctx):
     # param4: dim_y of matrix
     # param5: output ptr
     builder = _setup_builtin_func_builder(ctx, "mat_scalar_add", (double_ptr_ty, ctx.float_ty, ctx.int32_ty, ctx.int32_ty, double_ptr_ty))
-    m1, s, dim_x, dim_y, o  = builder.function.args
+    m1, s, dim_x, dim_y, o = builder.function.args
 
     with helpers.for_loop_zero_inc(builder, dim_x, "mat_scalar_add_outer") as (b1, x):
         with helpers.for_loop_zero_inc(b1, dim_y, "mat_scalar_add_inner") as (b2, y):
             matrix_index = b2.mul(x, dim_y)
             matrix_index = b2.add(matrix_index, y)
-            
+
             m1_ptr = b2.gep(m1, [matrix_index])
             o_ptr = b2.gep(o, [matrix_index])
-            
+
             m1_val = b2.load(m1_ptr)
-            o_val = b2.fadd(s,m1_val)
+            o_val = b2.fadd(s, m1_val)
 
-            b2.store(o_val,o_ptr)
+            b2.store(o_val, o_ptr)
 
     builder.ret_void()
 
@@ -319,8 +318,8 @@ def setup_mat_hadamard(ctx):
 
             m1_val = b2.load(m1_ptr)
             m2_val = b2.load(m2_ptr)
-            o_val = b2.fmul(m1_val,m2_val)
-            b2.store(o_val,o_ptr)
+            o_val = b2.fmul(m1_val, m2_val)
+            b2.store(o_val, o_ptr)
 
     builder.ret_void()
 
@@ -349,8 +348,8 @@ def setup_mat_sub(ctx):
 
             m1_val = b2.load(m1_ptr)
             m2_val = b2.load(m2_ptr)
-            o_val = b2.fsub(m1_val,m2_val)
-            b2.store(o_val,o_ptr)
+            o_val = b2.fsub(m1_val, m2_val)
+            b2.store(o_val, o_ptr)
 
     builder.ret_void()
 
@@ -379,8 +378,8 @@ def setup_mat_add(ctx):
 
             m1_val = b2.load(m1_ptr)
             m2_val = b2.load(m2_ptr)
-            o_val = b2.fadd(m1_val,m2_val)
-            b2.store(o_val,o_ptr)
+            o_val = b2.fadd(m1_val, m2_val)
+            b2.store(o_val, o_ptr)
 
     builder.ret_void()
 
@@ -719,7 +718,7 @@ def _setup_mt_rand_float(ctx, state_ty, gen_int):
     val = builder.fadd(val, bf)                                # Combine
     val = builder.fdiv(val, ctx.float_ty(9007199254740992.0))  # Scale
 
-    # The value is in interval [0,1)
+    # The value is in interval [0, 1)
     lower_bound = builder.fcmp_ordered(">=", val, val.type(0.0))
     builder.assume(lower_bound)
     upper_bound = builder.fcmp_ordered("<", val, val.type(1.0))
diff --git a/psyneulink/core/llvm/debug.py b/psyneulink/core/llvm/debug.py
index b5bc76256f9..4a902ec94f1 100644
--- a/psyneulink/core/llvm/debug.py
+++ b/psyneulink/core/llvm/debug.py
@@ -42,11 +42,12 @@
 """
 
 import os
+from typing import Any, Dict
 
-debug_env = dict()
+debug_env: Dict[str, Any] = dict()
 
 
-def _update():
+def _update() -> None:
     """Update debug_env variable with the latest state of PNL_LLVM_DEBUG env var."""
     global debug_env
     debug_env.clear()
diff --git a/psyneulink/core/llvm/execution.py b/psyneulink/core/llvm/execution.py
index 23d815a8446..7c7798949e1 100644
--- a/psyneulink/core/llvm/execution.py
+++ b/psyneulink/core/llvm/execution.py
@@ -189,7 +189,7 @@ def execute(self, variable):
         new_variable = np.asfarray(variable)
 
         if len(self._execution_ids) > 1:
-            # wrap_call casts the arguments so we only need contiguaous data
+            # wrap_call casts the arguments so we only need contiguous data
             # layout
             ct_vi = np.ctypeslib.as_ctypes(new_variable)
             self._bin_multirun.wrap_call(self._param_struct,
@@ -418,8 +418,8 @@ def execute_node(self, node, inputs=None, context=None):
         if node is not self._composition.input_CIM and self.__frozen_vals is None:
             self.freeze_values()
 
-        self._bin_func.wrap_call(self._state_struct, self._param_struct,
-                                 inputs, self.__frozen_vals, self._data_struct)
+        self._bin_func(self._state_struct, self._param_struct,
+                       inputs, self.__frozen_vals, self._data_struct)
 
         if "comp_node_debug" in self.__debug_env:
             print("RAN: {}. CTX: {}".format(node, self.extract_node_state(node)))
@@ -450,10 +450,10 @@ def execute(self, inputs):
                                                 self._data_struct,
                                                 self._conditions, self._ct_len)
         else:
-            self._bin_exec_func.wrap_call(self._state_struct,
-                                          self._param_struct,
-                                          self._get_input_struct(inputs),
-                                          self._data_struct, self._conditions)
+            self._bin_exec_func(self._state_struct,
+                                self._param_struct,
+                                self._get_input_struct(inputs),
+                                self._data_struct, self._conditions)
 
     def cuda_execute(self, inputs):
         # NOTE: Make sure that input struct generation is inlined.
@@ -507,6 +507,7 @@ def _initialize_autodiff_param_struct(self, autodiff_stimuli):
 
         # autodiff_values keeps the ctype values on the stack, so it doesn't get gc'd
         autodiff_values = []
+
         def make_node_data(dictionary, node):
             values = dictionary[node]
             assert len(values) == num_trials
@@ -534,10 +535,10 @@ def make_node_data(dictionary, node):
 
         return autodiff_values
 
-    def run(self, inputs, runs, num_input_sets, autodiff_stimuli={"targets" : {}, "epochs": 1}):
+    def run(self, inputs, runs, num_input_sets, autodiff_stimuli={"targets": {}, "epochs": 1}):
         inputs = self._get_run_input_struct(inputs, num_input_sets)
         # Special casing for autodiff
-        if hasattr(self._composition,"learning_enabled") and self._composition.learning_enabled is True:
+        if hasattr(self._composition, "learning_enabled") and self._composition.learning_enabled is True:
             assert num_input_sets == len(next(iter(autodiff_stimuli["inputs"].values())))
             assert num_input_sets == len(next(iter(autodiff_stimuli["targets"].values())))
             keep_on_stack = self._initialize_autodiff_param_struct(autodiff_stimuli)
diff --git a/psyneulink/core/llvm/helpers.py b/psyneulink/core/llvm/helpers.py
index f9ea8243ff3..197cbe83a64 100644
--- a/psyneulink/core/llvm/helpers.py
+++ b/psyneulink/core/llvm/helpers.py
@@ -43,7 +43,7 @@ def for_loop(builder, start, stop, inc, id):
 
     builder.position_at_end(out_block)
 
-# Helper that builds a for loop starting at 0, stopping at stop, and incremented by 1
+
 def for_loop_zero_inc(builder, stop, id):
     start = stop.type(0)
     inc = stop.type(1)
diff --git a/psyneulink/core/llvm/jit_engine.py b/psyneulink/core/llvm/jit_engine.py
index 8917c34b660..86a4d6e99e9 100644
--- a/psyneulink/core/llvm/jit_engine.py
+++ b/psyneulink/core/llvm/jit_engine.py
@@ -10,7 +10,7 @@
 
 from llvmlite import binding
 
-from .builder_context import _find_llvm_function, _gen_cuda_kernel_wrapper_module, _float_ty
+from .builder_context import LLVMBuilderContext, _find_llvm_function, _gen_cuda_kernel_wrapper_module
 from .builtins import _generate_cpu_builtins_module
 from .debug import debug_env
 
@@ -84,7 +84,7 @@ def _cpu_jit_constructor():
     __pass_manager_builder.populate(__cpu_pass_manager)
 
     # And an execution engine with a builtins backing module
-    builtins_module = _generate_cpu_builtins_module(_float_ty)
+    builtins_module = _generate_cpu_builtins_module(LLVMBuilderContext.float_ty)
     if "llvm" in debug_env:
         with open(builtins_module.name + '.parse.ll', 'w') as dump_file:
             dump_file.write(str(builtins_module))
@@ -252,7 +252,7 @@ def __init__(self, tm):
             self._target_machine = tm
 
             # -dc option tells the compiler that the code will be used for linking
-            self._generated_builtins = pycuda.compiler.compile(_ptx_builtin_source.format(type=str(_float_ty)), target='cubin', options=['-dc'])
+            self._generated_builtins = pycuda.compiler.compile(_ptx_builtin_source.format(type=str(LLVMBuilderContext.float_ty)), target='cubin', options=['-dc'])
 
         def set_object_cache(cache):
             pass
diff --git a/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py b/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py
index 5fedfa67bee..6adef8a0472 100644
--- a/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py
+++ b/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py
@@ -357,7 +357,7 @@ class LCControlMechanism(ControlMechanism):
     Arguments
     ---------
 
-    modulated_mechanisms : List[`Mechanism`] or *ALL*
+    modulated_mechanisms : List[`Mechanism <Mechanism>`] or *ALL*
         specifies the Mechanisms to be modulated by the LCControlMechanism. If it is a list, every item must be a
         Mechanism with a `function <Mechanism_Base.function>` that implements a `multiplicative_param
         <Function_Modulatory_Params>`;  alternatively the keyword *ALL* can be used to specify all of the
diff --git a/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py b/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py
index 33efc81f92e..22cd7d8398c 100644
--- a/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py
+++ b/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py
@@ -827,7 +827,7 @@ class PredictionMechanism(IntegratorMechanism):
         input to its `origin_mechanism <PredictionMechanism.origin_mechanism>`.  The format conforms to that of a
         System's `run <System.run>` method: items in the outermost dimension (axis 0) correspond to the inputs for
         each trial of a simulation, each of which is a 2d np.array containing the input for each `InputPort` of the
-        `Mechanism`.
+        `Mechanism <Mechanism>`.
 
     """
 
diff --git a/psyneulink/library/components/mechanisms/modulatory/control/evc/evccontrolmechanism.py b/psyneulink/library/components/mechanisms/modulatory/control/evc/evccontrolmechanism.py
index 9a0d6e23b8b..40253f4020c 100644
--- a/psyneulink/library/components/mechanisms/modulatory/control/evc/evccontrolmechanism.py
+++ b/psyneulink/library/components/mechanisms/modulatory/control/evc/evccontrolmechanism.py
@@ -351,7 +351,7 @@ class is specified in the **controller** argument of the System's constructor (s
     >>> mySystem = pnl.System(processes=[myRewardProcess, myDecisionProcess],           #doctest: +SKIP
     ...                       controller=pnl.EVCControlMechanism,                       #doctest: +SKIP
     ...                       monitor_for_control=[Reward,                              #doctest: +SKIP
-    ...                                            pnl.DDM_OUTPUT.DECISION_VARIABLE,    #doctest: +SKIP
+    ...                                            pnl.DECISION_VARIABLE,    #doctest: +SKIP
     ...                                            (pnl.RESPONSE_TIME, 1, -1)],         #doctest: +SKIP
 
 It uses the System's **monitor_for_control** argument to assign three OutputPorts to be monitored.  The first one
diff --git a/psyneulink/library/components/mechanisms/processing/integrator/ddm.py b/psyneulink/library/components/mechanisms/processing/integrator/ddm.py
index 95fb78f69db..29648b44aec 100644
--- a/psyneulink/library/components/mechanisms/processing/integrator/ddm.py
+++ b/psyneulink/library/components/mechanisms/processing/integrator/ddm.py
@@ -17,6 +17,8 @@
   * `DDM_Structure`
       - `DDM_Input`
       - `DDM_Output`
+          • `Default OutputPorts <DDM_Default_OutputPorts>`
+          • `Custom OutputPorts <DDM_Custom_OutputPorts>`
       - `DDM_Modes`
           • `DDM_Analytic_Mode`
           • `DDM_Integration_Mode`
@@ -90,7 +92,7 @@
 *SCALAR*.  However, if it is specified as *ARRAY*, the DDM's InputPort is configured to accept a 1d 2-item vector,
 and to use `Reduce` as its Function, which subtracts the 2nd element of the vector from the 1st, and provides this as
 the input to the DDM's `function <DDM.function>`.  If *ARRAY* is specified, two  `Standard OutputPorts
-<DDM_Standard_OutputPorts>` are added to the DDM, that allow the result of the decision process to be represented
+<OutputPorts_Standard>` are added to the DDM, that allow the result of the decision process to be represented
 as an array corresponding to the input array (see `below <DDM_Custom_OutputPorts>`).
 
 COMMENT:
@@ -115,10 +117,11 @@
 execution of the mechanism computes one step. (see `DDM_Modes` and `DDM_Execution` for additional details).
 
 The `value <DDM.value>` of the DDM Mechanism may have up to ten items. The first two of these are always assigned, and
-are represented by the DDM Mechanism's two default `output_ports <DDM.output_ports>`: `DECISION_VARIABLE
-<DDM_DECISION_VARIABLE>` and `RESPONSE_TIME <DDM_RESPONSE_TIME>`.  Other `output_ports <DDM.output_ports>` may be
-automatically assigned, depending on the `function <DDM.function>` that has been assigned to the DDM, as shown in the
-table below:
+are represented by the DDM Mechanism's two default `OutputPorts``: `DECISION_VARIABLE <DDM_DECISION_VARIABLE>` and
+`RESPONSE_TIME <DDM_RESPONSE_TIME>`.  Other `output_ports <DDM.output_ports>` may be automatically assigned,
+depending on the `function <DDM.function>` that has been assigned to the DDM, as shown in the table below:
+
+.. _DDM_Default_OutputPorts:
 
 +------------------------------------+---------------------------------------------------------+
 |                                    |                     **Function**                        |
@@ -159,16 +162,17 @@
 | <DDM_RT_INCORRECT_SKEW>`           |       X                    |                            |
 +------------------------------------+----------------------------+----------------------------+
 
-
 .. _DDM_Custom_OutputPorts:
 
-The `output_ports <DDM.output_ports>` assigned to a DDM can be customized by specifying a list of the desired DDM
-`Standard OutputPorts <DDM_Standard_OutputPorts>` in the **output_ports** argument of its constructor, or the
-*OUTPUT_PORTS* entry of an `OutputPort specification dictionary <OutputPort_Specification_Dictionary>`.  This can
-include two additional `Standard OutputPorts <DDM_Standard_OutputPorts>` for the DDM - `DECISION_VARIABLE_ARRAY
-<DDM_OUTPUT.DDM_DECISION_VARIABLE_ARRAY>` and `SELECTED_INPUT_ARRAY <DDM_OUTPUT.DDM_SELECTED_INPUT_ARRAY>`,
-that are available  if the *ARRAY* option is specified in its **input_format** argument (see `DDM_Input`).  As with
-any Mechanism, `customized OutputPorts <OutputPort_Customization>` can also be created and assigned.
+The `output_ports <DDM.output_ports>` assigned to a DDM can explicilty determined by specifying ones from its list
+of `standard_output_ports <DDM.standard_output_ports>` in the **output_ports** argument of its constructor, or the
+*OUTPUT_PORTS* entry of an `OutputPort specification dictionary <OutputPort_Specification_Dictionary>`.  This
+can include any of the OutputPorts `listed above `DDM_Default_OutputPorts`, as well as two additional ones --
+-- `DECISION_VARIABLE_ARRAY <DDM_DECISION_VARIABLE_ARRAY>` and `SELECTED_INPUT_ARRAY <DDM_SELECTED_INPUT_ARRAY>` --
+that are available if the *ARRAY* option is specified in its **input_format** argument (see `DDM_Input`).  All of
+these `Standard OutputPorts <OutputPort_Standard>` are listed in the DDM's `standard_output_ports
+<DDM.standard_output_ports>` attribute. As with any Mechanism, `customized OutputPorts <OutputPort_Customization>`
+can also be created and assigned.
 
 .. _DDM_Modes:
 
@@ -383,10 +387,11 @@
 from psyneulink.core.globals.utilities import is_numeric, is_same_function_spec, object_has_single_value
 
 __all__ = [
-    'DDM', 'DDM_OUTPUT', 'DDM_standard_output_ports', 'DDMError',
-    'DECISION_VARIABLE', 'DECISION_VARIABLE_ARRAY', 'PROBABILITY_LOWER_THRESHOLD', 'PROBABILITY_UPPER_THRESHOLD',
-    'RESPONSE_TIME', 'RT_CORRECT_MEAN', 'RT_CORRECT_VARIANCE',
-    'SCALAR', 'SELECTED_INPUT_ARRAY', 'ARRAY', 'VECTOR'
+    'ARRAY', 'DDM', 'DDMError', 'DECISION_VARIABLE', 'DECISION_VARIABLE_ARRAY',
+    'PROBABILITY_LOWER_THRESHOLD', 'PROBABILITY_UPPER_THRESHOLD', 'RESPONSE_TIME',
+    'RT_CORRECT_MEAN', 'RT_CORRECT_SKEW', 'RT_CORRECT_VARIANCE',
+    'RT_INCORRECT_MEAN', 'RT_INCORRECT_SKEW', 'RT_INCORRECT_VARIANCE',
+    'SCALAR', 'SELECTED_INPUT_ARRAY', 'VECTOR'
 ]
 
 logger = logging.getLogger(__name__)
@@ -421,191 +426,6 @@ def decision_variable_to_array(x):
     else:
         return [0,x]
 
-DDM_standard_output_ports = [{NAME: DECISION_VARIABLE,},           # Upper or lower threshold for Analtyic function
-                              {NAME: RESPONSE_TIME},                # TIME_STEP within TRIAL for Integrator function
-                              {NAME: PROBABILITY_UPPER_THRESHOLD},  # Accuracy (TRIAL mode only)
-                              {NAME: PROBABILITY_LOWER_THRESHOLD},  # Error rate (TRIAL mode only)
-                              {NAME: RT_CORRECT_MEAN},              # (DriftDiffusionAnalytical only)
-                              {NAME: RT_CORRECT_VARIANCE},          # (DriftDiffusionAnalytical only)
-                              {NAME: RT_CORRECT_SKEW},              # (DriftDiffusionAnalytical only)
-                              {NAME: RT_INCORRECT_MEAN},            # (DriftDiffusionAnalytical only)
-                              {NAME: RT_INCORRECT_VARIANCE},        # (DriftDiffusionAnalytical only)
-                              {NAME: RT_INCORRECT_SKEW},            # (DriftDiffusionAnalytical only)
-                              ]
-
-# This is a convenience class that provides list of standard_output_port names in IDE
-class DDM_OUTPUT():
-    """
-    .. _DDM_Standard_OutputPorts:
-
-    `Standard OutputPorts <OutputPort_Standard>` for `DDM`:
-
-    .. _DDM_DECISION_VARIABLE:
-
-    *DECISION_VARIABLE* : float
-      • `analytic mode <DDM_Analytic_Mode>`: the value of the threshold crossed by the decision variable on the
-        current TRIAL (which is either the value of the DDM `function <DDM.function>`'s threshold attribute or its
-        negative); \n
-      • `integration mode <DDM_Integration_Mode>`: the value of the decision variable at the current TIME_STEP of
-        execution. \n
-      Corresponds to the 1st item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_DECISION_VARIABLE_ARRAY:
-
-    *DECISION_VARIABLE_ARRAY* : 1d nparray
-      .. note::
-         This is available only if **input_format** is specified as *ARRAY* in the DDM Mechanism's constructor
-         (see `DDM_Input`).
-      • `analytic mode <DDM_Analytic_Mode>`: two element array, with the decision variable (1st item of the DDM's
-        `value <DDM.value>`) as the 1st element if the decision process crossed the upper threshold, and the 2nd element
-        if it is closer to the lower threshold; the other element is set to 0. \n
-      • `integration mode <DDM_Integration_Mode>`: the value of the decision variable at the current TIME_STEP of
-        execution, assigned to the 1st element if the decision variable is closer to the upper threshold, and to the
-        2nd element if it is closer to the lower threshold; the other element is set to 0. \n
-
-    .. _DDM_DECISION_VARIABLE_ARRAY:
-
-    *SELECTED_INPUT_ARRAY* : 1d nparray
-      .. note::
-         This is available only if **input_format** is specified as *ARRAY* in the DDM Mechanism's constructor
-         (see `DDM_Input`).
-      • `analytic mode <DDM_Analytic_Mode>`: two element array, with one ("selected") element -- determined by the
-        outcome of the decision process -- set to the value of the corresponding element in the stimulus array (i.e.,
-        the DDM's input_port `variable <InputPort.variable>`).  The "selected" element is the 1st one if the decision
-        process resulted in crossing the upper threshold, and the 2nd if it crossed the lower threshold; the other
-        element is set to 0. \n
-      • `integration mode <DDM_Integration_Mode>`: the value of the element in the stimulus array based on the
-        decision variable (1st item of the DDM's `value <DDM.value>`) at the current TIME_STEP of execution:
-        it is assigned to the 1st element if the decision variable is closer to the upper threshold, and to the  2nd
-        element if the decision variable is closer to the lower threshold; the other element is set to 0. \n
-
-    .. _DDM_RESPONSE_TIME:
-
-    *RESPONSE_TIME* : float
-      • `analytic mode <DDM_Analytic_Mode>`: mean time (in seconds) for the decision variable to reach the positive
-        or negative value of the DDM `function <DDM.function>`'s threshold attribute as estimated by the analytic
-        solution calculated by the `function <DDM.function>`); \n
-      • `integration mode <DDM_Integration_Mode>`: the number of `TIME_STEP` that have occurred since the DDM began
-        to execute in the current `TRIAL` or, if it has reached the positive or negative value of the DDM `function
-        <DDM.function>`'s threshold attribute, the `TIME_STEP` at which that occurred. \n
-      Corresponds to the 2nd item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_PROBABILITY_UPPER_THRESHOLD:
-
-    *PROBABILITY_UPPER_THRESHOLD* : float
-      • `analytic mode <DDM_Analytic_Mode>`: the probability of the decision variable reaching the positive value of
-        the DDM `function <DDM.function>`'s threshold attribute as estimated by the analytic solution calculated by the
-        `function <DDM.function>`; often, by convention, the positive (upper) threshold is associated with the
-        correct response, in which case *PROBABILITY_UPPER_THRESHOLD* corresponds to the accuracy of the decision
-        process. \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 3rd item of the DDM's `value <DDM.value>`.
-
-    COMMENT:
-      [TBI:]
-          `integration mode <DDM_Integration_Mode>`, if execution has completed, this is a binary value
-          indicating whether the decision process reached the upper (positive) threshold. If execution was
-          interrupted (using :py:meth:`terminate_function  <DDM.terminate_function>`, sometimes referred to as the
-          :ref:`interrogation protocol <LINK>`, then the value corresponds to the current likelihood that the upper
-          threshold would have been reached.
-    COMMENT
-
-    .. _DDM_PROBABILITY_LOWER_THRESHOLD:
-
-    *PROBABILITY_LOWER_THRESHOLD* : float
-      • `analytic mode <DDM_Analytic_Mode>`: the probability of the decision variable reaching the negative value of
-        the DDM `function <DDM.function>`'s threshold attribute as estimated by the analytic solution calculate by the
-        `function <DDM.function>`); often, by convention, the negative (lower) threshold is associated with an error
-        response, in which case *PROBABILITY_LOWER_THRESHOLD* corresponds to the error rate of the decision process; \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 4th item of the DDM's `value <DDM.value>`.
-
-        COMMENT:
-          [TBI:]
-              `integration mode <DDM_Integration_Mode>`, if execution has completed, this is a binary value
-              indicating whether the decision process reached the lower (negative) threshold. If execution was
-              interrupted (using :py:method:`terminate_method <DDM.terminate_function>`, sometimes referred to as the
-              :ref:`interrogation protocol <LINK>`), then the value corresponds to the current likelihood that the lower
-              threshold would have been reached.
-        COMMENT
-
-    .. _DDM_RT_CORRECT_MEAN:
-
-    *RT_CORRECT_MEAN* : floa
-      (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
-      • `analytic mode <DDM_Analytic_Mode>`:  the mean reaction time (in seconds) for responses in which the decision
-        variable reached the positive value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
-        closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 5th item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_RT_CORRECT_VARIANCE:
-
-    *RT_CORRECT_VARIANCE* : float
-      (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
-      • `analytic mode <DDM_Analytic_Mode>`:  the variance of reaction time (in seconds) for responses in which the
-        decision variable reached the positive value of the DDM `function <DDM.function>`'s threshold attribute as
-        estimated by closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 6th item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_RT_CORRECT_SKEW:
-
-    *RT_CORRECT_SKEW* : float
-      (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
-      • `analytic mode <DDM_Analytic_Mode>`:  the skew of decision time (in seconds) for responses in which the decision
-        variable reached the positive value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
-        closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 7th item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_RT_INCORRECT_MEAN:
-
-    *RT_INCORRECT_MEAN* : float
-      (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
-      • `analytic mode <DDM_Analytic_Mode>`:  the mean reaction time (in seconds) for responses in which the decision
-        variable reached the negative value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
-        closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 5th item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_RT_INCORRECT_VARIANCE:
-
-    *RT_INCORRECT_VARIANCE* : float
-      (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
-      • `analytic mode <DDM_Analytic_Mode>`:  the variance of reaction time (in seconds) for responses in which the
-        decision variable reached the negative value of the DDM `function <DDM.function>`'s threshold attribute as
-        estimated by closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 6th item of the DDM's `value <DDM.value>`.
-
-    .. _DDM_RT_INCORRECT_SKEW:
-
-    *RT_INCORRECT_SKEW* : float
-      (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
-      • `analytic mode <DDM_Analytic_Mode>`:  the skew of decision time (in seconds) for responses in which the decision
-        variable reached the negative value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
-        closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
-      • `integration mode <DDM_Integration_Mode>`: `None`.
-      Corresponds to the 7th item of the DDM's `value <DDM.value>`.
-
-    """
-    DECISION_VARIABLE=DECISION_VARIABLE
-    RESPONSE_TIME=RESPONSE_TIME
-    PROBABILITY_UPPER_THRESHOLD=PROBABILITY_UPPER_THRESHOLD
-    PROBABILITY_LOWER_THRESHOLD=PROBABILITY_LOWER_THRESHOLD
-    RT_CORRECT_MEAN=RT_CORRECT_MEAN
-    RT_CORRECT_VARIANCE=RT_CORRECT_VARIANCE
-    RT_CORRECT_SKEW = RT_CORRECT_SKEW
-    RT_INCORRECT_MEAN=RT_INCORRECT_MEAN
-    RT_INCORRECT_VARIANCE=RT_INCORRECT_VARIANCE
-    RT_INCORRECT_SKEW=RT_INCORRECT_SKEW
-    DECISION_VARIABLE_ARRAY=DECISION_VARIABLE_ARRAY
-    SELECTED_INPUT_ARRAY=SELECTED_INPUT_ARRAY
-# THE FOLLOWING WOULD HAVE BEEN NICE, BUT IDE DOESN'T EXECUTE IT, SO NAMES DON'T SHOW UP
-# for item in [item[NAME] for item in DDM_standard_output_ports]:
-#     setattr(DDM_OUTPUT.__class__, item, item)
-
 
 class DDMError(Exception):
     def __init__(self, error_value):
@@ -620,13 +440,9 @@ class DDM(ProcessingMechanism):
     #             ADD INFO ABOUT B VS. N&F
     #             ADD _instantiate_output_ports TO INSTANCE METHODS, AND EXPLAIN RE: NUM OUTPUT VALUES FOR B VS. N&F
     """
-    DDM(                               \
-    default_variable=None,             \
-    size=None,                         \
-    function=DriftDiffusionAnalytical, \
-    params=None,                       \
-    name=None,                         \
-    prefs=None)
+    DDM(                                   \
+        default_variable=None,             \
+        function=DriftDiffusionAnalytical)
 
     Implements a drift diffusion process (also known as the `Diffusion Decision Model
     <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2474742/>`_, either by calculating an `analytic solution
@@ -677,47 +493,175 @@ class DDM(ProcessingMechanism):
         <DDM.function>` attribute.  The first two items are always assigned the values of `DECISION_VARIABLE
         <DDM_DECISION_VARIABLE>` and `RESPONSE_TIME <DDM_RESPONSE_TIME>` (though their interpretation depends on the
         `function <DDM.function>` and corresponding `mode of <DDM_Modes>` of operation).  See `DDM_Modes`,
-        `DDM_Execution`, and `DDM Standard OutputPorts <DDM_Standard_OutputPorts>` for additional information about
-        other values that can be reported and their interpretation.
+        `DDM_Execution`, and `DDM_Output` for additional information about other values that can be reported and
+        their interpretation.
 
     output_ports : ContentAddressableList[OutputPort]
         list of the DDM's `OutputPorts <OutputPort>`.  There are always two OutputPorts, `DECISION_VARIABLE
         <DDM_DECISION_VARIABLE>` and `RESPONSE_TIME <DDM_RESPONSE_TIME>`; additional ones may be included
         based on the `function <DDM.function>` and/or any specifications made in the **output_ports** argument of the
-        DDM's constructor (see `DDM Standard OutputPorts <DDM_Standard_OutputPorts>`).
+        DDM's constructor (see `DDM_Output` for additional details).
 
     output_values : List[array(float64),array(float64),array(float64),array(float64)]
         each item is the `value <OutputPort.value> of the corresponding OutputPort in `output_ports
         <DDM.output_ports>`.  The first two items are always the `value <OutputPort.value>`\\s of the
         `DECISION_VARIABLE <DDM_DECISION_VARIABLE>` and `RESPONSE_TIME <DDM_RESPONSE_TIME>` OutputPorts;  additional
         ones may be included, based on the `function <DDM.function>` and any specifications made in the
-        **output_ports** argument of the DDM's constructor (see `DDM Standard OutputPorts
-        <DDM_Standard_OutputPorts>`).
+        **output_ports** argument of the DDM's constructor  (see `DDM_Output` for additional details).
+
+    standard_output_ports : list[str]
+        list of `Standard OutputPorts <OutputPort_Standard>` that includes the following addition to the
+        `standard_output_ports <Mechanism_Base.standard_output_ports>` of a `Mechanism <Mechanism>`:
+
+        .. _DDM_DECISION_VARIABLE:
+
+        *DECISION_VARIABLE* : float
+          • `analytic mode <DDM_Analytic_Mode>`: the value of the threshold crossed by the decision variable on the
+            current TRIAL (which is either the value of the DDM `function <DDM.function>`'s threshold attribute or its
+            negative); \n
+          • `integration mode <DDM_Integration_Mode>`: the value of the decision variable at the current TIME_STEP of
+            execution. \n
+          Corresponds to the 1st item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_DECISION_VARIABLE_ARRAY:
+
+        *DECISION_VARIABLE_ARRAY* : 1d nparray
+          .. note::
+             This is available only if **input_format** is specified as *ARRAY* in the DDM Mechanism's constructor
+             (see `DDM_Input`).
+          • `analytic mode <DDM_Analytic_Mode>`: two element array, with the decision variable (1st item of the DDM's
+            `value <DDM.value>`) as the 1st element if the decision process crossed the upper threshold, and the 2nd element
+            if it is closer to the lower threshold; the other element is set to 0. \n
+          • `integration mode <DDM_Integration_Mode>`: the value of the decision variable at the current TIME_STEP of
+            execution, assigned to the 1st element if the decision variable is closer to the upper threshold, and to the
+            2nd element if it is closer to the lower threshold; the other element is set to 0. \n
+
+        .. _DDM_SELECTED_INPUT_ARRAY:
+
+        *SELECTED_INPUT_ARRAY* : 1d nparray
+          .. note::
+             This is available only if **input_format** is specified as *ARRAY* in the DDM Mechanism's constructor
+             (see `DDM_Input`).
+          • `analytic mode <DDM_Analytic_Mode>`: two element array, with one ("selected") element -- determined by the
+            outcome of the decision process -- set to the value of the corresponding element in the stimulus array (i.e.,
+            the DDM's input_port `variable <InputPort.variable>`).  The "selected" element is the 1st one if the decision
+            process resulted in crossing the upper threshold, and the 2nd if it crossed the lower threshold; the other
+            element is set to 0. \n
+          • `integration mode <DDM_Integration_Mode>`: the value of the element in the stimulus array based on the
+            decision variable (1st item of the DDM's `value <DDM.value>`) at the current TIME_STEP of execution:
+            it is assigned to the 1st element if the decision variable is closer to the upper threshold, and to the  2nd
+            element if the decision variable is closer to the lower threshold; the other element is set to 0. \n
+
+        .. _DDM_RESPONSE_TIME:
+
+        *RESPONSE_TIME* : float
+          • `analytic mode <DDM_Analytic_Mode>`: mean time (in seconds) for the decision variable to reach the positive
+            or negative value of the DDM `function <DDM.function>`'s threshold attribute as estimated by the analytic
+            solution calculated by the `function <DDM.function>`); \n
+          • `integration mode <DDM_Integration_Mode>`: the number of `TIME_STEP` that have occurred since the DDM began
+            to execute in the current `TRIAL` or, if it has reached the positive or negative value of the DDM `function
+            <DDM.function>`'s threshold attribute, the `TIME_STEP` at which that occurred. \n
+          Corresponds to the 2nd item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_PROBABILITY_UPPER_THRESHOLD:
+
+        *PROBABILITY_UPPER_THRESHOLD* : float
+          • `analytic mode <DDM_Analytic_Mode>`: the probability of the decision variable reaching the positive value of
+            the DDM `function <DDM.function>`'s threshold attribute as estimated by the analytic solution calculated by the
+            `function <DDM.function>`; often, by convention, the positive (upper) threshold is associated with the
+            correct response, in which case *PROBABILITY_UPPER_THRESHOLD* corresponds to the accuracy of the decision
+            process. \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 3rd item of the DDM's `value <DDM.value>`.
+
+        COMMENT:
+          [TBI:]
+              `integration mode <DDM_Integration_Mode>`, if execution has completed, this is a binary value
+              indicating whether the decision process reached the upper (positive) threshold. If execution was
+              interrupted (using :py:meth:`terminate_function  <DDM.terminate_function>`, sometimes referred to as the
+              :ref:`interrogation protocol <LINK>`, then the value corresponds to the current likelihood that the upper
+              threshold would have been reached.
+        COMMENT
+
+        .. _DDM_PROBABILITY_LOWER_THRESHOLD:
+
+        *PROBABILITY_LOWER_THRESHOLD* : float
+          • `analytic mode <DDM_Analytic_Mode>`: the probability of the decision variable reaching the negative value of
+            the DDM `function <DDM.function>`'s threshold attribute as estimated by the analytic solution calculate by the
+            `function <DDM.function>`); often, by convention, the negative (lower) threshold is associated with an error
+            response, in which case *PROBABILITY_LOWER_THRESHOLD* corresponds to the error rate of the decision process; \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 4th item of the DDM's `value <DDM.value>`.
+
+            COMMENT:
+              [TBI:]
+                  `integration mode <DDM_Integration_Mode>`, if execution has completed, this is a binary value
+                  indicating whether the decision process reached the lower (negative) threshold. If execution was
+                  interrupted (using :py:method:`terminate_method <DDM.terminate_function>`, sometimes referred to as the
+                  :ref:`interrogation protocol <LINK>`), then the value corresponds to the current likelihood that the lower
+                  threshold would have been reached.
+            COMMENT
+
+        .. _DDM_RT_CORRECT_MEAN:
+
+        *RT_CORRECT_MEAN* : floa
+          (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
+          • `analytic mode <DDM_Analytic_Mode>`:  the mean reaction time (in seconds) for responses in which the decision
+            variable reached the positive value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
+            closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 5th item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_RT_CORRECT_VARIANCE:
+
+        *RT_CORRECT_VARIANCE* : float
+          (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
+          • `analytic mode <DDM_Analytic_Mode>`:  the variance of reaction time (in seconds) for responses in which the
+            decision variable reached the positive value of the DDM `function <DDM.function>`'s threshold attribute as
+            estimated by closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 6th item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_RT_CORRECT_SKEW:
+
+        *RT_CORRECT_SKEW* : float
+          (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
+          • `analytic mode <DDM_Analytic_Mode>`:  the skew of decision time (in seconds) for responses in which the decision
+            variable reached the positive value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
+            closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 7th item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_RT_INCORRECT_MEAN:
+
+        *RT_INCORRECT_MEAN* : float
+          (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
+          • `analytic mode <DDM_Analytic_Mode>`:  the mean reaction time (in seconds) for responses in which the decision
+            variable reached the negative value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
+            closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 5th item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_RT_INCORRECT_VARIANCE:
+
+        *RT_INCORRECT_VARIANCE* : float
+          (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
+          • `analytic mode <DDM_Analytic_Mode>`:  the variance of reaction time (in seconds) for responses in which the
+            decision variable reached the negative value of the DDM `function <DDM.function>`'s threshold attribute as
+            estimated by closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 6th item of the DDM's `value <DDM.value>`.
+
+        .. _DDM_RT_INCORRECT_SKEW:
+
+        *RT_INCORRECT_SKEW* : float
+          (only applicable if `function <DDM.function>` is `DriftDiffusionAnalytical`) \n
+          • `analytic mode <DDM_Analytic_Mode>`:  the skew of decision time (in seconds) for responses in which the decision
+            variable reached the negative value of the DDM `function <DDM.function>`'s threshold attribute as estimated by
+            closed form analytic solutions from Srivastava et al. (https://arxiv.org/abs/1601.06420) \n
+          • `integration mode <DDM_Integration_Mode>`: `None`.
+          Corresponds to the 7th item of the DDM's `value <DDM.value>`.
 
-    COMMENT:
-        MOVE TO METHOD DEFINITIONS:
-        Instance methods:
-            - _instantiate_function(context)
-                deletes params not in use, in order to restrict outputPorts to those that are computed for
-                specified params
-            - execute(variable, params, context)
-                executes specified version of DDM and returns outcome values (in self.value and values of
-                self.output_ports)
-            - _out_update(particle, drift, noise, time_step_size, decay)
-                single update for OU (special case l=0 is DDM) -- from Michael Shvartsman
-            - _ddm_update(particle, a, s, dt)
-                DOCUMENTATION NEEDED
-                from Michael Shvartsman
-            - _ddm_rt(x0, t0, a, s, z, dt)
-                DOCUMENTATION NEEDED
-                from Michael Shvartsman
-            - _ddm_distr(n, x0, t0, a, s, z, dt)
-                DOCUMENTATION NEEDED
-                from Michael Shvartsman
-            - _ddm_analytic(bais, t0, drift_rate, noise, threshold)
-                DOCUMENTATION NEEDED
-                from Michael Shvartsman
-    COMMENT
     """
 
     componentType = "DDM"
@@ -771,6 +715,19 @@ class Parameters(ProcessingMechanism.Parameters):
     paramClassDefaults.update({
         OUTPUT_PORTS: None})
 
+    standard_output_ports =[{NAME: DECISION_VARIABLE,},           # Upper or lower threshold for Analtyic function
+                            {NAME: RESPONSE_TIME},                # TIME_STEP within TRIAL for Integrator function
+                            {NAME: PROBABILITY_UPPER_THRESHOLD},  # Accuracy (TRIAL mode only)
+                            {NAME: PROBABILITY_LOWER_THRESHOLD},  # Error rate (TRIAL mode only)
+                            {NAME: RT_CORRECT_MEAN},              # (DriftDiffusionAnalytical only)
+                            {NAME: RT_CORRECT_VARIANCE},          # (DriftDiffusionAnalytical only)
+                            {NAME: RT_CORRECT_SKEW},              # (DriftDiffusionAnalytical only)
+                            {NAME: RT_INCORRECT_MEAN},            # (DriftDiffusionAnalytical only)
+                            {NAME: RT_INCORRECT_VARIANCE},        # (DriftDiffusionAnalytical only)
+                            {NAME: RT_INCORRECT_SKEW}             # (DriftDiffusionAnalytical only)
+                            ]
+    standard_output_port_names = [i['name'] for i in standard_output_ports]
+
     @tc.typecheck
     def __init__(self,
                  default_variable=None,
@@ -788,9 +745,9 @@ def __init__(self,
                  prefs: is_pref_set = None,
                  **kwargs):
 
-        self.standard_output_ports = StandardOutputPorts(self,
-                                                           DDM_standard_output_ports,
-                                                           indices=SEQUENTIAL)
+        # Override instantiation of StandardOutputPorts usually done in _instantiate_output_ports
+        #    in order to use SEQUENTIAL indices
+        self.standard_output_ports = StandardOutputPorts(self, self.standard_output_ports, indices=SEQUENTIAL)
 
         if input_format is not None and input_ports is not None:
             raise DDMError(
@@ -840,6 +797,10 @@ def __init__(self,
 
             ])
 
+        # Add StandardOutputPorts for Mechanism (after ones for DDM, so that their indices are not messed up)
+        # FIX 11/9/19:  ADD BACK ONCE Mechanism_Base.standard_output_ports ONLY HAS RESULTS IN ITS
+        # self.standard_output_ports.add_port_dicts(Mechanism_Base.standard_output_ports)
+
         # Default output_ports is specified in constructor as a tuple rather than a list
         # to avoid "gotcha" associated with mutable default arguments
         # (see: bit.ly/2uID3s3 and http://docs.python-guide.org/en/latest/writing/gotchas/)
diff --git a/psyneulink/library/components/mechanisms/processing/leabramechanism.py b/psyneulink/library/components/mechanisms/processing/leabramechanism.py
index 2ea504a2306..8bcd16f7ccf 100644
--- a/psyneulink/library/components/mechanisms/processing/leabramechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/leabramechanism.py
@@ -112,8 +112,6 @@
 from psyneulink.core.components.functions.function import Function_Base
 from psyneulink.core.components.mechanisms.mechanism import Mechanism_Base
 from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
-from psyneulink.core.components.ports.outputport import PRIMARY, StandardOutputPorts
-from psyneulink.core.globals.context import ContextFlags
 from psyneulink.core.globals.keywords import FUNCTION, INPUT_PORTS, LEABRA_FUNCTION, LEABRA_FUNCTION_TYPE, LEABRA_MECHANISM, NETWORK, OUTPUT_PORTS, PREFERENCE_SET_NAME
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set, REPORT_OUTPUT_PREF
@@ -445,9 +443,6 @@ class LeabraMechanism(ProcessingMechanism_Base):
                                INPUT_PORTS: input_port_names,
                                OUTPUT_PORTS: output_port_name})
 
-    standard_output_ports = ProcessingMechanism_Base.standard_output_ports.copy()
-    standard_output_port_names = ProcessingMechanism_Base.standard_output_port_names.copy()
-
     class Parameters(ProcessingMechanism_Base.Parameters):
         """
             Attributes
diff --git a/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py b/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py
index ca160368e96..5b6d3f632ff 100644
--- a/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py
@@ -149,9 +149,9 @@
 from psyneulink.core.components.mechanisms.processing.objectivemechanism import ObjectiveMechanism
 from psyneulink.core.components.shellclasses import Mechanism
 from psyneulink.core.components.ports.inputport import InputPort
-from psyneulink.core.components.ports.outputport import OutputPort, PRIMARY, StandardOutputPorts
+from psyneulink.core.components.ports.outputport import OutputPort
 from psyneulink.core.components.ports.port import _parse_port_spec
-from psyneulink.core.globals.context import Context, ContextFlags
+from psyneulink.core.globals.context import Context
 from psyneulink.core.globals.keywords import COMPARATOR_MECHANISM, FUNCTION, INPUT_PORTS, NAME, OUTCOME, SAMPLE, TARGET, VARIABLE, PREFERENCE_SET_NAME, MSE, SSE
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set, REPORT_OUTPUT_PREF
@@ -160,29 +160,9 @@
 from psyneulink.core.globals.utilities import safe_len
 
 __all__ = [
-    'COMPARATOR_OUTPUT', 'ComparatorMechanism', 'ComparatorMechanismError'
+    'ComparatorMechanism', 'ComparatorMechanismError'
 ]
 
-class COMPARATOR_OUTPUT():
-    """
-    .. _ComparatorMechanism_Standard_OutputPorts:
-
-    `Standard OutputPorts <OutputPort_Standard>` for `ComparatorMechanism`
-
-    .. _COMPARATOR_MECHANISM_SSE
-
-    *SSE*
-        the value of the sum squared error of the Mechanism's function
-
-    .. _COMPARATOR_MECHANISM_MSE
-
-    *MSE*
-        the value of the mean squared error of the Mechanism's function
-
-    """
-    SSE = SSE
-    MSE = MSE
-
 
 class ComparatorMechanismError(Exception):
     def __init__(self, error_value):
@@ -258,6 +238,20 @@ class ComparatorMechanism(ObjectiveMechanism):
     output_values : 2d np.array
         contains one item that is the value of the *OUTCOME* OutputPort.
 
+    standard_output_ports : list[str]
+        list of `Standard OutputPorts <OutputPort_Standard>` that includes the following in addition to the
+        `standard_output_ports <ObjectiveMechanism.standard_output_ports>` of an `ObjectiveMechanism`:
+
+        .. _COMPARATOR_MECHANISM_SSE
+
+        *SSE*
+            the value of the sum squared error of the Mechanism's function
+
+        .. _COMPARATOR_MECHANISM_MSE
+
+        *MSE*
+            the value of the mean squared error of the Mechanism's function
+
     """
     componentType = COMPARATOR_MECHANISM
 
@@ -308,11 +302,12 @@ class Parameters(ObjectiveMechanism.Parameters):
     paramClassDefaults = Mechanism_Base.paramClassDefaults.copy()
 
     standard_output_ports = ObjectiveMechanism.standard_output_ports.copy()
-
     standard_output_ports.extend([{NAME: SSE,
                                    FUNCTION: lambda x: np.sum(x * x)},
                                   {NAME: MSE,
                                    FUNCTION: lambda x: np.sum(x * x) / safe_len(x)}])
+    standard_output_port_names = ObjectiveMechanism.standard_output_port_names.copy()
+    standard_output_port_names.extend([SSE, MSE])
 
     @tc.typecheck
     def __init__(self,
@@ -366,13 +361,9 @@ def _validate_params(self, request_set, target_set=None, context=None):
             # Validate that there are exactly two input_ports (for sample and target)
             num_input_ports = len(input_ports)
             if num_input_ports != 2:
-                raise ComparatorMechanismError("{} arg is specified for {} ({}), so it must have exactly 2 items, "
-                                               "one each for {} and {}".
-                                               format(INPUT_PORTS,
-                                                      self.__class__.__name__,
-                                                      len(input_ports),
-                                                      SAMPLE,
-                                                      TARGET))
+                raise ComparatorMechanismError(f"{INPUT_PORTS} arg is specified for {self.__class__.__name__} "
+                                               f"({len(input_ports)}), so it must have exactly 2 items, "
+                                               f"one each for {SAMPLE} and {TARGET}.")
 
             # Validate that input_ports are specified as dicts
             if not all(isinstance(input_port,dict) for input_port in input_ports):
@@ -382,19 +373,16 @@ def _validate_params(self, request_set, target_set=None, context=None):
             # Validate length of variable for sample = target
             if VARIABLE in input_ports[0]:
                 # input_ports arg specified in standard port specification dict format
-                lengths = [len(input_port[VARIABLE]) for input_port in input_ports]
+                lengths = [len(input_port[VARIABLE]) if input_port[VARIABLE] is not None else 0
+                           for input_port in input_ports]
             else:
                 # input_ports arg specified in {<Port_Name>:<PORT SPECIFICATION DICT>} format
                 lengths = [len(list(input_port_dict.values())[0][VARIABLE]) for input_port_dict in input_ports]
 
             if lengths[0] != lengths[1]:
-                raise ComparatorMechanismError("Length of value specified for {} InputPort of {} ({}) must be "
-                                               "same as length of value specified for {} ({})".
-                                               format(SAMPLE,
-                                                      self.__class__.__name__,
-                                                      lengths[0],
-                                                      TARGET,
-                                                      lengths[1]))
+                raise ComparatorMechanismError(f"Length of value specified for {SAMPLE} InputPort "
+                                               f"of {self.__class__.__name__} ({lengths[0]}) must be "
+                                               f"same as length of value specified for {TARGET} ({lengths[1]}).")
 
         elif SAMPLE in request_set and TARGET in request_set:
 
@@ -421,12 +409,9 @@ def _validate_params(self, request_set, target_set=None, context=None):
             if sample is not None and target is not None:
                 if not iscompatible(sample, target, **{kwCompatibilityLength: True,
                                                        kwCompatibilityNumeric: True}):
-                    raise ComparatorMechanismError("The length of the sample ({}) must be the same as for the target ({})"
-                                                   "for {} {}".
-                                                   format(len(sample),
-                                                          len(target),
-                                                          self.__class__.__name__,
-                                                          self.name))
+                    raise ComparatorMechanismError(f"The length of the sample ({len(sample)}) "
+                                                   f"must be the same as for the target ({len(target)})"
+                                                   f"for {self.__class__.__name__} {self.name}.")
 
         super()._validate_params(request_set=request_set,
                                  target_set=target_set,
@@ -455,19 +440,17 @@ def _merge_legacy_constructor_args(self, sample, target, default_variable=None,
             input_ports = input_ports[INPUT_PORTS]
             # print("type input_ports = {}".format(type(input_ports)))
             if not isinstance(input_ports, list):
-                raise ComparatorMechanismError("If an \'{}\' argument is included in the constructor for a {} "
-                                               "it must be a list with two {} specifications.".
-                                               format(INPUT_PORTS, ComparatorMechanism.__name__, InputPort.__name__))
+                raise ComparatorMechanismError(f"If an '{INPUT_PORTS}' argument is included in the constructor "
+                                               f"for a {ComparatorMechanism.__name__} it must be a list with "
+                                               f"two {InputPort.__name__} specifications.")
 
         input_ports = input_ports or default_variable
 
         if input_ports is not None:
             if len(input_ports)!=2:
-                raise ComparatorMechanismError("If an \'input_ports\' arg is "
-                                               "included in the constructor for "
-                                               "a {}, it must be a list with "
-                                               "exactly two items (not {})".
-                                               format(ComparatorMechanism.__name__, len(input_ports)))
+                raise ComparatorMechanismError(f"If an \'input_ports\' arg is included in the constructor for a "
+                                               f"{ComparatorMechanism.__name__}, it must be a list with exactly "
+                                               f"two items (not {len(input_ports)}).")
 
             sample_input_port_dict = _parse_port_spec(owner=self,
                                                         port_type=InputPort,
diff --git a/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py b/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py
index 0277b767158..3287a97c70f 100644
--- a/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py
@@ -284,10 +284,6 @@ class Parameters(ComparatorMechanism.Parameters):
         sample = None
         target = None
 
-    # paramClassDefaults = ComparatorMechanism.paramClassDefaults.copy()
-    # standard_output_ports = ComparatorMechanism.standard_output_ports.copy()
-    # standard_output_port_names = ComparatorMechanism.standard_output_port_names.copy()
-
     @tc.typecheck
     def __init__(self,
                  sample: tc.optional(tc.any(OutputPort, Mechanism_Base, dict,
diff --git a/psyneulink/library/components/mechanisms/processing/transfer/contrastivehebbianmechanism.py b/psyneulink/library/components/mechanisms/processing/transfer/contrastivehebbianmechanism.py
index cba6642cf93..ec3aa53b9ab 100644
--- a/psyneulink/library/components/mechanisms/processing/transfer/contrastivehebbianmechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/transfer/contrastivehebbianmechanism.py
@@ -64,7 +64,7 @@
 ~~~~~~
 
 The **input_size** argument of the constructor must always be specified (this is comparable to specifying the
-**size** or *default_variable** arugments of other types of `Mechanism`).  If it is specified on its own,
+**size** or *default_variable** arguments of other types of `Mechanism`).  If it is specified on its own,
 it determines the total number of processing units.  If either the **hidden_size** and/or **target_size** arguments
 are specified, then those units are treated as distinct from the input units (see `ContrastiveHebbian_Execution` for
 details).
@@ -85,9 +85,9 @@
 *OututPorts*
 ~~~~~~~~~~~~
 
-The Mechanism is automatically assigned three of its five `Standard OutputPorts
-<ContrastiveHebbianMechanism_Standard_OutputPorts>`: *OUTPUT_ACTIVITY_OUTPUT*, *CURRENT_ACTIVITY_OUTPUT*,
-and *ACTIVITY_DIFFERENT_OUTPUT* (see `below <ContrastiveHebbian_Output>`). Additional OutputPorts can be specified
+The Mechanism is automatically assigned three of its five `standard_output_ports
+<ContrastiveHebbianMechanism.standard_output_ports>`: *OUTPUT_ACTIVITY*, *CURRENT_ACTIVITY*,
+and *ACTIVITY_DIFFERENT* (see `below <ContrastiveHebbian_Output>`). Additional OutputPorts can be specified
 in the **additional_output_ports** argument of the constructor.
 
 .. _ContrastiveHebbian_Learning:
@@ -100,7 +100,7 @@
 standard `RecurrentTransferMechanism <RecurrentTransferMechanism_Learning>`:  it is automatically assigned
 `ContrastiveHebbian` as its `learning_function <ContrastiveHebbianMechanism.learning_function>`; its `learning_condition
 <RecurrentTransferMechanism.learning_condition>` is automatically assigned as *CONVERGENCE*; and it is assigned a
-`MappingProjection` from its *ACTIVITY_DIFFERENCE_OUTPUT* (rather than its `primary <OutputPort_Primary>`)
+`MappingProjection` from its *ACTIVITY_DIFFERENCE* (rather than its `primary <OutputPort_Primary>`)
 `OutputPort <ContrastiveHebbian_Output>` to the *ACTIVATION_INPUT* of its `learning_mechanism
 <ContrastiveHebbianMechanism.learning_mechanism>`.
 
@@ -140,7 +140,7 @@
     ..
     * *TARGET:* only implemented if **target_size** is specified, **separated = `True` (default), and
       mode is not `SIMPLE_HEBBIAN <ContrastiveHebbian_SIMPLE_HEBBIAN>`;  receives the `target <Run.target>`
-      specified in the `run <System.run>` method of any `System` to which the Mechanism belongs.
+      specified in the `run <System.run>` method of any `Composition` to which the Mechanism belongs.
 
 The sizes of these are determined by arguments in its constructor, which generally conform to one of two
 configurations.
@@ -210,27 +210,27 @@
 
 A ContrastiveHebbianMechanism is automatically assigned three `OutputPorts <OutputPort>`:
 
-* *OUTPUT_ACTIVITY_OUTPUT:* assigned as the `primary OutputPort <OutputPort_Primary>`, and contains the pattern
+* *OUTPUT_ACTIVITY:* assigned as the `primary OutputPort <OutputPort_Primary>`, and contains the pattern
   of activity the Mechanism is trained to generate.  If **target_size** is specified, then it has the same size as
   the *TARGET* InputPort;  if **target_size** is not specified or is 0, if `separated
   <ContrastiveHebbianMechanism.separated>` is `False`, or if mode is *SIMPLE_HEBBIAN*, then the size of the
-  *OUTPUT_ACTIVITY_OUTPUT* OutputPort is the same as the *INPUT* InputPort (see `ContrastiveHebbian_Input`).
+  *OUTPUT_ACTIVITY* OutputPort is the same as the *INPUT* InputPort (see `ContrastiveHebbian_Input`).
 ..
-* *CURRENT_ACTIVITY_OUTPUT:* assigned the value of the `current_activity <ContrastiveHebbianMechanism.current_activity>`
+* *CURRENT_ACTIVITY:* assigned the value of the `current_activity <ContrastiveHebbianMechanism.current_activity>`
   attribute after each `execution <ContrastiveHebbian_Execution>` of the Mechanism, which contains the activity of all
   processing units in the Mechanism (input, hidden and/or target);  has the same size as the *RECURRENT* InputPort.
 ..
-* *ACTIVITY_DIFFERENCE_OUTPUT:* assigned the difference between `plus_phase_activity
+* *ACTIVITY_DIFFERENCE:* assigned the difference between `plus_phase_activity
   <ContrastiveHebbianMechanism.plus_phase_activity>` and `minus_phase_activity
   <ContrastiveHebbianMechanism.minus_phase_activity>` at the `completion of execution
   <ContrastiveHebbian_Execution>`. If `configured for learning <ContrastiveHebbian_Learning>`, a `MappingProjection`
-  is assigned from the *ACTIVITY_DIFFERENCE_OUTPUT* `OutputPort <ContrastiveHebbian_Output>` to the
+  is assigned from the *ACTIVITY_DIFFERENCE* `OutputPort <ContrastiveHebbian_Output>` to the
   *ACTIVATION_INPUT* of the `learning_mechanism <ContrastiveHebbianMechanism.learning_mechanism>`.
 
-A ContrastiveHebbianMechanism also has two additional `Standard OutputPorts
-<ContrastiveHebbianMechanism_Standard_OutputPorts>` -- *MINUS_PHASE_OUTPUT* and *PLUS_PHASE_ACTIVITY_OUTPUT* --
-that it can be assigned, as well as those of a `RecurrentTransferMechanism
-<RecurrentTransferMechanism_Standard_OutputPorts>` or `TransferMechanism <TransferMechanism_Standard_OutputPorts>`.
+These also appear in the ContrastiveHebbianMechanism's `standard_output_ports
+<ContrastiveHebbianMechanism.standard_output_ports>`, along with two others -- *MINUS_PHASE_ACTIVITY* and
+*PLUS_PHASE_ACTIVITY* -- that it can be assigned, in addition to the `standard_output_ports
+<RecurrentTransferMechanism.standard_output_ports>` of a `RecurrentTransferMechanism`.
 
 
 .. _ContrastiveHebbian_Execution:
@@ -296,16 +296,16 @@
 
 * if a *TARGET* InputPort `has been specified <ContrastiveHebbian_Input>`, then the `target field
   <ContrastiveHebbian_Fields>` of `current_activity <ContrastiveHebbianMechanism.current_activity>` is assigned as
-  `value <OutputPort.value>` of *OUTPUT_ACTIVITY_OUTPUT* `OutputPort <ContrastiveHebbian_Output>`;  otherwise,
+  `value <OutputPort.value>` of *OUTPUT_ACTIVITY* `OutputPort <ContrastiveHebbian_Output>`;  otherwise,
   it is assigned the value of the `input_field <ContrastiveHebbian_Fields>` of `current_activity
   <ContrastiveHebbianMechanism.current_activity>`.
 ..
 * `plus_phase_activity <ContrastiveHebbianMechanism.plus_phase_activity>` is assigned as the `value
-  <OutputPort.value>` of the *CURRENT_ACTIVITY* `OutputPort <ContrastiveHebbian_Output>`;
+  <OutputPort.value>` of the *CURRENT_ACTIVITY_ATTR* `OutputPort <ContrastiveHebbian_Output>`;
 ..
 * the difference between `plus_phase_activity <ContrastiveHebbianMechanism.plus_phase_activity>` and
   `minus_phase_activity <ContrastiveHebbianMechanism.minus_phase_activity>` is assigned as the `value
-  <OutputPort.value>` of the *ACTIVITY_DIFFERENCE_OUTPUT* `OutputPort <ContrastiveHebbian_Output>`.
+  <OutputPort.value>` of the *ACTIVITY_DIFFERENCE* `OutputPort <ContrastiveHebbian_Output>`.
 
 .. _ContrastiveHebbian_Learning_Execution:
 
@@ -313,7 +313,7 @@
 ~~~~~~~~~~
 
 If a ContrastiveHebbianMechanism is `configured for learning <ContrastiveHebbian_Learning>`, at the end of each
-`trial of execution <ContrastiveHebbian_Processing>` the `value <OutputPort.value>` of its *ACTIVITY_DIFFERENCE_OUTPUT*
+`trial of execution <ContrastiveHebbian_Processing>` the `value <OutputPort.value>` of its *ACTIVITY_DIFFERENCE*
 `OutputPort <ContrastiveHebbian_Output>` is passed to its `learning_mechanism
 <ContrastiveHebbianMechanism.learning_mechanism>`.  If the Mechanism is part of a `System`, then the
 `learning_mechanism <ContrastiveHebbianMechanism.learning_mechanism>` is executed during the `execution phase
@@ -338,7 +338,6 @@
 from psyneulink.core.components.functions.statefulfunctions.integratorfunctions import AdaptiveIntegrator
 from psyneulink.core.components.functions.transferfunctions import Linear, get_matrix
 from psyneulink.core.components.mechanisms.mechanism import Mechanism
-from psyneulink.core.components.ports.outputport import PRIMARY, StandardOutputPorts
 from psyneulink.core.globals.context import ContextFlags, handle_external_context
 from psyneulink.core.globals.keywords import \
     CONTRASTIVE_HEBBIAN_MECHANISM, COUNT, FUNCTION, HARD_CLAMP, HOLLOW_MATRIX, MAX_ABS_DIFF, NAME, \
@@ -351,9 +350,9 @@
 from psyneulink.library.components.projections.pathway.autoassociativeprojection import AutoAssociativeProjection
 
 __all__ = [
-    'ContrastiveHebbianError', 'ContrastiveHebbianMechanism', 'CONTRASTIVE_HEBBIAN_OUTPUT',
-    'ACTIVITY_DIFFERENCE_OUTPUT', 'CURRENT_ACTIVITY_OUTPUT', 'SIMPLE_HEBBIAN', 'INPUT',
-    'MINUS_PHASE_ACTIVITY', 'MINUS_PHASE_OUTPUT', 'PLUS_PHASE_ACTIVITY', 'PLUS_PHASE_OUTPUT'
+    'ACTIVITY_DIFFERENCE', 'CURRENT_ACTIVITY', 'SIMPLE_HEBBIAN', 'INPUT',
+    'MINUS_PHASE_ACTIVITY', 'PLUS_PHASE_ACTIVITY', 'OUTPUT_ACTIVITY',
+    'ContrastiveHebbianError', 'ContrastiveHebbianMechanism',
 ]
 
 INPUT = 'INPUT'
@@ -365,21 +364,21 @@
 
 SIMPLE_HEBBIAN = 'SIMPLE_HEBBIAN'
 
+OUTPUT_ACTIVITY = 'OUTPUT_ACTIVITY'
+CURRENT_ACTIVITY = 'CURRENT_ACTIVITY'
+ACTIVITY_DIFFERENCE = 'ACTIVITY_DIFFERENCE'
+MINUS_PHASE_ACTIVITY = 'MINUS_PHASE_ACTIVITY'
+PLUS_PHASE_ACTIVITY = 'PLUS_PHASE_ACTIVITY'
+
+OUTPUT_ACTIVITY_ATTR = 'output_activity'
+CURRENT_ACTIVITY_ATTR = 'current_activity'
+MINUS_PHASE_ACTIVITY_ATTR = 'minus_phase_activity'
+PLUS_PHASE_ACTIVITY_ATTR = 'plus_phase_activity'
+
 INPUT_INDEX = 0
 RECURRENT_INDEX = 1
 TARGET_INDEX = 2
 
-OUTPUT_ACTIVITY = 'output_activity'
-CURRENT_ACTIVITY = 'current_activity'
-MINUS_PHASE_ACTIVITY = 'minus_phase_activity'
-PLUS_PHASE_ACTIVITY = 'plus_phase_activity'
-
-OUTPUT_ACTIVITY_OUTPUT = 'OUTPUT_ACTIVITY_OUTPUT'
-CURRENT_ACTIVITY_OUTPUT = 'CURRENT_ACTIVITY_OUTPUT'
-ACTIVITY_DIFFERENCE_OUTPUT = 'ACTIVITY_DIFFERENCE_OUTPUT'
-MINUS_PHASE_OUTPUT = 'MINUS_PHASE_OUTPUT'
-PLUS_PHASE_OUTPUT = 'PLUS_PHASE_OUTPUT'
-
 MINUS_PHASE = False
 PLUS_PHASE  = True
 
@@ -391,58 +390,13 @@ def __init__(self, error_value):
     def __str__(self):
         return repr(self.error_value)
 
-# This is a convenience class that provides list of standard_output_port names in IDE
-class CONTRASTIVE_HEBBIAN_OUTPUT():
-    """
-        .. _ContrastiveHebbianMechanism_Standard_OutputPorts:
-
-        A ContrastiveHebbianMechanism has the following `Standard OutputPorts <OutputPort_Standard>` in addition to
-        those of a `RecurruentTransferMechanism <RecurrentTransferMechanism_Standard_OutputPorts>`:
-
-        .. _OUTPUT_ACTIVITY_OUTPUT:
-
-        *OUTPUT_ACTIVITY_OUTPUT* : 1d np.array
-            array with activity of the `target_field <ContrastiveHebbian_Fields>` of `current_activity
-            <ContrastiveHebbianMechanism.current_activity>` if a *TARGET* `InputPort is specified
-            <ContrastiveHebbian_Input>`;  otherwise, has activity of the `input_field <ContrastiveHebbian_Fields>` of
-            `current_activity <ContrastiveHebbianMechanism.current_activity>`.
-
-        .. _CURRENT_ACTIVITY_OUTPUT:
-
-        *CURRENT_ACTIVITY_OUTPUT* : 1d np.array
-            array with `current_activity <ContrastiveHebbianMechanism.current_activity>`.
-
-        .. _ACTIVITY_DIFFERENCE_OUTPUT:
-
-        *ACTIVITY_DIFFERENCE_OUTPUT* : 1d np.array
-            array of element-wise differences between `plus_phase_activity
-            <ContrastiveHebbianMechanism.plus_phase_activity>` and `minus_phase_activity
-            <ContrastiveHebbianMechanism.minus_phase_activity>`.
-
-        .. _MINUS_PHASE_OUTPUT:
-
-        *MINUS_PHASE_OUTPUT* : 1d np.array
-            array `minus_phase_activity <ContrastiveHebbianMechanism.minus_phase_activity>`
-            (i.e., activity at the end of the `minus phase of execution <ContrastiveHebbian_Minus_Phase>`.
-
-        .. _PLUS_PHASE_OUTPUT:
-
-        *PLUS_PHASE_OUTPUT* : 1d np.array
-            array `plus_phase_activity <ContrastiveHebbianMechanism.plus_phase_activity>`
-            (i.e., activity at the end of the `plus phase of execution <ContrastiveHebbian_Plus_Phase>`.
-
-
-        """
-    CURRENT_ACTIVITY_OUTPUT=CURRENT_ACTIVITY_OUTPUT
-    ACTIVITY_DIFFERENCE_OUTPUT=ACTIVITY_DIFFERENCE_OUTPUT
-    MINUS_PHASE_OUTPUT=MINUS_PHASE_OUTPUT
-    PLUS_PHASE_OUTPUT=PLUS_PHASE_OUTPUT
-
 
 def _CHM_output_activity_getter(owning_component=None, context=None):
     current_activity = owning_component.parameters.current_activity._get(context)
-    return current_activity[owning_component.target_start:owning_component.target_end]
-
+    if owning_component.target_size:
+        return current_activity[owning_component.target_start:owning_component.target_end]
+    else:
+        return current_activity[:owning_component.input_size]
 
 def _CHM_input_activity_getter(owning_component=None, context=None):
     current_activity = owning_component.parameters.current_activity._get(context)
@@ -499,7 +453,7 @@ class ContrastiveHebbianMechanism(RecurrentTransferMechanism):
     target_size : int : default None
         specifies the size of the *TARGET* `InputPort <ContrastiveHebbian_Input>`, number of units in the
         `input_field <ContrastiveHebbian_Fields>` of `current_activity <ContrastiveHebbianMechanism.current_activity>`,
-        and of the `OUTPUT_ACTIVITY_OUTPUT` `OutputPort <ContrastiveHebbian_Output>`.
+        and of the `OUTPUT_ACTIVITY` `OutputPort <ContrastiveHebbian_Output>`.
 
     separated : bool : default True
         specifies whether `target_field <ContrastiveHebbian_Fields>` should be different from the `input_field
@@ -581,7 +535,7 @@ class ContrastiveHebbianMechanism(RecurrentTransferMechanism):
         size of the *TARGET* `InputPort <ContrastiveHebbian_Input>` `if specified <ContrastiveHebbian_Creation>` and,
         if so, the number of units in `target_activity <ContrastiveHebbianMechanism.target_activity>`, the
         `target_field <ContrastiveHebbian_Fields>` of `current_activity <ContrastiveHebbianMechanism.current_activity>`,
-        and the *OUTPUT_ACTIVITY_OUTPUT* `OutputPort <ContrastiveHebbian_Output>`.
+        and the *OUTPUT_ACTIVITY* `OutputPort <ContrastiveHebbian_Output>`.
 
     target_start : int
         index of first unit of `target_field <ContrastiveHebbian_Fields>`.
@@ -595,7 +549,7 @@ class ContrastiveHebbianMechanism(RecurrentTransferMechanism):
 
     recurrent_size : int
         size of *RECURRENT* `InputPort <ContrastiveHebbian_Input>`, `current_activity
-        <ContrastiveHebbianMechanism.current_activity>`, and *CURRENT_ACTIVITY_OUTPUT* `OutputPort
+        <ContrastiveHebbianMechanism.current_activity>`, and *CURRENT_ACTIVITY* `OutputPort
         <ContrastiveHebbian_Output>`.
 
     mode : SIMPLE_HEBBIAN or None
@@ -603,7 +557,7 @@ class ContrastiveHebbianMechanism(RecurrentTransferMechanism):
         `SIMPLE_HEBBIAN mode <ContrastiveHebbian_SIMPLE_HEBBIAN>` for details).
 
     recurrent_projection : AutoAssociativeProjection
-        an `AutoAssociativeProjection` that projects from the *CURRENT_ACTIVITY_OUTPUT* `OutputPort
+        an `AutoAssociativeProjection` that projects from the *CURRENT_ACTIVITY* `OutputPort
         <ContrastiveHebbian_Output>` to the *RECURRENT* `InputPort <ContrastiveHebbian_Input>`.
 
     combination_function : method or function
@@ -708,23 +662,60 @@ class ContrastiveHebbianMechanism(RecurrentTransferMechanism):
         `False` = `minus phase <ContrastiveHebbian_Minus_Phase>`;
         `True` = `plus phase <ContrastiveHebbian_Plus_Phase>`.
 
-    output_ports : Dict[str: OutputPort]
-        an OrderedDict with the following `OutputPorts <OutputPort>` by default:
+    output_ports : ContentAddressableList[OutputPort]
+        contains the following `OutputPorts <OutputPort>` by default:
 
-        * *OUTPUT_ACTIVITY_OUTPUT*, the  `primary OutputPort  <OutputPort_Primary>` of the Mechanism, the `value
+        * *OUTPUT_ACTIVITY*, the `primary OutputPort  <OutputPort_Primary>` of the Mechanism, the `value
           <OutputPort.value>` of which is `target_activity <ContrastiveHebbianMechanism.target_activity>` if a
           *TARGET* `InputPort <ContrastiveHebbian_Input>` is implemented;  otherwise,  `input_activity
           <ContrastiveHebbianMechanism.input_activity>` is assigned as its `value <OutputPort.value>`.
 
-        * *CURRENT_ACTIVITY_OUTPUT* -- the `value <OutputPort.value>` of which is a 1d array containing the activity
+        * *CURRENT_ACTIVITY* -- the `value <OutputPort.value>` of which is a 1d array containing the activity
           of the ContrastiveHebbianMechanism after each execution;  at the end of an `execution sequence
           <ContrastiveHebbian_Execution>`, it is assigned the value of `plus_phase_activity
           <ContrastiveHebbianMechanism.plus_phase_activity>`.
 
-        * *ACTIVITY_DIFFERENCE_OUTPUT*, the `value <OutputPort.value>` of which is a 1d array with the elementwise
+        * *ACTIVITY_DIFFERENCE*, the `value <OutputPort.value>` of which is a 1d array with the elementwise
           differences in activity between the plus and minus phases at the end of an `execution sequence
           <ContrastiveHebbian_Execution>`.
 
+    standard_output_ports : list[str]
+        list of `Standard OutputPorts <OutputPort_Standard>` that includes the following in addition to the
+        `standard_output_ports <RecurrentTransferMechanism.standard_output_ports>` of a `RecurrentTransferMechanism`:
+
+        .. _OUTPUT_ACTIVITY:
+
+        *OUTPUT_ACTIVITY* : 1d np.array
+            array with activity of the `target_field <ContrastiveHebbian_Fields>` of `current_activity
+            <ContrastiveHebbianMechanism.current_activity>` if a *TARGET* `InputPort is specified
+            <ContrastiveHebbian_Input>`;  otherwise, has activity of the `input_field <ContrastiveHebbian_Fields>` of
+            `current_activity <ContrastiveHebbianMechanism.current_activity>`.
+
+        .. _CURRENT_ACTIVITY:
+
+        *CURRENT_ACTIVITY* : 1d np.array
+            array with `current_activity <ContrastiveHebbianMechanism.current_activity>`.
+
+        .. _ACTIVITY_DIFFERENCE:
+
+        *ACTIVITY_DIFFERENCE* : 1d np.array
+            array of element-wise differences between `plus_phase_activity
+            <ContrastiveHebbianMechanism.plus_phase_activity>` and `minus_phase_activity
+            <ContrastiveHebbianMechanism.minus_phase_activity>`.
+
+        .. _MINUS_PHASE_ACTIVITY:
+
+        *MINUS_PHASE_ACTIVITY* : 1d np.array
+            array `minus_phase_activity <ContrastiveHebbianMechanism.minus_phase_activity>`
+            (i.e., activity at the end of the `minus phase of execution <ContrastiveHebbian_Minus_Phase>`.
+
+        .. _PLUS_PHASE_ACTIVITY:
+
+        *PLUS_PHASE_ACTIVITY* : 1d np.array
+            array `plus_phase_activity <ContrastiveHebbianMechanism.plus_phase_activity>`
+            (i.e., activity at the end of the `plus phase of execution <ContrastiveHebbian_Plus_Phase>`.
+
+
     Returns
     -------
     instance of ContrastiveHebbianMechanism : ContrastiveHebbianMechanism
@@ -963,20 +954,20 @@ class Parameters(RecurrentTransferMechanism.Parameters):
     paramClassDefaults = RecurrentTransferMechanism.paramClassDefaults.copy()
 
     standard_output_ports = RecurrentTransferMechanism.standard_output_ports.copy()
-    standard_output_ports.extend([{NAME:OUTPUT_ACTIVITY_OUTPUT,
-                                    VARIABLE:OUTPUT_ACTIVITY},
-                                   {NAME:CURRENT_ACTIVITY_OUTPUT,
-                                    VARIABLE:CURRENT_ACTIVITY},
-                                   {NAME:ACTIVITY_DIFFERENCE_OUTPUT,
-                                    VARIABLE:[PLUS_PHASE_ACTIVITY, MINUS_PHASE_ACTIVITY],
+    standard_output_ports.extend([{NAME:OUTPUT_ACTIVITY,
+                                    VARIABLE:OUTPUT_ACTIVITY_ATTR},
+                                   {NAME:CURRENT_ACTIVITY,
+                                    VARIABLE:CURRENT_ACTIVITY_ATTR},
+                                   {NAME:ACTIVITY_DIFFERENCE,
+                                    VARIABLE:[PLUS_PHASE_ACTIVITY_ATTR, MINUS_PHASE_ACTIVITY_ATTR],
                                     FUNCTION: lambda v: v[0] - v[1]},
-                                   {NAME:MINUS_PHASE_OUTPUT,
-                                    VARIABLE:MINUS_PHASE_ACTIVITY},
-                                   {NAME:PLUS_PHASE_OUTPUT,
-                                    VARIABLE:PLUS_PHASE_ACTIVITY},
+                                   {NAME:MINUS_PHASE_ACTIVITY,
+                                    VARIABLE:MINUS_PHASE_ACTIVITY_ATTR},
+                                   {NAME:PLUS_PHASE_ACTIVITY,
+                                    VARIABLE:PLUS_PHASE_ACTIVITY_ATTR},
                                    ])
     standard_output_port_names = RecurrentTransferMechanism.standard_output_port_names.copy()
-    standard_output_port_names.extend([i['name'] for i in standard_output_ports])
+    standard_output_port_names = [i['name'] for i in standard_output_ports]
 
     @tc.typecheck
     def __init__(self,
@@ -1055,7 +1046,7 @@ def __init__(self,
 
         combination_function = combination_function or self.combination_function
 
-        output_ports = [OUTPUT_ACTIVITY_OUTPUT, CURRENT_ACTIVITY_OUTPUT, ACTIVITY_DIFFERENCE_OUTPUT]
+        output_ports = [OUTPUT_ACTIVITY, CURRENT_ACTIVITY, ACTIVITY_DIFFERENCE]
         if additional_output_ports:
             if isinstance(additional_output_ports, list):
                 output_ports += additional_output_ports
@@ -1140,7 +1131,7 @@ def _instantiate_recurrent_projection(self,
             matrix = get_matrix(matrix, size, size)
 
         return AutoAssociativeProjection(owner=mech,
-                                         sender=self.output_ports[CURRENT_ACTIVITY_OUTPUT],
+                                         sender=self.output_ports[CURRENT_ACTIVITY],
                                          receiver=self.input_ports[RECURRENT],
                                          matrix=matrix,
                                          name=mech.name + ' recurrent projection')
@@ -1148,10 +1139,10 @@ def _instantiate_recurrent_projection(self,
     def _instantiate_attributes_after_function(self, context=None):
 
         # Assign these after instantiation of function, since they are initialized in _execute (see below)
-        self.attributes_dict_entries.update({OUTPUT_ACTIVITY:OUTPUT_ACTIVITY,
-                                             CURRENT_ACTIVITY:CURRENT_ACTIVITY,
-                                             MINUS_PHASE_ACTIVITY:MINUS_PHASE_ACTIVITY,
-                                             PLUS_PHASE_ACTIVITY:PLUS_PHASE_ACTIVITY})
+        self.attributes_dict_entries.update({OUTPUT_ACTIVITY_ATTR:OUTPUT_ACTIVITY_ATTR,
+                                             CURRENT_ACTIVITY_ATTR:CURRENT_ACTIVITY_ATTR,
+                                             MINUS_PHASE_ACTIVITY_ATTR:MINUS_PHASE_ACTIVITY_ATTR,
+                                             PLUS_PHASE_ACTIVITY_ATTR:PLUS_PHASE_ACTIVITY_ATTR})
         super()._instantiate_attributes_after_function(context=context)
 
     def _execute(self,
@@ -1332,9 +1323,9 @@ def is_converged(self, value=NotImplemented, context=None):
 
     @property
     def _learning_signal_source(self):
-        """Override default to use ACTIVITY_DIFFERENCE_OUTPUT as source of learning signal
+        """Override default to use ACTIVITY_DIFFERENCE as source of learning signal
         """
-        return self.output_ports[ACTIVITY_DIFFERENCE_OUTPUT]
+        return self.output_ports[ACTIVITY_DIFFERENCE]
 
     @property
     def input_activity(self):
diff --git a/psyneulink/library/components/mechanisms/processing/transfer/kohonenmechanism.py b/psyneulink/library/components/mechanisms/processing/transfer/kohonenmechanism.py
index e900817c8be..1fbac92bc7f 100644
--- a/psyneulink/library/components/mechanisms/processing/transfer/kohonenmechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/transfer/kohonenmechanism.py
@@ -115,24 +115,6 @@ def __str__(self):
 INPUT_PATTERN = 'INPUT_PATTERN'
 
 
-# This is a convenience class that provides list of standard_output_port names in IDE
-class KohonenMechanism_OUTPUT():
-        """
-            .. _KohonenMechanism_Standard_OutputPorts:
-
-            A KohonenMechanism has the following `Standard OutputPorts <OutputPort_Standard>` in addition to those of a
-            `TransferMechanism <TransferMechanism_Standard_OutputPorts>`:
-
-            .. _KohonenMechanism_MAXIMUM_ACTIVITY:
-
-            *MAXIMUM_ACTIVITY* : 1d array
-                 "one hot" encoding of the most active element of the Mechanism's `value <Mechanisms_Base.value>` in
-                 the last execution.
-
-        """
-        MAXIMUM_ACTIVITY=MAXIMUM_ACTIVITY
-
-
 class KohonenMechanism(TransferMechanism):
     """
     KohonenMechanism(                                          \
@@ -216,6 +198,17 @@ class KohonenMechanism(TransferMechanism):
           <Mechanisms_Base.variable>`, which is provided to the *ACTIVATION_OUTPUT* InputPort of its
           `learning_mechanism <KohonenMechanisms.learning_mechanism>`.
 
+    standard_output_ports : list[dict]
+        list of `Standard OutputPort <OutputPort_Standard>` that includes the following in addition to
+        the `standard_output_ports <TransferMechanism.standard_output_ports>` of a `TransferMechanism`:
+
+        .. _MAXIMUM_ACTIVITY:
+
+        *MAXIMUM_ACTIVITY* : 1d array
+             "one hot" encoding of the most active element of the Mechanism's `value <Mechanism_Base.value>` in
+             the last execution.
+
+
     Returns
     -------
     instance of KohonenMechanism : KohonenMechanism
diff --git a/psyneulink/library/components/mechanisms/processing/transfer/kwtamechanism.py b/psyneulink/library/components/mechanisms/processing/transfer/kwtamechanism.py
index e70f3168c26..cb0eefcc7b2 100644
--- a/psyneulink/library/components/mechanisms/processing/transfer/kwtamechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/transfer/kwtamechanism.py
@@ -339,8 +339,6 @@ class Parameters(RecurrentTransferMechanism.Parameters):
     paramClassDefaults = RecurrentTransferMechanism.paramClassDefaults.copy()
     paramClassDefaults.update({'function': Logistic})  # perhaps hacky? not sure (7/10/17 CW)
 
-    standard_output_ports = RecurrentTransferMechanism.standard_output_ports.copy()
-
     @tc.typecheck
     def __init__(self,
                  default_variable=None,
diff --git a/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py b/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py
index 5f1a36c4bb4..9ad0677d299 100644
--- a/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py
@@ -81,7 +81,7 @@
 **self_excitation** and the off-diagonal consists of uniform weights specified by the *negative* of the
 **competition** argument.
 
-.. _LCAMechanism_Integrator_Mode
+.. _LCAMechanism_Integrator_Mode:
 
 *Integration*
 ~~~~~~~~~~~~~
@@ -155,25 +155,21 @@
 <LCAMechanism.competition>` off diagonal.
 
 Like any RecurrentTransferMechanism, by default an LCAMechanism has a single `primary OutputPort <OutputPort_Primary>`
-named *RESULT* that contains the Mechanism's current `value <Mechanism_Base.value>`.  The `StandardOutputPorts
-<OutputPort_Standard>` of a `RecurrentTransferMechanism <RecurrentTransferMechanism_Standard_OutputPorts>`,
-are also available for assignment, as well as two additional ones:
-
-    - `MAX_VS_NEXT <LCAMechanism_MAX_VS_NEXT_OUTPUT_PORT>`
-
-    - `MAX_VS_AVG <LCAMechanism_MAX_VS_AVG_OUTPUT_PORT>`
+named *RESULT* that contains the Mechanism's current `value <Mechanism_Base.value>`.  It also has two
+`StandardOutputPorts <OutputPort_Standard>` in its `standard_output_ports <LCAMechanism.standard_output_ports>`
+attribute -- *MAX_VS_NEXT* and *MAX_VS_AVG* that are available for assignment, in addition to the
+`standard_output_ports <RecurrentTransferMechanism.standard_output_ports>` of a `RecurrentTransferMechanism`:
 
 COMMENT:
-The two elements of the `MAX_VS_NEXT <LCAMechanism_MAX_VS_NEXT_OUTPUT_PORT>` OutputPort contain, respectively, the
-index of the LCAMechanism element with the greatest value, and the difference between its value and the next highest
-one. `MAX_VS_AVG <LCAMechanism_MAX_VS_AVG_OUTPUT_PORT>` contains the index of the LCAMechanism element with the
-greatest value, and the difference between its  value and the average of all the others.
+The two elements of the **MAX_VS_NEXT** OutputPort contain, respectively, the index of the LCAMechanism element with
+the greatest value, and the difference between its value and the next highest one. **MAX_VS_AVG** OutputPort contains
+the index of the LCAMechanism element with the greatest value, and the difference between its  value and the average
+of all the others.
 COMMENT
-The `value <OutputPort.value>` of the `MAX_VS_NEXT <LCAMechanism_MAX_VS_NEXT_OUTPUT_PORT>` OutputPort contains the
-difference between the two elements of the LCAMechanism’s `value <Mechanism_Base.value>` with the highest values, and
-the `value <OutputPort.value>` of the `MAX_VS_AVG <LCAMechanism_MAX_VS_AVG_OUTPUT_PORT>` OutputPort contains the
-difference between the element with the highest value and the average of all the others (see `above
-<LCAMechanism_DDM_APPROXIMATION>` for their relationship to the output of a `DDM` Mechanism).
+The `value <OutputPort.value>` of the *MAX_VS_NEXT* OutputPort contains the difference between the two elements of
+the LCAMechanism’s `value <Mechanism_Base.value>` with the highest values, and the `value <OutputPort.value>` of the
+*MAX_VS_AVG* OutputPort contains the difference between the element with the highest value and the average of all
+the others (see `above <LCAMechanism_DDM_APPROXIMATION>` for their relationship to the output of a `DDM` Mechanism).
 
 .. _LCAMechanism_Execution:
 
@@ -203,7 +199,6 @@
 from psyneulink.core.components.functions.statefulfunctions.integratorfunctions import LeakyCompetingIntegrator
 from psyneulink.core.components.functions.transferfunctions import Logistic
 from psyneulink.core.components.mechanisms.processing.transfermechanism import _integrator_mode_setter
-from psyneulink.core.components.ports.outputport import PRIMARY, StandardOutputPorts
 from psyneulink.core.globals.keywords import \
     BETA, CONVERGENCE, FUNCTION, GREATER_THAN_OR_EQUAL, INITIALIZER, LCA_MECHANISM, LESS_THAN_OR_EQUAL, NAME, NOISE, \
     RATE, RESULT, TERMINATION_THRESHOLD, TERMINATION_MEASURE, TERMINATION_COMPARISION_OP, TIME_STEP_SIZE, VALUE
@@ -213,7 +208,7 @@
 from psyneulink.library.components.mechanisms.processing.transfer.recurrenttransfermechanism import \
     RecurrentTransferMechanism
 
-__all__ = ['LCAMechanism', 'LCAMechanism_OUTPUT', 'LCAError', 'CONVERGENCE']
+__all__ = ['LCAMechanism', 'LCAError', 'CONVERGENCE']
 
 
 logger = logging.getLogger(__name__)
@@ -227,30 +222,6 @@ def __str__(self):
         return repr(self.error_value)
 
 
-# This is a convenience class that provides list of standard_output_port names in IDE
-class LCAMechanism_OUTPUT():
-        """
-            .. _LCAMechanism_Standard_OutputPorts:
-
-            An LCAMechanism has the following `Standard OutputPorts <OutputPort_Standard>` in addition to those of a
-            `RecurrentTransferMechanism <RecurrentTransferMechanism_Standard_OutputPorts>`:
-
-            .. _LCAMechanism_MAX_VS_NEXT_OUTPUT_PORT:
-
-            *MAX_VS_NEXT* : float
-                the difference between the two elements of the LCAMechanism's `value <Mechanism_Base.value>`
-                with the highest values.
-
-            .. _LCAMechanism_MAX_VS_AVG_OUTPUT_PORT:
-
-            *MAX_VS_AVG* : float
-                the difference between the element of the LCAMechanism's `value <Mechanism_Base.value>`
-                and the average of all of the other elements.
-
-        """
-        MAX_VS_NEXT=MAX_VS_NEXT
-        MAX_VS_AVG=MAX_VS_AVG
-
 
 # IMPLEMENTATION NOTE:  IMPLEMENTS OFFSET PARAM BUT IT IS NOT CURRENTLY BEING USED
 class LCAMechanism(RecurrentTransferMechanism):
@@ -259,6 +230,7 @@ class LCAMechanism(RecurrentTransferMechanism):
         leak=0.5,                    \
         competition=1.0,             \
         self_excitation=0.0,         \
+        time_step_size=0.1,          \
         threshold = None             \
         threshold_criterion = VALUE)
 
@@ -266,7 +238,6 @@ class LCAMechanism(RecurrentTransferMechanism):
     See `RecurrentTransferMechanism <RecurrentTransferMechanism_Class_Reference>` for additional
     arguments and attributes.
 
-
     Arguments
     ---------
 
@@ -284,6 +255,10 @@ class LCAMechanism(RecurrentTransferMechanism):
         <RecurrentTransferMechanism.recurrent_projection>` (see `self_excitation <LCAMechanism.self_excitation>` for
         additional details).
 
+    time_step_size : float : default 0.1
+        assigned as the `time_step_size <LeakyCompetingIntegrator.time_step_size>` parameter of the
+        `LeakyCompetingIntegrator` Function (see `time_step_size <LCAMechanism.time_step_size>` for additional details).
+
     threshold : float or None : default None
         specifes the value at which the Mechanism's `is_finished` attribute is set to True
         (see `LCAMechanism_Threshold` for additional details).
@@ -308,20 +283,41 @@ class LCAMechanism(RecurrentTransferMechanism):
         accumulation of its `variable <LeakyCompetingIntegrator.variable>` (:math:`x_{i}`) on each time step (see
         `LeakyCompetingIntegrator` for additional details.
 
-    competition : value : default 1.0
+    competition : value
         determines the magnitude of the off-diagonal terms in the LCAMechanism's `recurrent_projection
         <RecurrentTransferMechanism.recurrent_projection>`, thereby scaling the contributions of the competing unit
         (all :math:`f(x)_{j}` where :math:`j \\neq i`) to the accumulation of the `LeakyCompetingIntegrator's
         <LeakyCompetingIntegrator>` `variable <LeakyCompetingIntegrator.variable>` (:math:`x_{i}`) on each time step
         (see `LeakyCompetingIntegrator` for additional details.
 
-    self_excitation : value : default 0.0
+    self_excitation : value
         determines the diagonal terms in the LCAMechanism's `recurrent_projection
         <RecurrentTransferMechanism.recurrent_projection>`, thereby scaling the contributions of each unit's own
         recurrent value (:math:`f(x)_{i}`) to the accumulation of the `LeakyCompetingIntegrator's
         <LeakyCompetingIntegrator>` `variable <LeakyCompetingIntegrator.value>` (:math:`x_{i}`) on each time step
         (see `LeakyCompetingIntegrator` for additional details.
 
+    time_step_size : float
+        parameter of the `LeakyCompetingIntegrator` Function that determines the timing precision of the integration
+        process it implements, and used to scale its `noise <LeakyCompetingIntegrator.noise>` parameter appropriately.
+
+    standard_output_ports : list[str]
+        list of `Standard OutputPorts <OutputPort_Standard>` that includes the following in addition to the
+        `standard_output_ports <RecurrentTransferMechanism.standard_output_ports>` of a `RecurrentTransferMechanism`:
+
+        .. _MAX_VS_NEXT:
+
+        *MAX_VS_NEXT* : float
+            the difference between the two elements of the LCAMechanism's `value <Mechanism_Base.value>`
+            with the highest values.
+
+        .. _MAX_VS_AVG:
+
+        *MAX_VS_AVG* : float
+            the difference between the element of the LCAMechanism's `value <Mechanism_Base.value>`
+            and the average of all of the other elements.
+
+
     Returns
     -------
     instance of LCAMechanism : LCAMechanism
diff --git a/psyneulink/library/components/mechanisms/processing/transfer/recurrenttransfermechanism.py b/psyneulink/library/components/mechanisms/processing/transfer/recurrenttransfermechanism.py
index f8f7270dfb8..33514c831c7 100644
--- a/psyneulink/library/components/mechanisms/processing/transfer/recurrenttransfermechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/transfer/recurrenttransfermechanism.py
@@ -251,29 +251,6 @@ def __init__(self, error_value):
     def __str__(self):
         return repr(self.error_value)
 
-# # This is a convenience class that provides list of standard_output_port names in IDE
-# class RECURRENT_OUTPUT(TRANSFER_OUTPUT):
-#     """
-#         .. _RecurrentTransferMechanism_Standard_OutputPorts:
-#
-#         A RecurrentTransferMechanism has the following `Standard OutputPorts <OutputPort_Standard>` in addition to
-#         those of a `TransferMechanism <TransferMechanism_Standard_OutputPorts>`:
-#
-#         .. _RecurrentTransferMechanism_Standard_OutputPorts:
-#
-#         *ENERGY* : float
-#             the energy of the elements in the LCAMechanism's `value <Mechanism_Base.value>`,
-#             calculated using the `Stability` Function using the `ENERGY` metric.
-#
-#         .. _LCAMechanism_ENTROPY:
-#
-#         *ENTROPY* : float
-#             the entropy of the elements in the LCAMechanism's `value <Mechanism_Base.value>`,
-#             calculated using the `Stability` Function using the `ENTROPY <CROSS_ENTROPY>` metric.
-#
-#         """
-#     ENERGY=ENERGY_OUTPUT_PORT_NAME
-#     ENTROPY=ENTROPY_OUTPUT_PORT_NAME
 
 def _recurrent_transfer_mechanism_matrix_getter(owning_component=None, context=None):
     from psyneulink.library.components.projections.pathway.autoassociativeprojection import get_auto_matrix, get_hetero_matrix
@@ -546,11 +523,8 @@ class RecurrentTransferMechanism(TransferMechanism):
             `learning phase <System_Execution>` of a System's execution
 
     standard_output_ports : list[str]
-
-        the following `Standard OutputPorts <OutputPort_Standard>` are available to assign in addition to
-        those of a `TransferMechanism <TransferMechanism_Standard_OutputPorts>`:
-
-        .. _RecurrentTransferMechanism_Standard_OutputPorts:
+        list of `Standard OutputPorts <OutputPort_Standard>` that includes the following in addition to the
+        `standard_output_ports <TransferMechanism.standard_output_ports>` of a `TransferMechanism`:
 
         *ENERGY* : float
             the energy of the elements in the LCAMechanism's `value <Mechanism_Base.value>`,
@@ -562,7 +536,6 @@ class RecurrentTransferMechanism(TransferMechanism):
             the entropy of the elements in the LCAMechanism's `value <Mechanism_Base.value>`,
             calculated using the `Stability` Function using the `ENTROPY <CROSS_ENTROPY>` metric.
 
-
     Returns
     -------
     instance of RecurrentTransferMechanism : RecurrentTransferMechanism
@@ -1354,7 +1327,7 @@ def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
             last_idx = len(is_real_input.type.pointee) - 1
             real_last_ptr = builder.gep(is_real_input, [ctx.int32_ty(0), ctx.int32_ty(last_idx)])
 
-            recurrent_f = ctx.get_llvm_function(self.recurrent_projection)
+            recurrent_f = ctx.import_llvm_function(self.recurrent_projection)
             recurrent_state = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(1)])
             recurrent_params = builder.gep(params, [ctx.int32_ty(0), ctx.int32_ty(1)])
             # FIXME: Why does this have a wrapper struct?
diff --git a/psyneulink/library/compositions/autodiffcomposition.py b/psyneulink/library/compositions/autodiffcomposition.py
index 7abf93ead25..4af0f90b767 100644
--- a/psyneulink/library/compositions/autodiffcomposition.py
+++ b/psyneulink/library/compositions/autodiffcomposition.py
@@ -68,8 +68,8 @@
       the tensor of the parameter object corresponding to a particular MappingProjection not only has the same
       dimensionality as its `matrix <MappingProjection.matrix>`, it also has the exact same values;
 
-    * Pytorch functions representing the `function <Mechanism_Base.function>` of each `Mechanism` in the Composition
-      incorporate their scalar, untrainable biases.
+    * Pytorch functions representing the `function <Mechanism_Base.function>` of each `Mechanism <Mechanism>` in the
+      Composition incorporate their scalar, untrainable biases.
 
     If it is set to False:
 
diff --git a/psyneulink/library/compositions/compiledoptimizer.py b/psyneulink/library/compositions/compiledoptimizer.py
index 8a9612006f8..7d6aca87784 100644
--- a/psyneulink/library/compositions/compiledoptimizer.py
+++ b/psyneulink/library/compositions/compiledoptimizer.py
@@ -61,7 +61,7 @@ def _gen_zero_gradient_struct(self, ctx, builder, grad_struct):
     def zero_grad(self, ctx):
         name = self._composition.name + "_ZERO_GRAD"
         # try:
-        #     llvm_func = ctx.get_llvm_function(name)
+        #     llvm_func = ctx.import_llvm_function(name)
         #     return llvm_func
         # except Exception as e:
         #     pass
@@ -135,7 +135,7 @@ def initialize_optimizer_struct(self, ctx, builder, optim_struct):
     def step(self, ctx):
         name = self._composition.name + "_ADAM_STEP"
         # try:
-        #     llvm_func = ctx.get_llvm_function(name)
+        #     llvm_func = ctx.import_llvm_function(name)
         #     return llvm_func
         # except Exception as e:
         #     pass
@@ -156,7 +156,7 @@ def step(self, ctx):
         t = builder.gep(optim_struct, [zero, ctx.int32_ty(self._T_NUM)])
 
         # get methods needed
-        pow = ctx.get_llvm_function("__pnl_builtin_pow")
+        pow = ctx.import_llvm_function("__pnl_builtin_pow")
         sqrt = ctx.get_builtin("sqrt", [ctx.float_ty])
 
         lr = ctx.float_ty(self.lr)
@@ -304,7 +304,7 @@ def initialize_optimizer_struct(self, ctx, builder, optim_struct):
     def step(self, ctx):
         name = self._composition.name + "_SGD_STEP"
         # try:
-        #     llvm_func = ctx.get_llvm_function(name)
+        #     llvm_func = ctx.import_llvm_function(name)
         #     return llvm_func
         # except Exception as e:
         #     pass
diff --git a/psyneulink/library/compositions/pytorchmodelcreator.py b/psyneulink/library/compositions/pytorchmodelcreator.py
index aadcbf10d9e..76e0958233b 100644
--- a/psyneulink/library/compositions/pytorchmodelcreator.py
+++ b/psyneulink/library/compositions/pytorchmodelcreator.py
@@ -268,7 +268,7 @@ def _gen_inject_vec_copy(self, ctx, builder, vector, output_vec=None):
         vec_in = builder.gep(vector, [ctx.int32_ty(0), ctx.int32_ty(0)])
         vec_out = builder.gep(output_vec, [ctx.int32_ty(0), ctx.int32_ty(0)])
 
-        builtin = ctx.get_llvm_function("__pnl_builtin_vec_copy")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vec_copy")
         builder.call(builtin, [vec_in, ctx.int32_ty(dim), vec_out])
         return output_vec
 
@@ -284,7 +284,7 @@ def _gen_inject_vec_binop(self, ctx, builder, op, u, v, output_vec=None):
         vec_v = builder.gep(v, [ctx.int32_ty(0), ctx.int32_ty(0)])
         vec_out = builder.gep(output_vec, [ctx.int32_ty(0), ctx.int32_ty(0)])
 
-        builder.call(ctx.get_llvm_function(op), [vec_u, vec_v, ctx.int32_ty(dim), vec_out])
+        builder.call(ctx.import_llvm_function(op), [vec_u, vec_v, ctx.int32_ty(dim), vec_out])
         return output_vec
 
     def _gen_inject_vec_add(self, ctx, builder, u, v, output_vec=None):
@@ -308,7 +308,7 @@ def _gen_inject_mat_binop(self, ctx, builder, op, m1, m2, output_mat=None):
         assert len(output_mat.type.pointee) == x
         assert len(output_mat.type.pointee.element) == y
 
-        builtin = ctx.get_llvm_function(op)
+        builtin = ctx.import_llvm_function(op)
         builder.call(builtin, [builder.bitcast(m1, ctx.float_ty.as_pointer()),
                                builder.bitcast(m2, ctx.float_ty.as_pointer()),
                                ctx.int32_ty(x), ctx.int32_ty(y),
@@ -334,7 +334,7 @@ def _gen_inject_mat_scalar_mult(self, ctx, builder, m1, s, output_mat=None):
         assert len(output_mat.type.pointee) == x
         assert len(output_mat.type.pointee.element) == y
 
-        builtin = ctx.get_llvm_function("__pnl_builtin_mat_scalar_mult")
+        builtin = ctx.import_llvm_function("__pnl_builtin_mat_scalar_mult")
         builder.call(builtin, [builder.bitcast(m1, ctx.float_ty.as_pointer()),
                                s, ctx.int32_ty(x), ctx.int32_ty(y),
                                builder.bitcast(output_mat, ctx.float_ty.as_pointer())])
@@ -353,7 +353,7 @@ def _gen_inject_vxm(self, ctx, builder, m1, m2, output_vec=None):
         v = builder.gep(m1, [ctx.int32_ty(0), ctx.int32_ty(0)])
         out = builder.gep(output_vec, [ctx.int32_ty(0), ctx.int32_ty(0)])
 
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm")
         builder.call(builtin, [v, builder.bitcast(m2, ctx.float_ty.as_pointer()),
                                ctx.int32_ty(y), ctx.int32_ty(z), out])
         return output_vec
@@ -371,7 +371,7 @@ def _gen_inject_vxm_transposed(self, ctx, builder, m1, m2, output_vec=None):
         v = builder.gep(m1, [ctx.int32_ty(0), ctx.int32_ty(0)])
         out = builder.gep(output_vec, [ctx.int32_ty(0), ctx.int32_ty(0)])
 
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm_transposed")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm_transposed")
         builder.call(builtin, [v, builder.bitcast(m2, ctx.float_ty.as_pointer()),
                                ctx.int32_ty(y), ctx.int32_ty(z), out])
         return output_vec
@@ -441,7 +441,7 @@ def _gen_llvm_forward_function_body(self, ctx, builder, _, params, arg_in, arg_o
                 # Apply Activation Func to values
                 if store_z_values is True:
                     z_values[component] = self._gen_inject_vec_copy(ctx, builder, cmp_arg)
-                bin_func = ctx.get_llvm_function(self.bin_function_creator(ctx,component).name)
+                bin_func = ctx.import_llvm_function(self.bin_function_creator(ctx,component).name)
                 self._gen_inject_bin_function_call(ctx, builder, bin_func, cmp_arg, value)
 
                 # TODO: Add bias to value
@@ -518,7 +518,7 @@ def _get_node_array_ptr(node, node_idx, struct_ptr):
         for node in output_nodes:
             backprop_queue.append(node)
 
-        loss_fn = ctx.get_llvm_function(loss._gen_call_function(ctx).name)
+        loss_fn = ctx.import_llvm_function(loss._gen_call_function(ctx).name)
         total_loss = builder.alloca(ctx.float_ty)
         builder.store(ctx.float_ty(0),total_loss)
 
@@ -533,7 +533,7 @@ def _get_node_array_ptr(node, node_idx, struct_ptr):
             node_idx = composition._get_node_index(node)
 
 
-            activation_func_derivative_bin_func = ctx.get_llvm_function(self.bin_function_derivative_creator(ctx,node).name)
+            activation_func_derivative_bin_func = ctx.import_llvm_function(self.bin_function_derivative_creator(ctx,node).name)
             activation_func_derivative = self._gen_inject_bin_function_call(ctx, builder, activation_func_derivative_bin_func, z_values[node])
 
             error_val = builder.alloca(z_values[node].type.pointee)
@@ -693,9 +693,9 @@ def _gen_llvm_training_function_body(self, ctx, builder, context, params, comp_i
 
         optimizer_struct = builder.alloca(optimizer._get_optimizer_struct_type(ctx))
         optimizer.initialize_optimizer_struct(ctx,builder,optimizer_struct)
-        backprop = ctx.get_llvm_function(self._gen_llvm_training_backprop(ctx,optimizer,loss).name)
-        optimizer_step = ctx.get_llvm_function(optimizer.step(ctx).name)
-        optimizer_zero_grad = ctx.get_llvm_function(optimizer.zero_grad(ctx).name)
+        backprop = ctx.import_llvm_function(self._gen_llvm_training_backprop(ctx,optimizer,loss).name)
+        optimizer_step = ctx.import_llvm_function(optimizer.step(ctx).name)
+        optimizer_zero_grad = ctx.import_llvm_function(optimizer.zero_grad(ctx).name)
         with pnlvm.helpers.for_loop_zero_inc(builder, epochs, "epoch_loop") as (b1, epoch_idx):
             ctx.inject_printf(builder, "\033[0;32mEPOCH %d\033[0m\n", epoch_idx)
             with pnlvm.helpers.for_loop_zero_inc(b1, num_trials, "input_loop") as (b2, trial_num):
@@ -804,7 +804,7 @@ def bin_function_creator(self, ctx, node, context=None):
         # first try to get cached func
         name = node.name + "_" + node.function.name
         try:
-            llvm_func = ctx.get_llvm_function(name)
+            llvm_func = ctx.import_llvm_function(name)
             return llvm_func
         except Exception as e:
             pass
@@ -842,7 +842,7 @@ def modify_value(x):
             bias = get_fct_param_value('bias')
             offset = get_fct_param_value('offset')
             one = ctx.float_ty(1)
-            exp = ctx.get_llvm_function("__pnl_builtin_exp")
+            exp = ctx.import_llvm_function("__pnl_builtin_exp")
             def modify_value(x):
                 arg = builder.fadd(x, bias)
                 arg = builder.fmul(gain, arg)
@@ -875,7 +875,7 @@ def bin_function_derivative_creator(self, ctx, node, context=None):
         # first try to get cached func
         name = node.name + "_" + node.function.name + "_derivative"
         try:
-            llvm_func = ctx.get_llvm_function(name)
+            llvm_func = ctx.import_llvm_function(name)
             return llvm_func
         except Exception as e:
             pass
@@ -911,7 +911,7 @@ def modify_value(x):
             bias = get_fct_param_value('bias')
             offset = get_fct_param_value('offset')
             one = ctx.float_ty(1)
-            exp = ctx.get_llvm_function("__pnl_builtin_exp")
+            exp = ctx.import_llvm_function("__pnl_builtin_exp")
 
             def modify_value(x):
                 arg = builder.fadd(x, bias)
diff --git a/setup.cfg b/setup.cfg
index d62d4c2fcec..7d32cb02cfd 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -14,8 +14,8 @@ addopts =
     --benchmark-warmup=on
     --benchmark-warmup-iterations=2
     --cov-config setup.cfg
-    --docstyle
-    --codestyle
+    --pydocstyle
+    --pycodestyle
 
 markers =
 	stress: Long running tests, skipped by defaults
@@ -57,12 +57,13 @@ pytest_plugins = ['pytest_profiling', 'helpers_namespace', 'benchmark']
 
 xfail_strict = True
 
+[pycodestyle]
 # for code explanation see https://pep8.readthedocs.io/en/latest/intro.html#error-codes
-codestyle_ignore = E101 E111 E114 E115 E116 E117 E121 E122 E123 E124 E125 E126 E127 E128 E129 E131 E201 E202 E203 E211 E221 E225 E231 E241 E251 E252 E261 E262 E265 E266 E271 E301 E302 E303 E305 E306 E402 E501 E502 E701 E711 E712 E713 E714 E721 E722 E731 E741 W191 W292 W293 W391 W503 W504 W605
+ignore = E101,E111,E114,E115,E116,E117,E121,E122,E123,E124,E125,E126,E127,E128,E129,E131,E201,E202,E203,E211,E221,E225,E231,E241,E251,E252,E261,E262,E265,E266,E271,E301,E302,E303,E305,E306,E402,E501,E502,E701,E711,E712,E713,E714,E721,E722,E731,E741,W191,W292,W293,W391,W503,W504,W605
 
+[pydocstyle]
 # for code explanation see http://www.pydocstyle.org/en/latest/error_codes.html
-docstyle_add_ignore = D100 D101 D102 D103 D104 D105 D106 D107 D200 D202 D204 D205 D207 D208 D301 D400 D401 D402 D403 D412 D413 D414
-docstyle_exclude = __init__.py
+add-ignore = D100,D101,D102,D103,D104,D105,D106,D107,D200,D202,D204,D205,D207,D208,D301,D400,D401,D402,D403,D412,D413,D414
 
 [coverage:run]
 branch = True
diff --git a/tests/composition/test_autodiffcomposition.py b/tests/composition/test_autodiffcomposition.py
index 37c3675b859..ec8b0796680 100644
--- a/tests/composition/test_autodiffcomposition.py
+++ b/tests/composition/test_autodiffcomposition.py
@@ -8,6 +8,7 @@
 import psyneulink as pnl
 
 from psyneulink.core.components.functions.transferfunctions import Logistic
+from psyneulink.core.compositions.composition import Composition
 from psyneulink.core.globals import Context
 from psyneulink.core.globals.keywords import TRAINING_SET
 from psyneulink.core.components.mechanisms.processing.compositioninterfacemechanism import CompositionInterfaceMechanism
@@ -1549,123 +1550,6 @@ def test_semantic_net_training_time(self, eps, opt):
 @pytest.mark.acidenticalness
 class TestTrainingIdenticalness():
 
-    @pytest.mark.parametrize(
-        'eps, opt', [
-            # (1, 'sgd'),
-            (10, 'sgd'),
-            # (100, 'sgd')
-        ]
-    )
-    def test_xor_training_identicalness(self, eps, opt):
-        from torch.nn import MSELoss
-        # SET UP MECHANISMS FOR COMPOSITION
-
-        xor_in = TransferMechanism(name='xor_in',
-                                   default_variable=np.zeros(2))
-
-        xor_hid = TransferMechanism(name='xor_hid',
-                                    default_variable=np.zeros(10),
-                                    function=Logistic())
-
-        xor_out = TransferMechanism(name='xor_out',
-                                    default_variable=np.zeros(1),
-                                    function=Logistic())
-
-        # SET UP MECHANISMS FOR SYSTEM
-
-        xor_in_sys = TransferMechanism(name='xor_in_sys',
-                                       default_variable=np.zeros(2))
-
-        xor_hid_sys = TransferMechanism(name='xor_hid_sys',
-                                        default_variable=np.zeros(10),
-                                        function=Logistic())
-
-        xor_out_sys = TransferMechanism(name='xor_out_sys',
-                                        default_variable=np.zeros(1),
-                                        function=Logistic())
-
-        # SET UP PROJECTIONS FOR COMPOSITION
-
-        hid_map = MappingProjection(name='hid_map',
-                                    matrix=np.random.rand(2,10),
-                                    sender=xor_in,
-                                    receiver=xor_hid)
-
-        out_map = MappingProjection(name='out_map',
-                                    matrix=np.random.rand(10,1),
-                                    sender=xor_hid,
-                                    receiver=xor_out)
-
-        # SET UP PROJECTIONS FOR SYSTEM
-
-        hid_map_sys = MappingProjection(name='hid_map_sys',
-                                    matrix=hid_map.matrix.copy(),
-                                    sender=xor_in_sys,
-                                    receiver=xor_hid_sys)
-
-        out_map_sys = MappingProjection(name='out_map_sys',
-                                    matrix=out_map.matrix.copy(),
-                                    sender=xor_hid_sys,
-                                    receiver=xor_out_sys)
-
-        # SET UP COMPOSITION
-        # NOTE: default loss function has changed since implementation of System. We implement a custom loss function
-        # here to make this test pass
-        custom_loss = MSELoss(reduction='sum')
-        xor = AutodiffComposition(param_init_from_pnl=True,
-                                  learning_rate=10,
-                                  optimizer_type=opt,
-                                  loss_spec=lambda x,y: custom_loss(x,y) / 2
-                                  )
-
-        xor.add_node(xor_in)
-        xor.add_node(xor_hid)
-        xor.add_node(xor_out)
-
-        xor.add_projection(sender=xor_in, projection=hid_map, receiver=xor_hid)
-        xor.add_projection(sender=xor_hid, projection=out_map, receiver=xor_out)
-
-        # SET UP INPUTS AND TARGETS
-
-        xor_inputs = np.array(  # the inputs we will provide to the model
-            [[0, 0],
-             [0, 1],
-             [1, 0],
-             [1, 1]])
-
-        xor_targets = np.array(  # the outputs we wish to see from the model
-            [[0],
-             [1],
-             [1],
-             [0]])
-
-        # TRAIN COMPOSITION
-        inputs_dict = {"inputs": {xor_in:xor_inputs},
-                       "targets": {xor_out:xor_targets},
-                       "epochs": eps}
-
-        result = xor.run(inputs=inputs_dict)
-        comp_weights = xor.get_parameters()[0]
-
-        # SET UP SYSTEM
-        xor_process = Process(pathway=[xor_in_sys,
-                                       hid_map_sys,
-                                       xor_hid_sys,
-                                       out_map_sys,
-                                       xor_out_sys],
-                              learning=pnl.LEARNING)
-        xor_sys = System(processes=[xor_process],
-                         learning_rate=10)
-
-        # TRAIN SYSTEM
-        results_sys = xor_sys.run(inputs={xor_in_sys:xor_inputs},
-                                  targets={xor_out_sys:xor_targets},
-                                  num_trials=(eps * xor_inputs.shape[0]))
-        # CHECK THAT PARAMETERS FOR COMPOSITION, SYSTEM ARE SAME
-
-        assert np.allclose(comp_weights[hid_map], hid_map_sys.get_mod_matrix(xor_sys))
-        assert np.allclose(comp_weights[out_map], out_map_sys.get_mod_matrix(xor_sys))
-
     @pytest.mark.parametrize(
         'eps, opt', [
             # (1, 'sgd'),
@@ -1674,7 +1558,6 @@ def test_xor_training_identicalness(self, eps, opt):
         ]
     )
     def test_semantic_net_training_identicalness(self, eps, opt):
-        from torch.nn import MSELoss
         # SET UP MECHANISMS FOR SEMANTIC NET:
 
         nouns_in = TransferMechanism(name="nouns_input",
@@ -1814,11 +1697,9 @@ def test_semantic_net_training_identicalness(self, eps, opt):
                                            receiver=out_sig_can_sys)
 
         # SET UP COMPOSITION FOR SEMANTIC NET
-        custom_loss = MSELoss(reduction='sum')
         sem_net = AutodiffComposition(param_init_from_pnl=True,
                                       learning_rate=0.5,
                                       optimizer_type=opt,
-                                      loss_spec=lambda x, y: custom_loss(x, y) / 2
                                       )
 
         sem_net.add_node(nouns_in)
@@ -1933,44 +1814,56 @@ def test_semantic_net_training_identicalness(self, eps, opt):
         comp_weights = sem_net.get_parameters()[0]
 
         # SET UP SYSTEM
-
-        p11 = Process(pathway=[nouns_in_sys,
-                               map_nouns_h1_sys,
-                               h1_sys,
-                               map_h1_h2_sys,
-                               h2_sys,
-                               map_h2_I_sys,
-                               out_sig_I_sys],
-                      learning=pnl.LEARNING)
-
-        p12 = Process(pathway=[rels_in_sys,
-                               map_rels_h2_sys,
-                               h2_sys,
-                               map_h2_is_sys,
-                               out_sig_is_sys],
-                      learning=pnl.LEARNING)
-
-        p21 = Process(pathway=[h2_sys,
-                               map_h2_has_sys,
-                               out_sig_has_sys],
-                      learning=pnl.LEARNING)
-
-        p22 = Process(pathway=[h2_sys,
-                               map_h2_can_sys,
-                               out_sig_can_sys],
-                      learning=pnl.LEARNING)
-
-        sem_net_sys = System(processes=[p11,
-                                        p12,
-                                        p21,
-                                        p22,
-                                        ],
-                             learning_rate=0.5)
+        sem_net_sys = Composition()
+
+        learning_components = sem_net_sys.add_backpropagation_learning_pathway(
+            pathway=[
+                nouns_in_sys,
+                map_nouns_h1_sys,
+                h1_sys,
+                map_h1_h2_sys,
+                h2_sys,
+                map_h2_I_sys,
+                out_sig_I_sys
+            ],
+            learning_rate=0.5
+        )
+        inputs_dict_sys[learning_components[pnl.TARGET_MECHANISM]] = targets_dict[out_sig_I]
+
+        learning_components = sem_net_sys.add_backpropagation_learning_pathway(
+            pathway=[
+                rels_in_sys,
+                map_rels_h2_sys,
+                h2_sys,
+                map_h2_is_sys,
+                out_sig_is_sys
+            ],
+            learning_rate=0.5
+        )
+        inputs_dict_sys[learning_components[pnl.TARGET_MECHANISM]] = targets_dict[out_sig_is]
+
+        learning_components = sem_net_sys.add_backpropagation_learning_pathway(
+            pathway=[
+                h2_sys,
+                map_h2_has_sys,
+                out_sig_has_sys
+            ],
+            learning_rate=0.5
+        )
+        inputs_dict_sys[learning_components[pnl.TARGET_MECHANISM]] = targets_dict[out_sig_has]
+
+        learning_components = sem_net_sys.add_backpropagation_learning_pathway(
+            pathway=[
+                h2_sys,
+                map_h2_can_sys,
+                out_sig_can_sys
+            ],
+            learning_rate=0.5
+        )
+        inputs_dict_sys[learning_components[pnl.TARGET_MECHANISM]] = targets_dict[out_sig_can]
 
         # TRAIN SYSTEM
-
         results = sem_net_sys.run(inputs=inputs_dict_sys,
-                                  targets=targets_dict_sys,
                                   num_trials=(len(inputs_dict_sys[nouns_in_sys]) * eps))
 
         # CHECK THAT PARAMETERS FOR COMPOSITION, SYSTEM ARE SAME
diff --git a/tests/composition/test_learning.py b/tests/composition/test_learning.py
index 148e5a29a35..9e45e5fafe2 100644
--- a/tests/composition/test_learning.py
+++ b/tests/composition/test_learning.py
@@ -394,15 +394,42 @@ def test_multilayer(self):
                                              function=pnl.Logistic,
                                              size=3)
 
-        input_weights = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
-        middle_weights = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
-        output_weights = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
+        input_weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
+        middle_weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
+        output_weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
+
+        # This projection will be used by the process below by referencing it in the process' pathway;
+        #    note: sender and receiver args don't need to be specified
+        input_weights = pnl.MappingProjection(
+            name='Input Weights',
+            matrix=input_weights_matrix,
+        )
+
+        # This projection will be used by the process below by assigning its sender and receiver args
+        #    to mechanismss in the pathway
+        middle_weights = pnl.MappingProjection(
+            name='Middle Weights',
+            sender=hidden_layer_1,
+            receiver=hidden_layer_2,
+            matrix=middle_weights_matrix,
+        )
+
+        # Commented lines in this projection illustrate variety of ways in which matrix and learning signals can be specified
+        output_weights = pnl.MappingProjection(
+            name='Output Weights',
+            sender=hidden_layer_2,
+            receiver=output_layer,
+            matrix=output_weights_matrix,
+        )
 
         comp = pnl.Composition(name='multilayer')
 
         p = [input_layer, input_weights, hidden_layer_1, middle_weights, hidden_layer_2, output_weights, output_layer]
-        learning_components = comp.add_backpropagation_learning_pathway(pathway=p,
-                                                                learning_rate=1.)
+        learning_components = comp.add_backpropagation_learning_pathway(
+            pathway=p,
+            loss_function='sse',
+            learning_rate=1.
+        )
 
         target_node = learning_components[pnl.TARGET_MECHANISM]
 
@@ -414,6 +441,52 @@ def test_multilayer(self):
         comp.run(inputs=input_dictionary,
                  num_trials=10)
     
+        objective_output_layer = comp.nodes[5]
+
+        expected_output = [
+            (output_layer.get_output_values(comp), [np.array([0.22686074, 0.25270212, 0.91542149])]),
+            # error here? why still MSE
+            (objective_output_layer.output_ports[pnl.MSE].parameters.value.get(comp), np.array(0.04082589331852094)),
+            (input_weights.get_mod_matrix(comp), np.array([
+                [ 0.09900247, 0.19839653, 0.29785764, 0.39739191, 0.49700232],
+                [ 0.59629092, 0.69403786, 0.79203411, 0.89030237, 0.98885379],
+            ])),
+            (middle_weights.get_mod_matrix(comp), np.array([
+                [ 0.09490249, 0.10488719, 0.12074013, 0.1428774 ],
+                [ 0.29677354, 0.30507726, 0.31949676, 0.3404652 ],
+                [ 0.49857336, 0.50526254, 0.51830509, 0.53815062],
+                [ 0.70029406, 0.70544225, 0.71717037, 0.73594383],
+                [ 0.90192903, 0.90561554, 0.91609668, 0.93385292],
+            ])),
+            (output_weights.get_mod_matrix(comp), np.array([
+                [-0.74447522, -0.71016859, 0.31575293],
+                [-0.50885177, -0.47444784, 0.56676582],
+                [-0.27333719, -0.23912033, 0.8178167 ],
+                [-0.03767547, -0.00389039, 1.06888608],
+            ])),
+            (comp.parameters.results.get(comp), [
+                [np.array([0.8344837 , 0.87072018, 0.89997433])],
+                [np.array([0.77970193, 0.83263138, 0.90159627])],
+                [np.array([0.70218502, 0.7773823 , 0.90307765])],
+                [np.array([0.60279149, 0.69958079, 0.90453143])],
+                [np.array([0.4967927 , 0.60030321, 0.90610082])],
+                [np.array([0.4056202 , 0.49472391, 0.90786617])],
+                [np.array([0.33763025, 0.40397637, 0.90977675])],
+                [np.array([0.28892812, 0.33633532, 0.9117193 ])],
+                [np.array([0.25348771, 0.28791896, 0.9136125 ])],
+                [np.array([0.22686074, 0.25270212, 0.91542149])]
+            ]),
+        ]
+
+        # Test nparray output of log for Middle_Weights
+
+        for i in range(len(expected_output)):
+            val, expected = expected_output[i]
+            # setting absolute tolerance to be in accordance with reference_output precision
+            # if you do not specify, assert_allcose will use a relative tolerance of 1e-07,
+            # which WILL FAIL unless you gather higher precision values to use as reference
+            np.testing.assert_allclose(val, expected, atol=1e-08, err_msg='Failed on expected_output[{0}]'.format(i))
+
     @pytest.mark.parametrize('models', [
         # [pnl.SYSTEM,pnl.COMPOSITION],
         # [pnl.SYSTEM,'AUTODIFF'],
diff --git a/tests/learning/test_multilayer.py b/tests/learning/test_multilayer.py
deleted file mode 100644
index c315c8fa6f1..00000000000
--- a/tests/learning/test_multilayer.py
+++ /dev/null
@@ -1,482 +0,0 @@
-import numpy as np
-
-from psyneulink.core.components.functions.transferfunctions import Logistic
-from psyneulink.core.components.mechanisms.processing.transfermechanism import TransferMechanism
-from psyneulink.core.components.process import Process
-from psyneulink.core.components.projections.pathway.mappingprojection import MappingProjection
-from psyneulink.core.components.system import System
-from psyneulink.core.globals.keywords import EXECUTION, LEARNING, PROCESSING, SOFT_CLAMP, VALUE
-from psyneulink.core.globals.preferences.basepreferenceset import REPORT_OUTPUT_PREF, VERBOSE_PREF
-from psyneulink.library.components.mechanisms.processing.objective.comparatormechanism import MSE
-
-
-def test_multilayer():
-    Input_Layer = TransferMechanism(
-        name='Input Layer',
-        function=Logistic,
-        default_variable=np.zeros((2,)),
-    )
-
-    Hidden_Layer_1 = TransferMechanism(
-        name='Hidden Layer_1',
-        function=Logistic(),
-        # default_variable=np.zeros((5,)),
-        size=5
-    )
-
-    Hidden_Layer_2 = TransferMechanism(
-        name='Hidden Layer_2',
-        function=Logistic(),
-        default_variable=[0, 0, 0, 0],
-    )
-
-    Output_Layer = TransferMechanism(
-        name='Output Layer',
-        function=Logistic,
-        default_variable=[0, 0, 0],
-    )
-
-    Input_Weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
-    Middle_Weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
-    Output_Weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
-
-    # TEST PROCESS.LEARNING WITH:
-    # CREATION OF FREE STANDING PROJECTIONS THAT HAVE NO LEARNING (Input_Weights, Middle_Weights and Output_Weights)
-    # INLINE CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and Output_Weights)
-    # NO EXPLICIT CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and Output_Weights)
-
-    # This projection will be used by the process below by referencing it in the process' pathway;
-    #    note: sender and receiver args don't need to be specified
-    Input_Weights = MappingProjection(
-        name='Input Weights',
-        matrix=Input_Weights_matrix,
-    )
-
-    # This projection will be used by the process below by assigning its sender and receiver args
-    #    to mechanismss in the pathway
-    Middle_Weights = MappingProjection(
-        name='Middle Weights',
-        sender=Hidden_Layer_1,
-        receiver=Hidden_Layer_2,
-        matrix=Middle_Weights_matrix,
-    )
-
-    # Commented lines in this projection illustrate variety of ways in which matrix and learning signals can be specified
-    Output_Weights = MappingProjection(
-        name='Output Weights',
-        sender=Hidden_Layer_2,
-        receiver=Output_Layer,
-        matrix=Output_Weights_matrix,
-    )
-
-    p = Process(
-        # default_variable=[0, 0],
-        size=2,
-        pathway=[
-            Input_Layer,
-            # The following reference to Input_Weights is needed to use it in the pathway
-            #    since it's sender and receiver args are not specified in its declaration above
-            Input_Weights,
-            Hidden_Layer_1,
-            # No projection specification is needed here since the sender arg for Middle_Weights
-            #    is Hidden_Layer_1 and its receiver arg is Hidden_Layer_2
-            # Middle_Weights,
-            Hidden_Layer_2,
-            # Output_Weights does not need to be listed for the same reason as Middle_Weights
-            # If Middle_Weights and/or Output_Weights is not declared above, then the process
-            #    will assign a default for missing projection
-            # Output_Weights,
-            Output_Layer
-        ],
-        clamp_input=SOFT_CLAMP,
-        learning=LEARNING,
-        learning_rate=1.0,
-        target=[0, 0, 1],
-        prefs={
-            VERBOSE_PREF: False,
-            REPORT_OUTPUT_PREF: False
-        },
-    )
-
-    stim_list = {Input_Layer: [[-1, 30]]}
-    target_list = {Output_Layer: [[0, 0, 1]]}
-
-    def show_target():
-        i = s.input
-        t = s.target_input_ports[0].parameters.value.get(s)
-        print('\nOLD WEIGHTS: \n')
-        print('- Input Weights: \n', Input_Weights.get_mod_matrix(s))
-        print('- Middle Weights: \n', Middle_Weights.get_mod_matrix(s))
-        print('- Output Weights: \n', Output_Weights.get_mod_matrix(s))
-        print('\nSTIMULI:\n\n- Input: {}\n- Target: {}\n'.format(i, t))
-        print('ACTIVITY FROM OLD WEIGHTS: \n')
-        print('- Middle 1: \n', Hidden_Layer_1.parameters.value.get(s))
-        print('- Middle 2: \n', Hidden_Layer_2.parameters.value.get(s))
-        print('- Output:\n', Output_Layer.parameters.value.get(s))
-
-    s = System(
-        processes=[p],
-        targets=[0, 0, 1],
-        learning_rate=1.0,
-    )
-
-    # s.reportOutputPref = True
-
-    results = s.run(
-        num_trials=10,
-        inputs=stim_list,
-        targets=target_list,
-        call_after_trial=show_target,
-    )
-
-    objective_output_layer = s.mechanisms[4]
-
-    results_list = []
-    for elem in s.results:
-        for nested_elem in elem:
-            nested_elem = nested_elem.tolist()
-            try:
-                iter(nested_elem)
-            except TypeError:
-                nested_elem = [nested_elem]
-            results_list.extend(nested_elem)
-
-    expected_output = [
-        (Output_Layer.get_output_values(s), [np.array([0.22686074, 0.25270212, 0.91542149])]),
-        (objective_output_layer.output_ports[MSE].parameters.value.get(s), np.array(0.04082589331852094)),
-        (Input_Weights.get_mod_matrix(s), np.array([
-            [ 0.09900247, 0.19839653, 0.29785764, 0.39739191, 0.49700232],
-            [ 0.59629092, 0.69403786, 0.79203411, 0.89030237, 0.98885379],
-        ])),
-        (Middle_Weights.get_mod_matrix(s), np.array([
-            [ 0.09490249, 0.10488719, 0.12074013, 0.1428774 ],
-            [ 0.29677354, 0.30507726, 0.31949676, 0.3404652 ],
-            [ 0.49857336, 0.50526254, 0.51830509, 0.53815062],
-            [ 0.70029406, 0.70544225, 0.71717037, 0.73594383],
-            [ 0.90192903, 0.90561554, 0.91609668, 0.93385292],
-        ])),
-        (Output_Weights.get_mod_matrix(s), np.array([
-            [-0.74447522, -0.71016859, 0.31575293],
-            [-0.50885177, -0.47444784, 0.56676582],
-            [-0.27333719, -0.23912033, 0.8178167 ],
-            [-0.03767547, -0.00389039, 1.06888608],
-        ])),
-        (results, [
-            [np.array([0.8344837 , 0.87072018, 0.89997433])],
-            [np.array([0.77970193, 0.83263138, 0.90159627])],
-            [np.array([0.70218502, 0.7773823 , 0.90307765])],
-            [np.array([0.60279149, 0.69958079, 0.90453143])],
-            [np.array([0.4967927 , 0.60030321, 0.90610082])],
-            [np.array([0.4056202 , 0.49472391, 0.90786617])],
-            [np.array([0.33763025, 0.40397637, 0.90977675])],
-            [np.array([0.28892812, 0.33633532, 0.9117193 ])],
-            [np.array([0.25348771, 0.28791896, 0.9136125 ])],
-            [np.array([0.22686074, 0.25270212, 0.91542149])]
-        ]),
-    ]
-
-    # Test nparray output of log for Middle_Weights
-
-    for i in range(len(expected_output)):
-        val, expected = expected_output[i]
-        # setting absolute tolerance to be in accordance with reference_output precision
-        # if you do not specify, assert_allcose will use a relative tolerance of 1e-07,
-        # which WILL FAIL unless you gather higher precision values to use as reference
-        np.testing.assert_allclose(val, expected, atol=1e-08, err_msg='Failed on expected_output[{0}]'.format(i))
-
-
-def test_multilayer_log():
-    Input_Layer = TransferMechanism(
-        name='Input Layer',
-        function=Logistic,
-        default_variable=np.zeros((2,)),
-    )
-
-    Hidden_Layer_1 = TransferMechanism(
-        name='Hidden Layer_1',
-        function=Logistic(),
-        # default_variable=np.zeros((5,)),
-        size=5
-    )
-
-    Hidden_Layer_2 = TransferMechanism(
-        name='Hidden Layer_2',
-        function=Logistic(),
-        default_variable=[0, 0, 0, 0],
-    )
-
-    Output_Layer = TransferMechanism(
-        name='Output Layer',
-        function=Logistic,
-        default_variable=[0, 0, 0],
-    )
-
-    Input_Weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
-    Middle_Weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
-    Output_Weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
-
-    # TEST PROCESS.LEARNING WITH:
-    # CREATION OF FREE STANDING PROJECTIONS THAT HAVE NO LEARNING (Input_Weights, Middle_Weights and Output_Weights)
-    # INLINE CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and Output_Weights)
-    # NO EXPLICIT CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and Output_Weights)
-
-    # This projection will be used by the process below by referencing it in the process' pathway;
-    #    note: sender and receiver args don't need to be specified
-    Input_Weights = MappingProjection(
-        name='Input Weights',
-        matrix=Input_Weights_matrix,
-    )
-
-    # This projection will be used by the process below by assigning its sender and receiver args
-    #    to mechanismss in the pathway
-    Middle_Weights = MappingProjection(
-        name='Middle Weights',
-        sender=Hidden_Layer_1,
-        receiver=Hidden_Layer_2,
-        matrix=Middle_Weights_matrix,
-    )
-
-    # Commented lines in this projection illustrate variety of ways in which matrix and learning signals can be specified
-    Output_Weights = MappingProjection(
-        name='Output Weights',
-        sender=Hidden_Layer_2,
-        receiver=Output_Layer,
-        matrix=Output_Weights_matrix,
-    )
-
-    p = Process(
-        # default_variable=[0, 0],
-        size=2,
-        pathway=[
-            Input_Layer,
-            # The following reference to Input_Weights is needed to use it in the pathway
-            #    since it's sender and receiver args are not specified in its declaration above
-            Input_Weights,
-            Hidden_Layer_1,
-            # No projection specification is needed here since the sender arg for Middle_Weights
-            #    is Hidden_Layer_1 and its receiver arg is Hidden_Layer_2
-            # Middle_Weights,
-            Hidden_Layer_2,
-            # Output_Weights does not need to be listed for the same reason as Middle_Weights
-            # If Middle_Weights and/or Output_Weights is not declared above, then the process
-            #    will assign a default for missing projection
-            # Output_Weights,
-            Output_Layer
-        ],
-        clamp_input=SOFT_CLAMP,
-        learning=LEARNING,
-        learning_rate=1.0,
-        target=[0, 0, 1],
-        prefs={
-            VERBOSE_PREF: False,
-            REPORT_OUTPUT_PREF: False
-        },
-    )
-
-    Middle_Weights.set_log_conditions(('mod_matrix', PROCESSING))
-
-    stim_list = {Input_Layer: [[-1, 30]]}
-    target_list = {Output_Layer: [[0, 0, 1]]}
-
-    def show_target():
-        i = s.input
-        t = s.target_input_ports[0].parameters.value.get(s)
-        print('\nOLD WEIGHTS: \n')
-        print('- Input Weights: \n', Input_Weights.get_mod_matrix(s))
-        print('- Middle Weights: \n', Middle_Weights.get_mod_matrix(s))
-        print('- Output Weights: \n', Output_Weights.get_mod_matrix(s))
-        print('\nSTIMULI:\n\n- Input: {}\n- Target: {}\n'.format(i, t))
-        print('ACTIVITY FROM OLD WEIGHTS: \n')
-        print('- Middle 1: \n', Hidden_Layer_1.parameters.value.get(s))
-        print('- Middle 2: \n', Hidden_Layer_2.parameters.value.get(s))
-        print('- Output:\n', Output_Layer.parameters.value.get(s))
-
-    s = System(
-        processes=[p],
-        targets=[0, 0, 1],
-        learning_rate=1.0,
-    )
-
-    s.run(
-        num_trials=10,
-        inputs=stim_list,
-        targets=target_list,
-        call_after_trial=show_target,
-    )
-
-    expected_log_val = np.array(
-        [
-            ['System-0'],
-            [[
-                [[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]],
-                [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]],
-                [[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]],
-                [[2], [2], [2], [2], [2], [2], [2], [2], [2], [2]],
-                [ [[ 0.05,  0.1 ,  0.15,  0.2 ],
-                   [ 0.25,  0.3 ,  0.35,  0.4 ],
-                   [ 0.45,  0.5 ,  0.55,  0.6 ],
-                   [ 0.65,  0.7 ,  0.75,  0.8 ],
-                   [ 0.85,  0.9 ,  0.95,  1.  ]],
-                  [[ 0.04789907,  0.09413833,  0.14134241,  0.18938924],
-                   [ 0.24780811,  0.29388455,  0.34096758,  0.38892985],
-                   [ 0.44772121,  0.49364209,  0.54060947,  0.58849095],
-                   [ 0.64763875,  0.69341202,  0.74026967,  0.78807449],
-                   [ 0.84756101,  0.89319513,  0.93994932,  0.98768187]],
-                  [[ 0.04738148,  0.08891106,  0.13248753,  0.177898  ],
-                   [ 0.24726841,  0.28843403,  0.33173452,  0.37694783],
-                   [ 0.44716034,  0.48797777,  0.53101423,  0.57603893],
-                   [ 0.64705774,  0.6875443 ,  0.73032986,  0.77517531],
-                   [ 0.84696096,  0.88713512,  0.92968378,  0.97435998]],
-                  [[ 0.04937771,  0.08530344,  0.12439361,  0.16640433],
-                   [ 0.24934878,  0.28467436,  0.32329947,  0.36496974],
-                   [ 0.44932147,  0.48407216,  0.52225175,  0.56359587],
-                   [ 0.64929589,  0.68349948,  0.72125508,  0.76228876],
-                   [ 0.84927212,  0.88295836,  0.92031297,  0.96105307]],
-                  [[ 0.05440291,  0.08430585,  0.1183739 ,  0.15641064],
-                   [ 0.25458348,  0.28363519,  0.3170288 ,  0.35455942],
-                   [ 0.45475764,  0.48299299,  0.51573974,  0.55278488],
-                   [ 0.65492462,  0.68238209,  0.7145124 ,  0.75109483],
-                   [ 0.85508376,  0.88180465,  0.91335119,  0.94949538]],
-                  [[ 0.06177218,  0.0860581 ,  0.11525064,  0.14926369],
-                   [ 0.26225812,  0.28546004,  0.31377611,  0.34711631],
-                   [ 0.46272625,  0.48488774,  0.51236246,  0.54505667],
-                   [ 0.66317453,  0.68434373,  0.7110159 ,  0.74309381],
-                   [ 0.86360121,  0.88382991,  0.9097413 ,  0.94123489]],
-                  [[ 0.06989398,  0.08959148,  0.11465594,  0.14513241],
-                   [ 0.27071639,  0.2891398 ,  0.31315677,  0.34281389],
-                   [ 0.47150846,  0.48870843,  0.5117194 ,  0.54058946],
-                   [ 0.67226675,  0.68829929,  0.71035014,  0.73846891],
-                   [ 0.87298831,  0.88791376,  0.90905395,  0.93646   ]],
-                  [[ 0.07750784,  0.09371987,  0.11555569,  0.143181  ],
-                   [ 0.27864693,  0.29343991,  0.31409396,  0.3407813 ],
-                   [ 0.47974374,  0.49317377,  0.5126926 ,  0.53847878],
-                   [ 0.68079346,  0.69292265,  0.71135777,  0.73628353],
-                   [ 0.88179203,  0.89268732,  0.91009431,  0.93420362]],
-                  [[ 0.0841765 ,  0.09776672,  0.11711835,  0.14249779],
-                   [ 0.28559463,  0.29765609,  0.31572199,  0.34006951],
-                   [ 0.48695967,  0.49755273,  0.51438349,  0.5377395 ],
-                   [ 0.68826567,  0.69745713,  0.71310872,  0.735518  ],
-                   [ 0.88950757,  0.89736946,  0.91190228,  0.93341316]],
-                  [[ 0.08992499,  0.10150104,  0.11891032,  0.14250149],
-                   [ 0.29158517,  0.30154765,  0.31758943,  0.34007336],
-                   [ 0.49318268,  0.50159531,  0.51632339,  0.5377435 ],
-                   [ 0.69471052,  0.70164382,  0.71511777,  0.73552215],
-                   [ 0.8961628 ,  0.90169281,  0.91397691,  0.93341744]]]
-            ]]
-        ],
-        dtype=object
-    )
-    log_val = Middle_Weights.log.nparray(entries='mod_matrix', header=False)
-
-    assert log_val[0] == expected_log_val[0]
-
-    for i in range(1, len(log_val)):
-        try:
-            np.testing.assert_allclose(log_val[i], expected_log_val[i])
-        except TypeError:
-            for j in range(len(log_val[i])):
-                np.testing.assert_allclose(
-                    np.array(log_val[i][j][0]),
-                    np.array(expected_log_val[i][j][0]),
-                    atol=1e-08,
-                    err_msg='Failed on test item {0} of logged values'.format(i)
-                )
-
-    Middle_Weights.log.print_entries()
-
-    # Test Programatic logging
-    Hidden_Layer_2.log.log_values(VALUE, s)
-    log_val = Hidden_Layer_2.log.nparray(header=False)
-    expected_log_val = np.array(
-        [
-            ['System-0'],
-            [[
-                [[1]],
-                [[0]],
-                [[0]],
-                [[0]],
-                [[[0.8565238418942037, 0.8601053239957609, 0.8662098921116546, 0.8746933736954071]]]
-            ]]
-        ],
-        dtype=object
-    )
-    assert log_val[0] == expected_log_val[0]
-
-    for i in range(1, len(log_val)):
-        try:
-            np.testing.assert_allclose(log_val[i], expected_log_val[i])
-        except TypeError:
-            for j in range(len(log_val[i])):
-                np.testing.assert_allclose(
-                    np.array(log_val[i][j][0]),
-                    np.array(expected_log_val[i][j][0]),
-                    atol=1e-08,
-                    err_msg='Failed on test item {0} of logged values'.format(i)
-                )
-    Hidden_Layer_2.log.print_entries()
-
-    # Clear log and test with logging of weights set to LEARNING for another 5 trials of learning
-    Middle_Weights.log.clear_entries(entries=None, confirm=False)
-    Middle_Weights.set_log_conditions(('mod_matrix', LEARNING))
-    s.run(
-        num_trials=5,
-        inputs=stim_list,
-        targets=target_list,
-    )
-    log_val = Middle_Weights.log.nparray(entries='mod_matrix', header=False)
-    expected_log_val = np.array(
-        [
-            ['System-0'],
-            [[
-                    [[1], [1], [1], [1], [1]],  # RUN
-                    # [[0], [1], [2], [3], [4]],  # TRIAL
-                    [[1], [2], [3], [4], [5]],  # TRIAL
-                    # [[1], [1], [1], [1], [1]],  # PASS
-                    [[0], [0], [0], [0], [0]],  # PASS
-                    # [[1], [1], [1], [1], [1]],  # TIME_STEP
-                    [[0], [0], [0], [0], [0]],  # TIME_STEP
-                    [  [[0.09925812411381937, 0.1079522130303428, 0.12252820028789306, 0.14345816973727732],
-                        [0.30131473371328343, 0.30827285172236585, 0.3213609999139731, 0.3410707131678078],
-                        [0.5032924245149345, 0.5085833053183328, 0.5202423523987703, 0.5387798509126243],
-                        [0.70518251216691, 0.7088822116145151, 0.7191771716324874, 0.7365956448426355],
-                        [0.9069777724600303, 0.9091682860319945, 0.9181692763668221, 0.93452610920817]],
-                       [[0.103113468050986, 0.11073719161508278, 0.12424368674464399, 0.14415219181047598],
-                        [0.3053351724284921, 0.3111770895557729, 0.3231499474835138, 0.341794454877438],
-                        [0.5074709829757806, 0.5116017638574931, 0.5221016574478528, 0.5395320566440044],
-                        [0.7095115080472698, 0.7120093413898914, 0.7211034158081356, 0.7373749316571768],
-                        [0.9114489813353512, 0.9123981459792809, 0.9201588001021687, 0.935330996581107]],
-                      [[0.10656261740658036, 0.11328192907953168, 0.12587702586370172, 0.14490737831188183],
-                       [0.30893272045369513, 0.31383131362555394, 0.32485356055342113, 0.3425821330631872],
-                       [0.5112105492674988, 0.5143607671543178, 0.5238725230390068, 0.5403508295336265],
-                       [0.7133860755337162, 0.7148679468096026, 0.7229382109974996, 0.7382232628724675],
-                       [0.9154510531345043, 0.9153508224199809, 0.9220539747533424, 0.936207244690072]],
-                      [[0.10967776822419642, 0.11562091141141007, 0.12742795007904037, 0.14569308665620523],
-                       [0.3121824816018084, 0.316271366885665, 0.3264715025259811, 0.34340179304134666],
-                       [0.5145890402653069, 0.5168974760377518, 0.5255545550838675, 0.5412029579613059],
-                       [0.7168868378231593, 0.7174964619674593, 0.7246811176253708, 0.7391062307617761],
-                       [0.9190671994078436, 0.9180659725806082, 0.923854327015523, 0.9371193149131859]],
-                      [[0.11251466428344682, 0.11778293740676549, 0.12890014813698167, 0.14649079441816393],
-                       [0.31514245505635713, 0.3185271913574249, 0.328007571201157, 0.3442341089776976],
-                       [0.5176666356203712, 0.5192429413004418, 0.5271516632648602, 0.5420683480396268],
-                       [0.7200760707077265, 0.7199270072739019, 0.7263361597421493, 0.7400030122347587],
-                       [0.922361699102421, 0.9205767427437028, 0.9255639970037588, 0.9380456963960624]]]
-            ]]
-        ],
-        dtype=object
-    )
-
-    assert log_val.shape == expected_log_val.shape
-    assert log_val[0] == expected_log_val[0]
-    assert len(log_val[1]) == len(expected_log_val[1]) == 1
-
-    for i in range(len(log_val[1][0])):
-        try:
-            np.testing.assert_allclose(log_val[1][0][i], expected_log_val[1][0][i])
-        except TypeError:
-            for j in range(len(log_val[1][0][i])):
-                np.testing.assert_allclose(
-                    np.array(log_val[1][0][i][j]),
-                    np.array(expected_log_val[1][0][i][j]),
-                    atol=1e-08,
-                    err_msg='Failed on test item {0} of logged values'.format(i)
-                )
diff --git a/tests/llvm/test_builtins_matrix.py b/tests/llvm/test_builtins_matrix.py
index b0bfe0cba2c..81ecb56d462 100644
--- a/tests/llvm/test_builtins_matrix.py
+++ b/tests/llvm/test_builtins_matrix.py
@@ -112,7 +112,7 @@ def test_dot_llvm_constant_dim(benchmark, mode):
         func_ty = ir.FunctionType(ir.VoidType(), (double_ptr_ty, double_ptr_ty, double_ptr_ty))
 
         # get builtin IR
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm")
 
         # Create square vector matrix multiply
         function = ir.Function(ctx.module, func_ty, name=custom_name)
@@ -176,7 +176,7 @@ def test_dot_transposed_llvm_constant_dim(benchmark, mode):
         func_ty = ir.FunctionType(ir.VoidType(), (double_ptr_ty, double_ptr_ty, double_ptr_ty))
 
         # get builtin IR
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm_transposed")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm_transposed")
 
         # Create square vector matrix multiply
         function = ir.Function(ctx.module, func_ty, name=custom_name)
diff --git a/tests/llvm/test_custom_func.py b/tests/llvm/test_custom_func.py
index aa6e894d206..d9d1f32b770 100644
--- a/tests/llvm/test_custom_func.py
+++ b/tests/llvm/test_custom_func.py
@@ -42,7 +42,7 @@ def test_fixed_dimensions__pnl_builtin_vxm(mode):
         func_ty = ir.FunctionType(ir.VoidType(), (double_ptr_ty, double_ptr_ty, double_ptr_ty))
 
         # get builtin IR
-        builtin = ctx.get_llvm_function("__pnl_builtin_vxm")
+        builtin = ctx.import_llvm_function("__pnl_builtin_vxm")
 
         # Create square vector matrix multiply
         function = ir.Function(ctx.module, func_ty, name=custom_name)
diff --git a/tests/log/test_log.py b/tests/log/test_log.py
index e300bcaaf45..304b4dcfd4d 100644
--- a/tests/log/test_log.py
+++ b/tests/log/test_log.py
@@ -1178,3 +1178,250 @@ def test_csv(self, node_logged_in_simulation):
         for row in full_csv.split('\n')[1:]:
             # if present in a row, context will be in the first cell
             assert pnl.EID_SIMULATION not in row.replace("'", '').split(',')[0]
+
+
+class TestFullModels:
+    def test_multilayer(self):
+
+        input_layer = pnl.TransferMechanism(name='input_layer',
+                                            function=pnl.Logistic,
+                                            size=2)
+
+        hidden_layer_1 = pnl.TransferMechanism(name='hidden_layer_1',
+                                               function=pnl.Logistic,
+                                               size=5)
+
+        hidden_layer_2 = pnl.TransferMechanism(name='hidden_layer_2',
+                                               function=pnl.Logistic,
+                                               size=4)
+
+        output_layer = pnl.TransferMechanism(name='output_layer',
+                                             function=pnl.Logistic,
+                                             size=3)
+
+        input_weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
+        middle_weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
+        output_weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
+
+        # This projection will be used by the process below by referencing it in the process' pathway;
+        #    note: sender and receiver args don't need to be specified
+        input_weights = pnl.MappingProjection(
+            name='Input Weights',
+            matrix=input_weights_matrix,
+        )
+
+        # This projection will be used by the process below by assigning its sender and receiver args
+        #    to mechanismss in the pathway
+        middle_weights = pnl.MappingProjection(
+            name='Middle Weights',
+            sender=hidden_layer_1,
+            receiver=hidden_layer_2,
+            matrix=middle_weights_matrix,
+        )
+
+        # Commented lines in this projection illustrate variety of ways in which matrix and learning signals can be specified
+        output_weights = pnl.MappingProjection(
+            name='Output Weights',
+            sender=hidden_layer_2,
+            receiver=output_layer,
+            matrix=output_weights_matrix,
+        )
+
+        comp = pnl.Composition(name='multilayer')
+
+        p = [input_layer, input_weights, hidden_layer_1, middle_weights, hidden_layer_2, output_weights, output_layer]
+        learning_components = comp.add_backpropagation_learning_pathway(
+            pathway=p,
+            loss_function='sse',
+            learning_rate=1.
+        )
+
+        target_node = learning_components[pnl.TARGET_MECHANISM]
+
+        input_dictionary = {target_node: [[0., 0., 1.]],
+                            input_layer: [[-1., 30.]]}
+
+        middle_weights.set_log_conditions(('mod_matrix', pnl.PROCESSING))
+
+        comp.run(inputs=input_dictionary,
+                 num_trials=10)
+
+        expected_log_val = np.array(
+            [
+                ['multilayer'],
+                [[
+                    [[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]],
+                    [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]],
+                    [[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]],
+                    [[2], [2], [2], [2], [2], [2], [2], [2], [2], [2]],
+                    [ [[ 0.05,  0.1 ,  0.15,  0.2 ],
+                       [ 0.25,  0.3 ,  0.35,  0.4 ],
+                       [ 0.45,  0.5 ,  0.55,  0.6 ],
+                       [ 0.65,  0.7 ,  0.75,  0.8 ],
+                       [ 0.85,  0.9 ,  0.95,  1.  ]],
+                      [[ 0.04789907,  0.09413833,  0.14134241,  0.18938924],
+                       [ 0.24780811,  0.29388455,  0.34096758,  0.38892985],
+                       [ 0.44772121,  0.49364209,  0.54060947,  0.58849095],
+                       [ 0.64763875,  0.69341202,  0.74026967,  0.78807449],
+                       [ 0.84756101,  0.89319513,  0.93994932,  0.98768187]],
+                      [[ 0.04738148,  0.08891106,  0.13248753,  0.177898  ],
+                       [ 0.24726841,  0.28843403,  0.33173452,  0.37694783],
+                       [ 0.44716034,  0.48797777,  0.53101423,  0.57603893],
+                       [ 0.64705774,  0.6875443 ,  0.73032986,  0.77517531],
+                       [ 0.84696096,  0.88713512,  0.92968378,  0.97435998]],
+                      [[ 0.04937771,  0.08530344,  0.12439361,  0.16640433],
+                       [ 0.24934878,  0.28467436,  0.32329947,  0.36496974],
+                       [ 0.44932147,  0.48407216,  0.52225175,  0.56359587],
+                       [ 0.64929589,  0.68349948,  0.72125508,  0.76228876],
+                       [ 0.84927212,  0.88295836,  0.92031297,  0.96105307]],
+                      [[ 0.05440291,  0.08430585,  0.1183739 ,  0.15641064],
+                       [ 0.25458348,  0.28363519,  0.3170288 ,  0.35455942],
+                       [ 0.45475764,  0.48299299,  0.51573974,  0.55278488],
+                       [ 0.65492462,  0.68238209,  0.7145124 ,  0.75109483],
+                       [ 0.85508376,  0.88180465,  0.91335119,  0.94949538]],
+                      [[ 0.06177218,  0.0860581 ,  0.11525064,  0.14926369],
+                       [ 0.26225812,  0.28546004,  0.31377611,  0.34711631],
+                       [ 0.46272625,  0.48488774,  0.51236246,  0.54505667],
+                       [ 0.66317453,  0.68434373,  0.7110159 ,  0.74309381],
+                       [ 0.86360121,  0.88382991,  0.9097413 ,  0.94123489]],
+                      [[ 0.06989398,  0.08959148,  0.11465594,  0.14513241],
+                       [ 0.27071639,  0.2891398 ,  0.31315677,  0.34281389],
+                       [ 0.47150846,  0.48870843,  0.5117194 ,  0.54058946],
+                       [ 0.67226675,  0.68829929,  0.71035014,  0.73846891],
+                       [ 0.87298831,  0.88791376,  0.90905395,  0.93646   ]],
+                      [[ 0.07750784,  0.09371987,  0.11555569,  0.143181  ],
+                       [ 0.27864693,  0.29343991,  0.31409396,  0.3407813 ],
+                       [ 0.47974374,  0.49317377,  0.5126926 ,  0.53847878],
+                       [ 0.68079346,  0.69292265,  0.71135777,  0.73628353],
+                       [ 0.88179203,  0.89268732,  0.91009431,  0.93420362]],
+                      [[ 0.0841765 ,  0.09776672,  0.11711835,  0.14249779],
+                       [ 0.28559463,  0.29765609,  0.31572199,  0.34006951],
+                       [ 0.48695967,  0.49755273,  0.51438349,  0.5377395 ],
+                       [ 0.68826567,  0.69745713,  0.71310872,  0.735518  ],
+                       [ 0.88950757,  0.89736946,  0.91190228,  0.93341316]],
+                      [[ 0.08992499,  0.10150104,  0.11891032,  0.14250149],
+                       [ 0.29158517,  0.30154765,  0.31758943,  0.34007336],
+                       [ 0.49318268,  0.50159531,  0.51632339,  0.5377435 ],
+                       [ 0.69471052,  0.70164382,  0.71511777,  0.73552215],
+                       [ 0.8961628 ,  0.90169281,  0.91397691,  0.93341744]]]
+                ]]
+            ],
+            dtype=object
+        )
+        log_val = middle_weights.log.nparray(entries='mod_matrix', header=False)
+
+        assert log_val[0] == expected_log_val[0]
+
+        for i in range(1, len(log_val)):
+            try:
+                np.testing.assert_allclose(log_val[i], expected_log_val[i])
+            except TypeError:
+                for j in range(len(log_val[i])):
+                    np.testing.assert_allclose(
+                        np.array(log_val[i][j][0]),
+                        np.array(expected_log_val[i][j][0]),
+                        atol=1e-08,
+                        err_msg='Failed on test item {0} of logged values'.format(i)
+                    )
+
+        middle_weights.log.print_entries()
+
+        # Test Programatic logging
+        hidden_layer_2.log.log_values(pnl.VALUE, comp)
+        log_val = hidden_layer_2.log.nparray(header=False)
+        expected_log_val = np.array(
+            [
+                ['multilayer'],
+                [[
+                    [[1]],
+                    [[0]],
+                    [[0]],
+                    [[0]],
+                    [[[0.8565238418942037, 0.8601053239957609, 0.8662098921116546, 0.8746933736954071]]]
+                ]]
+            ],
+            dtype=object
+        )
+        assert log_val[0] == expected_log_val[0]
+
+        for i in range(1, len(log_val)):
+            try:
+                np.testing.assert_allclose(log_val[i], expected_log_val[i])
+            except TypeError:
+                for j in range(len(log_val[i])):
+                    np.testing.assert_allclose(
+                        np.array(log_val[i][j][0]),
+                        np.array(expected_log_val[i][j][0]),
+                        atol=1e-08,
+                        err_msg='Failed on test item {0} of logged values'.format(i)
+                    )
+        hidden_layer_2.log.print_entries()
+
+        # Clear log and test with logging of weights set to LEARNING for another 5 trials of learning
+        middle_weights.log.clear_entries(entries=None, confirm=False)
+        middle_weights.set_log_conditions(('mod_matrix', pnl.LEARNING))
+        comp.run(
+            num_trials=5,
+            inputs=input_dictionary,
+        )
+        log_val = middle_weights.log.nparray(entries='mod_matrix', header=False)
+        expected_log_val = np.array(
+            [
+                ['multilayer'],
+                [[
+                        [[1], [1], [1], [1], [1]],  # RUN
+                        # [[0], [1], [2], [3], [4]],  # TRIAL
+                        [[0], [1], [2], [3], [4]],  # TRIAL
+                        [[1], [1], [1], [1], [1]],  # PASS
+                        # [[0], [0], [0], [0], [0]],  # PASS
+                        # [[1], [1], [1], [1], [1]],  # TIME_STEP
+                        [[0], [0], [0], [0], [0]],  # TIME_STEP
+                        [  [[0.09925812411381937, 0.1079522130303428, 0.12252820028789306, 0.14345816973727732],
+                            [0.30131473371328343, 0.30827285172236585, 0.3213609999139731, 0.3410707131678078],
+                            [0.5032924245149345, 0.5085833053183328, 0.5202423523987703, 0.5387798509126243],
+                            [0.70518251216691, 0.7088822116145151, 0.7191771716324874, 0.7365956448426355],
+                            [0.9069777724600303, 0.9091682860319945, 0.9181692763668221, 0.93452610920817]],
+                           [[0.103113468050986, 0.11073719161508278, 0.12424368674464399, 0.14415219181047598],
+                            [0.3053351724284921, 0.3111770895557729, 0.3231499474835138, 0.341794454877438],
+                            [0.5074709829757806, 0.5116017638574931, 0.5221016574478528, 0.5395320566440044],
+                            [0.7095115080472698, 0.7120093413898914, 0.7211034158081356, 0.7373749316571768],
+                            [0.9114489813353512, 0.9123981459792809, 0.9201588001021687, 0.935330996581107]],
+                          [[0.10656261740658036, 0.11328192907953168, 0.12587702586370172, 0.14490737831188183],
+                           [0.30893272045369513, 0.31383131362555394, 0.32485356055342113, 0.3425821330631872],
+                           [0.5112105492674988, 0.5143607671543178, 0.5238725230390068, 0.5403508295336265],
+                           [0.7133860755337162, 0.7148679468096026, 0.7229382109974996, 0.7382232628724675],
+                           [0.9154510531345043, 0.9153508224199809, 0.9220539747533424, 0.936207244690072]],
+                          [[0.10967776822419642, 0.11562091141141007, 0.12742795007904037, 0.14569308665620523],
+                           [0.3121824816018084, 0.316271366885665, 0.3264715025259811, 0.34340179304134666],
+                           [0.5145890402653069, 0.5168974760377518, 0.5255545550838675, 0.5412029579613059],
+                           [0.7168868378231593, 0.7174964619674593, 0.7246811176253708, 0.7391062307617761],
+                           [0.9190671994078436, 0.9180659725806082, 0.923854327015523, 0.9371193149131859]],
+                          [[0.11251466428344682, 0.11778293740676549, 0.12890014813698167, 0.14649079441816393],
+                           [0.31514245505635713, 0.3185271913574249, 0.328007571201157, 0.3442341089776976],
+                           [0.5176666356203712, 0.5192429413004418, 0.5271516632648602, 0.5420683480396268],
+                           [0.7200760707077265, 0.7199270072739019, 0.7263361597421493, 0.7400030122347587],
+                           [0.922361699102421, 0.9205767427437028, 0.9255639970037588, 0.9380456963960624]]]
+                ]]
+            ],
+            dtype=object
+        )
+
+        assert log_val.shape == expected_log_val.shape
+        assert log_val[0] == expected_log_val[0]
+        assert len(log_val[1]) == len(expected_log_val[1]) == 1
+
+        for i in range(len(log_val[1][0])):
+            try:
+                np.testing.assert_allclose(
+                    log_val[1][0][i],
+                    expected_log_val[1][0][i],
+                    err_msg='Failed on test item {0} of logged values'.format(i)
+                )
+            except TypeError:
+                for j in range(len(log_val[1][0][i])):
+                    np.testing.assert_allclose(
+                        np.array(log_val[1][0][i][j]),
+                        np.array(expected_log_val[1][0][i][j]),
+                        atol=1e-08,
+                        err_msg='Failed on test item {0} of logged values'.format(i)
+                    )
diff --git a/tests/mechanisms/test_contrastive_hebbian_mechanism.py b/tests/mechanisms/test_contrastive_hebbian_mechanism.py
index 131d887694d..93eec69c4f5 100644
--- a/tests/mechanisms/test_contrastive_hebbian_mechanism.py
+++ b/tests/mechanisms/test_contrastive_hebbian_mechanism.py
@@ -68,11 +68,11 @@ def test_using_Hebbian_learning_of_orthognal_inputs_without_integrator_mode(self
         #   and the behavior of the scheduler's time can be a bit odd - should hopefully fix that in future
         #   and test in its own module
         # assert S.scheduler.get_clock(S).previous_time.pass_ == 6
-        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE_OUTPUT].parameters.value.get(C),
+        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE].parameters.value.get(C),
                                    [1.20074767, 0.0, 1.20074767, 0.0])
         np.testing.assert_allclose(R.parameters.plus_phase_activity.get(C), [1.20074767, 0.0, 1.20074767, 0.0])
         np.testing.assert_allclose(R.parameters.minus_phase_activity.get(C), [0.0, 0.0, 0.0, 0.0])
-        np.testing.assert_allclose(R.output_ports[pnl.CURRENT_ACTIVITY_OUTPUT].parameters.value.get(C),
+        np.testing.assert_allclose(R.output_ports[pnl.CURRENT_ACTIVITY].parameters.value.get(C),
                                    [1.20074767, 0.0, 1.20074767, 0.0])
         np.testing.assert_allclose(
             R.recurrent_projection.get_mod_matrix(C),
@@ -98,7 +98,7 @@ def test_using_Hebbian_learning_of_orthognal_inputs_without_integrator_mode(self
                 [0.0,        0.2399363,   0.0,        0.0      ]
             ]
         )
-        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE_OUTPUT].parameters.value.get(C),
+        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE].parameters.value.get(C),
                                    [0.0, 1.20074767, 0.0, 1.20074767])
         np.testing.assert_allclose(R.parameters.plus_phase_activity.get(C), [0.0, 1.20074767, 0.0, 1.20074767])
         np.testing.assert_allclose(R.parameters.minus_phase_activity.get(C), [0.0, 0.0, 0.0, 0.0])
@@ -137,11 +137,11 @@ def test_using_Hebbian_learning_of_orthognal_inputs_with_integrator_mode(self):
         #   and the behavior of the scheduler's time can be a bit odd - should hopefully fix that in future
         #   and test in its own module
         # assert S.scheduler.get_clock(S).previous_time.pass_ == 19
-        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE_OUTPUT].parameters.value.get(S),
+        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE].parameters.value.get(S),
                                    [1.14142296, 0.0, 1.14142296, 0.0])
         np.testing.assert_allclose(R.parameters.plus_phase_activity.get(S), [1.14142296, 0.0, 1.14142296, 0.0])
         np.testing.assert_allclose(R.parameters.minus_phase_activity.get(S), [0.0, 0.0, 0.0, 0.0])
-        np.testing.assert_allclose(R.output_ports[pnl.CURRENT_ACTIVITY_OUTPUT].parameters.value.get(S),
+        np.testing.assert_allclose(R.output_ports[pnl.CURRENT_ACTIVITY].parameters.value.get(S),
                                    [1.1414229612568625, 0.0, 1.1414229612568625, 0.0])
         np.testing.assert_allclose(
             R.recurrent_projection.get_mod_matrix(S),
@@ -166,9 +166,9 @@ def test_using_Hebbian_learning_of_orthognal_inputs_with_integrator_mode(self):
                 [0.0,        0.22035998, 0.0,        0.        ]
             ]
         )
-        np.testing.assert_allclose(R.output_ports[pnl.CURRENT_ACTIVITY_OUTPUT].parameters.value.get(S),
+        np.testing.assert_allclose(R.output_ports[pnl.CURRENT_ACTIVITY].parameters.value.get(S),
                                    [0.0, 1.1414229612568625, 0.0, 1.1414229612568625])
-        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE_OUTPUT].parameters.value.get(S),
+        np.testing.assert_allclose(R.output_ports[pnl.ACTIVITY_DIFFERENCE].parameters.value.get(S),
                                    [ 0.0, 1.14142296, 0.0, 1.14142296])
         np.testing.assert_allclose(R.parameters.plus_phase_activity.get(S), [0.0, 1.14142296, 0.0, 1.14142296])
         np.testing.assert_allclose(R.parameters.minus_phase_activity.get(S), [0.0, 0.0, 0.0, 0.0])
@@ -176,16 +176,16 @@ def test_using_Hebbian_learning_of_orthognal_inputs_with_integrator_mode(self):
     def test_additional_output_ports(self):
         CHL1 = pnl.ContrastiveHebbianMechanism(
                 input_size=2, hidden_size=0, target_size=2,
-                additional_output_ports=[pnl.PLUS_PHASE_OUTPUT, pnl.MINUS_PHASE_OUTPUT])
+                additional_output_ports=[pnl.PLUS_PHASE_ACTIVITY, pnl.MINUS_PHASE_ACTIVITY])
         assert len(CHL1.output_ports)==5
-        assert pnl.PLUS_PHASE_OUTPUT in CHL1.output_ports.names
+        assert pnl.PLUS_PHASE_ACTIVITY in CHL1.output_ports.names
 
         CHL2 = pnl.ContrastiveHebbianMechanism(
                 input_size=2, hidden_size=0, target_size=2,
-                additional_output_ports=[pnl.PLUS_PHASE_OUTPUT, pnl.MINUS_PHASE_OUTPUT],
+                additional_output_ports=[pnl.PLUS_PHASE_ACTIVITY, pnl.MINUS_PHASE_ACTIVITY],
                 separated=False)
         assert len(CHL2.output_ports)==5
-        assert pnl.PLUS_PHASE_OUTPUT in CHL2.output_ports.names
+        assert pnl.PLUS_PHASE_ACTIVITY in CHL2.output_ports.names
 
     def test_configure_learning(self):
 
diff --git a/tests/mechanisms/test_processing_mechanism.py b/tests/mechanisms/test_processing_mechanism.py
index 763f949629f..fbf04912747 100644
--- a/tests/mechanisms/test_processing_mechanism.py
+++ b/tests/mechanisms/test_processing_mechanism.py
@@ -12,6 +12,9 @@
 from psyneulink.core.components.functions.transferfunctions import Linear, Exponential, Logistic, SoftMax, LinearMatrix
 from psyneulink.core.components.functions.combinationfunctions import Reduce, LinearCombination, CombineMeans
 from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism
+from psyneulink.core.globals.keywords import \
+    MAX_ABS_INDICATOR, MAX_ABS_ONE_HOT, MAX_ABS_VAL, MAX_INDICATOR, MAX_ONE_HOT, MAX_VAL, \
+    MEAN, MEDIAN, PROB, STANDARD_DEVIATION, VARIANCE
 
 class TestProcessingMechanismFunctions:
 
@@ -274,3 +277,62 @@ def test_invalid_matrix_specs(self):
                                                                     [0.0, 0.0]])
         assert "Specification of matrix and/or default_variable" in str(error_text.value) and \
                "not compatible for multiplication" in str(error_text.value)
+
+class TestProcessingMechanismStandardOutputPorts:
+
+    def test_mean(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MEAN])
+        PM1.execute([1,2,4])
+        assert np.allclose(PM1.output_ports[0].value,[2.33333333])
+
+    def test_median(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MEDIAN])
+        PM1.execute([1,2,4])
+        assert np.allclose(PM1.output_ports[0].value,[2])
+
+    def test_std_dev(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[STANDARD_DEVIATION])
+        PM1.execute([1,2,4])
+        assert np.allclose(PM1.output_ports[0].value,[1.24721913])
+
+    def test_variance(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[VARIANCE])
+        PM1.execute([1,2,4])
+        assert np.allclose(PM1.output_ports[0].value,[1.55555556])
+
+    def test_max_val(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MAX_VAL])
+        PM1.execute([1,2,-4])
+        # assert np.allclose(PM1.output_ports[0].value,[0,2,0])
+        assert np.allclose(PM1.output_ports[0].value,[2])
+
+    def test_max_abs_val(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MAX_ABS_VAL])
+        PM1.execute([1,2,-4])
+        # assert np.allclose(PM1.output_ports[0].value,[0,0,-4])
+        assert np.allclose(PM1.output_ports[0].value,[4])
+
+    def test_max_one_hot(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MAX_ONE_HOT])
+        PM1.execute([1,2,-4])
+        assert np.allclose(PM1.output_ports[0].value,[0,2,0])
+
+    def test_max_abs_one_hot(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MAX_ABS_ONE_HOT])
+        PM1.execute([1,2,-4])
+        assert np.allclose(PM1.output_ports[0].value,[0,0,4])
+
+    def test_max_indicator(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MAX_INDICATOR])
+        PM1.execute([1,2,-4])
+        assert np.allclose(PM1.output_ports[0].value,[0,1,0])
+
+    def test_max_abs_indicator(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[MAX_ABS_INDICATOR])
+        PM1.execute([1,2,-4])
+        assert np.allclose(PM1.output_ports[0].value,[0,0,1])
+
+    def test_prob(self):
+        PM1 = ProcessingMechanism(default_variable=[0,0,0], output_ports=[PROB])
+        PM1.execute([1,2,4])
+        assert np.allclose(PM1.output_ports[0].value,[0,0,4])
diff --git a/tests/mechanisms/test_transfer_mechanism.py b/tests/mechanisms/test_transfer_mechanism.py
index 7ce2e163ba1..c26f36d6b41 100644
--- a/tests/mechanisms/test_transfer_mechanism.py
+++ b/tests/mechanisms/test_transfer_mechanism.py
@@ -18,7 +18,7 @@
 from psyneulink.core.components.ports.inputport import InputPort
 from psyneulink.core.components.system import System
 from psyneulink.core.compositions.composition import Composition
-from psyneulink.core.globals.keywords import INSTANTANEOUS_MODE_VALUE, INTEGRATOR_MODE_VALUE, REINITIALIZE
+from psyneulink.core.globals.keywords import INSTANTANEOUS_MODE_VALUE, INTEGRATOR_MODE_VALUE, REINITIALIZE, COMBINE
 from psyneulink.core.globals.utilities import UtilitiesError
 from psyneulink.core.scheduling.condition import Never
 
@@ -2023,6 +2023,11 @@ def test_add_input_ports(self):
         print("Number of output ports: ", len(T.output_ports))
         print(T.output_ports)
 
+    def test_combine_standard_output_port(self):
+        T = TransferMechanism(default_variable=[[0,0,0],[0,0,0]], output_ports=[COMBINE])
+        T.execute([[1,2,1],[5,0,4]])
+        assert np.allclose(T.output_ports[0].value, [6,2,5])
+
         # assert len(T.input_ports) == 4
         # assert len(T.output_ports) == 4
         #
diff --git a/tests/misc/test_user_seed.py b/tests/misc/test_user_seed.py
new file mode 100644
index 00000000000..9e29ae34816
--- /dev/null
+++ b/tests/misc/test_user_seed.py
@@ -0,0 +1,6 @@
+import subprocess
+
+def test_user_seed():
+    seed1 = subprocess.check_output(("python", "-c" ,"from psyneulink.core.globals.utilities import get_global_seed; print(get_global_seed())"))
+    seed2 = subprocess.check_output(("python", "-c" ,"from psyneulink.core.globals.utilities import get_global_seed; print(get_global_seed())"))
+    assert seed1 != seed2
diff --git a/tests/projections/test_projection_specifications.py b/tests/projections/test_projection_specifications.py
index aa7363f1e35..c33023ca0a6 100644
--- a/tests/projections/test_projection_specifications.py
+++ b/tests/projections/test_projection_specifications.py
@@ -244,13 +244,13 @@ def test_formats_for_control_specification_for_mechanism_and_function_params(sel
             C1, C2 = ctl_tuple
 
             # This shenanigans is to avoid assigning the same instantiated ControlProjection more than once
-            if C1 is 'CP_OBJECT':
+            if C1 == 'CP_OBJECT':
                 C1 = pnl.ControlProjection()
-            elif isinstance(C1, tuple) and C1[1] is 'CP_OBJECT':
+            elif isinstance(C1, tuple) and C1[1] == 'CP_OBJECT':
                 C1 = (C1[0], pnl.ControlProjection())
-            if C2 is 'CP_OBJECT':
+            if C2 == 'CP_OBJECT':
                 C2 = pnl.ControlProjection()
-            elif isinstance(C2, tuple) and C2[1] is 'CP_OBJECT':
+            elif isinstance(C2, tuple) and C2[1] == 'CP_OBJECT':
                 C2 = (C2[0], pnl.ControlProjection())
 
             R = pnl.RecurrentTransferMechanism(noise=C1,
@@ -301,13 +301,13 @@ def test_formats_for_gating_specification_of_input_and_output_ports(self):
             G_IN, G_OUT = gating_tuple
 
             # This shenanigans is to avoid assigning the same instantiated ControlProjection more than once
-            if G_IN is 'GP_OBJECT':
+            if G_IN == 'GP_OBJECT':
                 G_IN = pnl.GatingProjection()
-            elif isinstance(G_IN, tuple) and G_IN[1] is 'GP_OBJECT':
+            elif isinstance(G_IN, tuple) and G_IN[1] == 'GP_OBJECT':
                 G_IN = (G_IN[0], pnl.GatingProjection())
-            if G_OUT is 'GP_OBJECT':
+            if G_OUT == 'GP_OBJECT':
                 G_OUT = pnl.GatingProjection()
-            elif isinstance(G_OUT, tuple) and G_OUT[1] is 'GP_OBJECT':
+            elif isinstance(G_OUT, tuple) and G_OUT[1] == 'GP_OBJECT':
                 G_OUT = (G_OUT[0], pnl.GatingProjection())
 
             if isinstance(G_IN, tuple):