slight revision to docs

doc/user/assorted_guide.rst

@@ -37,10 +37,10 @@ The following settings are involved with enabling tight coupling in ARMI:
            convergence: 1.0e-2
 
 
-The ``tightCouplingSettings`` settings interact with the interfaces available in ARMI (or an ARMI app) and parameters can be a registered parameter. The ``convergence`` setting within ``tightCouplingSettings`` is expected to be any float value. In the current implementation, different interfaces may have different developer intended restrictions. For example, the global flux solver currently only allows the eigenvalue (i.e. :math:`k_{\text{eff}}`) or block-wise power to be valid ``parameter`` values.
+The ``tightCouplingSettings`` settings interact with the interfaces available in ARMI (or an ARMI app). The interface headers (i.e., "globalFlux" and "thermalHydraulics") must match the value prescribed for :py:attr:`Interface.function <armi.interfaces.interface.function>`. The option, ``parameter``, can be a registered parameter. The ``convergence`` option is expected to be any float value. In the current implementation, different interfaces may have different developer intended restrictions. For example, the global flux interface currently only allows the eigenvalue (i.e. :math:`k_{\text{eff}}`) or block-wise power to be valid ``parameter`` values.
 
 .. warning::
-    The inherent limitations of the above interface-based tight coupling settings have been documented and a new and improved interface is currently being developed.
+    The inherent limitations of the above interface-based tight coupling settings have been documented and a new and improved user-interface is currently being developed.
 
 In the global flux interface, the following norms are used to compute the convergence of :math:`k_{\text{eff}}` and block-wise power.
 
@@ -55,12 +55,12 @@ Block-wise Power
 ^^^^^^^^^^^^^^^^
 The block-wise power can be used as a convergence mechanism to avoid the integral effects of :math:`k_{\text{eff}}` (i.e., over and under predictions cancelling each other out) and in turn, can have a different convergence rate. To measure the convergence of the power distribution with the prescribed tolerances (e.g., 1e-4), the power is scaled in the following manner (otherwise the calculation struggles to converge). 
 
-For assembly, :math:`a`, we compute the total power of the assembly,
+For an assembly, :math:`a`, we compute the total power of the assembly,
 
 .. math::
     a_{\text{power},i} = \sum_{j}b_{\text{power},(i,j)},
 
-where :math:`i` is the :math:`i^{\text{th}}` assembly and :math:`j` is the :math:`j^{\text{th}}` block within assembly, :math:`i`. With the assembly power, we scale the block power and obtain an array of scaled block powers for a given assembly, :math:`b_i`,
+where :math:`i` is the :math:`i^{\text{th}}` assembly and :math:`j` is the :math:`j^{\text{th}}` block within assembly, :math:`i`. With the assembly power, we scale the block power and obtain an array of scaled block powers for a given assembly, :math:`\mathbf{b}_{i}`,
 
 .. math::
     \mathbf{b}_{i} = \left\lbrace \frac{b_{\text{power},(i,j)}}{a_{\text{power},i}} \right\rbrace, \quad \forall j \in a_i.
@@ -69,9 +69,9 @@ We can now calculate a convergence parameter for each assembly,
 
 .. math::
     \epsilon_i &= \| \textbf{b}_{i,\text{old}} - \textbf{b}_{i,\text{new}} \|_2 \\
-               &=\left(\left( \textbf{b}_{i,\text{old}} - \textbf{b}_{i,\text{new}} \right)^2\right)^\frac{1}{2},
+               &=\sqrt{\sum_{i}\left( \textbf{b}_{i,\text{old}} - \textbf{b}_{i,\text{new}} \right)^2}.
 
-and store in an array of convergence values,
+These assembly-wise convergence parameters are then stored in an array of convergence values,
 
 .. math::
     \xi = \left\lbrace \epsilon_i \right\rbrace,\quad \forall i \in \text{Core}.