--- a/+sbp/D1Staggered.m	Tue Nov 07 20:44:13 2017 -0800
+++ b/+sbp/D1Staggered.m	Wed Nov 08 10:56:09 2017 -0800
@@ -1,24 +1,24 @@
 classdef D1Staggered < sbp.OpSet
     properties
-        % xp: "plus" grid with m points
-        % xm: "minus" grid with m+1 points
+        % x_primal: "primal" grid with m points. Equidistant. Called Plus grid in Ossian's paper.
+        % x_dual: "dual" grid with m+1 points. Called Minus grid in Ossian's paper.
 
-        D1p % SBP operator approximating first derivative
-        D1m % SBP operator approximating first derivative
-        Hp % Norm matrix
-        Hm % Norm matrix
-        HpI % H^-1
-        HmI % H^-1
-        ep_l % Left boundary operator
-        em_l % Left boundary operator
-        ep_r % Right boundary operator
-        em_r % Right boundary operator
+        D1_primal % SBP operator approximating first derivative
+        D1_dual % SBP operator approximating first derivative
+        H_primal % Norm matrix
+        H_dual % Norm matrix
+        H_primalI % H^-1
+        H_dualI % H^-1
+        e_primal_l % Left boundary operator
+        e_dual_l % Left boundary operator
+        e_primal_r % Right boundary operator
+        e_dual_r % Right boundary operator
         m % Number of grid points.
-        mp % Number of grid points.
-        mm % Number of grid points.
+        m_primal % Number of grid points.
+        m_dual % Number of grid points.
         h % Step size
-        xp % grid
-        xm % grid
+        x_primal % grid
+        x_dual % grid
         x
         borrowing % Struct with borrowing limits for different norm matrices
     end
@@ -30,46 +30,46 @@
           x_r = lim{2};
           L = x_r-x_l;
 
-          mp = m;
-          mm = m+1;
+          m_primal = m;
+          m_dual = m+1;
 
           switch order
           case 2
-            [xp, xm, Pp, Pm, Qp, Qm] = sbp.implementations.d1_staggered_2(m, L);
+            [x_primal, x_dual, Pp, Pm, Qp, Qm] = sbp.implementations.d1_staggered_2(m, L);
           case 4
-            [xp, xm, Pp, Pm, Qp, Qm] = sbp.implementations.d1_staggered_4(m, L);
+            [x_primal, x_dual, Pp, Pm, Qp, Qm] = sbp.implementations.d1_staggered_4(m, L);
           case 6
-            [xp, xm, Pp, Pm, Qp, Qm] = sbp.implementations.d1_staggered_6(m, L);
+            [x_primal, x_dual, Pp, Pm, Qp, Qm] = sbp.implementations.d1_staggered_6(m, L);
           otherwise
            error('Invalid operator order %d.',order);
           end
 
           obj.m = m;
-          obj.mp = mp;
-          obj.mm = mm;
-          obj.xp = x_l + xp';
-          obj.xm = x_l + xm';
+          obj.m_primal = m_primal;
+          obj.m_dual = m_dual;
+          obj.x_primal = x_l + x_primal';
+          obj.x_dual = x_l + x_dual';
 
-          D1p = Pp\Qp;
-          D1m = Pm\Qm;
+          D1_primal = Pp\Qp;
+          D1_dual = Pm\Qm;
 
-          obj.D1p = D1p;
-          obj.D1m = D1m;
-          pbj.Hp = Pp;
-          obj.Hm = Pm; 
+          obj.D1_primal = D1_primal;
+          obj.D1_dual = D1_dual;
+          pbj.H_primal = Pp;
+          obj.H_dual = Pm; 
 
-          obj.ep_l = sparse(mp,1);
-          obj.ep_r = sparse(mp,1);
-          obj.ep_l(1) = 1;
-          obj.ep_r(mp) = 1;
+          obj.e_primal_l = sparse(m_primal,1);
+          obj.e_primal_r = sparse(m_primal,1);
+          obj.e_primal_l(1) = 1;
+          obj.e_primal_r(m_primal) = 1;
 
-          obj.em_l = sparse(mm,1);
-          obj.em_r = sparse(mm,1);
-          obj.em_l(1) = 1;
-          obj.em_r(mm) = 1;
+          obj.e_dual_l = sparse(m_dual,1);
+          obj.e_dual_r = sparse(m_dual,1);
+          obj.e_dual_l(1) = 1;
+          obj.e_dual_r(m_dual) = 1;
 
-          obj.HpI = inv(obj.Hp);
-          obj.HmI = inv(obj.Hm);
+          obj.H_primalI = inv(obj.H_primal);
+          obj.H_dualI = inv(obj.H_dual);
 
           obj.borrowing = [];
           obj.x = [];