diff --git a/Makefile.in b/Makefile.in
index 3e1f331fb2..94ea473642 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -62,6 +62,7 @@ SRC_FILES := $(wildcard src/*.cpp) \
              $(wildcard src/nr_radiation/implicit/*.cpp) \
              $(wildcard src/cr/*.cpp) \
              $(wildcard src/cr/integrators/*.cpp) \
+             $(wildcard src/crdiffusion/*.cpp) \
 	     src/hydro/rsolvers/$(RSOLVER_DIR)$(RSOLVER_FILE) \
 	     $(wildcard src/inputs/*.cpp) \
 	     $(wildcard src/mesh/*.cpp) \
diff --git a/configure.py b/configure.py
index 12d64e8472..58230282c1 100755
--- a/configure.py
+++ b/configure.py
@@ -46,6 +46,7 @@
 #   -nr_radiation        turn on non-relativistic radiation transport
 #   -implicit_radiation  implicit radiation transport module
 #   -cr                  enable cosmic ray transport
+#   -crdiff              enable cosmic ray diffusion with Multigrid
 # ----------------------------------------------------------------------------------------
 
 # Modules
@@ -267,6 +268,12 @@
                     default=False,
                     help='enable cosmic ray transport')
 
+# -cosmic ray diffusion argument
+parser.add_argument('-crdiff',
+                    action='store_true',
+                    default=False,
+                    help='enable implicit cosmic ray diffusion')
+
 # The main choices for --cxx flag, using "ctype[-suffix]" formatting, where "ctype" is the
 # major family/suite/group of compilers and "suffix" may represent variants of the
 # compiler version and/or predefined sets of compiler options. The C++ compiler front ends
@@ -558,6 +565,12 @@ def c_to_cpp(arg):
 else:
     definitions['CR_ENABLED'] = '0'
 
+# -crdiff argument
+if args['crdiff']:
+    definitions['CRDIFFUSION_ENABLED'] = '1'
+else:
+    definitions['CRDIFFUSION_ENABLED'] = '0'
+
 
 # --cxx=[name] argument
 if args['cxx'] == 'g++':
@@ -1025,6 +1038,7 @@ def output_config(opt_descr, opt_choice, filehandle=None):
 output_config('Radiative Transfer', ('ON' if args['nr_radiation'] else 'OFF'), flog)
 output_config('Implicit Radiation', ('ON' if args['implicit_radiation'] else 'OFF'), flog)
 output_config('Cosmic Ray Transport', ('ON' if args['cr'] else 'OFF'), flog)
+output_config('Cosmic Ray Diffusion', ('ON' if args['crdiff'] else 'OFF'), flog)
 output_config('Frame transformations', ('ON' if args['t'] else 'OFF'), flog)
 output_config('Self-Gravity', self_grav_string, flog)
 output_config('Super-Time-Stepping', ('ON' if args['sts'] else 'OFF'), flog)
diff --git a/inputs/cosmic_ray/athinput.cr_diffusion_mg b/inputs/cosmic_ray/athinput.cr_diffusion_mg
new file mode 100644
index 0000000000..779db0800e
--- /dev/null
+++ b/inputs/cosmic_ray/athinput.cr_diffusion_mg
@@ -0,0 +1,75 @@
+<comment>
+problem   = CR diffusion test with Multigrid
+reference = 
+configure = --prob=cr_diffusion_mg -crdiff
+
+<job>
+problem_id = MGCRDiffusion # problem ID: basename of output filenames
+
+<nooutput1>
+file_type  = hst        # History data dump
+dt         = 0.01       # time increment between outputs
+
+<output1>
+file_type  = vtk        # Binary data dump
+variable   = prim       # variables to be output
+dcycle        = 1       # time increment between outputs
+
+<time>
+cfl_number = 0.3        # The Courant, Friedrichs, & Lewy (CFL) Number
+nlim       = 1          # cycle limit
+tlim       = 1.0        # time limit
+integrator  = vl2       # time integration algorithm
+xorder      = 2         # order of spatial reconstruction
+ncycle_out  = 1         # interval for stdout summary info
+
+<mesh>
+nx1        = 64         # Number of zones in X1-direction
+x1min      = -0.5       # minimum value of X1
+x1max      = 0.5        # maximum value of X1
+ix1_bc     = outflow    # inner-X1 boundary flag
+ox1_bc     = outflow    # outer-X1 boundary flag
+
+nx2        = 64         # Number of zones in X2-direction
+x2min      = -0.5       # minimum value of X2
+x2max      = 0.5        # maximum value of X2
+ix2_bc     = outflow    # inner-X2 boundary flag
+ox2_bc     = outflow    # outer-X2 boundary flag
+
+nx3        = 64         # Number of zones in X3-direction
+x3min      = -0.5       # minimum value of X3
+x3max      = 0.5        # maximum value of X3
+ix3_bc     = outflow    # inner-X3 boundary flag
+ox3_bc     = outflow    # outer-X3 boundary flag
+
+<meshblock>
+nx1        = 64
+nx2        = 64
+nx3        = 64
+
+<hydro>
+gamma           = 1.666666666667 # gamma = C_p/C_v
+iso_sound_speed = 0.4082482905   # equivalent to sqrt(gamma*p/d) for p=0.1, d=1
+
+<crdiffusion>
+mgmode          = FMG
+fas             = true
+npresmooth      = 2
+npostsmooth     = 2
+omega           = 1.3
+niteration      = 10
+#threshold       = 0.00001
+output_defect   = true
+ix1_bc          = user 
+ox1_bc          = user
+ix2_bc          = user
+ox2_bc          = user
+ix3_bc          = zerograd
+ox3_bc          = zerograd
+
+Dpara           = 100.0
+Dperp           = 1.0
+Lambda          = 100.0
+zeta_factor     = 1.0
+
+<problem>
diff --git a/src/athena.hpp b/src/athena.hpp
index 7f6b42f533..90ca38a27f 100644
--- a/src/athena.hpp
+++ b/src/athena.hpp
@@ -50,7 +50,7 @@ class Coordinates;
 class ParameterInput;
 class HydroDiffusion;
 class FieldDiffusion;
-struct MGCoordinates;
+class MGCoordinates;
 class OrbitalAdvection;
 class NRRadiation;
 class IMRadiation;
@@ -166,8 +166,8 @@ enum CoordinateDirection {X1DIR=0, X2DIR=1, X3DIR=2};
 // KGF: Except for the 2x MG* enums, these may be unnessary w/ the new class inheritance
 // Now, only passed to BoundaryVariable::InitBoundaryData(); could replace w/ bool switch
 // TODO(tomo-ono): consider necessity of orbita_cc and orbital_fc
-enum class BoundaryQuantity {cc, fc, cc_flcor, fc_flcor, mggrav,
-                             mggrav_f, orbital_cc, orbital_fc};
+enum class BoundaryQuantity {cc, fc, cc_flcor, fc_flcor, mg, mg_faceonly, mg_coeff,
+                             orbital_cc, orbital_fc};
 enum class HydroBoundaryQuantity {cons, prim};
 enum class BoundaryCommSubset {mesh_init, gr_amr, all, orbital, radiation, radhydro};
 // TODO(felker): consider generalizing/renaming to QuantityFormulation
@@ -213,7 +213,7 @@ using FieldDiffusionCoeffFunc = void (*)(
     const AthenaArray<Real> &w,
     const AthenaArray<Real> &bmag,
     int is, int ie, int js, int je, int ks, int ke);
-using MGSourceMaskFunc = void (*)(AthenaArray<Real> &src,
+using MGMaskFunc = void (*)(AthenaArray<Real> &dat,
     int is, int ie, int js, int je, int ks, int ke, const MGCoordinates &coord);
 using OrbitalVelocityFunc = Real (*)(
     OrbitalAdvection *porb, Real x1, Real x2, Real x3);
diff --git a/src/bvals/bvals.hpp b/src/bvals/bvals.hpp
index 9bb8724d28..0f1b0ceade 100644
--- a/src/bvals/bvals.hpp
+++ b/src/bvals/bvals.hpp
@@ -124,8 +124,8 @@ class BoundaryValues : public BoundaryBase, //public BoundaryPhysics,
   std::vector<BoundaryVariable *> bvars_main_int;
   //! subset of bvars that are exchanged in the SuperTimeStepTaskList
   std::vector<BoundaryVariable *> bvars_sts;
-  //! Pointer to the Gravity Boundary Variable
-  CellCenteredBoundaryVariable *pgbvar;
+  //! Pointer to the Gravity and CRDiffusion Boundary Variable
+  CellCenteredBoundaryVariable *pgbvar, *pcrbvar;
 
   // inherited functions (interface shared with BoundaryVariable objects):
   // ------
@@ -150,8 +150,8 @@ class BoundaryValues : public BoundaryBase, //public BoundaryPhysics,
   void ProlongateBoundaries(const Real time, const Real dt,
                             std::vector<BoundaryVariable *> bvars_subset);
 
-  // temporary workaround for self-gravity
-  void ProlongateGravityBoundaries(const Real time, const Real dt);
+  // temporary workaround for Multigrid
+  void ProlongateBoundariesPostMG(CellCenteredBoundaryVariable* pbvar);
 
   // compute the shear at each integrator stage
   //! \todo (felker):
@@ -212,10 +212,11 @@ class BoundaryValues : public BoundaryBase, //public BoundaryPhysics,
   void ProlongateGhostCells(const NeighborBlock& nb,
                             int si, int ei, int sj, int ej, int sk, int ek);
 
-  // temporary workaround for self-gravity
-  void RestrictGravityGhostCellsOnSameLevel(const NeighborBlock& nb,
-                                            int nk, int nj, int ni);
-  void ProlongateGravityGhostCells(int si, int ei, int sj, int ej, int sk, int ek);
+  // temporary workaround for Multigrid
+  void RestrictGhostCellsOnSameLevelPostMG(CellCenteredBoundaryVariable* pbvar,
+                                    const NeighborBlock& nb, int nk, int nj, int ni);
+  void ProlongateGhostCellsPostMG(CellCenteredBoundaryVariable* pbvar,
+                                  int si, int ei, int sj, int ej, int sk, int ek);
 
   void DispatchBoundaryFunctions(
       MeshBlock *pmb, Coordinates *pco, Real time, Real dt,
diff --git a/src/bvals/bvals_refine_gravity.cpp b/src/bvals/bvals_refine_postmg.cpp
similarity index 75%
rename from src/bvals/bvals_refine_gravity.cpp
rename to src/bvals/bvals_refine_postmg.cpp
index ccc11f53a8..c0149a3268 100644
--- a/src/bvals/bvals_refine_gravity.cpp
+++ b/src/bvals/bvals_refine_postmg.cpp
@@ -24,13 +24,14 @@
 #include "bvals.hpp"
 
 
-class CellCenteredBoundaryVariable;
+class CellCenteredCellCenteredBoundaryVariable;
 
 //----------------------------------------------------------------------------------------
-//! \fn void BoundaryValues::ProlongateGravityBoundaries(const Real time, const Real dt)
-//! \brief Prolongate boundaries
+//! \fn void BoundaryValues::ProlongateBoundariesPostMG(
+//!                                              CellCenteredBoundaryVariable* pbvar)
+//! \brief Prolongate boundaries after Multigrid assuming physical boundaries are filled
 
-void BoundaryValues::ProlongateGravityBoundaries(const Real time, const Real dt) {
+void BoundaryValues::ProlongateBoundariesPostMG(CellCenteredBoundaryVariable* pbvar) {
   MeshBlock *pmb = pmy_block_;
   int &mylevel = loc.level;
 
@@ -69,7 +70,7 @@ void BoundaryValues::ProlongateGravityBoundaries(const Real time, const Real dt)
 
           // this neighbor block is on the same level
           // and needs to be restricted for prolongation
-          RestrictGravityGhostCellsOnSameLevel(nb, nk, nj, ni);
+          RestrictGhostCellsOnSameLevelPostMG(pbvar, nb, nk, nj, ni);
         }
       }
     }
@@ -108,18 +109,20 @@ void BoundaryValues::ProlongateGravityBoundaries(const Real time, const Real dt)
 
 
     // Step 3. Finally, the ghost-ghost zones are ready for prolongation:
-    ProlongateGravityGhostCells(si, ei, sj, ej, sk, ek);
+    ProlongateGhostCellsPostMG(pbvar, si, ei, sj, ej, sk, ek);
   } // end loop over nneighbor
   return;
 }
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void BoundaryValues::RestrictGravityGhostCellsOnSameLevel(const NeighborBlock& nb,
-//!                                                        int nk, int nj, int ni)
-//! \brief Restrict ghost cells on same level
-void BoundaryValues::RestrictGravityGhostCellsOnSameLevel(const NeighborBlock& nb,
-                                                          int nk, int nj, int ni) {
+//! \fn void BoundaryValues::RestrictGhostCellsOnSameLevelPostMG(
+//!                          CellCenteredBoundaryVariable* pbvar, const NeighborBlock& nb,
+//!                          int nk, int nj, int ni)
+//! \brief Restrict ghost cells on same level after Multigrid
+void BoundaryValues::RestrictGhostCellsOnSameLevelPostMG(
+                             CellCenteredBoundaryVariable* pbvar, const NeighborBlock& nb,
+                             int nk, int nj, int ni) {
   MeshBlock *pmb = pmy_block_;
   MeshRefinement *pmr = pmb->pmr;
 
@@ -152,7 +155,7 @@ void BoundaryValues::RestrictGravityGhostCellsOnSameLevel(const NeighborBlock& n
     rks = pmb->cks - 1, rke = pmb->cks - 1;
   }
 
-  pmb->pmr->RestrictCellCenteredValues(*(pgbvar->var_cc), *(pgbvar->coarse_buf), 0, 0,
+  pmb->pmr->RestrictCellCenteredValues(*(pbvar->var_cc), *(pbvar->coarse_buf), 0, 0,
                                        ris, rie, rjs, rje, rks, rke);
 
   return;
@@ -160,14 +163,15 @@ void BoundaryValues::RestrictGravityGhostCellsOnSameLevel(const NeighborBlock& n
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void BoundaryValues::ProlongateGravityGhostCells(int si, int ei, int sj, int ej,
-//!                                                      int sk, int ek)
-//! \brief Prolongate gravity ghost cells
+//! \fn void BoundaryValues::ProlongateGhostCellsPostMG(
+//!                                    CellCenteredBoundaryVariable* pbvar,
+//!                                    int si, int ei, int sj, int ej, int sk, int ek)
+//! \brief Prolongate ghost cells after Multigrid
 
-void BoundaryValues::ProlongateGravityGhostCells(int si, int ei, int sj, int ej,
-                                                 int sk, int ek) {
+void BoundaryValues::ProlongateGhostCellsPostMG(CellCenteredBoundaryVariable* pbvar,
+                               int si, int ei, int sj, int ej, int sk, int ek) {
   MeshRefinement *pmr = pmy_block_->pmr;
-  pmr->ProlongateCellCenteredValues(*(pgbvar->coarse_buf), *(pgbvar->var_cc), 0, 0,
+  pmr->ProlongateCellCenteredValues(*(pbvar->coarse_buf), *(pbvar->var_cc), 0, 0,
                                     si, ei, sj, ej, sk, ek);
   return;
 }
diff --git a/src/bvals/cc/bvals_cc.cpp b/src/bvals/cc/bvals_cc.cpp
index eb6f603918..590aaef10b 100644
--- a/src/bvals/cc/bvals_cc.cpp
+++ b/src/bvals/cc/bvals_cc.cpp
@@ -859,3 +859,265 @@ void CellCenteredBoundaryVariable::ClearBoundary(BoundaryCommSubset phase) {
   }
   return;
 }
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void CellCenteredBoundaryVariable::ExpandPhysicalBoundaries()
+//! \brief Expand physical boundary values to NGHOST = 2 and to edges/corners.
+void CellCenteredBoundaryVariable::ExpandPhysicalBoundaries() {
+  int is = pmy_block_->is, ie = pmy_block_->ie,
+      js = pmy_block_->js, je = pmy_block_->je,
+      ks = pmy_block_->ks, ke = pmy_block_->ke;
+  AthenaArray<Real> &u = *var_cc;
+
+  // push face boundary values
+  for (int n = nl_; n <= nu_; ++n) {
+    if (pmy_block_->pbval->nblevel[1][1][0] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        for (int j = js; j <= je; j++)
+          u(n, k, j, is-2) = u(n, k, j, is-1);
+      }
+    }
+    if (pmy_block_->pbval->nblevel[1][1][2] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        for (int j = js; j <= je; j++)
+          u(n, k, j, ie+2) = u(n, k, j, ie+1);
+      }
+    }
+    if (pmy_block_->pbval->nblevel[1][0][1] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        for (int i = is; i <= ie; i++)
+          u(n, k, js-2, i) = u(n, k, js-1, i);
+      }
+    }
+    if (pmy_block_->pbval->nblevel[1][2][1] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        for (int i = is; i <= ie; i++)
+          u(n, k, je+2, i) = u(n, k, je+1, i);
+      }
+    }
+    if (pmy_block_->pbval->nblevel[0][1][1] < 0) {
+      for (int j = js; j <= je; j++) {
+        for (int i = is; i <= ie; i++)
+          u(n, ks-2, j, i) = u(n, ks-1, j, i);
+      }
+    }
+    if (pmy_block_->pbval->nblevel[2][1][1] < 0) {
+      for (int j = js; j <= je; j++) {
+        for (int i = is; i <= ie; i++)
+          u(n, ke+2, j, i) = u(n, ke+1, j, i);
+      }
+    }
+
+    // fill edges
+    if (pmy_block_->pbval->nblevel[1][0][0] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        Real p = 0.5*(u(n, k, js-1, is) + u(n, k, js, is-1));
+        u(n, k, js-1, is-1) = p;
+        u(n, k, js-1, is-2) = p;
+        u(n, k, js-2, is-1) = p;
+        u(n, k, js-2, is-2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[1][0][2] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        Real p = 0.5*(u(n, k, js-1, ie) + u(n, k, js, ie+1));
+        u(n, k, js-1, ie+1) = p;
+        u(n, k, js-1, ie+2) = p;
+        u(n, k, js-2, ie+1) = p;
+        u(n, k, js-2, ie+2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[1][2][0] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        Real p = 0.5*(u(n, k, je+1, is) + u(n, k, je, is-1));
+        u(n, k, je+1, is-1) = p;
+        u(n, k, je+1, is-2) = p;
+        u(n, k, je+2, is-1) = p;
+        u(n, k, je+2, is-2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[1][2][2] < 0) {
+      for (int k = ks; k <= ke; k++) {
+        Real p = 0.5*(u(n, k, je+1, ie) + u(n, k, je, ie+1));
+        u(n, k, je+1, ie+1) = p;
+        u(n, k, je+1, ie+2) = p;
+        u(n, k, je+2, ie+1) = p;
+        u(n, k, je+2, ie+2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[0][1][0] < 0) {
+      for (int j = js; j <= je; j++) {
+        Real p = 0.5*(u(n, ks-1, j, is) + u(n, ks, j, is-1));
+        u(n, ks-1, j, is-1) = p;
+        u(n, ks-1, j, is-2) = p;
+        u(n, ks-2, j, is-1) = p;
+        u(n, ks-2, j, is-2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[0][1][2] < 0) {
+      for (int j = js; j <= je; j++) {
+        Real p = 0.5*(u(n, ks-1, j, ie) + u(n, ks, j, ie+1));
+        u(n, ks-1, j, ie+1) = p;
+        u(n, ks-1, j, ie+2) = p;
+        u(n, ks-2, j, ie+1) = p;
+        u(n, ks-2, j, ie+2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[2][1][0] < 0) {
+      for (int j = js; j <= je; j++) {
+        Real p = 0.5*(u(n, ke+1, j, is) + u(n, ke, j, is-1));
+        u(n, ke+1, j, is-1) = p;
+        u(n, ke+1, j, is-2) = p;
+        u(n, ke+2, j, is-1) = p;
+        u(n, ke+2, j, is-2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[2][1][2] < 0) {
+      for (int j = js; j <= je; j++) {
+        Real p = 0.5*(u(n, ke+1, j, ie) + u(n, ke, j, ie+1));
+        u(n, ke+1, j, ie+1) = p;
+        u(n, ke+1, j, ie+2) = p;
+        u(n, ke+2, j, ie+1) = p;
+        u(n, ke+2, j, ie+2) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[0][0][1] < 0) {
+      for (int i = is; i <= ie; i++) {
+        Real p = 0.5*(u(n, ks-1, js, i) + u(n, ks, js-1, i));
+        u(n, ks-1, js-1, i) = p;
+        u(n, ks-1, js-2, i) = p;
+        u(n, ks-2, js-1, i) = p;
+        u(n, ks-2, js-2, i) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[0][2][1] < 0) {
+      for (int i = is; i <= ie; i++) {
+        Real p = 0.5*(u(n, ks-1, je, i) + u(n, ks, je+1, i));
+        u(n, ks-1, je+1, i) = p;
+        u(n, ks-1, je+2, i) = p;
+        u(n, ks-2, je+1, i) = p;
+        u(n, ks-2, je+2, i) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[2][0][1] < 0) {
+      for (int i = is; i <= ie; i++) {
+        Real p = 0.5*(u(n, ke+1, js, i) + u(n, ke, js-1, i));
+        u(n, ke+1, js-1, i) = p;
+        u(n, ke+1, js-2, i) = p;
+        u(n, ke+2, js-1, i) = p;
+        u(n, ke+2, js-2, i) = p;
+      }
+    }
+    if (pmy_block_->pbval->nblevel[2][2][1] < 0) {
+      for (int i = is; i <= ie; i++) {
+        Real p = 0.5*(u(n, ke+1, je, i) + u(n, ke, je+1, i));
+        u(n, ke+1, je+1, i) = p;
+        u(n, ke+1, je+2, i) = p;
+        u(n, ke+2, je+1, i) = p;
+        u(n, ke+2, je+2, i) = p;
+      }
+    }
+
+    // fill corners
+    if (pmy_block_->pbval->nblevel[0][0][0] < 0) {
+      Real p = (u(n, ks, js-1, is-1) + u(n, ks-1, js, is-1)
+              + u(n, ks-1, js-1, is))/3.0;
+      u(n, ks-1, js-1, is-1) = p;
+      u(n, ks-1, js-1, is-2) = p;
+      u(n, ks-1, js-2, is-1) = p;
+      u(n, ks-1, js-2, is-2) = p;
+      u(n, ks-2, js-1, is-1) = p;
+      u(n, ks-2, js-1, is-2) = p;
+      u(n, ks-2, js-2, is-1) = p;
+      u(n, ks-2, js-2, is-2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[0][0][2] < 0) {
+      Real p = (u(n, ks, js-1, ie+1) + u(n, ks-1, js, ie+1)
+              + u(n, ks-1, js-1, ie))/3.0;
+      u(n, ks-1, js-1, ie+1) = p;
+      u(n, ks-1, js-1, ie+2) = p;
+      u(n, ks-1, js-2, ie+1) = p;
+      u(n, ks-1, js-2, ie+2) = p;
+      u(n, ks-2, js-1, ie+1) = p;
+      u(n, ks-2, js-1, ie+2) = p;
+      u(n, ks-2, js-2, ie+1) = p;
+      u(n, ks-2, js-2, ie+2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[0][2][0] < 0) {
+      Real p = (u(n, ks, je+1, is-1) + u(n, ks-1, je, is-1)
+              + u(n, ks-1, je+1, is))/3.0;
+      u(n, ks-1, je+1, is-1) = p;
+      u(n, ks-1, je+1, is-2) = p;
+      u(n, ks-1, je+2, is-1) = p;
+      u(n, ks-1, je+2, is-2) = p;
+      u(n, ks-2, je+1, is-1) = p;
+      u(n, ks-2, je+1, is-2) = p;
+      u(n, ks-2, je+2, is-1) = p;
+      u(n, ks-2, je+2, is-2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[2][0][0] < 0) {
+      Real p = (u(n, ke, js-1, is-1) + u(n, ke+1, js, is-1)
+              + u(n, ke+1, js-1, is))/3.0;
+      u(n, ke+1, js-1, is-1) = p;
+      u(n, ke+1, js-1, is-2) = p;
+      u(n, ke+1, js-2, is-1) = p;
+      u(n, ke+1, js-2, is-2) = p;
+      u(n, ke+2, js-1, is-1) = p;
+      u(n, ke+2, js-1, is-2) = p;
+      u(n, ke+2, js-2, is-1) = p;
+      u(n, ke+2, js-2, is-2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[0][2][2] < 0) {
+      Real p = (u(n, ks, je+1, ie+1) + u(n, ks-1, je, ie+1)
+              + u(n, ks-1, je+1, ie))/3.0;
+      u(n, ks-1, je+1, ie+1) = p;
+      u(n, ks-1, je+1, ie+2) = p;
+      u(n, ks-1, je+2, ie+1) = p;
+      u(n, ks-1, je+2, ie+2) = p;
+      u(n, ks-2, je+1, ie+1) = p;
+      u(n, ks-2, je+1, ie+2) = p;
+      u(n, ks-2, je+2, ie+1) = p;
+      u(n, ks-2, je+2, ie+2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[2][0][2] < 0) {
+      Real p = (u(n, ke, js-1, ie+1) + u(n, ke+1, js, ie+1)
+              + u(n, ke+1, js-1, ie))/3.0;
+      u(n, ke+1, js-1, ie+1) = p;
+      u(n, ke+1, js-1, ie+2) = p;
+      u(n, ke+1, js-2, ie+1) = p;
+      u(n, ke+1, js-2, ie+2) = p;
+      u(n, ke+2, js-1, ie+1) = p;
+      u(n, ke+2, js-1, ie+2) = p;
+      u(n, ke+2, js-2, ie+1) = p;
+      u(n, ke+2, js-2, ie+2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[2][2][0] < 0) {
+      Real p = (u(n, ke, je+1, is-1) + u(n, ke+1, je, is-1)
+              + u(n, ke+1, je+1, is))/3.0;
+      u(n, ke+1, je+1, is-1) = p;
+      u(n, ke+1, je+1, is-2) = p;
+      u(n, ke+1, je+2, is-1) = p;
+      u(n, ke+1, je+2, is-2) = p;
+      u(n, ke+2, je+1, is-1) = p;
+      u(n, ke+2, je+1, is-2) = p;
+      u(n, ke+2, je+2, is-1) = p;
+      u(n, ke+2, je+2, is-2) = p;
+    }
+    if (pmy_block_->pbval->nblevel[2][2][2] < 0) {
+      Real p = (u(n, ke, je+1, ie+1) + u(n, ke+1, je, ie+1)
+              + u(n, ke+1, je+1, ie))/3.0;
+      u(n, ke+1, je+1, ie+1) = p;
+      u(n, ke+1, je+1, ie+2) = p;
+      u(n, ke+1, je+2, ie+1) = p;
+      u(n, ke+1, je+2, ie+2) = p;
+      u(n, ke+2, je+1, ie+1) = p;
+      u(n, ke+2, je+1, ie+2) = p;
+      u(n, ke+2, je+2, ie+1) = p;
+      u(n, ke+2, je+2, ie+2) = p;
+    }
+  }
+
+  return;
+}
+
diff --git a/src/bvals/cc/bvals_cc.hpp b/src/bvals/cc/bvals_cc.hpp
index 3c959bcf2d..d167d729b9 100644
--- a/src/bvals/cc/bvals_cc.hpp
+++ b/src/bvals/cc/bvals_cc.hpp
@@ -92,6 +92,9 @@ class CellCenteredBoundaryVariable : public BoundaryVariable {
   void SetFluxShearingBoxBoundaryBuffers();
   //!@}
 
+  // for Multigrid
+  void ExpandPhysicalBoundaries();
+
   //!@{
   //! BoundaryPhysics:
   void ReflectInnerX1(Real time, Real dt,
diff --git a/src/bvals/cc/mg/bvals_mg.cpp b/src/bvals/cc/mg/bvals_mg.cpp
index 85a03b7e9a..7d0f8a7920 100644
--- a/src/bvals/cc/mg/bvals_mg.cpp
+++ b/src/bvals/cc/mg/bvals_mg.cpp
@@ -50,11 +50,14 @@ MGBoundaryValues::MGBoundaryValues(Multigrid *pmg, BoundaryFlag *input_bcs)
 #endif
   for (int i = 0; i < 6; ++i)
     MGBoundaryFunction_[i] = pmg->pmy_driver_->MGBoundaryFunction_[i];
+  for (int i = 0; i < 6; ++i)
+    MGCoeffBoundaryFunction_[i] = pmg->pmy_driver_->MGCoeffBoundaryFunction_[i];
   if (pmy_mg_->pmy_block_ != nullptr) {
-    InitBoundaryData(BoundaryQuantity::mggrav);
+    InitBoundaryData(BoundaryQuantity::mg);
     int nc = block_size_.nx1 + 2*pmy_mg_->ngh_;
-    cbuf_.NewAthenaArray(pmy_mg_->nvar_, nc, nc, nc);
-    cbufold_.NewAthenaArray(pmy_mg_->nvar_, nc, nc, nc);
+    int nv = std::max(pmy_mg_->nvar_, pmy_mg_->ncoeff_);
+    cbuf_.NewAthenaArray(nv, nc, nc, nc);
+    cbufold_.NewAthenaArray(nv, nc, nc, nc);
     for (int i = 0; i < 6; ++i) {
       if (block_bcs[i] != BoundaryFlag::block && block_bcs[i] != BoundaryFlag::periodic)
         apply_bndry_fn_[i] = true;
@@ -80,7 +83,6 @@ MGBoundaryValues::~MGBoundaryValues() {
 //! \brief Initialize BoundaryData<> structure
 
 void MGBoundaryValues::InitBoundaryData(BoundaryQuantity type) {
-  int size = 0;
   int nbuf = triplebuf_?3:1;
   for (int c = 0; c < nbuf; ++c) {
     bdata_[c].nbmax = maxneighbor_;
@@ -97,35 +99,26 @@ void MGBoundaryValues::InitBoundaryData(BoundaryQuantity type) {
 
       // Allocate buffers
       // calculate the buffer size
-      switch (type) {
-        case BoundaryQuantity::mggrav: {
-          int ngh = pmy_mg_->ngh_;
-          int nc = block_size_.nx1;
-          if (BoundaryValues::ni[n].type == NeighborConnect::face)
-            size = SQR(nc)*ngh;
-          else if (BoundaryValues::ni[n].type == NeighborConnect::edge)
-            size = nc*ngh*ngh;
-          else if (BoundaryValues::ni[n].type == NeighborConnect::corner)
-            size = ngh*ngh*ngh;
-          if (pmy_mg_->pmy_driver_->pmy_mesh_->multilevel) {
-            if (BoundaryValues::ni[n].type == NeighborConnect::face)
-              size += SQR(nc/2)*ngh;
-            else if (BoundaryValues::ni[n].type == NeighborConnect::edge)
-              size += nc/2*ngh*ngh;
-            else if (BoundaryValues::ni[n].type == NeighborConnect::corner)
-              size += ngh*ngh*ngh;
-          }
-        }
-          break;
-        default: {
-          std::stringstream msg;
-          msg << "### FATAL ERROR in InitBoundaryData" << std::endl
-              << "Invalid boundary type is specified." << std::endl;
-          ATHENA_ERROR(msg);
-        }
-          break;
+      int ngh = pmy_mg_->ngh_;
+      int nc = block_size_.nx1;
+      int size = 0;
+      if (BoundaryValues::ni[n].type == NeighborConnect::face)
+        size = SQR(nc)*ngh;
+      else if (BoundaryValues::ni[n].type == NeighborConnect::edge)
+        size = nc*ngh*ngh;
+      else if (BoundaryValues::ni[n].type == NeighborConnect::corner)
+        size = ngh*ngh*ngh;
+      if (pmy_mg_->pmy_driver_->pmy_mesh_->multilevel) {
+        if (BoundaryValues::ni[n].type == NeighborConnect::face)
+          size += SQR(nc/2)*ngh;
+        else if (BoundaryValues::ni[n].type == NeighborConnect::edge)
+          size += nc/2*ngh*ngh;
+        else if (BoundaryValues::ni[n].type == NeighborConnect::corner)
+          size += ngh*ngh*ngh;
       }
-      size *= pmy_mg_->nvar_*2; // for FAS
+
+      size *= std::max(pmy_mg_->nvar_*(1+pmy_mg_->pmy_driver_->ffas_), pmy_mg_->ncoeff_);
+
       bdata_[c].send[n] = new Real[size];
       bdata_[c].recv[n] = new Real[size];
     }
@@ -156,180 +149,248 @@ void MGBoundaryValues::DestroyBoundaryData() {
 
 //----------------------------------------------------------------------------------------
 //! \fn void MGBoundaryValues::DispatchBoundaryFunction(BoundaryFace face,
-//!                          AthenaArray<Real> &dst, Real time, int nvar,
-//!                          int is, int ie, int js, int je, int ks, int ke, int ngh,
-//!                          const MGCoordinates &coord)
-//! \brief Call multigrid boundary function for a face
+//                           AthenaArray<Real> &dst, Real time, int nvar,
+//                           int is, int ie, int js, int je, int ks, int ke, int ngh,
+//                           const MGCoordinates &coord, bool fcoeff)
+//  \brief Call multigrid boundary function for a face
 
 void MGBoundaryValues::DispatchBoundaryFunction(BoundaryFace face, AthenaArray<Real> &dst,
      Real time, int nvar, int is, int ie, int js, int je, int ks, int ke, int ngh,
-     const MGCoordinates &coord) {
-  AthenaArray<Real> &mpcoeff = pmy_mg_->pmy_driver_->mpcoeff_[0];
-  AthenaArray<Real> &mpo = pmy_mg_->pmy_driver_->mpo_;
-  int &mporder = pmy_mg_->pmy_driver_->mporder_;
-  switch (face) {
-    case BoundaryFace::inner_x1:
-      switch (block_bcs[BoundaryFace::inner_x1]) {
-        case BoundaryFlag::user:
-          MGBoundaryFunction_[BoundaryFace::inner_x1](dst, time, nvar,
-                              is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::periodic:
+     const MGCoordinates &coord, bool fcoeff) {
+  if (!fcoeff) {
+    AthenaArray<Real> &mpcoeff = pmy_mg_->pmy_driver_->mpcoeff_[0];
+    AthenaArray<Real> &mpo = pmy_mg_->pmy_driver_->mpo_;
+    int &mporder = pmy_mg_->pmy_driver_->mporder_;
+    switch (face) {
+      case BoundaryFace::inner_x1:
+        switch (block_bcs[BoundaryFace::inner_x1]) {
+          case BoundaryFlag::user:
+            MGBoundaryFunction_[BoundaryFace::inner_x1](dst, time, nvar,
+                                is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::periodic:
+            MGPeriodicInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerograd:
+            MGZeroGradientInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerofixed:
+            MGZeroFixedInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_multipole:
+            MGMultipoleInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
+                               mpcoeff, mpo, mporder);
+            break;
+          default:
+            break;
+        }
+        break;
+      case BoundaryFace::outer_x1:
+        switch (block_bcs[BoundaryFace::outer_x1]) {
+          case BoundaryFlag::user:
+            MGBoundaryFunction_[BoundaryFace::outer_x1](dst, time, nvar,
+                                is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::periodic:
+            MGPeriodicOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerograd:
+            MGZeroGradientOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerofixed:
+            MGZeroFixedOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_multipole:
+            MGMultipoleOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
+                               mpcoeff, mpo, mporder);
+            break;
+          default:
+            break;
+        }
+        break;
+      case BoundaryFace::inner_x2:
+        switch (block_bcs[BoundaryFace::inner_x2]) {
+          case BoundaryFlag::user:
+            MGBoundaryFunction_[BoundaryFace::inner_x2](dst, time, nvar,
+                                is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::periodic:
+            MGPeriodicInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerograd:
+            MGZeroGradientInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerofixed:
+            MGZeroFixedInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_multipole:
+            MGMultipoleInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
+                               mpcoeff, mpo, mporder);
+            break;
+          default:
+            break;
+        }
+        break;
+      case BoundaryFace::outer_x2:
+        switch (block_bcs[BoundaryFace::outer_x2]) {
+          case BoundaryFlag::user:
+            MGBoundaryFunction_[BoundaryFace::outer_x2](dst, time, nvar,
+                                is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::periodic:
+            MGPeriodicOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerograd:
+            MGZeroGradientOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerofixed:
+            MGZeroFixedOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_multipole:
+            MGMultipoleOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
+                               mpcoeff, mpo, mporder);
+            break;
+          default:
+            break;
+        }
+        break;
+      case BoundaryFace::inner_x3:
+        switch (block_bcs[BoundaryFace::inner_x3]) {
+          case BoundaryFlag::user:
+            MGBoundaryFunction_[BoundaryFace::inner_x3](dst, time, nvar,
+                                is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::periodic:
+            MGPeriodicInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerograd:
+            MGZeroGradientInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerofixed:
+            MGZeroFixedInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_multipole:
+            MGMultipoleInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
+                               mpcoeff, mpo, mporder);
+            break;
+          default:
+            break;
+        }
+        break;
+      case BoundaryFace::outer_x3:
+        switch (block_bcs[BoundaryFace::outer_x3]) {
+          case BoundaryFlag::user:
+            MGBoundaryFunction_[BoundaryFace::outer_x3](dst, time, nvar,
+                                is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::periodic:
+            MGPeriodicOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerograd:
+            MGZeroGradientOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_zerofixed:
+            MGZeroFixedOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
+            break;
+          case BoundaryFlag::mg_multipole:
+            MGMultipoleOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
+                               mpcoeff, mpo, mporder);
+            break;
+          default:
+            break;
+        }
+        break;
+      default:
+        break;
+    }
+  } else { // coeffient
+    switch (face) {
+      case BoundaryFace::inner_x1:
+        if (block_bcs[face] == BoundaryFlag::periodic)
           MGPeriodicInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerograd:
+        else if (MGCoeffBoundaryFunction_[face] != nullptr)
+          MGCoeffBoundaryFunction_[face](dst, time, nvar, is, ie, js, je, ks, ke,
+                                         ngh, coord);
+        else // default: zero gradient
           MGZeroGradientInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerofixed:
-          MGZeroFixedInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_multipole:
-          MGMultipoleInnerX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
-                             mpcoeff, mpo, mporder);
-          break;
-        default:
-          break;
-      }
-      break;
-    case BoundaryFace::outer_x1:
-      switch (block_bcs[BoundaryFace::outer_x1]) {
-        case BoundaryFlag::user:
-          MGBoundaryFunction_[BoundaryFace::outer_x1](dst, time, nvar,
-                              is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::periodic:
+        break;
+      case BoundaryFace::outer_x1:
+        if (block_bcs[face] == BoundaryFlag::periodic)
           MGPeriodicOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerograd:
+        else if (MGCoeffBoundaryFunction_[face] != nullptr)
+          MGCoeffBoundaryFunction_[face](dst, time, nvar, is, ie, js, je, ks, ke,
+                                         ngh, coord);
+        else // default: zero gradient
           MGZeroGradientOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerofixed:
-          MGZeroFixedOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_multipole:
-          MGMultipoleOuterX1(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
-                             mpcoeff, mpo, mporder);
-          break;
-        default:
-          break;
-      }
-      break;
-    case BoundaryFace::inner_x2:
-      switch (block_bcs[BoundaryFace::inner_x2]) {
-        case BoundaryFlag::user:
-          MGBoundaryFunction_[BoundaryFace::inner_x2](dst, time, nvar,
-                              is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::periodic:
+        break;
+      case BoundaryFace::inner_x2:
+        if (block_bcs[face] == BoundaryFlag::periodic)
           MGPeriodicInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerograd:
+        else if (MGCoeffBoundaryFunction_[face] != nullptr)
+          MGCoeffBoundaryFunction_[face](dst, time, nvar, is, ie, js, je, ks, ke,
+                                         ngh, coord);
+        else // default: zero gradient
           MGZeroGradientInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerofixed:
-          MGZeroFixedInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_multipole:
-          MGMultipoleInnerX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
-                             mpcoeff, mpo, mporder);
-          break;
-        default:
-          break;
-      }
-      break;
-    case BoundaryFace::outer_x2:
-      switch (block_bcs[BoundaryFace::outer_x2]) {
-        case BoundaryFlag::user:
-          MGBoundaryFunction_[BoundaryFace::outer_x2](dst, time, nvar,
-                              is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::periodic:
+        break;
+      case BoundaryFace::outer_x2:
+        if (block_bcs[face] == BoundaryFlag::periodic)
           MGPeriodicOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerograd:
+        else if (MGCoeffBoundaryFunction_[face] != nullptr)
+          MGCoeffBoundaryFunction_[face](dst, time, nvar, is, ie, js, je, ks, ke,
+                                         ngh, coord);
+        else // default: zero gradient
           MGZeroGradientOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerofixed:
-          MGZeroFixedOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_multipole:
-          MGMultipoleOuterX2(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
-                             mpcoeff, mpo, mporder);
-          break;
-        default:
-          break;
-      }
-      break;
-    case BoundaryFace::inner_x3:
-      switch (block_bcs[BoundaryFace::inner_x3]) {
-        case BoundaryFlag::user:
-          MGBoundaryFunction_[BoundaryFace::inner_x3](dst, time, nvar,
-                              is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::periodic:
+        break;
+      case BoundaryFace::inner_x3:
+        if (block_bcs[face] == BoundaryFlag::periodic)
           MGPeriodicInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerograd:
+        else if (MGCoeffBoundaryFunction_[face] != nullptr)
+          MGCoeffBoundaryFunction_[face](dst, time, nvar, is, ie, js, je, ks, ke,
+                                         ngh, coord);
+        else // default: zero gradient
           MGZeroGradientInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerofixed:
-          MGZeroFixedInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_multipole:
-          MGMultipoleInnerX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
-                             mpcoeff, mpo, mporder);
-          break;
-        default:
-          break;
-      }
-      break;
-    case BoundaryFace::outer_x3:
-      switch (block_bcs[BoundaryFace::outer_x3]) {
-        case BoundaryFlag::user:
-          MGBoundaryFunction_[BoundaryFace::outer_x3](dst, time, nvar,
-                              is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::periodic:
+        break;
+      case BoundaryFace::outer_x3:
+        if (block_bcs[face] == BoundaryFlag::periodic)
           MGPeriodicOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerograd:
+        else if (MGCoeffBoundaryFunction_[face] != nullptr)
+          MGCoeffBoundaryFunction_[face](dst, time, nvar, is, ie, js, je, ks, ke,
+                                         ngh, coord);
+        else // default: zero gradient
           MGZeroGradientOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_zerofixed:
-          MGZeroFixedOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord);
-          break;
-        case BoundaryFlag::mg_multipole:
-          MGMultipoleOuterX3(dst, time, nvar, is, ie, js, je, ks, ke, ngh, coord,
-                             mpcoeff, mpo, mporder);
-          break;
-        default:
-          break;
-      }
-      break;
-    default:
-      break;
+        break;
+      default:
+        break;
+    }
   }
-
   return;
 }
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MGBoundaryValues::ApplyPhysicalBoundaries(int flag)
+//! \fn void MGBoundaryValues::ApplyPhysicalBoundaries(int flag, bool fcoeff)
 //! \brief Apply physical boundary conditions to the current Multigrid data
 
-void MGBoundaryValues::ApplyPhysicalBoundaries(int flag) {
+void MGBoundaryValues::ApplyPhysicalBoundaries(int flag, bool fcoeff) {
   AthenaArray<Real> *u;
   MGCoordinates *c;
   int lev = pmy_mg_->GetCurrentLevel();
   int ll = pmy_mg_->nlevel_ - 1 - lev;
-  if (flag == 0)      u = &(pmy_mg_->GetCurrentData()), c=&(pmy_mg_->coord_[lev]);
-  else if (flag == 1) u = &cbuf_,                       c=&(pmy_mg_->ccoord_[lev]);
-  else                u = &cbufold_,                    c=&(pmy_mg_->ccoord_[lev]);
+  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  if (!fcoeff) {
+    if (flag == 0)      u = &(pmy_mg_->GetCurrentData()), c = &(pmy_mg_->coord_[lev]);
+    else if (flag == 1) u = &cbuf_,                       c = &(pmy_mg_->ccoord_[lev]);
+    else                u = &cbufold_,                    c = &(pmy_mg_->ccoord_[lev]);
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    if (flag == 0)
+      u = &(pmy_mg_->GetCurrentCoefficient()), c = &(pmy_mg_->coord_[lev]);
+    else
+      u = &cbuf_, c=&(pmy_mg_->ccoord_[lev]);
+  }
   AthenaArray<Real> &dst = *u;
   MGCoordinates &coord = *c;
   if (flag > 0) ll++;
-  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   int ncx = block_size_.nx1 >> ll, ncy = block_size_.nx2 >> ll,
       ncz = block_size_.nx3 >> ll;
   int is = ngh, ie = ncx + ngh - 1;
@@ -340,6 +401,7 @@ void MGBoundaryValues::ApplyPhysicalBoundaries(int flag) {
   int bjs = js,       bje = je;
   int bks = ks,       bke = ke;
   Real time = pmy_mesh_->time;
+
   if (!apply_bndry_fn_[BoundaryFace::inner_x2]) bjs = js - ngh;
   if (!apply_bndry_fn_[BoundaryFace::outer_x2]) bje = je + ngh;
   if (!apply_bndry_fn_[BoundaryFace::inner_x3]) bks = ks - ngh;
@@ -347,23 +409,23 @@ void MGBoundaryValues::ApplyPhysicalBoundaries(int flag) {
 
   if (apply_bndry_fn_[BoundaryFace::inner_x1])
     DispatchBoundaryFunction(BoundaryFace::inner_x1, dst, time, nvar,
-                             is, ie, bjs, bje, bks, bke, ngh, coord);
+                             is, ie, bjs, bje, bks, bke, ngh, coord, fcoeff);
   if (apply_bndry_fn_[BoundaryFace::outer_x1])
     DispatchBoundaryFunction(BoundaryFace::outer_x1, dst, time, nvar,
-                             is, ie, bjs, bje, bks, bke, ngh, coord);
+                             is, ie, bjs, bje, bks, bke, ngh, coord, fcoeff);
   if (apply_bndry_fn_[BoundaryFace::inner_x2])
     DispatchBoundaryFunction(BoundaryFace::inner_x2, dst, time, nvar,
-                             bis, bie, js, je, bks, bke, ngh, coord);
+                             bis, bie, js, je, bks, bke, ngh, coord, fcoeff);
   if (apply_bndry_fn_[BoundaryFace::outer_x2])
     DispatchBoundaryFunction(BoundaryFace::outer_x2, dst, time, nvar,
-                             bis, bie, js, je, bks, bke, ngh, coord);
+                             bis, bie, js, je, bks, bke, ngh, coord, fcoeff);
   bjs = js - ngh, bje = je + ngh;
   if (apply_bndry_fn_[BoundaryFace::inner_x3])
     DispatchBoundaryFunction(BoundaryFace::inner_x3, dst, time, nvar,
-                             bis, bie, bjs, bje, ks, ke, ngh, coord);
+                             bis, bie, bjs, bje, ks, ke, ngh, coord, fcoeff);
   if (apply_bndry_fn_[BoundaryFace::outer_x3])
     DispatchBoundaryFunction(BoundaryFace::outer_x3, dst, time, nvar,
-                             bis, bie, bjs, bje, ks, ke, ngh, coord);
+                             bis, bie, bjs, bje, ks, ke, ngh, coord, fcoeff);
   return;
 }
 
@@ -380,11 +442,12 @@ void MGBoundaryValues::StartReceivingMultigrid(BoundaryQuantity type, bool foldd
 #ifdef MPI_PARALLEL
   int nvar = pmy_mg_->nvar_, ngh = pmy_mg_->ngh_, cngh = ngh;
   int nc = pmy_mg_->GetCurrentNumberOfCells();
+  if (type == BoundaryQuantity::mg_coeff) nvar = pmy_mg_->ncoeff_;
 
   for (int n = 0; n < nneighbor; ++n) {
     NeighborBlock& nb = neighbor[n];
     if (nb.snb.rank!=Globals::my_rank) {
-      if (type == BoundaryQuantity::mggrav_f && nb.snb.level > loc.level
+      if (type == BoundaryQuantity::mg_faceonly && nb.snb.level > loc.level
         && nb.ni.type != NeighborConnect::face) continue;
       int size = 0;
       if (nb.snb.level == loc.level) { // same
@@ -429,7 +492,7 @@ void MGBoundaryValues::ClearBoundaryMultigrid(BoundaryQuantity type) {
     bdata_[bcolor_].sflag[nb.bufid] = BoundaryStatus::waiting;
 #ifdef MPI_PARALLEL
     if (nb.snb.rank != Globals::my_rank) {
-      if (!(type == BoundaryQuantity::mggrav_f
+      if (!(type == BoundaryQuantity::mg_faceonly
         &&  nb.ni.type != NeighborConnect::face && nb.snb.level < loc.level))
         MPI_Wait(&(bdata_[bcolor_].req_send[nb.bufid]),MPI_STATUS_IGNORE);
     }
@@ -441,13 +504,11 @@ void MGBoundaryValues::ClearBoundaryMultigrid(BoundaryQuantity type) {
 
 //----------------------------------------------------------------------------------------
 //! \fn int MGBoundaryValues::LoadMultigridBoundaryBufferSameLevel(Real *buf,
-//!                                                const NeighborBlock& nb, bool folddata)
+//!                               const NeighborBlock& nb, bool folddata, bool fcoeff)
 //! \brief Set Multigrid boundary buffers for sending to a block on the same level
 
 int MGBoundaryValues::LoadMultigridBoundaryBufferSameLevel(Real *buf,
-                                           const NeighborBlock& nb, bool folddata) {
-  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
-  const AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
+                                   const NeighborBlock& nb, bool folddata, bool fcoeff) {
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   int fs = ngh, fe = fs + nc - 1;
@@ -457,6 +518,15 @@ int MGBoundaryValues::LoadMultigridBoundaryBufferSameLevel(Real *buf,
   int ej = (nb.ni.ox2 < 0) ? (fs + ngh - 1) : fe;
   int sk = (nb.ni.ox3 > 0) ? (fe - ngh + 1) : fs;
   int ek = (nb.ni.ox3 < 0) ? (fs + ngh - 1) : fe;
+  AthenaArray<Real> *t;
+  if (!fcoeff) {
+    t = &(pmy_mg_->GetCurrentData());
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    t = &(pmy_mg_->GetCurrentCoefficient());
+  }
+  const AthenaArray<Real> &u = *t;
+  const AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
 
   int p = 0;
   BufferUtility::PackData(u, buf, 0, nvar-1, si, ei, sj, ej, sk, ek, p);
@@ -515,13 +585,11 @@ int MGBoundaryValues::LoadMultigridBoundaryBufferSameLevel(Real *buf,
 
 //----------------------------------------------------------------------------------------
 //! \fn int MGBoundaryValues::LoadMultigridBoundaryBufferToCoarser(Real *buf,
-//!                                                const NeighborBlock& nb, bool folddata)
+//!                               const NeighborBlock& nb, bool folddata, bool fcoeff)
 //! \brief Set Multigrid boundary buffers for sending to a block on the coarser level
 
 int MGBoundaryValues::LoadMultigridBoundaryBufferToCoarser(Real *buf,
-                                           const NeighborBlock& nb, bool folddata) {
-  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
-  const AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
+                                   const NeighborBlock& nb, bool folddata, bool fcoeff) {
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int cn = ngh - 1, cs = ngh, ce = cs + nc/2 - 1;
@@ -532,6 +600,15 @@ int MGBoundaryValues::LoadMultigridBoundaryBufferToCoarser(Real *buf,
   int ej = (nb.ni.ox2 < 0) ? (cs + cn) : ce;
   int sk = (nb.ni.ox3 > 0) ? (ce - cn) : cs;
   int ek = (nb.ni.ox3 < 0) ? (cs + cn) : ce;
+  AthenaArray<Real> *t;
+  if (!fcoeff) {
+    t = &(pmy_mg_->GetCurrentData());
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    t = &(pmy_mg_->GetCurrentCoefficient());
+  }
+  const AthenaArray<Real> &u = *t;
+  const AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
 
   // restrict and store in the coarse buffer
   for (int n=0; n<nvar; ++n) {
@@ -577,12 +654,10 @@ int MGBoundaryValues::LoadMultigridBoundaryBufferToCoarser(Real *buf,
 
 //----------------------------------------------------------------------------------------
 //! \fn int MGBoundaryValues::LoadMultigridBoundaryBufferToFiner(Real *buf,
-//!                                        const NeighborBlock& nb, bool folddata)
+//!                               const NeighborBlock& nb, bool folddata, bool fcoeff)
 //! \brief Set Multigrid boundary buffers for sending to a block on the finer level
 int MGBoundaryValues::LoadMultigridBoundaryBufferToFiner(Real *buf,
-                                           const NeighborBlock& nb, bool folddata) {
-  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
-  const AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
+                                   const NeighborBlock& nb, bool folddata, bool fcoeff) {
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   int cn = ngh - 1, fs = ngh, fe = fs + nc - 1;
@@ -592,6 +667,15 @@ int MGBoundaryValues::LoadMultigridBoundaryBufferToFiner(Real *buf,
   int ej = (nb.ni.ox2 < 0) ? (fs + cn) : fe;
   int sk = (nb.ni.ox3 > 0) ? (fe - cn) : fs;
   int ek = (nb.ni.ox3 < 0) ? (fs + cn) : fe;
+  AthenaArray<Real> *t;
+  if (!fcoeff) {
+    t = &(pmy_mg_->GetCurrentData());
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    t = &(pmy_mg_->GetCurrentCoefficient());
+  }
+  const AthenaArray<Real> &u = *t;
+  const AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
 
   int nred = nc/2 - ngh;
   if (nb.ni.ox1 == 0) {
@@ -634,11 +718,14 @@ int MGBoundaryValues::LoadMultigridBoundaryBufferToFiner(Real *buf,
 bool MGBoundaryValues::SendMultigridBoundaryBuffers(BoundaryQuantity type,
                                                     bool folddata) {
   bool bflag = true;
+  bool fcoeff = false;
+  if (type == BoundaryQuantity::mg_coeff)
+    fcoeff = true;
   Multigrid *pmg = nullptr;
   for (int n = 0; n < nneighbor; ++n) {
     NeighborBlock& nb = neighbor[n];
     if (bdata_[bcolor_].sflag[nb.bufid] == BoundaryStatus::completed) continue;
-    if (type == BoundaryQuantity::mggrav_f && nb.snb.level < loc.level
+    if (type == BoundaryQuantity::mg_faceonly && nb.snb.level < loc.level
       && nb.ni.type != NeighborConnect::face) continue;
     int ssize = 0;
     if (nb.snb.rank == Globals::my_rank) {
@@ -651,21 +738,21 @@ bool MGBoundaryValues::SendMultigridBoundaryBuffers(BoundaryQuantity type,
     }
     if (nb.snb.level == loc.level) {
       ssize = LoadMultigridBoundaryBufferSameLevel(bdata_[bcolor_].send[nb.bufid],
-                                                   nb, folddata);
+                                                   nb, folddata, fcoeff);
     } else if (nb.snb.level < loc.level) {
-      if (type == BoundaryQuantity::mggrav_f)
+      if (type == BoundaryQuantity::mg_faceonly)
         ssize = LoadMultigridBoundaryBufferToCoarserFluxCons(
                                                     bdata_[bcolor_].send[nb.bufid], nb);
       else
         ssize = LoadMultigridBoundaryBufferToCoarser(bdata_[bcolor_].send[nb.bufid],
-                                                     nb, folddata);
+                                                     nb, folddata, fcoeff);
     } else {
-      if (type == BoundaryQuantity::mggrav_f)
+      if (type == BoundaryQuantity::mg_faceonly)
         ssize = LoadMultigridBoundaryBufferToFinerFluxCons(
                                                   bdata_[bcolor_].send[nb.bufid], nb);
       else
         ssize = LoadMultigridBoundaryBufferToFiner(bdata_[bcolor_].send[nb.bufid],
-                                                   nb, folddata);
+                                                   nb, folddata, fcoeff);
     }
     if (nb.snb.rank == Globals::my_rank) {
       std::memcpy(pmg->pmgbval->bdata_[bcolor_].recv[nb.targetid],
@@ -689,16 +776,23 @@ bool MGBoundaryValues::SendMultigridBoundaryBuffers(BoundaryQuantity type,
 
 //----------------------------------------------------------------------------------------
 //! \fn void MGBoundaryValues::SetMultigridBoundarySameLevel(const Real *buf,
-//!                                                const NeighborBlock& nb, bool folddata)
+//!                               const NeighborBlock& nb, bool folddata, bool fcoeff)
 //! \brief Set Multigrid boundary received from a block on the same level
 
 void MGBoundaryValues::SetMultigridBoundarySameLevel(const Real *buf,
-                                           const NeighborBlock& nb, bool folddata) {
-  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
-  AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
+                                   const NeighborBlock& nb, bool folddata, bool fcoeff) {
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   int si, sj, sk, ei, ej, ek;
+  AthenaArray<Real> *t;
+  if (!fcoeff) {
+    t = &(pmy_mg_->GetCurrentData());
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    t = &(pmy_mg_->GetCurrentCoefficient());
+  }
+  AthenaArray<Real> &dst = *t;
+  AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
 
   if (nb.ni.ox1 == 0)     si = ngh,      ei = nc + ngh - 1;
   else if (nb.ni.ox1 > 0) si = nc + ngh, ei = nc + 2*ngh - 1;
@@ -749,13 +843,14 @@ void MGBoundaryValues::SetMultigridBoundarySameLevel(const Real *buf,
 
 //----------------------------------------------------------------------------------------
 //! \fn void MGBoundaryValues::SetMultigridBoundaryFromCoarser(const Real *buf,
-//!                                        const NeighborBlock& nb, boolf folddata)
+//!                               const NeighborBlock& nb, boolf folddata, bool fcoeff)
 //! \brief Set hydro boundary received from a block on the same level
 
 void MGBoundaryValues::SetMultigridBoundaryFromCoarser(const Real *buf,
-                                           const NeighborBlock& nb, bool folddata) {
+                                   const NeighborBlock& nb, bool folddata, bool fcoeff) {
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  if (fcoeff) nvar = pmy_mg_->ncoeff_;
   int si, sj, sk, ei, ej, ek;
   int cng = 1;
   int cs = cng, ce = cng + nc/2 -1;
@@ -799,17 +894,24 @@ void MGBoundaryValues::SetMultigridBoundaryFromCoarser(const Real *buf,
 
 //----------------------------------------------------------------------------------------
 //! \fn void MGBoundaryValues::SetMultigridBoundaryFromFiner(const Real *buf,
-//!                                                const NeighborBlock& nb, bool folddata)
+//!                               const NeighborBlock& nb, bool folddata, bool fcoeff)
 //! \brief Set hydro boundary received from a block on the same level
 
 void MGBoundaryValues::SetMultigridBoundaryFromFiner(const Real *buf,
-                                               const NeighborBlock& nb, bool folddata) {
-  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
-  AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
+                                   const NeighborBlock& nb, bool folddata, bool fcoeff) {
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   int fs = ngh, fe = fs + nc - 1;
   int si, sj, sk, ei, ej, ek;
+  AthenaArray<Real> *t;
+  if (!fcoeff) {
+    t = &(pmy_mg_->GetCurrentData());
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    t = &(pmy_mg_->GetCurrentCoefficient());
+  }
+  AthenaArray<Real> &dst = *t;
+  AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
 
   if (nb.ni.ox1 == 0) {
     si = fs, ei = fe;
@@ -870,7 +972,7 @@ bool MGBoundaryValues::ReceiveMultigridBoundaryBuffers(BoundaryQuantity type,
   for (int n = 0; n < nneighbor; ++n) {
     NeighborBlock& nb = neighbor[n];
     if (bdata_[bcolor_].flag[nb.bufid] == BoundaryStatus::completed) continue;
-    if (type == BoundaryQuantity::mggrav_f && nb.snb.level > loc.level
+    if (type == BoundaryQuantity::mg_faceonly && nb.snb.level > loc.level
       && nb.ni.type != NeighborConnect::face) continue;
     if (bdata_[bcolor_].flag[nb.bufid] == BoundaryStatus::waiting) {
       if (nb.snb.rank == Globals::my_rank) {// on the same process
@@ -891,17 +993,19 @@ bool MGBoundaryValues::ReceiveMultigridBoundaryBuffers(BoundaryQuantity type,
 #endif
     }
     if (nb.snb.level == loc.level) {
-      SetMultigridBoundarySameLevel(bdata_[bcolor_].recv[nb.bufid], nb, folddata);
+      SetMultigridBoundarySameLevel(bdata_[bcolor_].recv[nb.bufid], nb, folddata, false);
     } else if (nb.snb.level < loc.level) {
-      if (type == BoundaryQuantity::mggrav_f)
+      if (type == BoundaryQuantity::mg_faceonly)
         SetMultigridBoundaryFromCoarserFluxCons(bdata_[bcolor_].recv[nb.bufid], nb);
       else
-        SetMultigridBoundaryFromCoarser(bdata_[bcolor_].recv[nb.bufid], nb, folddata);
+        SetMultigridBoundaryFromCoarser(bdata_[bcolor_].recv[nb.bufid], nb,
+                                        folddata, false);
     } else {
-      if (type == BoundaryQuantity::mggrav_f)
+      if (type == BoundaryQuantity::mg_faceonly)
         SetMultigridBoundaryFromFinerFluxCons(bdata_[bcolor_].recv[nb.bufid], nb);
       else
-        SetMultigridBoundaryFromFiner(bdata_[bcolor_].recv[nb.bufid], nb, folddata);
+        SetMultigridBoundaryFromFiner(bdata_[bcolor_].recv[nb.bufid], nb,
+                                      folddata, false);
     }
     bdata_[bcolor_].flag[nb.bufid] = BoundaryStatus::completed; // completed
   }
@@ -911,22 +1015,53 @@ bool MGBoundaryValues::ReceiveMultigridBoundaryBuffers(BoundaryQuantity type,
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MGBoundaryValues::ProlongateMultigridBoundaries(bool folddata)
+//! \fn void MGBoundaryValues::ReceiveMultigridCoefficientBoundaryBuffers()
+//! \brief receive the boundary data for Multigrid coefficients
+
+void MGBoundaryValues::ReceiveMultigridCoefficientBoundaryBuffers() {
+  for (int n = 0; n < nneighbor; ++n) {
+    NeighborBlock& nb = neighbor[n];
+#ifdef MPI_PARALLEL
+    if (nb.snb.rank != Globals::my_rank)
+      MPI_Wait(&(bdata_[bcolor_].req_recv[nb.bufid]),MPI_STATUS_IGNORE);
+#endif
+    if (nb.snb.level == loc.level)
+      SetMultigridBoundarySameLevel(bdata_[bcolor_].recv[nb.bufid], nb, false, true);
+    else if (nb.snb.level < loc.level)
+      SetMultigridBoundaryFromCoarser(bdata_[bcolor_].recv[nb.bufid], nb, false, true);
+    else
+      SetMultigridBoundaryFromFiner(bdata_[bcolor_].recv[nb.bufid], nb, false, true);
+    bdata_[bcolor_].flag[nb.bufid] = BoundaryStatus::completed; // completed
+  }
+
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGBoundaryValues::ProlongateMultigridBoundaries(bool folddata, bool fcoeff)
 //! \brief prolongate boundaries for Multigrid
 
-void MGBoundaryValues::ProlongateMultigridBoundaries(bool folddata) {
-  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
-  AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
+void MGBoundaryValues::ProlongateMultigridBoundaries(bool folddata, bool fcoeff) {
   int nc = pmy_mg_->GetCurrentNumberOfCells();
   int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
   Real time = pmy_mesh_->time;
   int ll = pmy_mg_->nlevel_ - 1 - pmy_mg_->GetCurrentLevel();
   const int cn = 1, cs = cn, ce = cs + nc/2 -1;
   const int flim = ngh + nc;
+  AthenaArray<Real> *t;
+  if (!fcoeff) {
+    t = &(pmy_mg_->GetCurrentData());
+  } else {
+    nvar = pmy_mg_->ncoeff_;
+    t = &(pmy_mg_->GetCurrentCoefficient());
+  }
+  AthenaArray<Real> &dst = *t;
+  AthenaArray<Real> &old = pmy_mg_->GetCurrentOldData();
 
-  ApplyPhysicalBoundaries(1);
+  ApplyPhysicalBoundaries(1, fcoeff);
   if (folddata)
-    ApplyPhysicalBoundaries(2);
+    ApplyPhysicalBoundaries(2, fcoeff);
 
   for (int n = 0; n < nneighbor; ++n) {
     NeighborBlock& nb = neighbor[n];
@@ -1076,354 +1211,61 @@ void MGBoundaryValues::ProlongateMultigridBoundaries(bool folddata) {
 
 
 //----------------------------------------------------------------------------------------
-//! \fn int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToCoarserFluxCons(
+//! \fn int MGBoundaryValues::LoadMultigridBoundaryBufferToCoarserFluxCons(
 //!                                               Real *buf, const NeighborBlock& nb)
 //! \brief Set Multigrid boundary buffers for sending to a block on the coarser level
-//!        using the Mass Conservation formula for gravity
+//!        with flux-conservation for the base class (just call the normal version)
 
-int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToCoarserFluxCons(Real *buf,
+int MGBoundaryValues::LoadMultigridBoundaryBufferToCoarserFluxCons(Real *buf,
                                                           const NeighborBlock& nb) {
-  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
-  int nc = pmy_mg_->GetCurrentNumberOfCells();
-  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
-  int cn = ngh, fs = ngh, cs = cn, fe = fs + nc - 1, ce = cs + nc/2 - 1;
-  int p = 0;
-
-  // take averages of four cells contacting the interface and pack
-  if (nb.ni.ox1 != 0) { // x1 face
-    int fi;
-    if (nb.ni.ox1 < 0) fi = fs;
-    else               fi = fe;
-    for (int v=0; v<nvar; ++v) {
-      for (int fk=fs; fk<=fe; fk+=2) {
-#pragma ivdep
-        for (int fj=fs; fj<=fe; fj+=2)
-          buf[p++] = 0.25*((u(v, fk,   fj,   fi)+u(v, fk,   fj+1, fi))
-                          +(u(v, fk+1, fj,   fi)+u(v, fk+1, fj+1, fi)));
-      }
-    }
-  } else if (nb.ni.ox2 != 0) { // x2 face
-    int fj;
-    if (nb.ni.ox2 < 0) fj = fs;
-    else               fj = fe;
-    for (int v=0; v<nvar; ++v) {
-      for (int fk=fs; fk<=fe; fk+=2) {
-#pragma ivdep
-        for (int fi=fs; fi<=fe; fi+=2)
-          buf[p++] = 0.25*((u(v, fk,   fj, fi)+u(v, fk,   fj, fi+1))
-                          +(u(v, fk+1, fj, fi)+u(v, fk+1, fj, fi+1)));
-      }
-    }
-  } else { // x3 face
-    int fk;
-    if (nb.ni.ox3 < 0) fk = fs;
-    else               fk = fe;
-    for (int v=0; v<nvar; ++v) {
-      for (int fj=fs; fj<=fe; fj+=2) {
-#pragma ivdep
-        for (int fi=fs; fi<=fe; fi+=2)
-          buf[p++] = 0.25*((u(v, fk, fj,   fi)+u(v, fk, fj,   fi+1))
-                          +(u(v, fk, fj+1, fi)+u(v, fk, fj+1, fi+1)));
-      }
-    }
-  }
-
-  return p;
+  return LoadMultigridBoundaryBufferToCoarser(buf, nb, false, false);
 }
 
 
 //----------------------------------------------------------------------------------------
-//! \fn int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
+//! \fn int MGBoundaryValues::LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
 //!                                                             const NeighborBlock& nb)
 //! \brief Set Multigrid boundary buffers for sending to a block on the finer level
-int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
-                                                               const NeighborBlock& nb) {
-  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
-  int nc = pmy_mg_->GetCurrentNumberOfCells();
-  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
-  int cn = ngh - 1, fs = ngh, fe = fs + nc - 1;
-  int si = (nb.ni.ox1 > 0) ? (fe - cn) : fs;
-  int ei = (nb.ni.ox1 < 0) ? (fs + cn) : fe;
-  int sj = (nb.ni.ox2 > 0) ? (fe - cn) : fs;
-  int ej = (nb.ni.ox2 < 0) ? (fs + cn) : fe;
-  int sk = (nb.ni.ox3 > 0) ? (fe - cn) : fs;
-  int ek = (nb.ni.ox3 < 0) ? (fs + cn) : fe;
-
-  int nred = nc/2 - ngh;
-  if (nb.ni.ox1 == 0) {
-    if (nb.ni.fi1 == 1)   si += nred;
-    else                  ei -= nred;
-  }
-  if (nb.ni.ox2 == 0) {
-    if (nb.ni.ox1 != 0) {
-      if (nb.ni.fi1 == 1) sj += nred;
-      else                ej -= nred;
-    } else {
-      if (nb.ni.fi2 == 1) sj += nred;
-      else                ej -= nred;
-    }
-  }
-  if (nb.ni.ox3 == 0) {
-    if (nb.ni.ox1 != 0 && nb.ni.ox2 != 0) {
-      if (nb.ni.fi1 == 1) sk += nred;
-      else                ek -= nred;
-    } else {
-      if (nb.ni.fi2 == 1) sk += nred;
-      else                ek -= nred;
-    }
-  }
+//!        with flux-conservation for the base class (just call the normal version)
 
-  int p = 0;
-  BufferUtility::PackData(u, buf, 0, nvar-1, si, ei, sj, ej, sk, ek, p);
-
-  return p;
+int MGBoundaryValues::LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
+                                                               const NeighborBlock& nb) {
+  return LoadMultigridBoundaryBufferToFiner(buf, nb, false, false);
 }
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MGGravityBoundaryValues::SetMultigridBoundaryFromCoarserFluxCons(
+//! \fn void MGBoundaryValues::SetMultigridBoundaryFromCoarserFluxCons(
 //!                                      const Real *buf, const NeighborBlock& nb)
-//! \brief Set hydro boundary received from a block on the same level
+//! \brief Set Multigrid boundary received from a block from the coarser level
+//!        with flux-conservation for the base class (just call the normal version)
 
-void MGGravityBoundaryValues::SetMultigridBoundaryFromCoarserFluxCons(const Real *buf,
+void MGBoundaryValues::SetMultigridBoundaryFromCoarserFluxCons(const Real *buf,
                                                              const NeighborBlock& nb) {
-  int nc = pmy_mg_->GetCurrentNumberOfCells();
-  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
-  int si, sj, sk, ei, ej, ek;
-  int cng = 1;
-  int cs = cng, ce = cng + nc/2 -1;
-
-  if (nb.ni.ox1 == 0) {
-    si = cs, ei = ce;
-    if ((loc.lx1 & 1LL) == 0LL) ei += cng;
-    else                        si -= cng;
-  } else if (nb.ni.ox1 > 0)  {
-    si = ce + 1,   ei = ce + cng;
-  } else {
-    si = cs - cng, ei = cs - 1;
-  }
-  if (nb.ni.ox2 == 0) {
-    sj = cs, ej = ce;
-    if ((loc.lx2 & 1LL) == 0LL) ej += cng;
-    else                        sj -= cng;
-  } else if (nb.ni.ox2 > 0) {
-    sj = ce + 1,   ej = ce + cng;
-  } else {
-    sj = cs - cng, ej = cs - 1;
-  }
-  if (nb.ni.ox3 == 0) {
-    sk = cs, ek = ce;
-    if ((loc.lx3 & 1LL) == 0LL) ek += cng;
-    else                        sk -= cng;
-  } else if (nb.ni.ox3 > 0)  {
-    sk = ce + 1,   ek = ce + cng;
-  } else {
-    sk = cs - cng, ek = cs - 1;
-  }
-
-  int p = 0;
-  BufferUtility::UnpackData(buf, cbuf_, 0, nvar-1, si, ei, sj, ej, sk, ek, p);
-
+  SetMultigridBoundaryFromCoarser(buf, nb, false, false);
   return;
 }
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MGGravityBoundaryValues::SetMultigridBoundaryFromFinerFluxCons(
+//! \fn void MGBoundaryValues::SetMultigridBoundaryFromFinerFluxCons(
 //!                                      const Real *buf, const NeighborBlock& nb)
+//! \brief Set Multigrid boundary received from a block from the finer level
+//!        with flux-conservation for the base class (just call the normal version)
 
-void MGGravityBoundaryValues::SetMultigridBoundaryFromFinerFluxCons(const Real *buf,
+void MGBoundaryValues::SetMultigridBoundaryFromFinerFluxCons(const Real *buf,
                                                              const NeighborBlock& nb) {
-  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
-  int nc = pmy_mg_->GetCurrentNumberOfCells();
-  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
-  int fs = ngh, fe = fs + nc - 1;
-  int si, sj, sk, ei, ej, ek;
-  int oi = 0, oj = 0, ok = 0;
-
-  // could reuse the index calculation for normal boundaries
-  // but in general this depends on physics
-  if (nb.ni.ox1 == 0) {
-    si = fs, ei = fe;
-    if (nb.ni.fi1 == 1)   si += nc/2;
-    else                  ei -= nc/2;
-  } else if (nb.ni.ox1 > 0) {
-    si = fe + 1,   ei = fe + ngh, oi = -1;
-  } else {
-    si = fs - ngh, ei = fs - 1,   oi = 1;
-  }
-  if (nb.ni.ox2 == 0) {
-    sj = fs, ej = fe;
-    if (nb.ni.ox1 != 0) {
-      if (nb.ni.fi1 == 1) sj += nc/2;
-      else                ej -= nc/2;
-    } else {
-      if (nb.ni.fi2 == 1) sj += nc/2;
-      else                ej -= nc/2;
-    }
-  } else if (nb.ni.ox2 > 0) {
-    sj = fe + 1,   ej = fe + ngh, oj = -1;
-  } else {
-    sj = fs - ngh, ej = fs - 1,   oj = 1;
-  }
-  if (nb.ni.ox3 == 0) {
-    sk = fs, ek = fe;
-    if (nb.ni.ox1 != 0 && nb.ni.ox2 != 0) {
-      if (nb.ni.fi1 == 1) sk += nc/2;
-      else                ek -= nc/2;
-    } else {
-      if (nb.ni.fi2 == 1) sk += nc/2;
-      else                ek -= nc/2;
-    }
-  } else if (nb.ni.ox3 > 0) {
-    sk = fe + 1,   ek = fe + ngh, ok = -1;
-  } else {
-    sk = fs - ngh, ek = fs - 1,   ok = 1;
-  }
-
-  constexpr Real ot = 1.0/3.0;
-  int p = 0;
-
-  // correct the ghost values using the mass conservation formula
-  for (int v=0; v<nvar; ++v) {
-    for (int k=sk; k<=ek; ++k) {
-      for (int j=sj; j<=ej; ++j) {
-        for (int i=si; i<=ei; ++i) {
-          dst(v,k,j,i) = ot * (4.0*buf[p++] - dst(v,k+ok,j+oj,i+oi));
-        }
-      }
-    }
-  }
+  SetMultigridBoundaryFromFiner(buf, nb, false, false);
   return;
 }
 
 
-
 //----------------------------------------------------------------------------------------
 //! \fn void MGBoundaryValues::ProlongateMultigridBoundariesFluxCons()
-//! \brief prolongate boundaries for Multigrid
+//! \brief prolongate Multigrid boundaries with the flux-conservation formula
+//!        for the base class (just call the normal version)
 
 void MGBoundaryValues::ProlongateMultigridBoundariesFluxCons() {
-  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
-  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
-  int nc = pmy_mg_->GetCurrentNumberOfCells();
-  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
-  Real time = pmy_mesh_->time;
-  int lev = pmy_mg_->GetCurrentLevel();
-  int ll = pmy_mg_->nlevel_ - 1 - lev;
-  MGCoordinates &coord = pmy_mg_->ccoord_[lev];
-  constexpr Real ot = 1.0 / 3.0;
-  int cn = 1, cs = cn, ce = cs + nc/2 -1;
-  int fs = ngh, fe = fs + nc - 1;
-  int flim = ngh + nc;
-
-  // x1face
-  for (int ox1=-1; ox1<=1; ox1+=2) {
-    if (nblevel[1][1][ox1+1] == loc.level - 1) {
-      int i, fi, fig;
-      if (ox1 > 0) i = ce + 1, fi = fe, fig = fe + 1;
-      else         i = cs - 1, fi = fs, fig = fs - 1;
-      if (apply_bndry_fn_[BoundaryFace::inner_x2])
-        DispatchBoundaryFunction(BoundaryFace::inner_x2, cbuf_, time, nvar,
-                                 i, i, cs, ce, cs, ce, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::outer_x2])
-        DispatchBoundaryFunction(BoundaryFace::outer_x2, cbuf_, time, nvar,
-                                 i, i, cs, ce, cs, ce, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::inner_x3])
-        DispatchBoundaryFunction(BoundaryFace::inner_x3, cbuf_, time, nvar,
-                                 i, i, cs, ce, cs, ce, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::outer_x3])
-        DispatchBoundaryFunction(BoundaryFace::outer_x3, cbuf_, time, nvar,
-                                 i, i, cs, ce, cs, ce, ngh, coord);
-      for (int v=0; v<nvar; ++v) {
-        for(int k=cs; k<=ce; ++k) {
-          int fk = (k - cs) * 2 + fs;
-          for(int j=cs; j<=ce; ++j) {
-            int fj = (j - cs) * 2 + fs;
-            Real ccval = cbuf_(v, k, j, i);
-            Real gx2c = 0.125*(cbuf_(v, k, j+1, i) -  cbuf_(v, k, j-1, i));
-            Real gx3c = 0.125*(cbuf_(v, k+1, j, i) -  cbuf_(v, k-1, j, i));
-            dst(v,fk  ,fj  ,fig) = ot*(2.0*(ccval - gx2c - gx3c) + u(v,fk  ,fj  ,fi));
-            dst(v,fk  ,fj+1,fig) = ot*(2.0*(ccval + gx2c - gx3c) + u(v,fk  ,fj+1,fi));
-            dst(v,fk+1,fj  ,fig) = ot*(2.0*(ccval - gx2c + gx3c) + u(v,fk+1,fj  ,fi));
-            dst(v,fk+1,fj+1,fig) = ot*(2.0*(ccval + gx2c + gx3c) + u(v,fk+1,fj+1,fi));
-          }
-        }
-      }
-    }
-  }
-
-  // x2face
-  for (int ox2=-1; ox2<=1; ox2+=2) {
-    if (nblevel[1][ox2+1][1] == loc.level - 1) {
-      int j, fj, fjg;
-      if (ox2 > 0) j = ce + 1, fj = fe, fjg = fe + 1;
-      else         j = cs - 1, fj = fs, fjg = fs - 1;
-      if (apply_bndry_fn_[BoundaryFace::inner_x1])
-        DispatchBoundaryFunction(BoundaryFace::inner_x1, cbuf_, time, nvar,
-                                 cs, ce, j, j, cs, ce, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::outer_x1])
-        DispatchBoundaryFunction(BoundaryFace::outer_x1, cbuf_, time, nvar,
-                                 cs, ce, j, j, cs, ce, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::inner_x3])
-        DispatchBoundaryFunction(BoundaryFace::inner_x3, cbuf_, time, nvar,
-                                 cs, ce, j, j, cs, ce, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::outer_x3])
-        DispatchBoundaryFunction(BoundaryFace::outer_x3, cbuf_, time, nvar,
-                                 cs, ce, j, j, cs, ce, ngh, coord);
-      for (int v=0; v<nvar; ++v) {
-        for(int k=cs; k<=ce; ++k) {
-          int fk = (k - cs) * 2 + fs;
-          for(int i=cs; i<=ce; ++i) {
-            int fi = (i - cs) * 2 + fs;
-            Real ccval = cbuf_(v, k, j, i);
-            Real gx1c = 0.125*(cbuf_(v, k, j, i+1) -  cbuf_(v, k, j, i-1));
-            Real gx3c = 0.125*(cbuf_(v, k+1, j, i) -  cbuf_(v, k-1, j, i));
-            dst(v,fk  ,fjg,fi  ) = ot*(2.0*(ccval - gx1c - gx3c) + u(v,fk,  fj,fi  ));
-            dst(v,fk  ,fjg,fi+1) = ot*(2.0*(ccval + gx1c - gx3c) + u(v,fk,  fj,fi+1));
-            dst(v,fk+1,fjg,fi  ) = ot*(2.0*(ccval - gx1c + gx3c) + u(v,fk+1,fj,fi  ));
-            dst(v,fk+1,fjg,fi+1) = ot*(2.0*(ccval + gx1c + gx3c) + u(v,fk+1,fj,fi+1));
-          }
-        }
-      }
-    }
-  }
-
-  // x3face
-  for (int ox3=-1; ox3<=1; ox3+=2) {
-    if (nblevel[ox3+1][1][1] == loc.level - 1) {
-      int k, fk, fkg;
-      if (ox3 > 0) k = ce + 1, fk = fe, fkg = fe + 1;
-      else         k = cs - 1, fk = fs, fkg = fs - 1;
-      if (apply_bndry_fn_[BoundaryFace::inner_x1])
-        DispatchBoundaryFunction(BoundaryFace::inner_x1, cbuf_, time, nvar,
-                                 cs, ce, cs, ce, k, k, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::outer_x1])
-        DispatchBoundaryFunction(BoundaryFace::outer_x1, cbuf_, time, nvar,
-                                 cs, ce, cs, ce, k, k, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::inner_x2])
-        DispatchBoundaryFunction(BoundaryFace::inner_x2, cbuf_, time, nvar,
-                                 cs, ce, cs, ce, k, k, ngh, coord);
-      if (apply_bndry_fn_[BoundaryFace::outer_x2])
-        DispatchBoundaryFunction(BoundaryFace::outer_x2, cbuf_, time, nvar,
-                                 cs, ce, cs, ce, k, k, ngh, coord);
-      for (int v=0; v<nvar; ++v) {
-        for(int j=cs; j<=ce; ++j) {
-          int fj = (j - cs) * 2 + fs;
-          for(int i=cs; i<=ce; ++i) {
-            int fi = (i - cs) * 2 + fs;
-            Real ccval = cbuf_(v, k, j, i);
-            Real gx1c = 0.125*(cbuf_(v, k, j, i+1) -  cbuf_(v, k, j, i-1));
-            Real gx2c = 0.125*(cbuf_(v, k, j+1, i) -  cbuf_(v, k, j-1, i));
-            dst(v,fkg,fj  ,fi  ) = ot*(2.0*(ccval - gx1c - gx2c) + u(v,fk,fj  ,fi  ));
-            dst(v,fkg,fj  ,fi+1) = ot*(2.0*(ccval + gx1c - gx2c) + u(v,fk,fj  ,fi+1));
-            dst(v,fkg,fj+1,fi  ) = ot*(2.0*(ccval - gx1c + gx2c) + u(v,fk,fj+1,fi  ));
-            dst(v,fkg,fj+1,fi+1) = ot*(2.0*(ccval + gx1c + gx2c) + u(v,fk,fj+1,fi+1));
-          }
-        }
-      }
-    }
-  }
-
+  ProlongateMultigridBoundaries(false, false);
   return;
 }
diff --git a/src/bvals/cc/mg/bvals_mg.hpp b/src/bvals/cc/mg/bvals_mg.hpp
index 341ab13d41..28ff6402a6 100644
--- a/src/bvals/cc/mg/bvals_mg.hpp
+++ b/src/bvals/cc/mg/bvals_mg.hpp
@@ -43,21 +43,22 @@ class MGBoundaryValues : public BoundaryBase {
   void InitBoundaryData(BoundaryQuantity type);
   void DestroyBoundaryData();
 
-  void ApplyPhysicalBoundaries(int flag = 0);
+  void ApplyPhysicalBoundaries(int flag, bool fcoeff);
   void StartReceivingMultigrid(BoundaryQuantity type, bool folddata);
   void ClearBoundaryMultigrid(BoundaryQuantity type);
   bool SendMultigridBoundaryBuffers(BoundaryQuantity type, bool folddata);
   bool ReceiveMultigridBoundaryBuffers(BoundaryQuantity type, bool folddata);
-  void ProlongateMultigridBoundaries(bool folddata);
-  void ProlongateMultigridBoundariesFluxCons();
+  void ReceiveMultigridCoefficientBoundaryBuffers();
+  void ProlongateMultigridBoundaries(bool folddata, bool fcoeff);
+  virtual void ProlongateMultigridBoundariesFluxCons();
 
-  virtual void DispatchBoundaryFunction(BoundaryFace face, AthenaArray<Real> &dst,
+  void DispatchBoundaryFunction(BoundaryFace face, AthenaArray<Real> &dst,
        Real time, int nvar, int is, int ie, int js, int je, int ks, int ke, int ngh,
-       const MGCoordinates &coord);
+       const MGCoordinates &coord, bool fcoeff);
 
  protected:
   Multigrid *pmy_mg_;
-  MGBoundaryFunc MGBoundaryFunction_[6];
+  MGBoundaryFunc MGBoundaryFunction_[6], MGCoeffBoundaryFunction_[6];
   BoundaryData<> bdata_[3];
   AthenaArray<Real> cbuf_, cbufold_;
   int bcolor_;
@@ -68,27 +69,27 @@ class MGBoundaryValues : public BoundaryBase {
 #endif
 
   int LoadMultigridBoundaryBufferSameLevel(Real *buf, const NeighborBlock& nb,
-                                           bool folddata);
+                                           bool folddata, bool fcoeff);
   int LoadMultigridBoundaryBufferToCoarser(Real *buf, const NeighborBlock& nb,
-                                           bool folddata);
+                                           bool folddata, bool fcoeff);
   int LoadMultigridBoundaryBufferToFiner(Real *buf, const NeighborBlock& nb,
-                                         bool folddata);
+                                         bool folddata, bool fcoeff);
   void SetMultigridBoundarySameLevel(const Real *buf, const NeighborBlock& nb,
-                                     bool folddata);
+                                     bool folddata, bool fcoeff);
   void SetMultigridBoundaryFromCoarser(const Real *buf, const NeighborBlock& nb,
-                                       bool folddata);
+                                       bool folddata, bool fcoeff);
   void SetMultigridBoundaryFromFiner(const Real *buf, const NeighborBlock& nb,
-                                     bool folddata);
+                                     bool folddata, bool fcoeff);
   //!@{
   //! functions specific to physics
   virtual int LoadMultigridBoundaryBufferToCoarserFluxCons(Real *buf,
-                                                           const NeighborBlock& nb) = 0;
+                                                           const NeighborBlock& nb);
   virtual int LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
-                                                         const NeighborBlock& nb) = 0;
+                                                         const NeighborBlock& nb);
   virtual void SetMultigridBoundaryFromCoarserFluxCons(const Real *buf,
-                                                       const NeighborBlock& nb) = 0;
+                                                       const NeighborBlock& nb);
   virtual void SetMultigridBoundaryFromFinerFluxCons(const Real *buf,
-                                                     const NeighborBlock& nb) = 0;
+                                                     const NeighborBlock& nb);
   //!@}
   friend class Multigrid;
   friend class MultigridDriver;
@@ -103,6 +104,8 @@ class MGGravityBoundaryValues : public MGBoundaryValues {
  public:
   MGGravityBoundaryValues(Multigrid *pmg, BoundaryFlag *input_bcs)
     : MGBoundaryValues(pmg, input_bcs) {}
+  void ProlongateMultigridBoundariesFluxCons() final;
+
  private:
   int LoadMultigridBoundaryBufferToCoarserFluxCons(Real *buf,
                                                    const NeighborBlock& nb) final;
diff --git a/src/bvals/cc/mg/bvals_mg_gravity.cpp b/src/bvals/cc/mg/bvals_mg_gravity.cpp
new file mode 100644
index 0000000000..9b38d7d7c7
--- /dev/null
+++ b/src/bvals/cc/mg/bvals_mg_gravity.cpp
@@ -0,0 +1,393 @@
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file bvals_mg_gravity.cpp
+//! \brief
+
+// C headers
+
+// C++ headers
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>    // memcpy()
+#include <iomanip>
+#include <iostream>   // endl
+#include <sstream>    // stringstream
+#include <stdexcept>  // runtime_error
+#include <string>     // c_str()
+
+// Athena++ headers
+#include "../../../athena.hpp"
+#include "../../../athena_arrays.hpp"
+#include "../../../coordinates/coordinates.hpp"
+#include "../../../globals.hpp"
+#include "../../../mesh/mesh.hpp"
+#include "../../../multigrid/multigrid.hpp"
+#include "../../../parameter_input.hpp"
+#include "../../../utils/buffer_utils.hpp"
+#include "bvals_mg.hpp"
+
+// MPI header
+#ifdef MPI_PARALLEL
+#include <mpi.h>
+#endif
+
+class Multigrid;
+class MultigridDriver;
+class MGBoundaryValues;
+
+//----------------------------------------------------------------------------------------
+//! \fn int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToCoarserFluxCons(
+//!                                               Real *buf, const NeighborBlock& nb)
+//! \brief Set Multigrid boundary buffers for sending to a block on the coarser level
+//!        using the Mass Conservation formula for gravity
+
+int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToCoarserFluxCons(Real *buf,
+                                                          const NeighborBlock& nb) {
+  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
+  int nc = pmy_mg_->GetCurrentNumberOfCells();
+  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  int cn = ngh, fs = ngh, cs = cn, fe = fs + nc - 1, ce = cs + nc/2 - 1;
+  int p = 0;
+
+  // take averages of four cells contacting the interface and pack
+  if (nb.ni.ox1 != 0) { // x1 face
+    int fi;
+    if (nb.ni.ox1 < 0) fi = fs;
+    else               fi = fe;
+    for (int v=0; v<nvar; ++v) {
+      for (int fk=fs; fk<=fe; fk+=2) {
+#pragma ivdep
+        for (int fj=fs; fj<=fe; fj+=2)
+          buf[p++] = 0.25*((u(v, fk,   fj,   fi)+u(v, fk,   fj+1, fi))
+                          +(u(v, fk+1, fj,   fi)+u(v, fk+1, fj+1, fi)));
+      }
+    }
+  } else if (nb.ni.ox2 != 0) { // x2 face
+    int fj;
+    if (nb.ni.ox2 < 0) fj = fs;
+    else               fj = fe;
+    for (int v=0; v<nvar; ++v) {
+      for (int fk=fs; fk<=fe; fk+=2) {
+#pragma ivdep
+        for (int fi=fs; fi<=fe; fi+=2)
+          buf[p++] = 0.25*((u(v, fk,   fj, fi)+u(v, fk,   fj, fi+1))
+                          +(u(v, fk+1, fj, fi)+u(v, fk+1, fj, fi+1)));
+      }
+    }
+  } else { // x3 face
+    int fk;
+    if (nb.ni.ox3 < 0) fk = fs;
+    else               fk = fe;
+    for (int v=0; v<nvar; ++v) {
+      for (int fj=fs; fj<=fe; fj+=2) {
+#pragma ivdep
+        for (int fi=fs; fi<=fe; fi+=2)
+          buf[p++] = 0.25*((u(v, fk, fj,   fi)+u(v, fk, fj,   fi+1))
+                          +(u(v, fk, fj+1, fi)+u(v, fk, fj+1, fi+1)));
+      }
+    }
+  }
+
+  return p;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
+//!                                                             const NeighborBlock& nb)
+//! \brief Set Multigrid boundary buffers for sending to a block on the finer level
+int MGGravityBoundaryValues::LoadMultigridBoundaryBufferToFinerFluxCons(Real *buf,
+                                                               const NeighborBlock& nb) {
+  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
+  int nc = pmy_mg_->GetCurrentNumberOfCells();
+  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  int cn = ngh - 1, fs = ngh, fe = fs + nc - 1;
+  int si = (nb.ni.ox1 > 0) ? (fe - cn) : fs;
+  int ei = (nb.ni.ox1 < 0) ? (fs + cn) : fe;
+  int sj = (nb.ni.ox2 > 0) ? (fe - cn) : fs;
+  int ej = (nb.ni.ox2 < 0) ? (fs + cn) : fe;
+  int sk = (nb.ni.ox3 > 0) ? (fe - cn) : fs;
+  int ek = (nb.ni.ox3 < 0) ? (fs + cn) : fe;
+
+  int nred = nc/2 - ngh;
+  if (nb.ni.ox1 == 0) {
+    if (nb.ni.fi1 == 1)   si += nred;
+    else                  ei -= nred;
+  }
+  if (nb.ni.ox2 == 0) {
+    if (nb.ni.ox1 != 0) {
+      if (nb.ni.fi1 == 1) sj += nred;
+      else                ej -= nred;
+    } else {
+      if (nb.ni.fi2 == 1) sj += nred;
+      else                ej -= nred;
+    }
+  }
+  if (nb.ni.ox3 == 0) {
+    if (nb.ni.ox1 != 0 && nb.ni.ox2 != 0) {
+      if (nb.ni.fi1 == 1) sk += nred;
+      else                ek -= nred;
+    } else {
+      if (nb.ni.fi2 == 1) sk += nred;
+      else                ek -= nred;
+    }
+  }
+
+  int p = 0;
+  BufferUtility::PackData(u, buf, 0, nvar-1, si, ei, sj, ej, sk, ek, p);
+
+  return p;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGGravityBoundaryValues::SetMultigridBoundaryFromCoarserFluxCons(
+//!                                      const Real *buf, const NeighborBlock& nb)
+//! \brief Set hydro boundary received from a block on the same level
+
+void MGGravityBoundaryValues::SetMultigridBoundaryFromCoarserFluxCons(const Real *buf,
+                                                             const NeighborBlock& nb) {
+  int nc = pmy_mg_->GetCurrentNumberOfCells();
+  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  int si, sj, sk, ei, ej, ek;
+  int cng = 1;
+  int cs = cng, ce = cng + nc/2 -1;
+
+  if (nb.ni.ox1 == 0) {
+    si = cs, ei = ce;
+    if ((loc.lx1 & 1LL) == 0LL) ei += cng;
+    else                        si -= cng;
+  } else if (nb.ni.ox1 > 0)  {
+    si = ce + 1,   ei = ce + cng;
+  } else {
+    si = cs - cng, ei = cs - 1;
+  }
+  if (nb.ni.ox2 == 0) {
+    sj = cs, ej = ce;
+    if ((loc.lx2 & 1LL) == 0LL) ej += cng;
+    else                        sj -= cng;
+  } else if (nb.ni.ox2 > 0) {
+    sj = ce + 1,   ej = ce + cng;
+  } else {
+    sj = cs - cng, ej = cs - 1;
+  }
+  if (nb.ni.ox3 == 0) {
+    sk = cs, ek = ce;
+    if ((loc.lx3 & 1LL) == 0LL) ek += cng;
+    else                        sk -= cng;
+  } else if (nb.ni.ox3 > 0)  {
+    sk = ce + 1,   ek = ce + cng;
+  } else {
+    sk = cs - cng, ek = cs - 1;
+  }
+
+  int p = 0;
+  BufferUtility::UnpackData(buf, cbuf_, 0, nvar-1, si, ei, sj, ej, sk, ek, p);
+
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGGravityBoundaryValues::SetMultigridBoundaryFromFinerFluxCons(
+//!                                      const Real *buf, const NeighborBlock& nb)
+
+void MGGravityBoundaryValues::SetMultigridBoundaryFromFinerFluxCons(const Real *buf,
+                                                             const NeighborBlock& nb) {
+  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
+  int nc = pmy_mg_->GetCurrentNumberOfCells();
+  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  int fs = ngh, fe = fs + nc - 1;
+  int si, sj, sk, ei, ej, ek;
+  int oi = 0, oj = 0, ok = 0;
+
+  // could reuse the index calculation for normal boundaries
+  // but in general this depends on physics
+  if (nb.ni.ox1 == 0) {
+    si = fs, ei = fe;
+    if (nb.ni.fi1 == 1)   si += nc/2;
+    else                  ei -= nc/2;
+  } else if (nb.ni.ox1 > 0) {
+    si = fe + 1,   ei = fe + ngh, oi = -1;
+  } else {
+    si = fs - ngh, ei = fs - 1,   oi = 1;
+  }
+  if (nb.ni.ox2 == 0) {
+    sj = fs, ej = fe;
+    if (nb.ni.ox1 != 0) {
+      if (nb.ni.fi1 == 1) sj += nc/2;
+      else                ej -= nc/2;
+    } else {
+      if (nb.ni.fi2 == 1) sj += nc/2;
+      else                ej -= nc/2;
+    }
+  } else if (nb.ni.ox2 > 0) {
+    sj = fe + 1,   ej = fe + ngh, oj = -1;
+  } else {
+    sj = fs - ngh, ej = fs - 1,   oj = 1;
+  }
+  if (nb.ni.ox3 == 0) {
+    sk = fs, ek = fe;
+    if (nb.ni.ox1 != 0 && nb.ni.ox2 != 0) {
+      if (nb.ni.fi1 == 1) sk += nc/2;
+      else                ek -= nc/2;
+    } else {
+      if (nb.ni.fi2 == 1) sk += nc/2;
+      else                ek -= nc/2;
+    }
+  } else if (nb.ni.ox3 > 0) {
+    sk = fe + 1,   ek = fe + ngh, ok = -1;
+  } else {
+    sk = fs - ngh, ek = fs - 1,   ok = 1;
+  }
+
+  constexpr Real ot = 1.0/3.0;
+  int p = 0;
+
+  // correct the ghost values using the mass conservation formula
+  for (int v=0; v<nvar; ++v) {
+    for (int k=sk; k<=ek; ++k) {
+      for (int j=sj; j<=ej; ++j) {
+        for (int i=si; i<=ei; ++i) {
+          dst(v,k,j,i) = ot * (4.0*buf[p++] - dst(v,k+ok,j+oj,i+oi));
+        }
+      }
+    }
+  }
+  return;
+}
+
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGGravityBoundaryValues::ProlongateMultigridBoundariesFluxCons()
+//! \brief prolongate boundaries for Multigrid
+
+void MGGravityBoundaryValues::ProlongateMultigridBoundariesFluxCons() {
+  const AthenaArray<Real> &u = pmy_mg_->GetCurrentData();
+  AthenaArray<Real> &dst = pmy_mg_->GetCurrentData();
+  int nc = pmy_mg_->GetCurrentNumberOfCells();
+  int ngh = pmy_mg_->ngh_, nvar = pmy_mg_->nvar_;
+  Real time = pmy_mesh_->time;
+  int lev = pmy_mg_->GetCurrentLevel();
+  int ll = pmy_mg_->nlevel_ - 1 - lev;
+  MGCoordinates &coord = pmy_mg_->ccoord_[lev];
+  constexpr Real ot = 1.0 / 3.0;
+  int cn = 1, cs = cn, ce = cs + nc/2 -1;
+  int fs = ngh, fe = fs + nc - 1;
+  int flim = ngh + nc;
+
+  // x1face
+  for (int ox1=-1; ox1<=1; ox1+=2) {
+    if (nblevel[1][1][ox1+1] == loc.level - 1) {
+      int i, fi, fig;
+      if (ox1 > 0) i = ce + 1, fi = fe, fig = fe + 1;
+      else         i = cs - 1, fi = fs, fig = fs - 1;
+      if (apply_bndry_fn_[BoundaryFace::inner_x2])
+        DispatchBoundaryFunction(BoundaryFace::inner_x2, cbuf_, time, nvar,
+                                 i, i, cs, ce, cs, ce, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::outer_x2])
+        DispatchBoundaryFunction(BoundaryFace::outer_x2, cbuf_, time, nvar,
+                                 i, i, cs, ce, cs, ce, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::inner_x3])
+        DispatchBoundaryFunction(BoundaryFace::inner_x3, cbuf_, time, nvar,
+                                 i, i, cs, ce, cs, ce, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::outer_x3])
+        DispatchBoundaryFunction(BoundaryFace::outer_x3, cbuf_, time, nvar,
+                                 i, i, cs, ce, cs, ce, ngh, coord, false);
+      for (int v=0; v<nvar; ++v) {
+        for(int k=cs; k<=ce; ++k) {
+          int fk = (k - cs) * 2 + fs;
+          for(int j=cs; j<=ce; ++j) {
+            int fj = (j - cs) * 2 + fs;
+            Real ccval = cbuf_(v, k, j, i);
+            Real gx2c = 0.125*(cbuf_(v, k, j+1, i) -  cbuf_(v, k, j-1, i));
+            Real gx3c = 0.125*(cbuf_(v, k+1, j, i) -  cbuf_(v, k-1, j, i));
+            dst(v,fk  ,fj  ,fig) = ot*(2.0*(ccval - gx2c - gx3c) + u(v,fk  ,fj  ,fi));
+            dst(v,fk  ,fj+1,fig) = ot*(2.0*(ccval + gx2c - gx3c) + u(v,fk  ,fj+1,fi));
+            dst(v,fk+1,fj  ,fig) = ot*(2.0*(ccval - gx2c + gx3c) + u(v,fk+1,fj  ,fi));
+            dst(v,fk+1,fj+1,fig) = ot*(2.0*(ccval + gx2c + gx3c) + u(v,fk+1,fj+1,fi));
+          }
+        }
+      }
+    }
+  }
+
+  // x2face
+  for (int ox2=-1; ox2<=1; ox2+=2) {
+    if (nblevel[1][ox2+1][1] == loc.level - 1) {
+      int j, fj, fjg;
+      if (ox2 > 0) j = ce + 1, fj = fe, fjg = fe + 1;
+      else         j = cs - 1, fj = fs, fjg = fs - 1;
+      if (apply_bndry_fn_[BoundaryFace::inner_x1])
+        DispatchBoundaryFunction(BoundaryFace::inner_x1, cbuf_, time, nvar,
+                                 cs, ce, j, j, cs, ce, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::outer_x1])
+        DispatchBoundaryFunction(BoundaryFace::outer_x1, cbuf_, time, nvar,
+                                 cs, ce, j, j, cs, ce, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::inner_x3])
+        DispatchBoundaryFunction(BoundaryFace::inner_x3, cbuf_, time, nvar,
+                                 cs, ce, j, j, cs, ce, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::outer_x3])
+        DispatchBoundaryFunction(BoundaryFace::outer_x3, cbuf_, time, nvar,
+                                 cs, ce, j, j, cs, ce, ngh, coord, false);
+      for (int v=0; v<nvar; ++v) {
+        for(int k=cs; k<=ce; ++k) {
+          int fk = (k - cs) * 2 + fs;
+          for(int i=cs; i<=ce; ++i) {
+            int fi = (i - cs) * 2 + fs;
+            Real ccval = cbuf_(v, k, j, i);
+            Real gx1c = 0.125*(cbuf_(v, k, j, i+1) -  cbuf_(v, k, j, i-1));
+            Real gx3c = 0.125*(cbuf_(v, k+1, j, i) -  cbuf_(v, k-1, j, i));
+            dst(v,fk  ,fjg,fi  ) = ot*(2.0*(ccval - gx1c - gx3c) + u(v,fk,  fj,fi  ));
+            dst(v,fk  ,fjg,fi+1) = ot*(2.0*(ccval + gx1c - gx3c) + u(v,fk,  fj,fi+1));
+            dst(v,fk+1,fjg,fi  ) = ot*(2.0*(ccval - gx1c + gx3c) + u(v,fk+1,fj,fi  ));
+            dst(v,fk+1,fjg,fi+1) = ot*(2.0*(ccval + gx1c + gx3c) + u(v,fk+1,fj,fi+1));
+          }
+        }
+      }
+    }
+  }
+
+  // x3face
+  for (int ox3=-1; ox3<=1; ox3+=2) {
+    if (nblevel[ox3+1][1][1] == loc.level - 1) {
+      int k, fk, fkg;
+      if (ox3 > 0) k = ce + 1, fk = fe, fkg = fe + 1;
+      else         k = cs - 1, fk = fs, fkg = fs - 1;
+      if (apply_bndry_fn_[BoundaryFace::inner_x1])
+        DispatchBoundaryFunction(BoundaryFace::inner_x1, cbuf_, time, nvar,
+                                 cs, ce, cs, ce, k, k, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::outer_x1])
+        DispatchBoundaryFunction(BoundaryFace::outer_x1, cbuf_, time, nvar,
+                                 cs, ce, cs, ce, k, k, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::inner_x2])
+        DispatchBoundaryFunction(BoundaryFace::inner_x2, cbuf_, time, nvar,
+                                 cs, ce, cs, ce, k, k, ngh, coord, false);
+      if (apply_bndry_fn_[BoundaryFace::outer_x2])
+        DispatchBoundaryFunction(BoundaryFace::outer_x2, cbuf_, time, nvar,
+                                 cs, ce, cs, ce, k, k, ngh, coord, false);
+      for (int v=0; v<nvar; ++v) {
+        for(int j=cs; j<=ce; ++j) {
+          int fj = (j - cs) * 2 + fs;
+          for(int i=cs; i<=ce; ++i) {
+            int fi = (i - cs) * 2 + fs;
+            Real ccval = cbuf_(v, k, j, i);
+            Real gx1c = 0.125*(cbuf_(v, k, j, i+1) -  cbuf_(v, k, j, i-1));
+            Real gx2c = 0.125*(cbuf_(v, k, j+1, i) -  cbuf_(v, k, j-1, i));
+            dst(v,fkg,fj  ,fi  ) = ot*(2.0*(ccval - gx1c - gx2c) + u(v,fk,fj  ,fi  ));
+            dst(v,fkg,fj  ,fi+1) = ot*(2.0*(ccval + gx1c - gx2c) + u(v,fk,fj  ,fi+1));
+            dst(v,fkg,fj+1,fi  ) = ot*(2.0*(ccval - gx1c + gx2c) + u(v,fk,fj+1,fi  ));
+            dst(v,fkg,fj+1,fi+1) = ot*(2.0*(ccval + gx1c + gx2c) + u(v,fk,fj+1,fi+1));
+          }
+        }
+      }
+    }
+  }
+
+  return;
+}
diff --git a/src/crdiffusion/crdiffusion.cpp b/src/crdiffusion/crdiffusion.cpp
new file mode 100644
index 0000000000..b065907584
--- /dev/null
+++ b/src/crdiffusion/crdiffusion.cpp
@@ -0,0 +1,123 @@
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file crdiffusion.cpp
+//! \brief implementation of functions in class CRDiffusion
+
+// C headers
+
+// C++ headers
+#include <iostream>
+#include <sstream>    // sstream
+#include <stdexcept>  // runtime_error
+#include <string>     // c_str()
+#include <vector>
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "../athena_arrays.hpp"
+#include "../bvals/bvals.hpp"
+#include "../bvals/bvals_interfaces.hpp"
+#include "../bvals/cc/bvals_cc.hpp"
+#include "../coordinates/coordinates.hpp"
+#include "../mesh/mesh.hpp"
+#include "../parameter_input.hpp"
+#include "../utils/buffer_utils.hpp"
+#include "crdiffusion.hpp"
+#include "mg_crdiffusion.hpp"
+
+
+//----------------------------------------------------------------------------------------
+//! \fn CRDiffusion::CRDiffusion(MeshBlock *pmb, ParameterInput *pin)
+//! \brief CRDiffusion constructor
+CRDiffusion::CRDiffusion(MeshBlock *pmb, ParameterInput *pin) :
+    pmy_block(pmb), ecr(pmb->ncells3, pmb->ncells2, pmb->ncells1),
+    source(pmb->ncells3, pmb->ncells2, pmb->ncells1),
+    coeff(NCOEFF, pmb->ncells3, pmb->ncells2, pmb->ncells1),
+    coarse_ecr(pmb->ncc3, pmb->ncc2, pmb->ncc1,
+              (pmb->pmy_mesh->multilevel ? AthenaArray<Real>::DataStatus::allocated :
+               AthenaArray<Real>::DataStatus::empty)),
+    empty_flux{AthenaArray<Real>(), AthenaArray<Real>(), AthenaArray<Real>()},
+    output_defect(false), crbvar(pmb, &ecr, &coarse_ecr, empty_flux, false),
+    refinement_idx_(), Dpara_(), Dperp_(), Lambda_() {
+  Dpara_ = pin->GetReal("crdiffusion", "Dpara");
+  Dperp_ = pin->GetReal("crdiffusion", "Dperp");
+  Lambda_ = pin->GetReal("crdiffusion", "Lambda");
+
+  output_defect = pin->GetOrAddBoolean("crdiffusion", "output_defect", false);
+  if (output_defect)
+    def.NewAthenaArray(pmb->ncells3, pmb->ncells2, pmb->ncells1);
+
+  pmb->RegisterMeshBlockData(ecr);
+  // "Enroll" in S/AMR by adding to vector of tuples of pointers in MeshRefinement class
+  if (pmb->pmy_mesh->multilevel)
+    refinement_idx_ = pmy_block->pmr->AddToRefinement(&ecr, &coarse_ecr);
+
+  pmg = new MGCRDiffusion(pmb->pmy_mesh->pmcrd, pmb);
+
+  // Enroll CellCenteredBoundaryVariable object
+  crbvar.bvar_index = pmb->pbval->bvars.size();
+  pmb->pbval->bvars.push_back(&crbvar);
+  pmb->pbval->pcrbvar = &crbvar;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn CRDiffusion::~CRDiffusion()
+//! \brief CRDiffusion destructor
+CRDiffusion::~CRDiffusion() {
+  delete pmg;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void CRDiffusion::CalculateCoefficients()
+//! \brief Calculate coefficients required for CR calculation
+void CRDiffusion::CalculateCoefficients(const AthenaArray<Real> &w,
+                                        const AthenaArray<Real> &bcc) {
+  int il = pmy_block->is - NGHOST, iu = pmy_block->ie + NGHOST;
+  int jl = pmy_block->js, ju = pmy_block->je;
+  int kl = pmy_block->ks, ku = pmy_block->ke;
+  if (pmy_block->pmy_mesh->f2)
+    jl -= NGHOST, ju += NGHOST;
+  if (pmy_block->pmy_mesh->f3)
+    kl -= NGHOST, ku += NGHOST;
+  Real Dpara = Dpara_, Dperp = Dperp_, Lambda = Lambda_;
+
+  if (MAGNETIC_FIELDS_ENABLED) {
+    for (int k = kl; k <= ku; ++k) {
+      for (int j = jl; j <= ju; ++j) {
+        for (int i = il; i <= iu; ++i) {
+          const Real &bx = bcc(IB1,k,j,i);
+          const Real &by = bcc(IB2,k,j,i);
+          const Real &bz = bcc(IB3,k,j,i);
+          Real ba = std::sqrt(SQR(bx) + SQR(by) + SQR(bz) + TINY_NUMBER);
+          Real nx = bx / ba, ny = by / ba, nz = bz / ba;
+          coeff(DXX,k,j,i) = Dperp + (Dpara - Dperp) * nx * nx;
+          coeff(DXY,k,j,i) =         (Dpara - Dperp) * nx * ny;
+          coeff(DXZ,k,j,i) =         (Dpara - Dperp) * nx * nz;
+          coeff(DYY,k,j,i) = Dperp + (Dpara - Dperp) * ny * ny;
+          coeff(DYZ,k,j,i) =         (Dpara - Dperp) * ny * nz;
+          coeff(DZZ,k,j,i) = Dperp + (Dpara - Dperp) * nz * nz;
+          coeff(NLAMBDA, k,j,i) = Lambda * w(IDN,k,j,i);
+        }
+      }
+    }
+  } else {
+    for (int k = kl; k <= ku; ++k) {
+      for (int j = jl; j <= ju; ++j) {
+        for (int i = il; i <= iu; ++i) {
+          coeff(DXX,k,j,i) = coeff(DXY,k,j,i) = coeff(DXZ,k,j,i) = coeff(DYY,k,j,i)
+                           = coeff(DYZ,k,j,i) = coeff(DZZ,k,j,i) = Dpara;
+          coeff(NLAMBDA, k,j,i) = Lambda * w(IDN,k,j,i);
+        }
+      }
+    }
+  }
+
+  return;
+}
+
+
diff --git a/src/crdiffusion/crdiffusion.hpp b/src/crdiffusion/crdiffusion.hpp
new file mode 100644
index 0000000000..47921521b6
--- /dev/null
+++ b/src/crdiffusion/crdiffusion.hpp
@@ -0,0 +1,62 @@
+#ifndef CRDIFFUSION_CRDIFFUSION_HPP_
+#define CRDIFFUSION_CRDIFFUSION_HPP_
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file crdiffusion.hpp
+//! \brief defines CRDiffusion class which implements data and functions for the implicit
+//!        Cosmic-Ray diffusion solver
+
+// C headers
+
+// C++ headers
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "../athena_arrays.hpp"
+#include "../bvals/bvals.hpp"
+#include "../bvals/cc/bvals_cc.hpp"
+
+class MeshBlock;
+class ParameterInput;
+class Coordinates;
+class CRDiffusionBoundaryValues;
+class MGCRDiffusion;
+class MGCRDiffusionDriver;
+
+constexpr int NCOEFF = 7, NMATRIX = 19;
+enum CoeffIndex {DXX=0, DXY=1, DYX=1, DXZ=2, DZX=2, DYY=3, DYZ=4, DZY=4, DZZ=5,
+                 NLAMBDA=6};
+enum MatrixIndex {CCC=0, CCM=1, CCP=2, CMC=3, CPC=4, MCC=5, PCC=6, CMM=7, CMP=8, CPM=9,
+                  CPP=10, MCM=11, MCP=12, PCM=13, PCP=14, MMC=15, MPC=16, PMC=17, PPC=18};
+
+//! \class CRDiffusion
+//! \brief gravitational potential data and functions
+
+class CRDiffusion {
+ public:
+  CRDiffusion(MeshBlock *pmb, ParameterInput *pin);
+  ~CRDiffusion();
+
+  MeshBlock* pmy_block;
+  MGCRDiffusion *pmg;
+  AthenaArray<Real> ecr, source, zeta, coeff;
+  AthenaArray<Real> coarse_ecr, empty_flux[3];
+  AthenaArray<Real> def;   // defect from the Multigrid solver
+  bool output_defect;
+
+  CellCenteredBoundaryVariable crbvar;
+
+  void CalculateCoefficients(const AthenaArray<Real> &w,
+                             const AthenaArray<Real> &bcc);
+
+  friend class MGCRDiffusuionDriver;
+
+ private:
+  int refinement_idx_;
+  Real Dpara_, Dperp_, Lambda_;
+};
+
+#endif // CRDIFFUSION_CRDIFFUSION_HPP_
diff --git a/src/crdiffusion/mg_crdiffusion.cpp b/src/crdiffusion/mg_crdiffusion.cpp
new file mode 100644
index 0000000000..5565a9f3db
--- /dev/null
+++ b/src/crdiffusion/mg_crdiffusion.cpp
@@ -0,0 +1,637 @@
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file mg_crdiffusion.cpp
+//! \brief create multigrid solver for comic-ray diffusion
+
+// C headers
+
+// C++ headers
+#include <algorithm>
+#include <iostream>
+#include <sstream>    // sstream
+#include <stdexcept>  // runtime_error
+#include <string>     // c_str()
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "../athena_arrays.hpp"
+#include "../coordinates/coordinates.hpp"
+#include "../field/field.hpp"
+#include "../globals.hpp"
+#include "../hydro/hydro.hpp"
+#include "../mesh/mesh.hpp"
+#include "../multigrid/multigrid.hpp"
+#include "../parameter_input.hpp"
+#include "../task_list/crdiffusion_task_list.hpp"
+#include "crdiffusion.hpp"
+#include "mg_crdiffusion.hpp"
+
+#ifdef MPI_PARALLEL
+#include <mpi.h>
+#endif
+
+class MeshBlock;
+
+namespace {
+  AthenaArray<Real> *temp; // temporary data for the Jacobi iteration
+}
+
+//----------------------------------------------------------------------------------------
+//! \fn MGCRDiffusionDriver::MGCRDiffusionDriver(Mesh *pm, ParameterInput *pin)
+//! \brief MGCRDiffusionDriver constructor
+
+MGCRDiffusionDriver::MGCRDiffusionDriver(Mesh *pm, ParameterInput *pin)
+    : MultigridDriver(pm, pm->MGCRDiffusionBoundaryFunction_,
+                          pm->MGCRDiffusionCoeffBoundaryFunction_,
+                          pm->MGCRDiffusionSourceMaskFunction_,
+                          pm->MGCRDiffusionCoeffMaskFunction_,
+                          1, NCOEFF, NMATRIX) {
+  eps_ = pin->GetOrAddReal("crdiffusion", "threshold", -1.0);
+  niter_ = pin->GetOrAddInteger("crdiffusion", "niteration", -1);
+  ffas_ = pin->GetOrAddBoolean("crdiffusion", "fas", ffas_);
+  fsubtract_average_ = false;
+  omega_ = pin->GetOrAddReal("crdiffusion", "omega", 1.0);
+  fsteady_ = pin->GetOrAddBoolean("crdiffusion", "steady", false);
+  npresmooth_ = pin->GetOrAddReal("crdiffusion", "npresmooth", 2);
+  npostsmooth_ = pin->GetOrAddReal("crdiffusion", "npostsmooth", 2);
+  fshowdef_ = pin->GetOrAddBoolean("crdiffusion", "show_defect", fshowdef_);
+  std::string smoother = pin->GetOrAddString("crdiffusion", "smoother", "jacobi-rb");
+  if (smoother == "jacobi-rb") {
+    fsmoother_ = 1;
+    redblack_ = true;
+  } else if (smoother == "jacobi-double") {
+    fsmoother_ = 0;
+    redblack_ = true;
+  } else { // jacobi
+    fsmoother_ = 0;
+    redblack_ = false;
+  }
+  std::string prol = pin->GetOrAddString("crdiffusion", "prolongation", "trilinear");
+  if (prol == "tricubic")
+    fprolongation_ = 1;
+
+  std::string m = pin->GetOrAddString("crdiffusion", "mgmode", "none");
+  std::transform(m.begin(), m.end(), m.begin(), ::tolower);
+  if (m == "fmg") {
+    mode_ = 0;
+  } else if (m == "mgi") {
+    mode_ = 1; // Iterative
+  } else {
+    std::stringstream msg;
+    msg << "### FATAL ERROR in MGCRDiffusionDriver::MGCRDiffusionDriver" << std::endl
+        << "The \"mgmode\" parameter in the <gravity> block is invalid." << std::endl
+        << "FMG: Full Multigrid + Multigrid iteration (default)" << std::endl
+        << "MGI: Multigrid Iteration" << std::endl;
+    ATHENA_ERROR(msg);
+  }
+  if (eps_ < 0.0 && niter_ < 0) {
+    std::stringstream msg;
+    msg << "### FATAL ERROR in MGCRDiffusionDriver::MGCRDiffusionDriver" << std::endl
+        << "Either \"threshold\" or \"niteration\" parameter must be set "
+        << "in the <crdiffusion> block." << std::endl
+        << "When both parameters are specified, \"niteration\" is ignored." << std::endl
+        << "Set \"threshold = 0.0\" for automatic convergence control." << std::endl;
+    ATHENA_ERROR(msg);
+  }
+  mg_mesh_bcs_[inner_x1] =
+              GetMGBoundaryFlag(pin->GetOrAddString("crdiffusion", "ix1_bc", "none"));
+  mg_mesh_bcs_[outer_x1] =
+              GetMGBoundaryFlag(pin->GetOrAddString("crdiffusion", "ox1_bc", "none"));
+  mg_mesh_bcs_[inner_x2] =
+              GetMGBoundaryFlag(pin->GetOrAddString("crdiffusion", "ix2_bc", "none"));
+  mg_mesh_bcs_[outer_x2] =
+              GetMGBoundaryFlag(pin->GetOrAddString("crdiffusion", "ox2_bc", "none"));
+  mg_mesh_bcs_[inner_x3] =
+              GetMGBoundaryFlag(pin->GetOrAddString("crdiffusion", "ix3_bc", "none"));
+  mg_mesh_bcs_[outer_x3] =
+              GetMGBoundaryFlag(pin->GetOrAddString("crdiffusion", "ox3_bc", "none"));
+  CheckBoundaryFunctions();
+
+  mgtlist_ = new MultigridTaskList(this);
+
+  // Allocate the root multigrid
+  mgroot_ = new MGCRDiffusion(this, nullptr);
+
+  crtlist_ = new CRDiffusionBoundaryTaskList(pin, pm);
+
+  int nth = 1;
+#ifdef OPENMP_PARALLEL
+  nth = omp_get_max_threads();
+#endif
+  temp = new AthenaArray<Real>[nth];
+  int nx = std::max(pmy_mesh_->block_size.nx1, pmy_mesh_->nrbx1) + 2*mgroot_->ngh_;
+  int ny = std::max(pmy_mesh_->block_size.nx2, pmy_mesh_->nrbx2) + 2*mgroot_->ngh_;
+  int nz = std::max(pmy_mesh_->block_size.nx3, pmy_mesh_->nrbx3) + 2*mgroot_->ngh_;
+  for (int n = 0; n < nth; ++n)
+    temp[n].NewAthenaArray(nz, ny, nx);
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn MGCRDiffusionDriver::~MGCRDiffusionDriver()
+//! \brief MGCRDiffusionDriver destructor
+
+MGCRDiffusionDriver::~MGCRDiffusionDriver() {
+  delete crtlist_;
+  delete mgroot_;
+  delete mgtlist_;
+  delete [] temp;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn MGCRDiffusion::MGCRDiffusion(MGCRDiffusionDriver *pmd, MeshBlock *pmb)
+//! \brief MGCRDiffusion constructor
+
+MGCRDiffusion::MGCRDiffusion(MGCRDiffusionDriver *pmd, MeshBlock *pmb)
+  : Multigrid(pmd, pmb, 1), omega_(pmd->omega_), fsmoother_(pmd->fsmoother_) {
+  btype = btypef = BoundaryQuantity::mg;
+  pmgbval = new MGBoundaryValues(this, mg_block_bcs_);
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn MGCRDiffusion::~MGCRDiffusion()
+//! \brief MGCRDiffusion deconstructor
+
+MGCRDiffusion::~MGCRDiffusion() {
+  delete pmgbval;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGCRDiffusionDriver::AddCRSource(const AthenaArray<Real> &src,
+//!                                           int ngh, Real dt)
+//! \brief Add the cosmic-ray source term
+
+void MGCRDiffusion::AddCRSource(const AthenaArray<Real> &src, int ngh, Real dt) {
+  AthenaArray<Real> &dst=src_[nlevel_-1];
+  int is, ie, js, je, ks, ke;
+  is=js=ks=ngh_;
+  ie=is+size_.nx1-1, je=js+size_.nx2-1, ke=ks+size_.nx3-1;
+  if (!(static_cast<MGCRDiffusionDriver*>(pmy_driver_)->fsteady_)) {
+    for (int mk=ks; mk<=ke; ++mk) {
+      int k = mk - ks + ngh;
+      for (int mj=js; mj<=je; ++mj) {
+        int j = mj - js + ngh;
+#pragma omp simd
+        for (int mi=is; mi<=ie; ++mi) {
+          int i = mi - is + ngh;
+          dst(mk,mj,mi) += dt * src(k,j,i);
+        }
+      }
+    }
+  } else {
+    for (int mk=ks; mk<=ke; ++mk) {
+      int k = mk - ks + ngh;
+      for (int mj=js; mj<=je; ++mj) {
+        int j = mj - js + ngh;
+#pragma omp simd
+        for (int mi=is; mi<=ie; ++mi) {
+          int i = mi - is + ngh;
+          dst(mk,mj,mi) = src(k,j,i);
+        }
+      }
+    }
+  }
+
+  return;
+}
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGCRDiffusionDriver::Solve(int stage, Real dt)
+//! \brief load the data and solve
+
+void MGCRDiffusionDriver::Solve(int stage, Real dt) {
+  // Construct the Multigrid array
+  vmg_.clear();
+  for (int i = 0; i < pmy_mesh_->nblocal; ++i)
+    vmg_.push_back(pmy_mesh_->my_blocks(i)->pcrdiff->pmg);
+
+  // load the source
+#pragma omp parallel for num_threads(nthreads_)
+  for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+    MGCRDiffusion *pmg = static_cast<MGCRDiffusion*>(*itr);
+    // assume all the data are located on the same node
+    CRDiffusion *pcrdiff = pmg->pmy_block_->pcrdiff;
+    Hydro *phydro = pmg->pmy_block_->phydro;
+    Field *pfield = pmg->pmy_block_->pfield;
+    pcrdiff->CalculateCoefficients(phydro->w, pfield->bcc);
+    if (!fsteady_)
+      pmg->LoadSource(pcrdiff->ecr, 0, NGHOST, 1.0);
+    if (mode_ == 1) // load the current data as the initial guess
+      pmg->LoadFinestData(pcrdiff->ecr, 0, NGHOST);
+    pmg->LoadCoefficients(pcrdiff->coeff, NGHOST);
+    pmg->AddCRSource(pcrdiff->source, NGHOST, dt);
+  }
+
+  if (dt > 0.0 || fsteady_) {
+    SetupMultigrid(dt, false);
+    if (mode_ == 0) {
+      SolveFMGCycle();
+    } else {
+      if (eps_ >= 0.0)
+        SolveIterative();
+      else
+        SolveIterativeFixedTimes();
+    }
+  } else { // just copy trivial solution and set boundaries
+    SetupMultigrid(dt, true);
+    if (mode_ != 1) {
+#pragma omp parallel for num_threads(nthreads_)
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        MGCRDiffusion *pmg = static_cast<MGCRDiffusion*>(*itr);
+        AthenaArray<Real> &ecr = pmg->GetCurrentData();
+        AthenaArray<Real> &ecr0 = pmg->GetCurrentSource();
+        ecr = ecr0;
+      }
+    }
+    mgtlist_->SetMGTaskListBoundaryCommunication();
+    mgtlist_->DoTaskListOneStage(this);
+  }
+
+  // Return the result
+#pragma omp parallel for num_threads(nthreads_)
+  for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+    Multigrid *pmg = *itr;
+    CRDiffusion *pcrdiff = pmg->pmy_block_->pcrdiff;
+    pmg->RetrieveResult(pcrdiff->ecr, 0, NGHOST);
+    if(pcrdiff->output_defect)
+      pmg->RetrieveDefect(pcrdiff->def, 0, NGHOST);
+  }
+
+  crtlist_->DoTaskListOneStage(pmy_mesh_, stage);
+
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGCRDiffusion::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src,
+//!            const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix, int rlev,
+//!            int il, int iu, int jl, int ju, int kl, int ku, int color, bool th)
+//! \brief Implementation of the Red-Black Gauss-Seidel Smoother
+//!        rlev = relative level from the finest level of this Multigrid block
+
+void MGCRDiffusion::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src,
+         const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix, int rlev,
+         int il, int iu, int jl, int ju, int kl, int ku, int color, bool th) {
+  Real dx;
+  if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
+  else           dx = rdx_/static_cast<Real>(1<<rlev);
+  Real dx2 = SQR(dx);
+  Real isix = omega_/6.0;
+  color ^= pmy_driver_->coffset_;
+  if (fsmoother_ == 1) { // jacobi-rb
+    if (th == true && (ku-kl) >=  minth_) {
+      AthenaArray<Real> &work = temp[0];
+#pragma omp parallel num_threads(pmy_driver_->nthreads_)
+      {
+#pragma omp for
+        for (int k=kl; k<=ku; k++) {
+          for (int j=jl; j<=ju; j++) {
+            int c = (color + k + j) & 1;
+#pragma ivdep
+            for (int i=il+c; i<=iu; i+=2) {
+              Real M = matrix(CCM,k,j,i)*u(k,j,i-1)   + matrix(CCP,k,j,i)*u(k,j,i+1)
+                     + matrix(CMC,k,j,i)*u(k,j-1,i)   + matrix(CPC,k,j,i)*u(k,j+1,i)
+                     + matrix(MCC,k,j,i)*u(k-1,j,i)   + matrix(PCC,k,j,i)*u(k+1,j,i)
+                     + matrix(CMM,k,j,i)*u(k,j-1,i-1) + matrix(CMP,k,j,i)*u(k,j-1,i+1)
+                     + matrix(CPM,k,j,i)*u(k,j+1,i-1) + matrix(CPP,k,j,i)*u(k,j+1,i+1)
+                     + matrix(MCM,k,j,i)*u(k-1,j,i-1) + matrix(MCP,k,j,i)*u(k-1,j,i+1)
+                     + matrix(PCM,k,j,i)*u(k+1,j,i-1) + matrix(PCP,k,j,i)*u(k+1,j,i+1)
+                     + matrix(MMC,k,j,i)*u(k-1,j-1,i) + matrix(MPC,k,j,i)*u(k-1,j+1,i)
+                     + matrix(PMC,k,j,i)*u(k+1,j-1,i) + matrix(PPC,k,j,i)*u(k+1,j+1,i);
+                work(k,j,i) = (src(k,j,i) - M) / matrix(CCC,k,j,i);
+            }
+          }
+        }
+#pragma omp for
+        for (int k=kl; k<=ku; k++) {
+          for (int j=jl; j<=ju; j++) {
+            int c = (color + k + j) & 1;
+#pragma ivdep
+            for (int i=il+c; i<=iu; i+=2)
+              u(k,j,i) += omega_ * (work(k,j,i) - u(k,j,i));
+          }
+        }
+      }
+    } else {
+      int t = 0;
+#ifdef OPENMP_PARALLEL
+      t = omp_get_thread_num();
+#endif
+      AthenaArray<Real> &work = temp[t];
+      for (int k=kl; k<=ku; k++) {
+        for (int j=jl; j<=ju; j++) {
+          int c = (color + k + j) & 1;
+#pragma ivdep
+          for (int i=il+c; i<=iu; i+=2) {
+            Real M = matrix(CCM,k,j,i)*u(k,j,i-1)   + matrix(CCP,k,j,i)*u(k,j,i+1)
+                   + matrix(CMC,k,j,i)*u(k,j-1,i)   + matrix(CPC,k,j,i)*u(k,j+1,i)
+                   + matrix(MCC,k,j,i)*u(k-1,j,i)   + matrix(PCC,k,j,i)*u(k+1,j,i)
+                   + matrix(CMM,k,j,i)*u(k,j-1,i-1) + matrix(CMP,k,j,i)*u(k,j-1,i+1)
+                   + matrix(CPM,k,j,i)*u(k,j+1,i-1) + matrix(CPP,k,j,i)*u(k,j+1,i+1)
+                   + matrix(MCM,k,j,i)*u(k-1,j,i-1) + matrix(MCP,k,j,i)*u(k-1,j,i+1)
+                   + matrix(PCM,k,j,i)*u(k+1,j,i-1) + matrix(PCP,k,j,i)*u(k+1,j,i+1)
+                   + matrix(MMC,k,j,i)*u(k-1,j-1,i) + matrix(MPC,k,j,i)*u(k-1,j+1,i)
+                   + matrix(PMC,k,j,i)*u(k+1,j-1,i) + matrix(PPC,k,j,i)*u(k+1,j+1,i);
+            work(k,j,i) = (src(k,j,i) - M) / matrix(CCC,k,j,i);
+          }
+        }
+      }
+      for (int k=kl; k<=ku; k++) {
+        for (int j=jl; j<=ju; j++) {
+          int c = (color + k + j) & 1;
+#pragma ivdep
+          for (int i=il+c; i<=iu; i+=2)
+            u(k,j,i) += omega_ * (work(k,j,i) - u(k,j,i));
+        }
+      }
+    }
+  } else { // jacobi
+    if (th == true && (ku-kl) >=  minth_) {
+      AthenaArray<Real> &work = temp[0];
+#pragma omp parallel num_threads(pmy_driver_->nthreads_)
+      {
+#pragma omp for
+        for (int k=kl; k<=ku; k++) {
+          for (int j=jl; j<=ju; j++) {
+#pragma ivdep
+            for (int i=il; i<=iu; i++) {
+              Real M = matrix(CCM,k,j,i)*u(k,j,i-1)   + matrix(CCP,k,j,i)*u(k,j,i+1)
+                     + matrix(CMC,k,j,i)*u(k,j-1,i)   + matrix(CPC,k,j,i)*u(k,j+1,i)
+                     + matrix(MCC,k,j,i)*u(k-1,j,i)   + matrix(PCC,k,j,i)*u(k+1,j,i)
+                     + matrix(CMM,k,j,i)*u(k,j-1,i-1) + matrix(CMP,k,j,i)*u(k,j-1,i+1)
+                     + matrix(CPM,k,j,i)*u(k,j+1,i-1) + matrix(CPP,k,j,i)*u(k,j+1,i+1)
+                     + matrix(MCM,k,j,i)*u(k-1,j,i-1) + matrix(MCP,k,j,i)*u(k-1,j,i+1)
+                     + matrix(PCM,k,j,i)*u(k+1,j,i-1) + matrix(PCP,k,j,i)*u(k+1,j,i+1)
+                     + matrix(MMC,k,j,i)*u(k-1,j-1,i) + matrix(MPC,k,j,i)*u(k-1,j+1,i)
+                     + matrix(PMC,k,j,i)*u(k+1,j-1,i) + matrix(PPC,k,j,i)*u(k+1,j+1,i);
+                work(k,j,i) = (src(k,j,i) - M) / matrix(CCC,k,j,i);
+            }
+          }
+        }
+#pragma omp for
+        for (int k=kl; k<=ku; k++) {
+          for (int j=jl; j<=ju; j++) {
+#pragma ivdep
+            for (int i=il; i<=iu; i++)
+              u(k,j,i) += omega_ * (work(k,j,i) - u(k,j,i));
+          }
+        }
+      }
+    } else {
+      int t = 0;
+#ifdef OPENMP_PARALLEL
+      t = omp_get_thread_num();
+#endif
+      AthenaArray<Real> &work = temp[t];
+      for (int k=kl; k<=ku; k++) {
+        for (int j=jl; j<=ju; j++) {
+#pragma ivdep
+          for (int i=il; i<=iu; i++) {
+            Real M = matrix(CCM,k,j,i)*u(k,j,i-1)   + matrix(CCP,k,j,i)*u(k,j,i+1)
+                   + matrix(CMC,k,j,i)*u(k,j-1,i)   + matrix(CPC,k,j,i)*u(k,j+1,i)
+                   + matrix(MCC,k,j,i)*u(k-1,j,i)   + matrix(PCC,k,j,i)*u(k+1,j,i)
+                   + matrix(CMM,k,j,i)*u(k,j-1,i-1) + matrix(CMP,k,j,i)*u(k,j-1,i+1)
+                   + matrix(CPM,k,j,i)*u(k,j+1,i-1) + matrix(CPP,k,j,i)*u(k,j+1,i+1)
+                   + matrix(MCM,k,j,i)*u(k-1,j,i-1) + matrix(MCP,k,j,i)*u(k-1,j,i+1)
+                   + matrix(PCM,k,j,i)*u(k+1,j,i-1) + matrix(PCP,k,j,i)*u(k+1,j,i+1)
+                   + matrix(MMC,k,j,i)*u(k-1,j-1,i) + matrix(MPC,k,j,i)*u(k-1,j+1,i)
+                   + matrix(PMC,k,j,i)*u(k+1,j-1,i) + matrix(PPC,k,j,i)*u(k+1,j+1,i);
+            work(k,j,i) = (src(k,j,i) - M) / matrix(CCC,k,j,i);
+          }
+        }
+      }
+      for (int k=kl; k<=ku; k++) {
+        for (int j=jl; j<=ju; j++) {
+#pragma ivdep
+          for (int i=il; i<=iu; i++)
+            u(k,j,i) += omega_ * (work(k,j,i) - u(k,j,i));
+        }
+      }
+    }
+  }
+
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGCRDiffusion::CalculateDefect(AthenaArray<Real> &def,
+//!            const AthenaArray<Real> &u, const AthenaArray<Real> &src,
+//!            const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
+//!            int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th)
+//! \brief Implementation of the Defect calculation
+//!        rlev = relative level from the finest level of this Multigrid block
+
+void MGCRDiffusion::CalculateDefect(AthenaArray<Real> &def, const AthenaArray<Real> &u,
+                    const AthenaArray<Real> &src, const AthenaArray<Real> &coeff,
+                    const AthenaArray<Real> &matrix, int rlev, int il, int iu,
+                    int jl, int ju, int kl, int ku, bool th) {
+  Real dx;
+  if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
+  else           dx = rdx_/static_cast<Real>(1<<rlev);
+  Real idx2 = 1.0/SQR(dx);
+
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+  for (int k=kl; k<=ku; k++) {
+    for (int j=jl; j<=ju; j++) {
+#pragma omp simd
+      for (int i=il; i<=iu; i++) {
+        Real M = matrix(CCC,k,j,i)*u(k,j,i)
+               + matrix(CCM,k,j,i)*u(k,j,i-1)   + matrix(CCP,k,j,i)*u(k,j,i+1)
+               + matrix(CMC,k,j,i)*u(k,j-1,i)   + matrix(CPC,k,j,i)*u(k,j+1,i)
+               + matrix(MCC,k,j,i)*u(k-1,j,i)   + matrix(PCC,k,j,i)*u(k+1,j,i)
+               + matrix(CMM,k,j,i)*u(k,j-1,i-1) + matrix(CMP,k,j,i)*u(k,j-1,i+1)
+               + matrix(CPM,k,j,i)*u(k,j+1,i-1) + matrix(CPP,k,j,i)*u(k,j+1,i+1)
+               + matrix(MCM,k,j,i)*u(k-1,j,i-1) + matrix(MCP,k,j,i)*u(k-1,j,i+1)
+               + matrix(PCM,k,j,i)*u(k+1,j,i-1) + matrix(PCP,k,j,i)*u(k+1,j,i+1)
+               + matrix(MMC,k,j,i)*u(k-1,j-1,i) + matrix(MPC,k,j,i)*u(k-1,j+1,i)
+               + matrix(PMC,k,j,i)*u(k+1,j-1,i) + matrix(PPC,k,j,i)*u(k+1,j+1,i);
+        def(k,j,i) = src(k,j,i) - M;
+      }
+    }
+  }
+
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGCRDiffusion::CalculateFASRHS(AthenaArray<Real> &src,
+//!            const AthenaArray<Real> &u, const AthenaArray<Real> &coeff,
+//!            const AthenaArray<Real> &matrix, int rlev, int il, int iu, int jl, int ju,
+//!            int kl, int ku, bool th)
+//! \brief Implementation of the RHS calculation for FAS
+//!        rlev = relative level from the finest level of this Multigrid block
+
+void MGCRDiffusion::CalculateFASRHS(AthenaArray<Real> &src, const AthenaArray<Real> &u,
+                    const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
+                    int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) {
+  Real dx;
+  if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
+  else           dx = rdx_/static_cast<Real>(1<<rlev);
+  Real idx2 = 1.0/SQR(dx);
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+  for (int k=kl; k<=ku; k++) {
+    for (int j=jl; j<=ju; j++) {
+#pragma omp simd
+      for (int i=il; i<=iu; i++) {
+        Real M = matrix(CCC,k,j,i)*u(k,j,i)
+               + matrix(CCM,k,j,i)*u(k,j,i-1)   + matrix(CCP,k,j,i)*u(k,j,i+1)
+               + matrix(CMC,k,j,i)*u(k,j-1,i)   + matrix(CPC,k,j,i)*u(k,j+1,i)
+               + matrix(MCC,k,j,i)*u(k-1,j,i)   + matrix(PCC,k,j,i)*u(k+1,j,i)
+               + matrix(CMM,k,j,i)*u(k,j-1,i-1) + matrix(CMP,k,j,i)*u(k,j-1,i+1)
+               + matrix(CPM,k,j,i)*u(k,j+1,i-1) + matrix(CPP,k,j,i)*u(k,j+1,i+1)
+               + matrix(MCM,k,j,i)*u(k-1,j,i-1) + matrix(MCP,k,j,i)*u(k-1,j,i+1)
+               + matrix(PCM,k,j,i)*u(k+1,j,i-1) + matrix(PCP,k,j,i)*u(k+1,j,i+1)
+               + matrix(MMC,k,j,i)*u(k-1,j-1,i) + matrix(MPC,k,j,i)*u(k-1,j+1,i)
+               + matrix(PMC,k,j,i)*u(k+1,j-1,i) + matrix(PPC,k,j,i)*u(k+1,j+1,i);
+        src(k,j,i) += M;
+      }
+    }
+  }
+
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MGCRDiffusion::CalculateMatrix(AthenaArray<Real> &matrix,
+//!                         const AthenaArray<Real> &coeff, int rlev, Real dt,
+//!                         int il, int iu, int jl, int ju, int kl, int ku, bool th)
+//! \brief calculate Matrix element for cosmic ray transport
+//!        rlev = relative level from the finest level of this Multigrid block
+
+void MGCRDiffusion::CalculateMatrix(AthenaArray<Real> &matrix,
+                             const AthenaArray<Real> &coeff, Real dt, int rlev,
+                             int il, int iu, int jl, int ju, int kl, int ku, bool th) {
+  Real dx;
+  if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
+  else           dx = rdx_/static_cast<Real>(1<<rlev);
+  if (!(static_cast<MGCRDiffusionDriver*>(pmy_driver_)->fsteady_)) { // time-dependent
+    Real fac = dt/SQR(dx), efac = 0.125*fac;
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+    for (int k=kl; k<=ku; k++) {
+      for (int j=jl; j<=ju; j++) {
+#pragma omp simd
+        for (int i=il; i<=iu; i++) {
+          // center
+          matrix(CCC,k,j,i) = 1.0 + dt*coeff(NLAMBDA,k,j,i) + 0.5*fac*(
+                              2.0*coeff(DXX,k,j,i)+coeff(DXX,k,j,i+1)+coeff(DXX,k,j,i-1)
+                            + 2.0*coeff(DYY,k,j,i)+coeff(DYY,k,j+1,i)+coeff(DYY,k,j-1,i)
+                            + 2.0*coeff(DZZ,k,j,i)+coeff(DZZ,k+1,j,i)+coeff(DZZ,k-1,j,i));
+          // face
+          matrix(CCM,k,j,i) = fac*(-0.5*(coeff(DXX,k,j,i) + coeff(DXX,k,j,i-1))
+                                +0.125*((coeff(DYX,k,j+1,i)-coeff(DYX,k,j-1,i))
+                                       +(coeff(DZX,k+1,j,i)-coeff(DZX,k-1,j,i))));
+          matrix(CCP,k,j,i) = fac*(-0.5*(coeff(DXX,k,j,i+1)+coeff(DXX,k,j,i))
+                                -0.125*((coeff(DYX,k,j+1,i)-coeff(DYX,k,j-1,i))
+                                       +(coeff(DZX,k+1,j,i)-coeff(DZX,k-1,j,i))));
+          matrix(CMC,k,j,i) = fac*(-0.5*(coeff(DYY,k,j,i) + coeff(DYY,k,j-1,i))
+                                +0.125*((coeff(DXY,k,j,i+1)-coeff(DXY,k,j,i-1))
+                                       +(coeff(DZY,k+1,j,i)-coeff(DZY,k-1,j,i))));
+          matrix(CPC,k,j,i) = fac*(-0.5*(coeff(DYY,k,j+1,i)+coeff(DYY,k,j,i))
+                                -0.125*((coeff(DXY,k,j,i+1)-coeff(DXY,k,j,i-1))
+                                       +(coeff(DZY,k+1,j,i)-coeff(DZY,k-1,j,i))));
+          matrix(MCC,k,j,i) = fac*(-0.5*(coeff(DZZ,k,j,i) + coeff(DZZ,k-1,j,i))
+                                +0.125*((coeff(DYZ,k,j+1,i)-coeff(DYZ,k,j-1,i))
+                                       +(coeff(DXZ,k,j,i+1)-coeff(DXZ,k,j,i-1))));
+          matrix(PCC,k,j,i) = fac*(-0.5*(coeff(DZZ,k+1,j,i)+coeff(DZZ,k,j,i))
+                                -0.125*((coeff(DYZ,k,j+1,i)-coeff(DYZ,k,j-1,i))
+                                       +(coeff(DXZ,k,j,i+1)-coeff(DXZ,k,j,i-1))));
+          // edge
+          matrix(CMM,k,j,i) = -efac*(coeff(DXY,k,j,i) + coeff(DXY,k,j,i-1)
+                                    +coeff(DYX,k,j,i) + coeff(DYX,k,j-1,i));
+          matrix(CMP,k,j,i) =  efac*(coeff(DXY,k,j,i+1)+coeff(DXY,k,j,i)
+                                    +coeff(DYX,k,j,i) + coeff(DYX,k,j-1,i));
+          matrix(CPM,k,j,i) =  efac*(coeff(DXY,k,j,i) + coeff(DXY,k,j,i-1)
+                                    +coeff(DYX,k,j+1,i)+coeff(DYX,k,j,i));
+          matrix(CPP,k,j,i) = -efac*(coeff(DXY,k,j,i+1)+coeff(DXY,k,j,i)
+                                    +coeff(DYX,k,j+1,i)+coeff(DYX,k,j,i));
+          matrix(MCM,k,j,i) = -efac*(coeff(DZX,k,j,i) + coeff(DZX,k-1,j,i)
+                                    +coeff(DXZ,k,j,i) + coeff(DXZ,k,j,i-1));
+          matrix(MCP,k,j,i) =  efac*(coeff(DZX,k,j,i) + coeff(DZX,k-1,j,i)
+                                    +coeff(DXZ,k,j,i+1)+coeff(DXZ,k,j,i));
+          matrix(PCM,k,j,i) =  efac*(coeff(DZX,k+1,j,i)+coeff(DZX,k,j,i)
+                                    +coeff(DXZ,k,j,i) + coeff(DXZ,k,j,i-1));
+          matrix(PCP,k,j,i) = -efac*(coeff(DZX,k+1,j,i)+coeff(DZX,k,j,i)
+                                    +coeff(DXZ,k,j,i+1)+coeff(DXZ,k,j,i));
+          matrix(MMC,k,j,i) = -efac*(coeff(DYZ,k,j,i) + coeff(DYZ,k,j-1,i)
+                                    +coeff(DZY,k,j,i) + coeff(DZY,k-1,j,i));
+          matrix(MPC,k,j,i) =  efac*(coeff(DYZ,k,j+1,i)+coeff(DYZ,k,j,i)
+                                    +coeff(DZY,k,j,i) + coeff(DZY,k-1,j,i));
+          matrix(PMC,k,j,i) =  efac*(coeff(DYZ,k,j,i) + coeff(DYZ,k,j-1,i)
+                                    +coeff(DZY,k+1,j,i)+coeff(DZY,k,j,i));
+          matrix(PPC,k,j,i) = -efac*(coeff(DYZ,k,j+1,i)+coeff(DYZ,k,j,i)
+                                    +coeff(DZY,k+1,j,i)+coeff(DZY,k,j,i));
+        }
+      }
+    }
+  } else { // steady state
+    Real fac = 1.0/SQR(dx), efac = 0.125*fac;
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+    for (int k=kl; k<=ku; k++) {
+      for (int j=jl; j<=ju; j++) {
+#pragma omp simd
+        for (int i=il; i<=iu; i++) {
+          // center
+          matrix(CCC,k,j,i) = coeff(NLAMBDA,k,j,i) + 0.5*fac*(
+                              2.0*coeff(DXX,k,j,i)+coeff(DXX,k,j,i+1)+coeff(DXX,k,j,i-1)
+                            + 2.0*coeff(DYY,k,j,i)+coeff(DYY,k,j+1,i)+coeff(DYY,k,j-1,i)
+                            + 2.0*coeff(DZZ,k,j,i)+coeff(DZZ,k+1,j,i)+coeff(DZZ,k-1,j,i));
+          // face
+          matrix(CCM,k,j,i) = fac*(-0.5*(coeff(DXX,k,j,i) + coeff(DXX,k,j,i-1))
+                                +0.125*((coeff(DYX,k,j+1,i)-coeff(DYX,k,j-1,i))
+                                       +(coeff(DZX,k+1,j,i)-coeff(DZX,k-1,j,i))));
+          matrix(CCP,k,j,i) = fac*(-0.5*(coeff(DXX,k,j,i+1)+coeff(DXX,k,j,i))
+                                -0.125*((coeff(DYX,k,j+1,i)-coeff(DYX,k,j-1,i))
+                                       +(coeff(DZX,k+1,j,i)-coeff(DZX,k-1,j,i))));
+          matrix(CMC,k,j,i) = fac*(-0.5*(coeff(DYY,k,j,i) + coeff(DYY,k,j-1,i))
+                                +0.125*((coeff(DXY,k,j,i+1)-coeff(DXY,k,j,i-1))
+                                       +(coeff(DZY,k+1,j,i)-coeff(DZY,k-1,j,i))));
+          matrix(CPC,k,j,i) = fac*(-0.5*(coeff(DYY,k,j+1,i)+coeff(DYY,k,j,i))
+                                -0.125*((coeff(DXY,k,j,i+1)-coeff(DXY,k,j,i-1))
+                                       +(coeff(DZY,k+1,j,i)-coeff(DZY,k-1,j,i))));
+          matrix(MCC,k,j,i) = fac*(-0.5*(coeff(DZZ,k,j,i) + coeff(DZZ,k-1,j,i))
+                                +0.125*((coeff(DYZ,k,j+1,i)-coeff(DYZ,k,j-1,i))
+                                       +(coeff(DXZ,k,j,i+1)-coeff(DXZ,k,j,i-1))));
+          matrix(PCC,k,j,i) = fac*(-0.5*(coeff(DZZ,k+1,j,i)+coeff(DZZ,k,j,i))
+                                -0.125*((coeff(DYZ,k,j+1,i)-coeff(DYZ,k,j-1,i))
+                                       +(coeff(DXZ,k,j,i+1)-coeff(DXZ,k,j,i-1))));
+          // edge
+          matrix(CMM,k,j,i) = -efac*(coeff(DXY,k,j,i) + coeff(DXY,k,j,i-1)
+                                    +coeff(DYX,k,j,i) + coeff(DYX,k,j-1,i));
+          matrix(CMP,k,j,i) =  efac*(coeff(DXY,k,j,i+1)+coeff(DXY,k,j,i)
+                                    +coeff(DYX,k,j,i) + coeff(DYX,k,j-1,i));
+          matrix(CPM,k,j,i) =  efac*(coeff(DXY,k,j,i) + coeff(DXY,k,j,i-1)
+                                    +coeff(DYX,k,j+1,i)+coeff(DYX,k,j,i));
+          matrix(CPP,k,j,i) = -efac*(coeff(DXY,k,j,i+1)+coeff(DXY,k,j,i)
+                                    +coeff(DYX,k,j+1,i)+coeff(DYX,k,j,i));
+          matrix(MCM,k,j,i) = -efac*(coeff(DZX,k,j,i) + coeff(DZX,k-1,j,i)
+                                    +coeff(DXZ,k,j,i) + coeff(DXZ,k,j,i-1));
+          matrix(MCP,k,j,i) =  efac*(coeff(DZX,k,j,i) + coeff(DZX,k-1,j,i)
+                                    +coeff(DXZ,k,j,i+1)+coeff(DXZ,k,j,i));
+          matrix(PCM,k,j,i) =  efac*(coeff(DZX,k+1,j,i)+coeff(DZX,k,j,i)
+                                    +coeff(DXZ,k,j,i) + coeff(DXZ,k,j,i-1));
+          matrix(PCP,k,j,i) = -efac*(coeff(DZX,k+1,j,i)+coeff(DZX,k,j,i)
+                                    +coeff(DXZ,k,j,i+1)+coeff(DXZ,k,j,i));
+          matrix(MMC,k,j,i) = -efac*(coeff(DYZ,k,j,i) + coeff(DYZ,k,j-1,i)
+                                    +coeff(DZY,k,j,i) + coeff(DZY,k-1,j,i));
+          matrix(MPC,k,j,i) =  efac*(coeff(DYZ,k,j+1,i)+coeff(DYZ,k,j,i)
+                                    +coeff(DZY,k,j,i) + coeff(DZY,k-1,j,i));
+          matrix(PMC,k,j,i) =  efac*(coeff(DYZ,k,j,i) + coeff(DYZ,k,j-1,i)
+                                    +coeff(DZY,k+1,j,i)+coeff(DZY,k,j,i));
+          matrix(PPC,k,j,i) = -efac*(coeff(DYZ,k,j+1,i)+coeff(DYZ,k,j,i)
+                                    +coeff(DZY,k+1,j,i)+coeff(DZY,k,j,i));
+        }
+      }
+    }
+  }
+  return;
+}
diff --git a/src/crdiffusion/mg_crdiffusion.hpp b/src/crdiffusion/mg_crdiffusion.hpp
new file mode 100644
index 0000000000..2b210cb700
--- /dev/null
+++ b/src/crdiffusion/mg_crdiffusion.hpp
@@ -0,0 +1,77 @@
+#ifndef CRDIFFUSION_MG_CRDIFFUSION_HPP_
+#define CRDIFFUSION_MG_CRDIFFUSION_HPP_
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file mg_crdiffusion.hpp
+//! \brief defines MGCRDiffusion class
+
+// C headers
+
+// C++ headers
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "../athena_arrays.hpp"
+#include "../multigrid/multigrid.hpp"
+#include "crdiffusion.hpp"
+
+class MeshBlock;
+class ParameterInput;
+class Coordinates;
+class Multigrid;
+class CRDiffusionBoundaryTaskList;
+
+
+//! \class MGCRDiffusion
+//! \brief Multigrid CR Diffusion solver for each block
+
+class MGCRDiffusion : public Multigrid {
+ public:
+  MGCRDiffusion(MGCRDiffusionDriver *pmd, MeshBlock *pmb);
+  ~MGCRDiffusion();
+
+  void AddCRSource(const AthenaArray<Real> &src, int ngh, Real dt);
+
+  void Smooth(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
+              const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix, int rlev,
+              int il, int iu, int jl, int ju, int kl, int ku, int color, bool th) final;
+  void CalculateDefect(AthenaArray<Real> &def, const AthenaArray<Real> &u,
+                const AthenaArray<Real> &src, const AthenaArray<Real> &coeff,
+                const AthenaArray<Real> &matrix, int rlev, int il, int iu, int jl, int ju,
+                int kl, int ku, bool th) final;
+  void CalculateFASRHS(AthenaArray<Real> &def, const AthenaArray<Real> &src,
+                const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
+                int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) final;
+  void CalculateMatrix(AthenaArray<Real> &matrix, const AthenaArray<Real> &coeff,
+       Real dt, int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) final;
+
+  friend class MGCRDiffusionDriver;
+
+ private:
+  Real omega_;
+  int fsmoother_;
+};
+
+
+//! \class MGCRDiffusionDriver
+//! \brief Multigrid CR Diffusion solver
+
+class MGCRDiffusionDriver : public MultigridDriver {
+ public:
+  MGCRDiffusionDriver(Mesh *pm, ParameterInput *pin);
+  ~MGCRDiffusionDriver();
+  void Solve(int stage, Real dt) final;
+
+  friend class MGCRDiffusion;
+
+ private:
+  CRDiffusionBoundaryTaskList *crtlist_;
+  Real omega_;
+  int fsmoother_;
+  bool fsteady_;
+};
+
+#endif // CRDIFFUSION_MG_CRDIFFUSION_HPP_
diff --git a/src/defs.hpp.in b/src/defs.hpp.in
index 325ac1612d..8d533536b8 100644
--- a/src/defs.hpp.in
+++ b/src/defs.hpp.in
@@ -70,6 +70,9 @@
 // include cosmic ray transport? default=0 (false)
 #define CR_ENABLED @CR_ENABLED@
 
+// include cosmic ray diffusion? default=0 (false)
+#define CRDIFFUSION_ENABLED @CRDIFFUSION_ENABLED@
+
 // enable special or general relativity? default=0 (false)
 #define RELATIVISTIC_DYNAMICS @RELATIVISTIC_DYNAMICS@
 
diff --git a/src/gravity/gravity.cpp b/src/gravity/gravity.cpp
index 52279b8c0c..1967189e22 100644
--- a/src/gravity/gravity.cpp
+++ b/src/gravity/gravity.cpp
@@ -35,7 +35,7 @@
 //! \brief Gravity constructor
 Gravity::Gravity(MeshBlock *pmb, ParameterInput *pin) :
     pmy_block(pmb), phi(pmb->ncells3, pmb->ncells2, pmb->ncells1),
-    coarse_phi(NHYDRO, pmb->ncc3, pmb->ncc2, pmb->ncc1,
+    coarse_phi(pmb->ncc3, pmb->ncc2, pmb->ncc1,
               (pmb->pmy_mesh->multilevel ? AthenaArray<Real>::DataStatus::allocated :
                AthenaArray<Real>::DataStatus::empty)),
     empty_flux{AthenaArray<Real>(), AthenaArray<Real>(), AthenaArray<Real>()},
@@ -180,253 +180,3 @@ void Gravity::RestoreFaceBoundaries() {
   return;
 }
 
-
-//----------------------------------------------------------------------------------------
-//! \fn Gravity::ExpandPhysicalBoundaries()
-//! \brief Expand physical boundary values to NGHOST = 2 and to edges/corners.
-void Gravity::ExpandPhysicalBoundaries() {
-  int is = pmy_block->is, ie = pmy_block->ie,
-      js = pmy_block->js, je = pmy_block->je,
-      ks = pmy_block->ks, ke = pmy_block->ke;
-
-  // push face boundary values
-  if (pmy_block->pbval->nblevel[1][1][0] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      for (int j = js; j <= je; j++)
-        phi(k, j, is-2) = phi(k, j, is-1);
-    }
-  }
-  if (pmy_block->pbval->nblevel[1][1][2] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      for (int j = js; j <= je; j++)
-        phi(k, j, ie+2) = phi(k, j, ie+1);
-    }
-  }
-  if (pmy_block->pbval->nblevel[1][0][1] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      for (int i = is; i <= ie; i++)
-        phi(k, js-2, i) = phi(k, js-1, i);
-    }
-  }
-  if (pmy_block->pbval->nblevel[1][2][1] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      for (int i = is; i <= ie; i++)
-        phi(k, je+2, i) = phi(k, je+1, i);
-    }
-  }
-  if (pmy_block->pbval->nblevel[0][1][1] < 0) {
-    for (int j = js; j <= je; j++) {
-      for (int i = is; i <= ie; i++)
-        phi(ks-2, j, i) = phi(ks-1, j, i);
-    }
-  }
-  if (pmy_block->pbval->nblevel[2][1][1] < 0) {
-    for (int j = js; j <= je; j++) {
-      for (int i = is; i <= ie; i++)
-        phi(ke+2, j, i) = phi(ke+1, j, i);
-    }
-  }
-
-  // fill edges
-  if (pmy_block->pbval->nblevel[1][0][0] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      Real p = 0.5*(phi(k, js-1, is) + phi(k, js, is-1));
-      phi(k, js-1, is-1) = p;
-      phi(k, js-1, is-2) = p;
-      phi(k, js-2, is-1) = p;
-      phi(k, js-2, is-2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[1][0][2] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      Real p = 0.5*(phi(k, js-1, ie) + phi(k, js, ie+1));
-      phi(k, js-1, ie+1) = p;
-      phi(k, js-1, ie+2) = p;
-      phi(k, js-2, ie+1) = p;
-      phi(k, js-2, ie+2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[1][2][0] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      Real p = 0.5*(phi(k, je+1, is) + phi(k, je, is-1));
-      phi(k, je+1, is-1) = p;
-      phi(k, je+1, is-2) = p;
-      phi(k, je+2, is-1) = p;
-      phi(k, je+2, is-2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[1][2][2] < 0) {
-    for (int k = ks; k <= ke; k++) {
-      Real p = 0.5*(phi(k, je+1, ie) + phi(k, je, ie+1));
-      phi(k, je+1, ie+1) = p;
-      phi(k, je+1, ie+2) = p;
-      phi(k, je+2, ie+1) = p;
-      phi(k, je+2, ie+2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[0][1][0] < 0) {
-    for (int j = js; j <= je; j++) {
-      Real p = 0.5*(phi(ks-1, j, is) + phi(ks, j, is-1));
-      phi(ks-1, j, is-1) = p;
-      phi(ks-1, j, is-2) = p;
-      phi(ks-2, j, is-1) = p;
-      phi(ks-2, j, is-2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[0][1][2] < 0) {
-    for (int j = js; j <= je; j++) {
-      Real p = 0.5*(phi(ks-1, j, ie) + phi(ks, j, ie+1));
-      phi(ks-1, j, ie+1) = p;
-      phi(ks-1, j, ie+2) = p;
-      phi(ks-2, j, ie+1) = p;
-      phi(ks-2, j, ie+2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[2][1][0] < 0) {
-    for (int j = js; j <= je; j++) {
-      Real p = 0.5*(phi(ke+1, j, is) + phi(ke, j, is-1));
-      phi(ke+1, j, is-1) = p;
-      phi(ke+1, j, is-2) = p;
-      phi(ke+2, j, is-1) = p;
-      phi(ke+2, j, is-2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[2][1][2] < 0) {
-    for (int j = js; j <= je; j++) {
-      Real p = 0.5*(phi(ke+1, j, ie) + phi(ke, j, ie+1));
-      phi(ke+1, j, ie+1) = p;
-      phi(ke+1, j, ie+2) = p;
-      phi(ke+2, j, ie+1) = p;
-      phi(ke+2, j, ie+2) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[0][0][1] < 0) {
-    for (int i = is; i <= ie; i++) {
-      Real p = 0.5*(phi(ks-1, js, i) + phi(ks, js-1, i));
-      phi(ks-1, js-1, i) = p;
-      phi(ks-1, js-2, i) = p;
-      phi(ks-2, js-1, i) = p;
-      phi(ks-2, js-2, i) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[0][2][1] < 0) {
-    for (int i = is; i <= ie; i++) {
-      Real p = 0.5*(phi(ks-1, je, i) + phi(ks, je+1, i));
-      phi(ks-1, je+1, i) = p;
-      phi(ks-1, je+2, i) = p;
-      phi(ks-2, je+1, i) = p;
-      phi(ks-2, je+2, i) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[2][0][1] < 0) {
-    for (int i = is; i <= ie; i++) {
-      Real p = 0.5*(phi(ke+1, js, i) + phi(ke, js-1, i));
-      phi(ke+1, js-1, i) = p;
-      phi(ke+1, js-2, i) = p;
-      phi(ke+2, js-1, i) = p;
-      phi(ke+2, js-2, i) = p;
-    }
-  }
-  if (pmy_block->pbval->nblevel[2][2][1] < 0) {
-    for (int i = is; i <= ie; i++) {
-      Real p = 0.5*(phi(ke+1, je, i) + phi(ke, je+1, i));
-      phi(ke+1, je+1, i) = p;
-      phi(ke+1, je+2, i) = p;
-      phi(ke+2, je+1, i) = p;
-      phi(ke+2, je+2, i) = p;
-    }
-  }
-
-  // fill corners
-  if (pmy_block->pbval->nblevel[0][0][0] < 0) {
-    Real p = (phi(ks, js-1, is-1) + phi(ks-1, js, is-1) + phi(ks-1, js-1, is))/3.0;
-    phi(ks-1, js-1, is-1) = p;
-    phi(ks-1, js-1, is-2) = p;
-    phi(ks-1, js-2, is-1) = p;
-    phi(ks-1, js-2, is-2) = p;
-    phi(ks-2, js-1, is-1) = p;
-    phi(ks-2, js-1, is-2) = p;
-    phi(ks-2, js-2, is-1) = p;
-    phi(ks-2, js-2, is-2) = p;
-  }
-  if (pmy_block->pbval->nblevel[0][0][2] < 0) {
-    Real p = (phi(ks, js-1, ie+1) + phi(ks-1, js, ie+1) + phi(ks-1, js-1, ie))/3.0;
-    phi(ks-1, js-1, ie+1) = p;
-    phi(ks-1, js-1, ie+2) = p;
-    phi(ks-1, js-2, ie+1) = p;
-    phi(ks-1, js-2, ie+2) = p;
-    phi(ks-2, js-1, ie+1) = p;
-    phi(ks-2, js-1, ie+2) = p;
-    phi(ks-2, js-2, ie+1) = p;
-    phi(ks-2, js-2, ie+2) = p;
-  }
-  if (pmy_block->pbval->nblevel[0][2][0] < 0) {
-    Real p = (phi(ks, je+1, is-1) + phi(ks-1, je, is-1) + phi(ks-1, je+1, is))/3.0;
-    phi(ks-1, je+1, is-1) = p;
-    phi(ks-1, je+1, is-2) = p;
-    phi(ks-1, je+2, is-1) = p;
-    phi(ks-1, je+2, is-2) = p;
-    phi(ks-2, je+1, is-1) = p;
-    phi(ks-2, je+1, is-2) = p;
-    phi(ks-2, je+2, is-1) = p;
-    phi(ks-2, je+2, is-2) = p;
-  }
-  if (pmy_block->pbval->nblevel[2][0][0] < 0) {
-    Real p = (phi(ke, js-1, is-1) + phi(ke+1, js, is-1) + phi(ke+1, js-1, is))/3.0;
-    phi(ke+1, js-1, is-1) = p;
-    phi(ke+1, js-1, is-2) = p;
-    phi(ke+1, js-2, is-1) = p;
-    phi(ke+1, js-2, is-2) = p;
-    phi(ke+2, js-1, is-1) = p;
-    phi(ke+2, js-1, is-2) = p;
-    phi(ke+2, js-2, is-1) = p;
-    phi(ke+2, js-2, is-2) = p;
-  }
-  if (pmy_block->pbval->nblevel[0][2][2] < 0) {
-    Real p = (phi(ks, je+1, ie+1) + phi(ks-1, je, ie+1) + phi(ks-1, je+1, ie))/3.0;
-    phi(ks-1, je+1, ie+1) = p;
-    phi(ks-1, je+1, ie+2) = p;
-    phi(ks-1, je+2, ie+1) = p;
-    phi(ks-1, je+2, ie+2) = p;
-    phi(ks-2, je+1, ie+1) = p;
-    phi(ks-2, je+1, ie+2) = p;
-    phi(ks-2, je+2, ie+1) = p;
-    phi(ks-2, je+2, ie+2) = p;
-  }
-  if (pmy_block->pbval->nblevel[2][0][2] < 0) {
-    Real p = (phi(ke, js-1, ie+1) + phi(ke+1, js, ie+1) + phi(ke+1, js-1, ie))/3.0;
-    phi(ke+1, js-1, ie+1) = p;
-    phi(ke+1, js-1, ie+2) = p;
-    phi(ke+1, js-2, ie+1) = p;
-    phi(ke+1, js-2, ie+2) = p;
-    phi(ke+2, js-1, ie+1) = p;
-    phi(ke+2, js-1, ie+2) = p;
-    phi(ke+2, js-2, ie+1) = p;
-    phi(ke+2, js-2, ie+2) = p;
-  }
-  if (pmy_block->pbval->nblevel[2][2][0] < 0) {
-    Real p = (phi(ke, je+1, is-1) + phi(ke+1, je, is-1) + phi(ke+1, je+1, is))/3.0;
-    phi(ke+1, je+1, is-1) = p;
-    phi(ke+1, je+1, is-2) = p;
-    phi(ke+1, je+2, is-1) = p;
-    phi(ke+1, je+2, is-2) = p;
-    phi(ke+2, je+1, is-1) = p;
-    phi(ke+2, je+1, is-2) = p;
-    phi(ke+2, je+2, is-1) = p;
-    phi(ke+2, je+2, is-2) = p;
-  }
-  if (pmy_block->pbval->nblevel[2][2][2] < 0) {
-    Real p = (phi(ke, je+1, ie+1) + phi(ke+1, je, ie+1) + phi(ke+1, je+1, ie))/3.0;
-    phi(ke+1, je+1, ie+1) = p;
-    phi(ke+1, je+1, ie+2) = p;
-    phi(ke+1, je+2, ie+1) = p;
-    phi(ke+1, je+2, ie+2) = p;
-    phi(ke+2, je+1, ie+1) = p;
-    phi(ke+2, je+1, ie+2) = p;
-    phi(ke+2, je+2, ie+1) = p;
-    phi(ke+2, je+2, ie+2) = p;
-  }
-
-  return;
-}
-
diff --git a/src/gravity/gravity.hpp b/src/gravity/gravity.hpp
index cd9876d7af..ad0c05e7c6 100644
--- a/src/gravity/gravity.hpp
+++ b/src/gravity/gravity.hpp
@@ -48,14 +48,11 @@ class Gravity {
 
   void SaveFaceBoundaries();
   void RestoreFaceBoundaries();
-  void ExpandPhysicalBoundaries();
 
   friend class MGGravityDriver;
 
  private:
   MGGravity *pmg;
-  bool gravity_tensor_momentum_;
-  bool gravity_tensor_energy_;
   AthenaArray<Real> fbuf_[6];
 };
 
diff --git a/src/gravity/mg_gravity.cpp b/src/gravity/mg_gravity.cpp
index 7a58de2317..062e227fd8 100644
--- a/src/gravity/mg_gravity.cpp
+++ b/src/gravity/mg_gravity.cpp
@@ -39,12 +39,18 @@ class MeshBlock;
 //! \brief MGGravityDriver constructor
 
 MGGravityDriver::MGGravityDriver(Mesh *pm, ParameterInput *pin)
-    : MultigridDriver(pm, pm->MGGravityBoundaryFunction_,
-                      pm->MGGravitySourceMaskFunction_, 1) {
+    : MultigridDriver(pm, pm->MGGravityBoundaryFunction_, pm->MGGravityBoundaryFunction_,
+                      pm->MGGravitySourceMaskFunction_, pm->MGGravitySourceMaskFunction_,
+                      1, 0, 0) {
   four_pi_G_ = pmy_mesh_->four_pi_G_;
+  omega_ = pin->GetOrAddReal("gravity", "omega", 1.15);
   eps_ = pin->GetOrAddReal("gravity", "threshold", -1.0);
   niter_ = pin->GetOrAddInteger("gravity", "niteration", -1);
   ffas_ = pin->GetOrAddBoolean("gravity", "fas", ffas_);
+  npresmooth_ = pin->GetOrAddReal("gravity", "npresmooth", npresmooth_);
+  npostsmooth_ = pin->GetOrAddReal("gravity", "npostsmooth", npostsmooth_);
+  redblack_ = true;
+  fshowdef_ = pin->GetOrAddBoolean("gravity", "show_defect", fshowdef_);
   std::string m = pin->GetOrAddString("gravity", "mgmode", "none");
   std::transform(m.begin(), m.end(), m.begin(), ::tolower);
   if (m == "fmg") {
@@ -143,9 +149,9 @@ MGGravityDriver::~MGGravityDriver() {
 //! \fn MGGravity::MGGravity(MultigridDriver *pmd, MeshBlock *pmb)
 //! \brief MGGravity constructor
 
-MGGravity::MGGravity(MultigridDriver *pmd, MeshBlock *pmb) : Multigrid(pmd, pmb, 1, 1) {
-  btype = BoundaryQuantity::mggrav;
-  btypef = BoundaryQuantity::mggrav_f;
+MGGravity::MGGravity(MultigridDriver *pmd, MeshBlock *pmb) : Multigrid(pmd, pmb, 1) {
+  btype = BoundaryQuantity::mg;
+  btypef = BoundaryQuantity::mg_faceonly;
   pmgbval = new MGGravityBoundaryValues(this, mg_block_bcs_);
 }
 
@@ -160,11 +166,10 @@ MGGravity::~MGGravity() {
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MGGravityDriver::Solve(int stage)
+//! \fn void MGGravityDriver::Solve(int stage, Real dt)
 //! \brief load the data and solve
 
-void MGGravityDriver::Solve(int stage) {
-  four_pi_G_ = pmy_mesh_->four_pi_G_;
+void MGGravityDriver::Solve(int stage, Real dt) {
   // Construct the Multigrid array
   vmg_.clear();
   for (int i = 0; i < pmy_mesh_->nblocal; ++i)
@@ -180,7 +185,7 @@ void MGGravityDriver::Solve(int stage) {
       pmg->LoadFinestData(pmg->pmy_block_->pgrav->phi, 0, NGHOST);
   }
 
-  SetupMultigrid();
+  SetupMultigrid(dt, false);
 
   if (mode_ == 0) {
     SolveFMGCycle();
@@ -210,40 +215,29 @@ void MGGravityDriver::Solve(int stage) {
 
 //----------------------------------------------------------------------------------------
 //! \fn  void MGGravity::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src,
-//!        int rlev, int il, int iu, int jl, int ju, int kl, int ku, int color, bool th)
+//!           const AthenaArray<Real> &coeff, const AthenaArray<Real> &mmatrix, int rlev,
+//!           int il, int iu, int jl, int ju, int kl, int ku, int color, bool th)
 //! \brief Implementation of the Red-Black Gauss-Seidel Smoother
 //!        rlev = relative level from the finest level of this Multigrid block
 
-void MGGravity::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src, int rlev,
+void MGGravity::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src,
+                const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix, int rlev,
                 int il, int iu, int jl, int ju, int kl, int ku, int color, bool th) {
   Real dx;
   if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
   else           dx = rdx_/static_cast<Real>(1<<rlev);
   Real dx2 = SQR(dx);
-  Real isix = omega_/6.0;
+  Real isix = static_cast<MGGravityDriver*>(pmy_driver_)->omega_/6.0;
   color ^= pmy_driver_->coffset_;
-  if (th == true && (ku-kl) >=  minth_) {
-#pragma omp parallel for num_threads(pmy_driver_->nthreads_)
-    for (int k=kl; k<=ku; k++) {
-      for (int j=jl; j<=ju; j++) {
-        int c = (color + k + j) & 1;
-#pragma ivdep
-        for (int i=il+c; i<=iu; i+=2)
-          u(0,k,j,i) -= ((6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i) - u(0,k,j,i+1)
-                        - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))
-                         + src(0,k,j,i)*dx2)*isix;
-      }
-    }
-  } else {
-    for (int k=kl; k<=ku; k++) {
-      for (int j=jl; j<=ju; j++) {
-        int c = (color + k + j) & 1;
+
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+  for (int k=kl; k<=ku; k++) {
+    for (int j=jl; j<=ju; j++) {
+      int c = (color + k + j) & 1;
 #pragma ivdep
-        for (int i=il+c; i<=iu; i+=2)
-          u(0,k,j,i) -= ((6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i) - u(0,k,j,i+1)
-                        - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))
-                         + src(0,k,j,i)*dx2)*isix;
-      }
+      for (int i=il+c; i<=iu; i+=2)
+        u(k,j,i) -= ((6.0*u(k,j,i) - u(k+1,j,i) - u(k,j+1,i) - u(k,j,i+1)
+                      - u(k-1,j,i) - u(k,j-1,i) - u(k,j,i-1)) + src(k,j,i)*dx2)*isix;
     }
   }
 
@@ -255,15 +249,15 @@ void MGGravity::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src, int r
   for (int k=kl; k<=ku; k++) {
     for (int j=jl; j<=ju; j++) {
       for (int i=il; i<=iu; i++)
-        temp(0,k,j,i) = u(0,k,j,i) - (((6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i)
-                      - u(0,k,j,i+1) - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))
-                      + src(0,k,j,i)*dx2)*isix);
+        temp(k,j,i) = u(k,j,i) - (((6.0*u(k,j,i) - u(k+1,j,i) - u(k,j+1,i)
+                      - u(k,j,i+1) - u(k-1,j,i) - u(k,j-1,i) - u(k,j,i-1))
+                      + src(k,j,i)*dx2)*isix);
     }
   }
   for (int k=kl; k<=ku; k++) {
     for (int j=jl; j<=ju; j++) {
       for (int i=il; i<=iu; i++)
-      u(0,k,j,i) = temp(0,k,j,i);
+      u(k,j,i) = temp(k,j,i);
     }
   }*/
   return;
@@ -272,38 +266,28 @@ void MGGravity::Smooth(AthenaArray<Real> &u, const AthenaArray<Real> &src, int r
 
 //----------------------------------------------------------------------------------------
 //! \fn  void MGGravity::CalculateDefect(AthenaArray<Real> &def,
-//!           const AthenaArray<Real> &u, const AthenaArray<Real> &src, int rlev,
-//!           int il, int iu, int jl, int ju, int kl, int ku, bool th)
+//!             const AthenaArray<Real> &u, const AthenaArray<Real> &src,
+//!             const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
+//!            int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th)
 //! \brief Implementation of the Defect calculation
 //!        rlev = relative level from the finest level of this Multigrid block
 
 void MGGravity::CalculateDefect(AthenaArray<Real> &def, const AthenaArray<Real> &u,
-                                const AthenaArray<Real> &src, int rlev,
-                                int il, int iu, int jl, int ju, int kl, int ku, bool th) {
+                const AthenaArray<Real> &src, const AthenaArray<Real> &coeff,
+                const AthenaArray<Real> &matrix, int rlev,
+                int il, int iu, int jl, int ju, int kl, int ku, bool th) {
   Real dx;
   if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
   else           dx = rdx_/static_cast<Real>(1<<rlev);
   Real idx2 = 1.0/SQR(dx);
-  if (th == true && (ku-kl) >=  minth_) {
-#pragma omp parallel for num_threads(pmy_driver_->nthreads_)
-    for (int k=kl; k<=ku; k++) {
-      for (int j=jl; j<=ju; j++) {
-#pragma omp simd
-        for (int i=il; i<=iu; i++)
-          def(0,k,j,i) = (6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i) - u(0,k,j,i+1)
-                         - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))*idx2
-                         + src(0,k,j,i);
-      }
-    }
-  } else {
-    for (int k=kl; k<=ku; k++) {
-      for (int j=jl; j<=ju; j++) {
+
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+  for (int k=kl; k<=ku; k++) {
+    for (int j=jl; j<=ju; j++) {
 #pragma omp simd
-        for (int i=il; i<=iu; i++)
-          def(0,k,j,i) = (6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i) - u(0,k,j,i+1)
-                         - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))*idx2
-                         + src(0,k,j,i);
-      }
+      for (int i=il; i<=iu; i++)
+        def(k,j,i) = (6.0*u(k,j,i) - u(k+1,j,i) - u(k,j+1,i) - u(k,j,i+1)
+                       - u(k-1,j,i) - u(k,j-1,i) - u(k,j,i-1))*idx2 + src(k,j,i);
     }
   }
 
@@ -313,37 +297,30 @@ void MGGravity::CalculateDefect(AthenaArray<Real> &def, const AthenaArray<Real>
 
 //----------------------------------------------------------------------------------------
 //! \fn  void MGGravity::CalculateFASRHS(AthenaArray<Real> &src,
-//!                      const AthenaArray<Real> &u, int rlev,
-//!                      int il, int iu, int jl, int ju, int kl, int ku, bool th)
+//!             const AthenaArray<Real> &u, const AthenaArray<Real> &coeff,
+//!             const AthenaArray<Real> &matrix, int rlev, int il, int iu, int jl, int ju,
+//!             int kl, int ku, bool th)
 //! \brief Implementation of the RHS calculation for FAS
 //!        rlev = relative level from the finest level of this Multigrid block
 
 void MGGravity::CalculateFASRHS(AthenaArray<Real> &src, const AthenaArray<Real> &u,
+                const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
                 int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) {
   Real dx;
   if (rlev <= 0) dx = rdx_*static_cast<Real>(1<<(-rlev));
   else           dx = rdx_/static_cast<Real>(1<<rlev);
   Real idx2 = 1.0/SQR(dx);
-  if (th == true && (ku-kl) >=  minth_) {
-#pragma omp parallel for num_threads(pmy_driver_->nthreads_)
-    for (int k=kl; k<=ku; k++) {
-      for (int j=jl; j<=ju; j++) {
-#pragma omp simd
-        for (int i=il; i<=iu; i++)
-          src(0,k,j,i) -= (6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i) - u(0,k,j,i+1)
-                          - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))*idx2;
-      }
-    }
-  } else {
-    for (int k=kl; k<=ku; k++) {
-      for (int j=jl; j<=ju; j++) {
+
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+  for (int k=kl; k<=ku; k++) {
+    for (int j=jl; j<=ju; j++) {
 #pragma omp simd
-        for (int i=il; i<=iu; i++)
-          src(0,k,j,i) -= (6.0*u(0,k,j,i) - u(0,k+1,j,i) - u(0,k,j+1,i) - u(0,k,j,i+1)
-                          - u(0,k-1,j,i) - u(0,k,j-1,i) - u(0,k,j,i-1))*idx2;
-      }
+      for (int i=il; i<=iu; i++)
+        src(k,j,i) -= (6.0*u(k,j,i) - u(k+1,j,i) - u(k,j+1,i) - u(k,j,i+1)
+                        - u(k-1,j,i) - u(k,j-1,i) - u(k,j,i-1))*idx2;
     }
   }
+
   return;
 }
 
@@ -366,13 +343,13 @@ void MGGravityDriver::ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
       int i, fi, fig;
       if (ox1 > 0) i = ngh + 1, fi = ngh + 1, fig = ngh + 2;
       else         i = ngh - 1, fi = ngh,     fig = ngh - 1;
-      Real ccval = cbuf(0, ck, cj, i);
-      Real gx2c = 0.125*(cbuf(0, ck, cj+1, i) - cbuf(0, ck, cj-1, i));
-      Real gx3c = 0.125*(cbuf(0, ck+1, cj, i) - cbuf(0, ck-1, cj, i));
-      dst(0, l, l, fig) = ot*(2.0*(ccval - gx2c - gx3c) + u(0, l, l, fi));
-      dst(0, l, r, fig) = ot*(2.0*(ccval + gx2c - gx3c) + u(0, l, r, fi));
-      dst(0, r, l, fig) = ot*(2.0*(ccval - gx2c + gx3c) + u(0, r, l, fi));
-      dst(0, r, r, fig) = ot*(2.0*(ccval + gx2c + gx3c) + u(0, r, r, fi));
+      Real ccval = cbuf(ck, cj, i);
+      Real gx2c = 0.125*(cbuf(ck, cj+1, i) - cbuf(ck, cj-1, i));
+      Real gx3c = 0.125*(cbuf(ck+1, cj, i) - cbuf(ck-1, cj, i));
+      dst(l, l, fig) = ot*(2.0*(ccval - gx2c - gx3c) + u(l, l, fi));
+      dst(l, r, fig) = ot*(2.0*(ccval + gx2c - gx3c) + u(l, r, fi));
+      dst(r, l, fig) = ot*(2.0*(ccval - gx2c + gx3c) + u(r, l, fi));
+      dst(r, r, fig) = ot*(2.0*(ccval + gx2c + gx3c) + u(r, r, fi));
     }
   }
 
@@ -382,13 +359,13 @@ void MGGravityDriver::ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
       int j, fj, fjg;
       if (ox2 > 0) j = ngh + 1, fj = ngh + 1, fjg = ngh + 2;
       else         j = ngh - 1, fj = ngh,     fjg = ngh - 1;
-      Real ccval = cbuf(0, ck, j, ci);
-      Real gx1c = 0.125*(cbuf(0, ck, j, ci+1) - cbuf(0, ck, j, ci-1));
-      Real gx3c = 0.125*(cbuf(0, ck+1, j, ci) - cbuf(0, ck-1, j, ci));
-      dst(0, l, fjg, l) = ot*(2.0*(ccval - gx1c - gx3c) + u(0, l, fj, l));
-      dst(0, l, fjg, r) = ot*(2.0*(ccval + gx1c - gx3c) + u(0, l, fj, r));
-      dst(0, r, fjg, l) = ot*(2.0*(ccval - gx1c + gx3c) + u(0, r, fj, l));
-      dst(0, r, fjg, r) = ot*(2.0*(ccval + gx1c + gx3c) + u(0, r, fj, r));
+      Real ccval = cbuf(ck, j, ci);
+      Real gx1c = 0.125*(cbuf(ck, j, ci+1) - cbuf(ck, j, ci-1));
+      Real gx3c = 0.125*(cbuf(ck+1, j, ci) - cbuf(ck-1, j, ci));
+      dst(l, fjg, l) = ot*(2.0*(ccval - gx1c - gx3c) + u(l, fj, l));
+      dst(l, fjg, r) = ot*(2.0*(ccval + gx1c - gx3c) + u(l, fj, r));
+      dst(r, fjg, l) = ot*(2.0*(ccval - gx1c + gx3c) + u(r, fj, l));
+      dst(r, fjg, r) = ot*(2.0*(ccval + gx1c + gx3c) + u(r, fj, r));
     }
   }
 
@@ -398,13 +375,13 @@ void MGGravityDriver::ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
       int k, fk, fkg;
       if (ox3 > 0) k = ngh + 1, fk = ngh + 1, fkg = ngh + 2;
       else         k = ngh - 1, fk = ngh,     fkg = ngh - 1;
-      Real ccval = cbuf(0, k, cj, ci);
-      Real gx1c = 0.125*(cbuf(0, k, cj, ci+1) - cbuf(0, k, cj, ci-1));
-      Real gx2c = 0.125*(cbuf(0, k, cj+1, ci) - cbuf(0, k, cj-1, ci));
-      dst(0, fkg, l, l) = ot*(2.0*(ccval - gx1c - gx2c) + u(0, fk, l, l));
-      dst(0, fkg, l, r) = ot*(2.0*(ccval + gx1c - gx2c) + u(0, fk, l, r));
-      dst(0, fkg, r, l) = ot*(2.0*(ccval - gx1c + gx2c) + u(0, fk, r, l));
-      dst(0, fkg, r, r) = ot*(2.0*(ccval + gx1c + gx2c) + u(0, fk, r, r));
+      Real ccval = cbuf(k, cj, ci);
+      Real gx1c = 0.125*(cbuf(k, cj, ci+1) - cbuf(k, cj, ci-1));
+      Real gx2c = 0.125*(cbuf(k, cj+1, ci) - cbuf(k, cj-1, ci));
+      dst(fkg, l, l) = ot*(2.0*(ccval - gx1c - gx2c) + u(fk, l, l));
+      dst(fkg, l, r) = ot*(2.0*(ccval + gx1c - gx2c) + u(fk, l, r));
+      dst(fkg, r, l) = ot*(2.0*(ccval - gx1c + gx2c) + u(fk, r, l));
+      dst(fkg, r, r) = ot*(2.0*(ccval + gx1c + gx2c) + u(fk, r, r));
     }
   }
 
diff --git a/src/gravity/mg_gravity.hpp b/src/gravity/mg_gravity.hpp
index 7883fce855..e04e3d3845 100644
--- a/src/gravity/mg_gravity.hpp
+++ b/src/gravity/mg_gravity.hpp
@@ -31,16 +31,16 @@ class MGGravity : public Multigrid {
   MGGravity(MultigridDriver *pmd, MeshBlock *pmb);
   ~MGGravity();
 
-  void Smooth(AthenaArray<Real> &dst, const AthenaArray<Real> &src, int rlev,
+  void Smooth(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
+              const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix, int rlev,
               int il, int iu, int jl, int ju, int kl, int ku, int color, bool th) final;
   void CalculateDefect(AthenaArray<Real> &def, const AthenaArray<Real> &u,
-                       const AthenaArray<Real> &src, int rlev,
-                       int il, int iu, int jl, int ju, int kl, int ku, bool th) final;
+                const AthenaArray<Real> &src, const AthenaArray<Real> &coeff,
+                const AthenaArray<Real> &matrix, int rlev, int il, int iu, int jl, int ju,
+                int kl, int ku, bool th) final;
   void CalculateFASRHS(AthenaArray<Real> &def, const AthenaArray<Real> &src,
+                const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
                 int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) final;
-
- private:
-  static constexpr Real omega_ = 1.15;
 };
 
 
@@ -51,11 +51,12 @@ class MGGravityDriver : public MultigridDriver {
  public:
   MGGravityDriver(Mesh *pm, ParameterInput *pin);
   ~MGGravityDriver();
-  void Solve(int stage) final;
+  void Solve(int stage, Real dt = 0.0) final;
   void ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
                  AthenaArray<Real> &cbuf, const AthenaArray<bool> &ncoarse) final;
+  friend class MGGravity;
  private:
-  Real four_pi_G_;
+  Real four_pi_G_, omega_;
   GravityBoundaryTaskList *gtlist_;
 };
 
diff --git a/src/main.cpp b/src/main.cpp
index 3079b79b82..3a72d4ce68 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -35,6 +35,7 @@
 // Athena++ headers
 #include "athena.hpp"
 #include "chem_rad/chem_rad.hpp"
+#include "crdiffusion/mg_crdiffusion.hpp"
 #include "fft/turbulence.hpp"
 #include "globals.hpp"
 #include "gravity/fft_gravity.hpp"
@@ -482,6 +483,10 @@ int main(int argc, char *argv[]) {
 
     if (pmesh->turb_flag > 1) pmesh->ptrbd->Driving(); // driven turbulence
 
+    if (CRDIFFUSION_ENABLED) {
+      pmesh->pmcrd->Solve(0, pmesh->dt);
+    }
+
     // chemistry with radiation
     if (CHEMRADIATION_ENABLED) {
       clock_t tstart_rad, tstop_rad;
diff --git a/src/mesh/mesh.cpp b/src/mesh/mesh.cpp
index 4698bad403..8bf56995fe 100644
--- a/src/mesh/mesh.cpp
+++ b/src/mesh/mesh.cpp
@@ -34,6 +34,8 @@
 #include "../chem_rad/integrators/rad_integrators.hpp"
 #include "../coordinates/coordinates.hpp"
 #include "../cr/cr.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
+#include "../crdiffusion/mg_crdiffusion.hpp"
 #include "../eos/eos.hpp"
 #include "../fft/athena_fft.hpp"
 #include "../fft/turbulence.hpp"
@@ -122,7 +124,11 @@ Mesh::Mesh(ParameterInput *pin, int mesh_test) :
     ConductionCoeff_{}, FieldDiffusivity_{},
     OrbitalVelocity_{}, OrbitalVelocityDerivative_{nullptr, nullptr},
     MGGravityBoundaryFunction_{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
-    MGGravitySourceMaskFunction_{} {
+    MGCRDiffusionBoundaryFunction_{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
+    MGCRDiffusionCoeffBoundaryFunction_{nullptr, nullptr, nullptr,
+                                        nullptr, nullptr, nullptr},
+    MGGravitySourceMaskFunction_{}, MGCRDiffusionSourceMaskFunction_{},
+    MGCRDiffusionCoeffMaskFunction_{} {
   std::stringstream msg;
   BoundaryFlag block_bcs[6];
   std::int64_t nbmax;
@@ -535,6 +541,9 @@ Mesh::Mesh(ParameterInput *pin, int mesh_test) :
     pmgrd = new MGGravityDriver(this, pin);
   }
 
+  if (CRDIFFUSION_ENABLED)
+    pmcrd = new MGCRDiffusionDriver(this, pin);
+
   if (IM_RADIATION_ENABLED) {
     pimrad = new IMRadiation(this, pin);
   }
@@ -617,7 +626,11 @@ Mesh::Mesh(ParameterInput *pin, IOWrapper& resfile, int mesh_test) :
     ConductionCoeff_{}, FieldDiffusivity_{},
     OrbitalVelocity_{}, OrbitalVelocityDerivative_{nullptr, nullptr},
     MGGravityBoundaryFunction_{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
-    MGGravitySourceMaskFunction_{} {
+    MGCRDiffusionBoundaryFunction_{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
+    MGCRDiffusionCoeffBoundaryFunction_{nullptr, nullptr, nullptr,
+                                        nullptr, nullptr, nullptr},
+    MGGravitySourceMaskFunction_{}, MGCRDiffusionSourceMaskFunction_{},
+    MGCRDiffusionCoeffMaskFunction_{} {
   std::stringstream msg;
   BoundaryFlag block_bcs[6];
   IOWrapperSizeT *offset{};
@@ -862,6 +875,9 @@ Mesh::Mesh(ParameterInput *pin, IOWrapper& resfile, int mesh_test) :
     pmgrd = new MGGravityDriver(this, pin);
   }
 
+  if (CRDIFFUSION_ENABLED)
+    pmcrd = new MGCRDiffusionDriver(this, pin);
+
   if (IM_RADIATION_ENABLED) {
     pimrad = new IMRadiation(this, pin);
   }
@@ -1199,7 +1215,7 @@ void Mesh::EnrollUserBoundaryFunction(int dir, BValFunc my_bc) {
 //----------------------------------------------------------------------------------------
 //! \fn void Mesh::EnrollUserMGGravityBoundaryFunction(BoundaryFace dir,
 //!                                                    MGBoundaryFunc my_bc)
-//! \brief Enroll a user-defined Multigrid boundary function
+//! \brief Enroll a user-defined Multigrid gravity boundary function
 
 void Mesh::EnrollUserMGGravityBoundaryFunction(BoundaryFace dir, MGBoundaryFunc my_bc) {
   std::stringstream msg;
@@ -1212,16 +1228,55 @@ void Mesh::EnrollUserMGGravityBoundaryFunction(BoundaryFace dir, MGBoundaryFunc
   return;
 }
 
+
 //----------------------------------------------------------------------------------------
-//! \fn void Mesh::EnrollUserMGGravitySourceMaskFunction(MGSourceMaskFunc srcmask)
+//! \fn void Mesh::EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace dir,
+//!                                                        MGBoundaryFunc my_bc)
+//! \brief Enroll a user-defined Multigrid CR Diffusion boundary function
+
+void Mesh::EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace dir,
+                                                   MGBoundaryFunc my_bc) {
+  std::stringstream msg;
+  if (dir < 0 || dir > 5) {
+    msg << "### FATAL ERROR in EnrollUserMGCRDiffusionBoundaryFunction" << std::endl
+        << "dirName = " << dir << " not valid" << std::endl;
+    ATHENA_ERROR(msg);
+  }
+  MGCRDiffusionBoundaryFunction_[static_cast<int>(dir)] = my_bc;
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void Mesh::EnrollUserMGGravitySourceMaskFunction(MGMaskFunc srcmask)
 //  \brief Enroll a user-defined Multigrid gravity source mask function
 
-void Mesh::EnrollUserMGGravitySourceMaskFunction(MGSourceMaskFunc srcmask) {
+void Mesh::EnrollUserMGGravitySourceMaskFunction(MGMaskFunc srcmask) {
   MGGravitySourceMaskFunction_ = srcmask;
   return;
 }
 
 
+//----------------------------------------------------------------------------------------
+//! \fn void Mesh::EnrollUserMGCRDiffusionSourceMaskFunction(MGMaskFunc srcmask)
+//  \brief Enroll a user-defined Multigrid CR diffusion source mask function
+
+void Mesh::EnrollUserMGCRDiffusionSourceMaskFunction(MGMaskFunc srcmask) {
+  MGCRDiffusionSourceMaskFunction_ = srcmask;
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void Mesh::EnrollUserMGCRDiffusionCoefficientMaskFunction(MGMaskFunc coeffmask)
+//  \brief Enroll a user-defined Multigrid CR diffusion coefficient mask function
+
+void Mesh::EnrollUserMGCRDiffusionCoefficientMaskFunction(MGMaskFunc coeffmask) {
+  MGCRDiffusionCoeffMaskFunction_ = coeffmask;
+  return;
+}
+
+
 //----------------------------------------------------------------------------------------
 // radiation related boundaries
 
@@ -1509,6 +1564,8 @@ void Mesh::Initialize(int res_flag, ParameterInput *pin) {
       }
       if (IM_RADIATION_ENABLED)
         pmb->pnrrad->rad_bvar.SetupPersistentMPI();
+      if (CRDIFFUSION_ENABLED)
+        pmb->pcrdiff->crbvar.SetupPersistentMPI();
     }
 
     // solve gravity for the first time
@@ -1772,6 +1829,9 @@ void Mesh::Initialize(int res_flag, ParameterInput *pin) {
       }
     }
 
+    if (CRDIFFUSION_ENABLED) // CR has to be processed after MHD boundaries
+      pmcrd->Solve(1, 0.0);
+
     if (!res_flag && adaptive) {
       iflag = false;
       int onb = nbtotal;
@@ -2095,7 +2155,7 @@ void Mesh::ReserveMeshBlockPhysIDs() {
     ReserveTagPhysIDs(FaceCenteredBoundaryVariable::max_phys_id);
   }
   if (SELF_GRAVITY_ENABLED) {
-    ReserveTagPhysIDs(CellCenteredBoundaryVariable::max_phys_id);
+    ReserveTagPhysIDs(1);
   }
   if (NSCALARS > 0) {
     ReserveTagPhysIDs(CellCenteredBoundaryVariable::max_phys_id);
@@ -2109,6 +2169,10 @@ void Mesh::ReserveMeshBlockPhysIDs() {
   if (CR_ENABLED) {
     ReserveTagPhysIDs(CellCenteredBoundaryVariable::max_phys_id);
   }
+  if (CRDIFFUSION_ENABLED) {
+    ReserveTagPhysIDs(1);
+  }
+
 #endif
   return;
 }
diff --git a/src/mesh/mesh.hpp b/src/mesh/mesh.hpp
index a56668306f..812b702cee 100644
--- a/src/mesh/mesh.hpp
+++ b/src/mesh/mesh.hpp
@@ -46,20 +46,24 @@ struct TaskStates;
 class Coordinates;
 class Reconstruction;
 class Hydro;
-class NRRadiation;
-class IMRadiation;
+
 class CosmicRay;
+class CRDiffusion;
+class MGCRDiffusionDriver;
+class EquationOfState;
 class Field;
-class Particles;
-class PassiveScalars;
 class Gravity;
 class MGGravityDriver;
-class EquationOfState;
 class FFTDriver;
 class FFTGravityDriver;
 class TurbulenceDriver;
 class ChemRadiation;
 class OrbitalAdvection;
+class Particles;
+class PassiveScalars;
+class NRRadiation;
+class IMRadiation;
+class TurbulenceDriver;
 
 FluidFormulation GetFluidFormulation(const std::string& input_string);
 
@@ -124,6 +128,7 @@ class MeshBlock {
   Hydro *phydro;
   NRRadiation *pnrrad;
   CosmicRay *pcr;
+  CRDiffusion *pcrdiff;
   Field *pfield;
   Gravity *pgrav;
   PassiveScalars *pscalars;
@@ -220,6 +225,7 @@ class Mesh {
   friend class TurbulenceDriver;
   friend class MultigridDriver;
   friend class MGGravityDriver;
+  friend class MGCRDiffusionDriver;
   friend class Gravity;
   friend class HydroDiffusion;
   friend class FieldDiffusion;
@@ -267,6 +273,7 @@ class Mesh {
   TurbulenceDriver *ptrbd;
   FFTGravityDriver *pfgrd;
   MGGravityDriver *pmgrd;
+  MGCRDiffusionDriver *pmcrd;
   Units *punit;
 
   // implicit radiation iteration
@@ -351,7 +358,11 @@ class Mesh {
   FieldDiffusionCoeffFunc FieldDiffusivity_;
   OrbitalVelocityFunc OrbitalVelocity_, OrbitalVelocityDerivative_[2];
   MGBoundaryFunc MGGravityBoundaryFunction_[6];
-  MGSourceMaskFunc MGGravitySourceMaskFunction_;
+  MGBoundaryFunc MGCRDiffusionBoundaryFunction_[6];
+  MGBoundaryFunc MGCRDiffusionCoeffBoundaryFunction_[6];
+  MGMaskFunc MGGravitySourceMaskFunction_;
+  MGMaskFunc MGCRDiffusionSourceMaskFunction_;
+  MGMaskFunc MGCRDiffusionCoeffMaskFunction_;
 
   void AllocateRealUserMeshDataField(int n);
   void AllocateIntUserMeshDataField(int n);
@@ -389,11 +400,15 @@ class Mesh {
   // often used (not defined) in prob file in ../pgen/
   void EnrollUserBoundaryFunction(BoundaryFace face, BValFunc my_func);
   void EnrollUserMGGravityBoundaryFunction(BoundaryFace dir, MGBoundaryFunc my_bc);
-  void EnrollUserMGGravitySourceMaskFunction(MGSourceMaskFunc srcmask);
+  void EnrollUserMGGravitySourceMaskFunction(MGMaskFunc srcmask);
+  void EnrollUserMGCRDiffusionSourceMaskFunction(MGMaskFunc srcmask);
+  void EnrollUserMGCRDiffusionCoefficientMaskFunction(MGMaskFunc coeffmask);
 
   void EnrollUserRadBoundaryFunction(BoundaryFace face, RadBoundaryFunc my_func);
   void EnrollUserCRBoundaryFunction(BoundaryFace face, CRBoundaryFunc my_func);
 
+  void EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace dir, MGBoundaryFunc my_bc);
+
   //! \deprecated (felker):
   //! * provide trivial overload for old-style BoundaryFace enum argument
   void EnrollUserBoundaryFunction(int face, BValFunc my_func);
diff --git a/src/mesh/meshblock.cpp b/src/mesh/meshblock.cpp
index 368495715a..3e3d0e41f8 100644
--- a/src/mesh/meshblock.cpp
+++ b/src/mesh/meshblock.cpp
@@ -27,6 +27,7 @@
 #include "../chem_rad/chem_rad.hpp"
 #include "../coordinates/coordinates.hpp"
 #include "../cr/cr.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
 #include "../eos/eos.hpp"
 #include "../fft/athena_fft.hpp"
 #include "../field/field.hpp"
@@ -257,6 +258,11 @@ MeshBlock::MeshBlock(int igid, int ilid, LogicalLocation iloc, RegionSize input_
     pbval->AdvanceCounterPhysID(CellCenteredBoundaryVariable::max_phys_id);
   }
 
+  if (CRDIFFUSION_ENABLED) {
+    pcrdiff = new CRDiffusion(this, pin);
+    pbval->AdvanceCounterPhysID(CellCenteredBoundaryVariable::max_phys_id);
+  }
+
   // OrbitalAdvection: constructor depends on Coordinates, Hydro, Field, PassiveScalars.
   porb = new OrbitalAdvection(this, pin);
 
@@ -451,6 +457,10 @@ MeshBlock::MeshBlock(int igid, int ilid, Mesh *pm, ParameterInput *pin,
     pbval->AdvanceCounterPhysID(CellCenteredBoundaryVariable::max_phys_id);
   }
 
+  if (CRDIFFUSION_ENABLED) {
+    pcrdiff = new CRDiffusion(this, pin);
+    pbval->AdvanceCounterPhysID(CellCenteredBoundaryVariable::max_phys_id);
+  }
 
   // OrbitalAdvection: constructor depends on Coordinates, Hydro, Field, PassiveScalars.
   porb = new OrbitalAdvection(this, pin);
@@ -526,6 +536,12 @@ MeshBlock::MeshBlock(int igid, int ilid, Mesh *pm, ParameterInput *pin,
     std::memcpy(pcr->u_cr1.data(), &(mbdata[os]), pcr->u_cr1.GetSizeInBytes());
     os += pcr->u_cr.GetSizeInBytes();
   }
+
+  if (CRDIFFUSION_ENABLED) {
+    std::memcpy(pcrdiff->ecr.data(), &(mbdata[os]), pcrdiff->ecr.GetSizeInBytes());
+    os += pcrdiff->ecr.GetSizeInBytes();
+  }
+
   // (conserved variable) Passive scalars:
   if (NSCALARS > 0) {
     std::memcpy(pscalars->s.data(), &(mbdata[os]), pscalars->s.GetSizeInBytes());
@@ -574,6 +590,7 @@ MeshBlock::~MeshBlock() {
 
   if (NR_RADIATION_ENABLED || IM_RADIATION_ENABLED) delete pnrrad;
   if (CR_ENABLED) delete pcr;
+  if (CRDIFFUSION_ENABLED) delete pcrdiff;
 
   // BoundaryValues should be destructed AFTER all BoundaryVariable objects are destroyed
   delete pbval;
@@ -684,6 +701,8 @@ std::size_t MeshBlock::GetBlockSizeInBytes() {
     size += pnrrad->ir.GetSizeInBytes();
   if (CR_ENABLED)
     size += pcr->u_cr.GetSizeInBytes();
+  if (CRDIFFUSION_ENABLED)
+    size += pcrdiff->ecr.GetSizeInBytes();
 
   // calculate user MeshBlock data size
   for (int n=0; n<nint_user_meshblock_data_; n++)
@@ -718,6 +737,8 @@ std::size_t MeshBlock::GetBlockSizeInBytesGray() {
   }
   if (CR_ENABLED)
     size += pcr->u_cr.GetSizeInBytes();
+  if (CRDIFFUSION_ENABLED)
+    size += pcrdiff->ecr.GetSizeInBytes();
 
 
   // calculate user MeshBlock data size
diff --git a/src/mesh/meshblock_tree.cpp b/src/mesh/meshblock_tree.cpp
index 81a4f9a950..2029368339 100644
--- a/src/mesh/meshblock_tree.cpp
+++ b/src/mesh/meshblock_tree.cpp
@@ -514,8 +514,8 @@ void MeshBlockTree::GetMGOctetList(std::vector<MGOctet> *oct,
   if (lev >= 0) {
     oid = noct[lev];
     oct[lev][oid].loc = loc_;
-    octmap[lev][loc_] = oid;
     oct[lev][oid].fleaf = true;
+    octmap[lev][loc_] = oid;
     noct[lev]++;
   }
   for (int n=0; n<nleaf_; n++) {
diff --git a/src/mesh/meshblock_tree.hpp b/src/mesh/meshblock_tree.hpp
index 72f4fb18ae..ba8686c871 100644
--- a/src/mesh/meshblock_tree.hpp
+++ b/src/mesh/meshblock_tree.hpp
@@ -23,7 +23,7 @@
 #include "../multigrid/multigrid.hpp"
 
 class Mesh;
-struct MGOctet;
+class MGOctet;
 struct LogicalLocationHash;
 
 //--------------------------------------------------------------------------------------
diff --git a/src/multigrid/multigrid.cpp b/src/multigrid/multigrid.cpp
index 79bb1e4ff0..dab6a11cda 100644
--- a/src/multigrid/multigrid.cpp
+++ b/src/multigrid/multigrid.cpp
@@ -26,11 +26,12 @@
 #include "multigrid.hpp"
 
 //----------------------------------------------------------------------------------------
-//! \fn Multigrid::Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int invar, int nghost)
-//! \brief Multigrid constructor
+//! \fn Multigrid::Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int nghost)
+//  \brief Multigrid constructor
 
-Multigrid::Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int invar, int nghost) :
-  pmy_driver_(pmd), pmy_block_(pmb), ngh_(nghost), nvar_(invar), defscale_(1.0) {
+Multigrid::Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int nghost) :
+  pmy_driver_(pmd), pmy_block_(pmb), ngh_(nghost), nvar_(pmd->nvar_),
+  ncoeff_(pmd->ncoeff_), nmatrix_(pmd->nmatrix_), defscale_(1.0) {
   if (pmy_block_ != nullptr) {
     loc_ = pmy_block_->loc;
     size_ = pmy_block_->block_size;
@@ -120,6 +121,8 @@ Multigrid::Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int invar, int nghost
   def_ = new AthenaArray<Real>[nlevel_];
   coord_ = new MGCoordinates[nlevel_];
   ccoord_ = new MGCoordinates[nlevel_];
+  coeff_ = new AthenaArray<Real>[nlevel_];
+  matrix_ = new AthenaArray<Real>[nlevel_];
   if (pmy_block_ == nullptr)
     uold_ = new AthenaArray<Real>[nlevel_];
   else
@@ -136,6 +139,10 @@ Multigrid::Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int invar, int nghost
       uold_[l].NewAthenaArray(nvar_,ncz,ncy,ncx);
     coord_[l].AllocateMGCoordinates(ncx,ncy,ncz);
     coord_[l].CalculateMGCoordinates(size_, ll, ngh_);
+    if (ncoeff_ > 0)
+      coeff_[l].NewAthenaArray(ncoeff_,ncz,ncy,ncx);
+    if (nmatrix_ > 0)
+      matrix_[l].NewAthenaArray(nmatrix_,ncz,ncy,ncx);
     ncx=(size_.nx1>>(ll+1))+2*ngh_;
     ncy=(size_.nx2>>(ll+1))+2*ngh_;
     ncz=(size_.nx3>>(ll+1))+2*ngh_;
@@ -154,6 +161,8 @@ Multigrid::~Multigrid() {
   delete [] src_;
   delete [] def_;
   delete [] uold_;
+  delete [] coeff_;
+  delete [] matrix_;
   delete [] coord_;
   delete [] ccoord_;
 }
@@ -233,16 +242,46 @@ void Multigrid::LoadSource(const AthenaArray<Real> &src, int ns, int ngh, Real f
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void Multigrid::ApplySourceMask()
+//! \fn void Multigrid::LoadCoefficients(const AthenaArray<Real> &coeff, int ngh)
+//! \brief Load coefficients of the diffusion and source terms
+
+void Multigrid::LoadCoefficients(const AthenaArray<Real> &coeff, int ngh) {
+  AthenaArray<Real> &cm=coeff_[nlevel_-1];
+  int is, ie, js, je, ks, ke;
+  is=js=ks=0;
+  ie=size_.nx1+2*ngh_-1, je=size_.nx2+2*ngh_-1, ke=size_.nx3+2*ngh_-1;
+  for (int v = 0; v < ncoeff_; ++v) {
+    for (int mk=ks; mk<=ke; ++mk) {
+      int k = mk + ngh - ngh_;
+      for (int mj=js; mj<=je; ++mj) {
+        int j = mj + ngh - ngh_;
+#pragma omp simd
+        for (int mi=is; mi<=ie; ++mi) {
+          int i = mi + ngh - ngh_;
+          cm(v,mk,mj,mi) = coeff(v,k,j,i);
+        }
+      }
+    }
+  }
+  return;
+}
+
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void Multigrid::ApplyMask()
 //  \brief Apply the user-defined source mask function on the finest level
 
-void Multigrid::ApplySourceMask() {
+void Multigrid::ApplyMask() {
   int is, ie, js, je, ks, ke;
   is = js = ks = ngh_;
   ie = is + size_.nx1;
   je = js + size_.nx2;
   ke = ks + size_.nx3;
-  pmy_driver_->srcmask_(src_[nlevel_-1], is, ie, js, je, ks, ke, coord_[nlevel_-1]);
+  if (pmy_driver_->srcmask_ != nullptr)
+    pmy_driver_->srcmask_(src_[nlevel_-1], is, ie, js, je, ks, ke, coord_[nlevel_-1]);
+  if (ncoeff_ > 0 && pmy_driver_->coeffmask_ != nullptr)
+    pmy_driver_->coeffmask_(coeff_[nlevel_-1], is, ie, js, je, ks, ke, coord_[nlevel_-1]);
   return;
 }
 
@@ -256,7 +295,24 @@ void Multigrid::RestrictFMGSource() {
   for (current_level_=nlevel_-1; current_level_>0; current_level_--) {
     int ll=nlevel_-current_level_;
     ie=is+(size_.nx1>>ll)-1, je=js+(size_.nx2>>ll)-1, ke=ks+(size_.nx3>>ll)-1;
-    Restrict(src_[current_level_-1], src_[current_level_], is, ie, js, je, ks, ke, false);
+    Restrict(src_[current_level_-1], src_[current_level_],
+             nvar_, is, ie, js, je, ks, ke, false);
+  }
+  return;
+}
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void Multigrid::RestrictCoefficients()
+//! \brief restrict coefficients within a Multigrid object
+
+void Multigrid::RestrictCoefficients() {
+  int is, ie, js, je, ks, ke;
+  is=js=ks=ngh_;
+  for (int lev = nlevel_ - 1; lev > 0; lev--) {
+    int ll = nlevel_ - lev;
+    ie=is+(size_.nx1>>ll)-1, je=js+(size_.nx2>>ll)-1, ke=ks+(size_.nx3>>ll)-1;
+    Restrict(coeff_[lev-1], coeff_[lev], ncoeff_, is, ie, js, je, ks, ke, false);
   }
   return;
 }
@@ -341,11 +397,13 @@ void Multigrid::RestrictBlock() {
   is=js=ks=ngh_;
   ie=is+(size_.nx1>>ll)-1, je=js+(size_.nx2>>ll)-1, ke=ks+(size_.nx3>>ll)-1;
 
-  Restrict(src_[current_level_-1], def_[current_level_], is, ie, js, je, ks, ke, th);
+  Restrict(src_[current_level_-1], def_[current_level_],
+           nvar_, is, ie, js, je, ks, ke, th);
 
   // Full Approximation Scheme - restrict the variable itself
   if (pmy_driver_->ffas_)
-    Restrict(u_[current_level_-1], u_[current_level_], is, ie, js, je, ks, ke, th);
+    Restrict(u_[current_level_-1], u_[current_level_],
+             nvar_, is, ie, js, je, ks, ke, th);
 
   current_level_--;
 
@@ -422,8 +480,8 @@ void Multigrid::SmoothBlock(int color) {
   is = js = ks = ngh_;
   ie = is+(size_.nx1>>ll)-1, je = js+(size_.nx2>>ll)-1, ke = ks+(size_.nx3>>ll)-1;
 
-  Smooth(u_[current_level_], src_[current_level_],
-         -ll, is, ie, js, je, ks, ke, color, th);
+  Smooth(u_[current_level_], src_[current_level_],  coeff_[current_level_],
+         matrix_[current_level_], -ll, is, ie, js, je, ks, ke, color, th);
 
   return;
 }
@@ -445,6 +503,7 @@ void Multigrid::CalculateDefectBlock() {
   ie = is+(size_.nx1>>ll)-1, je = js+(size_.nx2>>ll)-1, ke = ks+(size_.nx3>>ll)-1;
 
   CalculateDefect(def_[current_level_], u_[current_level_], src_[current_level_],
+                  coeff_[current_level_], matrix_[current_level_],
                   -ll, is, ie, js, je, ks, ke, th);
 
   return;
@@ -466,13 +525,29 @@ void Multigrid::CalculateFASRHSBlock() {
   is = js = ks = ngh_;
   ie = is+(size_.nx1>>ll)-1, je = js+(size_.nx2>>ll)-1, ke = ks+(size_.nx3>>ll)-1;
 
-  CalculateFASRHS(src_[current_level_], u_[current_level_],
-                  -ll, is, ie, js, je, ks, ke, th);
+  CalculateFASRHS(src_[current_level_], u_[current_level_], coeff_[current_level_],
+                  matrix_[current_level_], -ll, is, ie, js, je, ks, ke, th);
 
   return;
 }
 
 
+//----------------------------------------------------------------------------------------
+//! \fn void Multigrid::CalculateMatrixBlock(Real dt)
+//  \brief calculate matrix elements for all the levels
+
+void Multigrid::CalculateMatrixBlock(Real dt) {
+  int is, ie, js, je, ks, ke;
+  is=js=ks=ngh_;
+  for (int lev = nlevel_ - 1; lev >= 0; lev--) {
+    int ll = nlevel_ - lev - 1;
+    ie=is+(size_.nx1>>ll)-1, je=js+(size_.nx2>>ll)-1, ke=ks+(size_.nx3>>ll)-1;
+    CalculateMatrix(matrix_[lev], coeff_[lev], dt, -ll, is, ie, js, je, ks, ke, false);
+  }
+
+  return;
+}
+
 //----------------------------------------------------------------------------------------
 //! \fn void Multigrid::SetFromRootGrid(bool folddata)
 //! \brief Load the data from the root grid or octets
@@ -562,6 +637,7 @@ Real Multigrid::CalculateDefectNorm(MGNormType nrm, int n) {
        dz=rdz_*static_cast<Real>(1<<ll);
 
   CalculateDefect(def_[current_level_], u_[current_level_], src_[current_level_],
+                  coeff_[current_level_], matrix_[current_level_],
                   -ll, is, ie, js, je, ks, ke, false);
 
   Real norm=0.0;
@@ -655,11 +731,15 @@ void Multigrid::StoreOldData() {
 
 //----------------------------------------------------------------------------------------
 //! \fn Real Multigrid::GetCoarsestData(MGVariable type, int n)
-//! \brief get the value on the coarsest level in the MG block (type: 0=src, 1=u)
+//  \brief get the value on the coarsest level in the MG block
 
 Real Multigrid::GetCoarsestData(MGVariable type, int n) {
-  AthenaArray<Real> &src = (type == MGVariable::src) ? src_[0] : u_[0];
-  return src(n, ngh_, ngh_, ngh_);
+  if (type == MGVariable::src)
+    return src_[0](n, ngh_, ngh_, ngh_);
+  else if (type == MGVariable::u)
+    return u_[0](n, ngh_, ngh_, ngh_);
+  else
+    return coeff_[0](n, ngh_, ngh_, ngh_);
 }
 
 
@@ -668,53 +748,36 @@ Real Multigrid::GetCoarsestData(MGVariable type, int n) {
 //! \brief set a value to a cell on the current level
 
 void Multigrid::SetData(MGVariable type, int n, int k, int j, int i, Real v) {
-  AthenaArray<Real> &dst =
-                    (type == MGVariable::src) ? src_[current_level_] : u_[current_level_];
-  dst(n, ngh_+k, ngh_+j, ngh_+i) = v;
-
+  if (type == MGVariable::src)
+    src_[current_level_](n, ngh_+k, ngh_+j, ngh_+i) = v;
+  else if (type == MGVariable::u)
+    u_[current_level_](n, ngh_+k, ngh_+j, ngh_+i) = v;
+  else
+    coeff_[current_level_](n, ngh_+k, ngh_+j, ngh_+i) = v;
   return;
 }
 
 
 //----------------------------------------------------------------------------------------
 //! \fn void Multigrid::Restrict(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
-//!                              int il, int iu, int jl, int ju, int kl, int ku, bool th)
-//! \brief Actual implementation of prolongation and correction
+//                      int nvar, int il, int iu, int jl, int ju, int kl, int ku, bool th)
+//  \brief Actual implementation of prolongation and correction
 
 void Multigrid::Restrict(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
-                         int il, int iu, int jl, int ju, int kl, int ku, bool th) {
-  if (th == true && (ku-kl) >=  minth_) {
-    for (int v=0; v<nvar_; ++v) {
-#pragma omp parallel for num_threads(pmy_driver_->nthreads_)
-      for (int k=kl; k<=ku; ++k) {
-        int fk = 2*k - kl;
-        for (int j=jl; j<=ju; ++j) {
-          int fj = 2*j - jl;
+                int nvar, int il, int iu, int jl, int ju, int kl, int ku, bool th) {
+  for (int v=0; v<nvar; ++v) {
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl) >= minth_)
+    for (int k=kl; k<=ku; ++k) {
+      int fk = 2*k - kl;
+      for (int j=jl; j<=ju; ++j) {
+        int fj = 2*j - jl;
 #pragma ivdep
-          for (int i=il; i<=iu; ++i) {
-            int fi = 2*i - il;
-            dst(v, k, j, i)=0.125*(src(v, fk,   fj,   fi)+src(v, fk,   fj,   fi+1)
-                                  +src(v, fk,   fj+1, fi)+src(v, fk,   fj+1, fi+1)
-                                  +src(v, fk+1, fj,   fi)+src(v, fk+1, fj,   fi+1)
-                                  +src(v, fk+1, fj+1, fi)+src(v, fk+1, fj+1, fi+1));
-          }
-        }
-      }
-    }
-  } else {
-    for (int v=0; v<nvar_; ++v) {
-      for (int k=kl; k<=ku; ++k) {
-        int fk = 2*k - kl;
-        for (int j=jl; j<=ju; ++j) {
-          int fj = 2*j - jl;
-#pragma ivdep
-          for (int i=il; i<=iu; ++i) {
-            int fi = 2*i - il;
-            dst(v, k, j, i)=0.125*(src(v, fk,   fj,   fi)+src(v, fk,   fj,   fi+1)
-                                  +src(v, fk,   fj+1, fi)+src(v, fk,   fj+1, fi+1)
-                                  +src(v, fk+1, fj,   fi)+src(v, fk+1, fj,   fi+1)
-                                  +src(v, fk+1, fj+1, fi)+src(v, fk+1, fj+1, fi+1));
-          }
+        for (int i=il; i<=iu; ++i) {
+          int fi = 2*i - il;
+          dst(v, k, j, i)=0.125*(src(v, fk,   fj,   fi)+src(v, fk,   fj,   fi+1)
+                                +src(v, fk,   fj+1, fi)+src(v, fk,   fj+1, fi+1)
+                                +src(v, fk+1, fj,   fi)+src(v, fk+1, fj,   fi+1)
+                                +src(v, fk+1, fj+1, fi)+src(v, fk+1, fj+1, fi+1));
         }
       }
     }
@@ -732,9 +795,9 @@ void Multigrid::Restrict(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
 
 void Multigrid::ProlongateAndCorrect(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
      int il, int iu, int jl, int ju, int kl, int ku, int fil, int fjl, int fkl, bool th) {
-  if (th == true && (ku-kl) >=  minth_/2) {
+  if (pmy_driver_->fprolongation_ == 1) { // tricubic
     for (int v=0; v<nvar_; ++v) {
-#pragma omp parallel for num_threads(pmy_driver_->nthreads_)
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl)>=minth_/2)
       for (int k=kl; k<=ku; ++k) {
         int fk = 2*(k-kl) + fkl;
         for (int j=jl; j<=ju; ++j) {
@@ -742,44 +805,101 @@ void Multigrid::ProlongateAndCorrect(AthenaArray<Real> &dst, const AthenaArray<R
 #pragma ivdep
           for (int i=il; i<=iu; ++i) {
             int fi = 2*(i-il) + fil;
-            dst(v,fk  ,fj  ,fi  ) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k-1,j-1,i-1)
-                          +9.0*(src(v,k,j,i-1)+src(v,k,j-1,i)+src(v,k-1,j,i))
-                          +3.0*(src(v,k-1,j-1,i)+src(v,k-1,j,i-1)+src(v,k,j-1,i-1)));
-            dst(v,fk  ,fj  ,fi+1) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k-1,j-1,i+1)
-                          +9.0*(src(v,k,j,i+1)+src(v,k,j-1,i)+src(v,k-1,j,i))
-                          +3.0*(src(v,k-1,j-1,i)+src(v,k-1,j,i+1)+src(v,k,j-1,i+1)));
-            dst(v,fk  ,fj+1,fi  ) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k-1,j+1,i-1)
-                          +9.0*(src(v,k,j,i-1)+src(v,k,j+1,i)+src(v,k-1,j,i))
-                          +3.0*(src(v,k-1,j+1,i)+src(v,k-1,j,i-1)+src(v,k,j+1,i-1)));
-            dst(v,fk+1,fj  ,fi  ) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k+1,j-1,i-1)
-                          +9.0*(src(v,k,j,i-1)+src(v,k,j-1,i)+src(v,k+1,j,i))
-                          +3.0*(src(v,k+1,j-1,i)+src(v,k+1,j,i-1)+src(v,k,j-1,i-1)));
-            dst(v,fk+1,fj+1,fi  ) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k+1,j+1,i-1)
-                          +9.0*(src(v,k,j,i-1)+src(v,k,j+1,i)+src(v,k+1,j,i))
-                          +3.0*(src(v,k+1,j+1,i)+src(v,k+1,j,i-1)+src(v,k,j+1,i-1)));
-            dst(v,fk+1,fj  ,fi+1) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k+1,j-1,i+1)
-                          +9.0*(src(v,k,j,i+1)+src(v,k,j-1,i)+src(v,k+1,j,i))
-                          +3.0*(src(v,k+1,j-1,i)+src(v,k+1,j,i+1)+src(v,k,j-1,i+1)));
-            dst(v,fk  ,fj+1,fi+1) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k-1,j+1,i+1)
-                          +9.0*(src(v,k,j,i+1)+src(v,k,j+1,i)+src(v,k-1,j,i))
-                          +3.0*(src(v,k-1,j+1,i)+src(v,k-1,j,i+1)+src(v,k,j+1,i+1)));
-            dst(v,fk+1,fj+1,fi+1) +=
-                0.015625*(27.0*src(v,k,j,i) + src(v,k+1,j+1,i+1)
-                          +9.0*(src(v,k,j,i+1)+src(v,k,j+1,i)+src(v,k+1,j,i))
-                          +3.0*(src(v,k+1,j+1,i)+src(v,k+1,j,i+1)+src(v,k,j+1,i+1)));
+          dst(v,fk  ,fj,  fi  ) += (
+            + 125.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
+            + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
+            + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
+            -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
+            +  45.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )-  27.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk,  fj,  fi+1) += (
+            -  75.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )+ 125.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
+            +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
+            + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            -  27.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk  ,fj+1,fi  ) += (
+            -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
+            + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            + 125.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            +  45.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )-  27.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
+            -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk,  fj+1,fi+1) += (
+            +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
+            -  75.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )+ 125.*src(v,k-1,j+1,i+1)
+            + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
+            -  27.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
+            + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj,  fi  ) += (
+            -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
+            +  45.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )-  27.*src(v,k-1,j+1,i+1)
+            + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
+            + 125.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
+            + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj,  fi+1) += (
+            +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
+            + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            -  27.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            -  75.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )+ 125.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
+            +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj+1,fi  ) += (
+            +  45.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )-  27.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
+            -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
+            + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            + 125.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj+1,fi+1) += (
+            -  27.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
+            + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
+            + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
+            +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
+            -  75.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )+ 125.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
           }
         }
       }
     }
-  } else {
+  } else { // trilinear
     for (int v=0; v<nvar_; ++v) {
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl)>=minth_/2)
       for (int k=kl; k<=ku; ++k) {
         int fk = 2*(k-kl) + fkl;
         for (int j=jl; j<=ju; ++j) {
@@ -838,206 +958,103 @@ void Multigrid::ProlongateAndCorrect(AthenaArray<Real> &dst, const AthenaArray<R
 void Multigrid::FMGProlongate(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
                               int il, int iu, int jl, int ju, int kl, int ku,
                               int fil, int fjl, int fkl, bool th) {
-  if (th == true && (ku-kl) >=  minth_/2) {
-    for (int v=0; v<nvar_; ++v) {
-#pragma omp parallel for num_threads(pmy_driver_->nthreads_)
-      for (int k=kl; k<=ku; ++k) {
-        int fk = 2*(k-kl) + fkl;
-        for (int j=jl; j<=ju; ++j) {
-          int fj = 2*(j-jl) + fjl;
-#pragma ivdep
-          for (int i=il; i<=iu; ++i) {
-            int fi = 2*(i-il) + fil;
-            dst(v,fk  ,fj,  fi  )=(
-              + 125.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
-              + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
-              + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
-              -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
-              +  45.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )-  27.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk,  fj,  fi+1)=(
-              -  75.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )+ 125.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
-              +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
-              + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              -  27.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk  ,fj+1,fi  )=(
-              -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
-              + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              + 125.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              +  45.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )-  27.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
-              -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk,  fj+1,fi+1)=(
-              +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
-              -  75.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )+ 125.*src(v,k-1,j+1,i+1)
-              + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
-              -  27.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
-              + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj,  fi  )=(
-              -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
-              +  45.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )-  27.*src(v,k-1,j+1,i+1)
-              + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
-              + 125.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
-              + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj,  fi+1)=(
-              +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
-              + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              -  27.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              -  75.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )+ 125.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
-              +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj+1,fi  )=(
-              +  45.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )-  27.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
-              -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
-              + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              + 125.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj+1,fi+1)=(
-              -  27.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
-              + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
-              + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
-              +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
-              -  75.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )+ 125.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-          }
-        }
-      }
-    }
-  } else {
-    for (int v=0; v<nvar_; ++v) {
-      for (int k=kl; k<=ku; ++k) {
-        int fk = 2*(k-kl) + fkl;
-        for (int j=jl; j<=ju; ++j) {
-          int fj = 2*(j-jl) + fjl;
+  for (int v=0; v<nvar_; ++v) {
+#pragma omp parallel for num_threads(pmy_driver_->nthreads_) if (th && (ku-kl)>=minth_/2)
+    for (int k=kl; k<=ku; ++k) {
+      int fk = 2*(k-kl) + fkl;
+      for (int j=jl; j<=ju; ++j) {
+        int fj = 2*(j-jl) + fjl;
 #pragma ivdep
-          for (int i=il; i<=iu; ++i) {
-            int fi = 2*(i-il) + fil;
-            dst(v,fk  ,fj,  fi  )=(
-              + 125.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
-              + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
-              + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
-              -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
-              +  45.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )-  27.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk,  fj,  fi+1)=(
-              -  75.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )+ 125.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
-              +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
-              + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              -  27.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk  ,fj+1,fi  )=(
-              -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
-              + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              + 125.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              +  45.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )-  27.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
-              -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk,  fj+1,fi+1)=(
-              +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
-              -  75.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )+ 125.*src(v,k-1,j+1,i+1)
-              + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
-              -  27.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
-              + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj,  fi  )=(
-              -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
-              +  45.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )-  27.*src(v,k-1,j+1,i+1)
-              + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
-              + 125.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
-              + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj,  fi+1)=(
-              +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
-              + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              -  27.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              -  75.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )+ 125.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
-              +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj+1,fi  )=(
-              +  45.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )-  27.*src(v,k-1,j-1,i+1)
-              - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
-              -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
-              - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
-              +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
-              + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
-              -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
-              + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
-              + 125.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-            dst(v,fk+1,fj+1,fi+1)=(
-              -  27.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
-              + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
-              +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
-              + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
-              -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
-              - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
-              +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
-              - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
-              -  75.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )+ 125.*src(v,k+1,j+1,i+1)
-                                 )/32768.0;
-          }
+        for (int i=il; i<=iu; ++i) {
+          int fi = 2*(i-il) + fil;
+          dst(v,fk  ,fj,  fi  )=(
+            + 125.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
+            + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
+            + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
+            -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
+            +  45.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )-  27.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk,  fj,  fi+1)=(
+            -  75.*src(v,k-1,j-1,i-1)+  750.*src(v,k-1,j-1,i  )+ 125.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
+            +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
+            + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            -  27.*src(v,k+1,j+1,i-1)+  270.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk  ,fj+1,fi  )=(
+            -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
+            + 750.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            + 125.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            +  45.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )-  27.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )+ 270.*src(v,k+1,j,  i+1)
+            -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk,  fj+1,fi+1)=(
+            +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)+ 4500.*src(v,k-1,j,  i  )+ 750.*src(v,k-1,j,  i+1)
+            -  75.*src(v,k-1,j+1,i-1)+  750.*src(v,k-1,j+1,i  )+ 125.*src(v,k-1,j+1,i+1)
+            + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
+            -  27.*src(v,k+1,j-1,i-1)+  270.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
+            + 270.*src(v,k+1,j,  i-1)- 2700.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj,  fi  )=(
+            -  75.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
+            +  45.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )-  27.*src(v,k-1,j+1,i+1)
+            + 750.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )+ 270.*src(v,k,  j+1,i+1)
+            + 125.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
+            + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            -  75.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )+  45.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj,  fi+1)=(
+            +  45.*src(v,k-1,j-1,i-1)-  450.*src(v,k-1,j-1,i  )-  75.*src(v,k-1,j-1,i+1)
+            + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            -  27.*src(v,k-1,j+1,i-1)+  270.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)+ 4500.*src(v,k,  j-1,i  )+ 750.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            + 270.*src(v,k,  j+1,i-1)- 2700.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            -  75.*src(v,k+1,j-1,i-1)+  750.*src(v,k+1,j-1,i  )+ 125.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
+            +  45.*src(v,k+1,j+1,i-1)-  450.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj+1,fi  )=(
+            +  45.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )-  27.*src(v,k-1,j-1,i+1)
+            - 450.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )+ 270.*src(v,k-1,j,  i+1)
+            -  75.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )+  45.*src(v,k-1,j+1,i+1)
+            - 450.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )+ 270.*src(v,k,  j-1,i+1)
+            +4500.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )-2700.*src(v,k,  j,  i+1)
+            + 750.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )- 450.*src(v,k,  j+1,i+1)
+            -  75.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )+  45.*src(v,k+1,j-1,i+1)
+            + 750.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )- 450.*src(v,k+1,j,  i+1)
+            + 125.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )-  75.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
+          dst(v,fk+1,fj+1,fi+1)=(
+            -  27.*src(v,k-1,j-1,i-1)+  270.*src(v,k-1,j-1,i  )+  45.*src(v,k-1,j-1,i+1)
+            + 270.*src(v,k-1,j,  i-1)- 2700.*src(v,k-1,j,  i  )- 450.*src(v,k-1,j,  i+1)
+            +  45.*src(v,k-1,j+1,i-1)-  450.*src(v,k-1,j+1,i  )-  75.*src(v,k-1,j+1,i+1)
+            + 270.*src(v,k,  j-1,i-1)- 2700.*src(v,k,  j-1,i  )- 450.*src(v,k,  j-1,i+1)
+            -2700.*src(v,k,  j,  i-1)+27000.*src(v,k,  j,  i  )+4500.*src(v,k,  j,  i+1)
+            - 450.*src(v,k,  j+1,i-1)+ 4500.*src(v,k,  j+1,i  )+ 750.*src(v,k,  j+1,i+1)
+            +  45.*src(v,k+1,j-1,i-1)-  450.*src(v,k+1,j-1,i  )-  75.*src(v,k+1,j-1,i+1)
+            - 450.*src(v,k+1,j,  i-1)+ 4500.*src(v,k+1,j,  i  )+ 750.*src(v,k+1,j,  i+1)
+            -  75.*src(v,k+1,j+1,i-1)+  750.*src(v,k+1,j+1,i  )+ 125.*src(v,k+1,j+1,i+1)
+                               )/32768.0;
         }
       }
     }
diff --git a/src/multigrid/multigrid.hpp b/src/multigrid/multigrid.hpp
index 5edf40be5c..8274f8797a 100644
--- a/src/multigrid/multigrid.hpp
+++ b/src/multigrid/multigrid.hpp
@@ -34,10 +34,8 @@ class Mesh;
 class MeshBlock;
 class ParameterInput;
 class Coordinates;
-struct MGCoordinates;
-struct MGOctet;
 
-enum class MGVariable {src, u};
+enum class MGVariable {src, u, coeff};
 enum class MGNormType {max, l1, l2};
 
 constexpr int minth_ = 8;
@@ -61,34 +59,62 @@ struct LogicalLocationHash {
 };
 
 
+//! \class MGCoordinates
+//  \brief Minimum set of coordinate arrays for Multigrid
+
+class MGCoordinates {
+ public:
+  void AllocateMGCoordinates(int nx, int ny, int nz);
+  void CalculateMGCoordinates(const RegionSize &size, int ll, int ngh);
+
+  AthenaArray<Real> x1f, x2f, x3f, x1v, x2v, x3v;
+};
+
+
+//! \class MGOctet
+//  \brief structure containing eight (+ ghost) cells for Mesh Refinement
+
+class MGOctet {
+ public:
+  void Allocate(int nvar, int ncoct, int nccoct, int ncoeff, int nmatrix);
+  LogicalLocation loc;
+  bool fleaf;
+  AthenaArray<Real> u, def, src, uold, coeff, matrix;
+  MGCoordinates coord, ccoord;
+};
+
+
 //! \class Multigrid
 //  \brief Multigrid object containing each MeshBlock and/or the root block
 
 class Multigrid {
  public:
-  Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int invar, int nghost);
+  Multigrid(MultigridDriver *pmd, MeshBlock *pmb, int nghost);
   virtual ~Multigrid();
 
   MGBoundaryValues *pmgbval;
-  // KGF: Both btype=BoundaryQuantity::mggrav and btypef=BoundaryQuantity::mggrav_f (face
+  // KGF: Both btype=BoundaryQuantity::mg and btypef=BoundaryQuantity::mg_faceonly (face
   // neighbors only) are passed to comm function calls in mg_task_list.cpp Only
-  // BoundaryQuantity::mggrav is handled in a case in InitBoundaryData(). Passed directly
+  // BoundaryQuantity::mg is handled in a case in InitBoundaryData(). Passed directly
   // (not through btype) in MGBoundaryValues() ctor
   BoundaryQuantity btype, btypef;
 
   void LoadFinestData(const AthenaArray<Real> &src, int ns, int ngh);
   void LoadSource(const AthenaArray<Real> &src, int ns, int ngh, Real fac);
-  void ApplySourceMask();
+  void LoadCoefficients(const AthenaArray<Real> &coeff, int ngh);
+  void ApplyMask();
   void RestrictFMGSource();
   void RetrieveResult(AthenaArray<Real> &dst, int ns, int ngh);
   void RetrieveDefect(AthenaArray<Real> &dst, int ns, int ngh);
   void ZeroClearData();
   void RestrictBlock();
+  void RestrictCoefficients();
   void ProlongateAndCorrectBlock();
   void FMGProlongateBlock();
   void SmoothBlock(int color);
   void CalculateDefectBlock();
   void CalculateFASRHSBlock();
+  void CalculateMatrixBlock(Real dt);
   void SetFromRootGrid(bool folddata);
   Real CalculateDefectNorm(MGNormType nrm, int n);
   Real CalculateTotal(MGVariable type, int n);
@@ -107,10 +133,11 @@ class Multigrid {
   AthenaArray<Real>& GetCurrentData() { return u_[current_level_]; }
   AthenaArray<Real>& GetCurrentSource() { return src_[current_level_]; }
   AthenaArray<Real>& GetCurrentOldData() { return uold_[current_level_]; }
+  AthenaArray<Real>& GetCurrentCoefficient() { return coeff_[current_level_]; }
 
   // actual implementations of Multigrid operations
   void Restrict(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
-                int il, int iu, int jl, int ju, int kl, int ku, bool th);
+                int nvar, int il, int iu, int jl, int ju, int kl, int ku, bool th);
   void ProlongateAndCorrect(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
     int il, int iu, int jl, int ju, int kl, int ku, int fil, int fjl, int fkl, bool th);
   void FMGProlongate(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
@@ -118,19 +145,25 @@ class Multigrid {
 
   // physics-dependent virtual functions
   virtual void Smooth(AthenaArray<Real> &dst, const AthenaArray<Real> &src,
+                      const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrx,
                       int rlev, int il, int iu, int jl, int ju, int kl, int ku,
                       int color, bool th) = 0;
   virtual void CalculateDefect(AthenaArray<Real> &def, const AthenaArray<Real> &u,
-                        const AthenaArray<Real> &src, int rlev,
-                        int il, int iu, int jl, int ju, int kl, int ku, bool th) = 0;
+               const AthenaArray<Real> &src, const AthenaArray<Real> &coeff,
+               const AthenaArray<Real> &matrix, int rlev, int il, int iu, int jl, int ju,
+               int kl, int ku, bool th) = 0;
   virtual void CalculateFASRHS(AthenaArray<Real> &def, const AthenaArray<Real> &src,
+                 const AthenaArray<Real> &coeff, const AthenaArray<Real> &matrix,
                  int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) = 0;
+  virtual void CalculateMatrix(AthenaArray<Real> &matrix, const AthenaArray<Real> &coeff,
+          Real dt, int rlev, int il, int iu, int jl, int ju, int kl, int ku, bool th) {}
 
   friend class MultigridDriver;
   friend class MultigridTaskList;
   friend class MGBoundaryValues;
   friend class MGGravityBoundaryValues;
   friend class MGGravityDriver;
+  friend class MGCRDiffusionDriver;
 
  protected:
   MultigridDriver *pmy_driver_;
@@ -138,10 +171,10 @@ class Multigrid {
   LogicalLocation loc_;
   RegionSize size_;
   BoundaryFlag mg_block_bcs_[6];
-  int nlevel_, ngh_, nvar_, current_level_;
+  int nlevel_, ngh_, nvar_, ncoeff_, nmatrix_, current_level_;
   Real rdx_, rdy_, rdz_;
   Real defscale_;
-  AthenaArray<Real> *u_, *def_, *src_, *uold_;
+  AthenaArray<Real> *u_, *def_, *src_, *uold_, *coeff_, *matrix_;
   MGCoordinates *coord_, *ccoord_;
 
  private:
@@ -154,28 +187,32 @@ class Multigrid {
 
 class MultigridDriver {
  public:
-  MultigridDriver(Mesh *pm, MGBoundaryFunc *MGBoundary,
-                  MGSourceMaskFunc MGSourceMask, int invar);
+  MultigridDriver(Mesh *pm, MGBoundaryFunc *MGBoundary, MGBoundaryFunc *MGCoeffBoundary,
+                  MGMaskFunc MGSourceMask, MGMaskFunc MGCoeffMask, int invar, int ncoeff,
+                  int nmatrix);
   virtual ~MultigridDriver();
 
   // pure virtual function
-  virtual void Solve(int step) = 0;
+  virtual void Solve(int step, Real dt = 0.0) = 0;
 
   friend class Multigrid;
   friend class MultigridTaskList;
   friend class MGGravity;
   friend class MGBoundaryValues;
   friend class MGGravityBoundaryValues;
+  friend class MGCRDiffusion;
 
  protected:
   void CheckBoundaryFunctions();
   void SubtractAverage(MGVariable type);
-  void SetupMultigrid();
-  void TransferFromBlocksToRoot(bool initflag = false);
-  void FMGProlongate();
+  void SetupMultigrid(Real dt, bool ftrivial);
+  void SetupCoefficients();
+  void TransferFromBlocksToRoot(bool initflag);
   void TransferFromRootToBlocks(bool folddata);
+  void TransferCoefficientFromBlocksToRoot();
   void OneStepToFiner(int nsmooth);
   void OneStepToCoarser(int nsmooth);
+  void FMGProlongate();
   void SolveVCycle(int npresmooth, int npostsmooth);
   void SolveFMGCycle();
   void SolveIterative();
@@ -183,6 +220,7 @@ class MultigridDriver {
 
   virtual void SolveCoarsestGrid();
   Real CalculateDefectNorm(MGNormType nrm, int n);
+  void CalculateMatrix(Real dt);
   Multigrid* FindMultigrid(int tgid);
 
   // octet manipulation functions
@@ -195,22 +233,24 @@ class MultigridDriver {
   void SmoothOctets(int color);
   void ProlongateAndCorrectOctets();
   void FMGProlongateOctets();
-  void SetBoundariesOctets(bool fprolong, bool folddata);
+  void SetBoundariesOctets(bool fprolong, bool folddata, bool fcoeff);
   void SetOctetBoundarySameLevel(AthenaArray<Real> &dst, const AthenaArray<Real> &un,
                        AthenaArray<Real> &uold, const AthenaArray<Real> &unold,
                        AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
-                       int ox1, int ox2, int ox3, bool folddata);
+                       int nvar, int ox1, int ox2, int ox3, bool folddata);
   void SetOctetBoundaryFromCoarser(const AthenaArray<Real> &un,
                        const AthenaArray<Real> &unold, AthenaArray<Real> &cbuf,
-                       AthenaArray<Real> &cbufold, const LogicalLocation &loc,
+                       AthenaArray<Real> &cbufold, int nvar, const LogicalLocation &loc,
                        int ox1, int ox2, int ox3, bool folddata);
   void ApplyPhysicalBoundariesOctet(AthenaArray<Real> &u, const LogicalLocation &loc,
-                                    const MGCoordinates &coord, bool fcbuf);
+                                    const MGCoordinates &coord, bool fcbuf, bool fcoeff);
   void ProlongateOctetBoundaries(AthenaArray<Real> &u, AthenaArray<Real> &uold,
-                                 AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
-                                 const AthenaArray<bool> &ncoarse, bool folddata);
+                      AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
+                      int nvar, const AthenaArray<bool> &ncoarse, bool folddata);
   void SetOctetBoundariesBeforeTransfer(bool folddata);
   void RestrictOctetsBeforeTransfer();
+  virtual void ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
+               AthenaArray<Real> &cbuf, const AthenaArray<bool> &ncoarse);
 
   // for multipole expansion
   void AllocateMultipoleCoefficients();
@@ -221,27 +261,26 @@ class MultigridDriver {
   // small functions
   int GetNumMultigrids() { return nblist_[Globals::my_rank]; }
 
-  // pure virtual functions
-  virtual void ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
-               AthenaArray<Real> &cbuf, const AthenaArray<bool> &ncoarse) = 0;
-
-  int nranks_, nthreads_, nbtotal_, nvar_, mode_;
+  int nranks_, nthreads_, nbtotal_, nvar_, ncoeff_, nmatrix_, mode_;
   int locrootlevel_, nrootlevel_, nmblevel_, ntotallevel_, nreflevel_, maxreflevel_;
   int current_level_, fmglevel_;
-  int *nslist_, *nblist_, *nvlist_, *nvslist_, *nvlisti_, *nvslisti_, *ranklist_;
+  int *nslist_, *nblist_, *nvlist_, *nvslist_, *nvlisti_, *nvslisti_,
+                          *nclist_, *ncslist_, *ranklist_;
   int nrbx1_, nrbx2_, nrbx3_;
   BoundaryFlag mg_mesh_bcs_[6];
   MGBoundaryFunc MGBoundaryFunction_[6];
-  MGSourceMaskFunc srcmask_;
+  MGBoundaryFunc MGCoeffBoundaryFunction_[6];
+  MGMaskFunc srcmask_, coeffmask_;
   Mesh *pmy_mesh_;
   std::vector<Multigrid*> vmg_;
   Multigrid *mgroot_;
-  bool fsubtract_average_, ffas_, needinit_;
+  bool fsubtract_average_, ffas_, redblack_, needinit_, fshowdef_;
   Real last_ave_;
   Real eps_;
-  int niter_;
+  int niter_, npresmooth_, npostsmooth_;
   int os_, oe_;
   int coffset_;
+  int fprolongation_;
 
   // for mesh refinement
   std::vector<MGOctet> *octets_;
@@ -269,29 +308,12 @@ class MultigridDriver {
 };
 
 
-//! \struct MGCoordinates
-//  \brief Minimum set of coordinate arrays for Multigrid
-
-struct MGCoordinates {
- public:
-  void AllocateMGCoordinates(int nx, int ny, int nz);
-  void CalculateMGCoordinates(const RegionSize &size, int ll, int ngh);
-
-  AthenaArray<Real> x1f, x2f, x3f, x1v, x2v, x3v;
-};
-
-
-//! \struct MGOctet
-//  \brief structure containing eight (+ ghost) cells for Mesh Refinement
-
-struct MGOctet {
- public:
-  LogicalLocation loc;
-  bool fleaf;
-  AthenaArray<Real> u, def, src, uold;
-  MGCoordinates coord, ccoord;
-};
-
+inline Real RestrictOne(const AthenaArray<Real> &src, int v, int fi, int fj, int fk) {
+  return 0.125*(src(v, fk,   fj,   fi)+src(v, fk,   fj,   fi+1)
+               +src(v, fk,   fj+1, fi)+src(v, fk,   fj+1, fi+1)
+               +src(v, fk+1, fj,   fi)+src(v, fk+1, fj,   fi+1)
+               +src(v, fk+1, fj+1, fi)+src(v, fk+1, fj+1, fi+1));
+}
 
 
 // Multigrid Boundary functions
diff --git a/src/multigrid/multigrid_driver.cpp b/src/multigrid/multigrid_driver.cpp
index 22348a0d2c..c0d6379fd3 100644
--- a/src/multigrid/multigrid_driver.cpp
+++ b/src/multigrid/multigrid_driver.cpp
@@ -38,14 +38,16 @@
 // constructor, initializes data structures and parameters
 
 MultigridDriver::MultigridDriver(Mesh *pm, MGBoundaryFunc *MGBoundary,
-                                 MGSourceMaskFunc MGSourceMask, int invar) :
+                 MGBoundaryFunc *MGCoeffBoundary, MGMaskFunc MGSourceMask,
+                 MGMaskFunc MGCoeffMask, int invar, int ncoeff, int nmatrix) :
     nranks_(Globals::nranks), nthreads_(pm->num_mesh_threads_), nbtotal_(pm->nbtotal),
-    nvar_(invar), mode_(0), // 0: FMG V(1,1) + iterative, 1: V(1,1) iterative
+    nvar_(invar), ncoeff_(ncoeff), nmatrix_(nmatrix), mode_(0), // 0: FMG+V, 1: V-cycle
     maxreflevel_(pm->multilevel?pm->max_level-pm->root_level:0),
     nrbx1_(pm->nrbx1), nrbx2_(pm->nrbx2), nrbx3_(pm->nrbx3), srcmask_(MGSourceMask),
-    pmy_mesh_(pm), fsubtract_average_(false), ffas_(pm->multilevel), needinit_(true),
-    eps_(-1.0), niter_(-1), coffset_(0), mporder_(-1), nmpcoeff_(0), mpo_(3),
-    autompo_(false), nodipole_(false), nb_rank_(0) {
+    coeffmask_(MGCoeffMask), pmy_mesh_(pm), fsubtract_average_(false),
+    ffas_(pm->multilevel), redblack_(true), needinit_(true), fshowdef_(false), eps_(-1.0),
+    niter_(-1), npresmooth_(1), npostsmooth_(1), coffset_(0), fprolongation_(0),
+    mporder_(-1), nmpcoeff_(0), mpo_(3), autompo_(false), nodipole_(false), nb_rank_(0) {
   std::cout << std::scientific << std::setprecision(15);
 
   if (pmy_mesh_->mesh_size.nx2==1 || pmy_mesh_->mesh_size.nx3==1) {
@@ -65,19 +67,27 @@ MultigridDriver::MultigridDriver(Mesh *pm, MGBoundaryFunc *MGBoundary,
     return;
   }
 
-  for (int i=0; i<6; i++)
-    MGBoundaryFunction_[i]=MGBoundary[i];
+  for (int i=0; i<6; i++) {
+    MGBoundaryFunction_[i] = MGBoundary[i];
+    MGCoeffBoundaryFunction_[i] = MGCoeffBoundary[i];
+  }
 
   ranklist_  = new int[nbtotal_];
-  rootbuf_=new Real[nbtotal_*nvar_*2];
+  int nv = std::max(nvar_*2, ncoeff_);
+  rootbuf_ = new Real[nbtotal_*nv];
   for (int n = 0; n < nbtotal_; ++n)
-    ranklist_[n]=pmy_mesh_->ranklist[n];
+    ranklist_[n] = pmy_mesh_->ranklist[n];
   nslist_  = new int[nranks_];
   nblist_  = new int[nranks_];
   nvlist_  = new int[nranks_];
   nvslist_ = new int[nranks_];
   nvlisti_  = new int[nranks_];
   nvslisti_ = new int[nranks_];
+  if (ncoeff_ > 0) {
+    nclist_  = new int[nranks_];
+    ncslist_ = new int[nranks_];
+  }
+
 
 #ifdef MPI_PARALLEL
   MPI_Comm_dup(MPI_COMM_WORLD, &MPI_COMM_MULTIGRID);
@@ -91,6 +101,20 @@ MultigridDriver::MultigridDriver(Mesh *pm, MGBoundaryFunc *MGBoundary,
     octetbflag_ = new std::vector<bool>[maxreflevel_];
     noctets_ = new int[maxreflevel_]();
     pmaxnoct_ = new int[maxreflevel_]();
+
+    int nth = 1;
+#ifdef OPENMP_PARALLEL
+    nth = omp_get_max_threads();
+#endif
+    cbuf_ = new AthenaArray<Real>[nth];
+    cbufold_ = new AthenaArray<Real>[nth];
+    ncoarse_ = new AthenaArray<bool>[nth];
+    nv = std::max(nvar_, ncoeff_);
+    for (int n = 0; n < nth; ++n) {
+      cbuf_[n].NewAthenaArray(nv,3,3,3);
+      cbufold_[n].NewAthenaArray(nv,3,3,3);
+      ncoarse_[n].NewAthenaArray(3,3,3);
+    }
   }
 }
 
@@ -105,12 +129,19 @@ MultigridDriver::~MultigridDriver() {
   delete [] nvlisti_;
   delete [] nvslisti_;
   delete [] rootbuf_;
+  if (ncoeff_ > 0) {
+    delete [] nclist_;
+    delete [] ncslist_;
+  }
   if (maxreflevel_ > 0) {
     delete [] octets_;
     delete [] octetmap_;
     delete [] octetbflag_;
     delete [] noctets_;
     delete [] pmaxnoct_;
+    delete [] cbuf_;
+    delete [] cbufold_;
+    delete [] ncoarse_;
   }
   if (mporder_ > 0)
     delete [] mpcoeff_;
@@ -120,6 +151,25 @@ MultigridDriver::~MultigridDriver() {
 }
 
 
+//----------------------------------------------------------------------------------------
+//! \fn void MGOctet::Allocate(int nvar, int ncoct, int nccoct, int ncoeff, int nmatrix)
+//  \brief allocate arrays and coordinates in MGOctet
+
+void MGOctet::Allocate(int nvar, int ncoct, int nccoct, int ncoeff, int nmatrix) {
+  u.NewAthenaArray(nvar, ncoct, ncoct, ncoct);
+  uold.NewAthenaArray(nvar, ncoct, ncoct, ncoct);
+  def.NewAthenaArray(nvar, ncoct, ncoct, ncoct);
+  src.NewAthenaArray(nvar, ncoct, ncoct, ncoct);
+  if (ncoeff > 0)
+    coeff.NewAthenaArray(ncoeff, ncoct, ncoct, ncoct);
+  if (nmatrix > 0)
+    matrix.NewAthenaArray(nmatrix, ncoct, ncoct, ncoct);
+  coord.AllocateMGCoordinates(ncoct, ncoct, ncoct);
+  ccoord.AllocateMGCoordinates(nccoct, nccoct, nccoct);
+  return;
+}
+
+
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::CheckBoundaryFunctions()
 //  \brief check boundary functions and set some internal flags.
@@ -289,6 +339,20 @@ void MultigridDriver::CheckBoundaryFunctions() {
       break;
   }
 
+  // check periodic boundary conditions
+  for (int i = 0; i < 6; ++i) {
+    if (pmy_mesh_->mesh_bcs[i] == BoundaryFlag::periodic
+     || mg_mesh_bcs_[i] == BoundaryFlag::periodic) {
+      if (pmy_mesh_->mesh_bcs[i] != mg_mesh_bcs_[i]) {
+        std::stringstream msg;
+        msg << "### FATAL ERROR in MGGravityDriver::CheckBoundaryFunctions" << std::endl
+            << "When periodic boundary condition is set either for" << std::endl
+            << "Multigrid or for the main part, both must be periodic." << std::endl;
+        ATHENA_ERROR(msg);
+      }
+    }
+  }
+
   if (mporder_ >= 0) {
     ffas_ = true;
     fsubtract_average_ = false;
@@ -337,19 +401,19 @@ void MultigridDriver::SubtractAverage(MGVariable type) {
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MultigridDriver::SetupMultigrid()
-//! \brief initialize the source assuming that the source terms are already loaded
+//! \fn void MultigridDriver::SetupMultigrid(Real dt, bool ftrivial)
+//  \brief initialize the source assuming that the source terms are already loaded
 
-void MultigridDriver::SetupMultigrid() {
+void MultigridDriver::SetupMultigrid(Real dt, bool ftrivial) {
   locrootlevel_ = pmy_mesh_->root_level;
   nrootlevel_ = mgroot_->GetNumberOfLevels();
   nmblevel_ = vmg_[0]->GetNumberOfLevels();
   nreflevel_ = pmy_mesh_->current_level - locrootlevel_;
   ntotallevel_ = nrootlevel_ + nmblevel_ + nreflevel_ - 1;
   fmglevel_ = current_level_ = ntotallevel_ - 1;
-  int ncoct = mgroot_->ngh_*2 + 2, nccoct = mgroot_->ngh_*2 + 1;
   os_ = mgroot_->ngh_;
   oe_ = os_+1;
+  const int ncoct = 2 + 2*mgroot_->ngh_, nccoct = 1 + 2*mgroot_->ngh_;
 
   if (pmy_mesh_->amr_updated)
     needinit_ = true;
@@ -368,20 +432,11 @@ void MultigridDriver::SetupMultigrid() {
         octetmap_[l].reserve(noctets_[l]);
         octetbflag_[l].resize(noctets_[l]);
       }
+      for (int o = pmaxnoct_[l]; o < noctets_[l]; ++o)
+        octets_[l][o].Allocate(nvar_, ncoct, nccoct, ncoeff_, nmatrix_);
       noctets_[l] = 0;
     }
     pmy_mesh_->tree.GetMGOctetList(octets_, octetmap_, noctets_);
-    for (int l = 0; l < nreflevel_; ++l) {
-      for (int o = pmaxnoct_[l]; o < noctets_[l]; ++o) {
-        octets_[l][o].u.NewAthenaArray(nvar_, ncoct, ncoct, ncoct);
-        octets_[l][o].def.NewAthenaArray(nvar_, ncoct, ncoct, ncoct);
-        octets_[l][o].src.NewAthenaArray(nvar_, ncoct, ncoct, ncoct);
-        octets_[l][o].coord.AllocateMGCoordinates(ncoct, ncoct, ncoct);
-        octets_[l][o].ccoord.AllocateMGCoordinates(nccoct, nccoct, nccoct);
-        if (ffas_)
-          octets_[l][o].uold.NewAthenaArray(nvar_, ncoct, ncoct, ncoct);
-      }
-    }
   }
 
   if (needinit_) {
@@ -391,7 +446,8 @@ void MultigridDriver::SetupMultigrid() {
         delete [] ranklist_;
         delete [] rootbuf_;
         ranklist_ = new int[pmy_mesh_->nbtotal];
-        rootbuf_ = new Real[pmy_mesh_->nbtotal*nvar_*2];
+        int nv = std::max(nvar_*2, ncoeff_);
+        rootbuf_ = new Real[pmy_mesh_->nbtotal*nv];
       }
       nbtotal_ = pmy_mesh_->nbtotal;
     }
@@ -418,6 +474,12 @@ void MultigridDriver::SetupMultigrid() {
       nvslisti_[n] = nslist_[n]*nvar_;
       nvlisti_[n]  = nblist_[n]*nvar_;
     }
+    if (ncoeff_ > 0) {
+      for (int n = 0; n < nranks_; ++n) {
+        nclist_[n]  = nblist_[n]*ncoeff_;
+        ncslist_[n] = nslist_[n]*ncoeff_;
+      }
+    }
     for (Multigrid* pmg : vmg_) {
       pmg->pmgbval->SearchAndSetNeighbors(pmy_mesh_->tree, ranklist_, nslist_);
       pmg->pmgbval->bcolor_ = 0;
@@ -427,12 +489,10 @@ void MultigridDriver::SetupMultigrid() {
     needinit_ = false;
   }
 
-  if (srcmask_ != nullptr) {
 #pragma omp parallel for num_threads(nthreads_)
-    for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
-      Multigrid *pmg = *itr;
-      pmg->ApplySourceMask();
-    }
+  for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+    Multigrid *pmg = *itr;
+    pmg->ApplyMask();
   }
 
   if (fsubtract_average_)
@@ -444,17 +504,129 @@ void MultigridDriver::SetupMultigrid() {
     CalculateMultipoleCoefficients();
   }
 
-  if (mode_ == 0) { // FMG
+  if (!ftrivial) {
+    if (ncoeff_ > 0)
+      SetupCoefficients();
+    if (nmatrix_ > 0)
+      CalculateMatrix(dt);
+
+    if (mode_ == 0) { // FMG
+#pragma omp parallel for num_threads(nthreads_)
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        Multigrid *pmg = *itr;
+        pmg->RestrictFMGSource();
+      }
+      TransferFromBlocksToRoot(true);
+      RestrictFMGSourceOctets();
+      mgroot_->RestrictFMGSource();
+      current_level_ = 0;
+    }
+  }
+
+  return;
+}
+
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MultigridDiffusionDriver::SetupCoefficients()
+//! \brief Setup coefficients
+
+void MultigridDriver::SetupCoefficients() {
 #pragma omp parallel for num_threads(nthreads_)
+  for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+    Multigrid *pmg = *itr;
+    pmg->RestrictCoefficients();
+  }
+  TransferCoefficientFromBlocksToRoot();
+  if (nreflevel_ > 0) {
+    const int &ngh = mgroot_->ngh_;
+    for (int l = nreflevel_ - 1; l >= 1; --l) {  // fine octets to coarse octets
+#pragma omp parallel for num_threads(nthreads_)
+      for (int o = 0; o < noctets_[l]; ++o) {
+        MGOctet &foct = octets_[l][o];
+        const LogicalLocation &loc = foct.loc;
+        LogicalLocation cloc;
+        cloc.lx1 = (loc.lx1 >> 1);
+        cloc.lx2 = (loc.lx2 >> 1);
+        cloc.lx3 = (loc.lx3 >> 1);
+        cloc.level = loc.level - 1;
+        int oid = octetmap_[l-1][cloc];
+        int oi = (static_cast<int>(loc.lx1) & 1) + ngh;
+        int oj = (static_cast<int>(loc.lx2) & 1) + ngh;
+        int ok = (static_cast<int>(loc.lx3) & 1) + ngh;
+        MGOctet &coct = octets_[l-1][oid];
+        for (int v = 0; v < ncoeff_; ++v)
+          coct.coeff(v, ok, oj, oi) = RestrictOne(foct.coeff, v, ngh, ngh, ngh);
+      }
+    }
+#pragma omp parallel for num_threads(nthreads_)
+    for (int o = 0; o < noctets_[0]; ++o) { // octets to the root grid
+      MGOctet &oct = octets_[0][o];
+      const LogicalLocation &loc = oct.loc;
+      int lx1 = static_cast<int>(loc.lx1) + mgroot_->ngh_;
+      int lx2 = static_cast<int>(loc.lx2) + mgroot_->ngh_;
+      int lx3 = static_cast<int>(loc.lx3) + mgroot_->ngh_;
+      for (int v = 0; v < ncoeff_; ++v)
+        mgroot_->coeff_[mgroot_->nlevel_-1](v, lx3, lx2, lx1)
+          = RestrictOne(oct.coeff, v, ngh, ngh, ngh);
+    }
+  }
+  mgroot_->RestrictCoefficients();
+
+  // Block boundaries
+#pragma omp parallel num_threads(nthreads_)
+  {
+    for (int lev = nmblevel_ - 2; lev >= 1; lev--) {
+#pragma omp for nowait
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        Multigrid *pmg = *itr;
+        pmg->current_level_ = lev;
+        pmg->pmgbval->StartReceivingMultigrid(BoundaryQuantity::mg_coeff, false);
+      }
+#pragma omp for nowait
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        Multigrid *pmg = *itr;
+        pmg->pmgbval->SendMultigridBoundaryBuffers(BoundaryQuantity::mg_coeff, false);
+      }
+#pragma omp for nowait
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        Multigrid *pmg = *itr;
+        pmg->pmgbval->ReceiveMultigridCoefficientBoundaryBuffers();
+      }
+#pragma omp for nowait
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        Multigrid *pmg = *itr;
+        pmg->pmgbval->ClearBoundaryMultigrid(BoundaryQuantity::mg_coeff);
+      }
+      if (nreflevel_ > 0) {
+#pragma omp for nowait
+        for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+          Multigrid *pmg = *itr;
+          pmg->pmgbval->ProlongateMultigridBoundaries(false, true);
+        }
+      }
+#pragma omp for nowait
+      for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+        Multigrid *pmg = *itr;
+        pmg->pmgbval->ApplyPhysicalBoundaries(0, true);
+      }
+    }
+#pragma omp for nowait
     for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
       Multigrid *pmg = *itr;
-      pmg->RestrictFMGSource();
+      pmg->current_level_ = nmblevel_ - 1;
     }
-    TransferFromBlocksToRoot(true);
-    RestrictFMGSourceOctets();
-    mgroot_->RestrictFMGSource();
-    current_level_ = 0;
   }
+  for (int lev = 0; lev < nreflevel_; lev++) { // octets
+    current_level_ = nrootlevel_ + lev;
+    SetBoundariesOctets(false, false, true);
+  }
+  for (int lev = nrootlevel_ - 1; lev >= 0; lev--) {
+    mgroot_->current_level_ = lev;
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, true);
+  }
+  mgroot_->current_level_ = nrootlevel_ - 1;
 
   return;
 }
@@ -516,11 +688,12 @@ void MultigridDriver::TransferFromBlocksToRoot(bool initflag) {
       int oi = (i&1) + ngh;
       int oj = (j&1) + ngh;
       int ok = (k&1) + ngh;
+      MGOctet &oct = octets_[olev][oid];
       for (int v = 0; v < nvar_; ++v)
-        octets_[olev][oid].src(v,ok,oj,oi) = rootbuf_[n*nv+v];
+        oct.src(v,ok,oj,oi) = rootbuf_[n*nv+v];
       if (ffas_ && !initflag) {
         for (int v = 0; v < nvar_; ++v)
-          octets_[olev][oid].u(v,ok,oj,oi) = rootbuf_[n*nv+nvar_+v];
+          oct.u(v,ok,oj,oi) = rootbuf_[n*nv+nvar_+v];
       }
     }
   }
@@ -548,6 +721,59 @@ void MultigridDriver::TransferFromRootToBlocks(bool folddata) {
 }
 
 
+//----------------------------------------------------------------------------------------
+//! \fn void MultigridDriver::TransferCoefficientFromBlocksToRoot()
+//  \brief collect coefficient on the coarsest level on MB and transfer to the root grid
+
+void MultigridDriver::TransferCoefficientFromBlocksToRoot() {
+  int ngh = mgroot_->ngh_;
+#pragma omp parallel for num_threads(nthreads_)
+  for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+    Multigrid *pmg = *itr;
+    for (int v = 0; v < ncoeff_; ++v)
+      rootbuf_[pmg->pmy_block_->gid*ncoeff_+v]=pmg->GetCoarsestData(MGVariable::coeff, v);
+  }
+
+#ifdef MPI_PARALLEL
+  if (nb_rank_ > 0) // every rank has the same number of MeshBlocks
+    MPI_Allgather(MPI_IN_PLACE, nb_rank_*ncoeff_, MPI_ATHENA_REAL,
+                  rootbuf_, nb_rank_*ncoeff_, MPI_ATHENA_REAL, MPI_COMM_MULTIGRID);
+  else
+    MPI_Allgatherv(MPI_IN_PLACE, nblist_[Globals::my_rank]*ncoeff_, MPI_ATHENA_REAL,
+                   rootbuf_, nclist_, ncslist_, MPI_ATHENA_REAL, MPI_COMM_MULTIGRID);
+#endif
+
+#pragma omp parallel for num_threads(nthreads_)
+  for (int n = 0; n < nbtotal_; ++n) {
+    const LogicalLocation &loc=pmy_mesh_->loclist[n];
+    int i = static_cast<int>(loc.lx1);
+    int j = static_cast<int>(loc.lx2);
+    int k = static_cast<int>(loc.lx3);
+    if (loc.level == locrootlevel_) {
+      for (int v = 0; v < ncoeff_; ++v)
+        mgroot_->SetData(MGVariable::coeff, v, k, j, i, rootbuf_[n*ncoeff_+v]);
+    } else {
+      LogicalLocation oloc;
+      oloc.lx1 = (loc.lx1 >> 1);
+      oloc.lx2 = (loc.lx2 >> 1);
+      oloc.lx3 = (loc.lx3 >> 1);
+      oloc.level = loc.level - 1;
+      int olev = oloc.level - locrootlevel_;
+      int oid = octetmap_[olev][oloc];
+      int oi = (i&1) + ngh;
+      int oj = (j&1) + ngh;
+      int ok = (k&1) + ngh;
+      MGOctet &oct = octets_[olev][oid];
+      for (int v = 0; v < ncoeff_; ++v)
+        oct.coeff(v,ok,oj,oi) = rootbuf_[n*ncoeff_+v];
+    }
+  }
+
+  return;
+}
+
+
+
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::FMGProlongate()
 //! \brief Prolongation for FMG Cycle
@@ -555,7 +781,7 @@ void MultigridDriver::TransferFromRootToBlocks(bool folddata) {
 void MultigridDriver::FMGProlongate() {
   int flag=0;
   if (current_level_ == nrootlevel_ + nreflevel_ - 1) {
-    mgroot_->pmgbval->ApplyPhysicalBoundaries();
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     TransferFromRootToBlocks(false);
     flag=1;
   }
@@ -564,12 +790,12 @@ void MultigridDriver::FMGProlongate() {
     mgtlist_->DoTaskListOneStage(this);
   } else if (current_level_ >= nrootlevel_ - 1) { // root to octets
     if (current_level_ == nrootlevel_ - 1)
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
+      mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     else
-      SetBoundariesOctets(true, false);
+      SetBoundariesOctets(true, false, false);
     FMGProlongateOctets();
   } else { // root grid
-    mgroot_->pmgbval->ApplyPhysicalBoundaries();
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     mgroot_->FMGProlongateBlock();
   }
   current_level_++;
@@ -586,7 +812,7 @@ void MultigridDriver::OneStepToFiner(int nsmooth) {
   int ngh=mgroot_->ngh_;
   int flag=0;
   if (current_level_ == nrootlevel_ + nreflevel_ - 1) {
-    mgroot_->pmgbval->ApplyPhysicalBoundaries();
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     TransferFromRootToBlocks(ffas_);
     flag=1;
   }
@@ -597,26 +823,30 @@ void MultigridDriver::OneStepToFiner(int nsmooth) {
     current_level_++;
   } else if (current_level_ >= nrootlevel_ - 1) { // non uniform octets
     if (current_level_ == nrootlevel_ - 1)
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
+      mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     else
-      SetBoundariesOctets(true, ffas_);
+      SetBoundariesOctets(true, ffas_, false);
     ProlongateAndCorrectOctets();
     current_level_++;
     for (int n = 0; n < nsmooth; ++n) {
-      SetBoundariesOctets(false, false);
-      SmoothOctets(0);
-      SetBoundariesOctets(false, false);
-      SmoothOctets(1);
+      SetBoundariesOctets(false, false, false);
+      SmoothOctets(coffset_);
+      if (redblack_) {
+        SetBoundariesOctets(false, false, false);
+        SmoothOctets(1-coffset_);
+      }
     }
   } else { // root grid
-    mgroot_->pmgbval->ApplyPhysicalBoundaries();
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     mgroot_->ProlongateAndCorrectBlock();
     current_level_++;
     for (int n = 0; n < nsmooth; ++n) {
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
-      mgroot_->SmoothBlock(0);
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
-      mgroot_->SmoothBlock(1);
+      mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
+      mgroot_->SmoothBlock(coffset_);
+      if (redblack_) {
+        mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
+        mgroot_->SmoothBlock(1-coffset_);
+      }
     }
   }
 
@@ -634,7 +864,7 @@ void MultigridDriver::OneStepToCoarser(int nsmooth) {
     mgtlist_->SetMGTaskListToCoarser(nsmooth, ngh);
     mgtlist_->DoTaskListOneStage(this);
     if (current_level_ == nrootlevel_ + nreflevel_) {
-      TransferFromBlocksToRoot();
+      TransferFromBlocksToRoot(false);
       if (!ffas_) {
         mgroot_->ZeroClearData();
         if (nreflevel_ > 0)
@@ -642,16 +872,18 @@ void MultigridDriver::OneStepToCoarser(int nsmooth) {
       }
     }
   } else if (current_level_ > nrootlevel_-1) { // refined octets
-    SetBoundariesOctets(false, false);
+    SetBoundariesOctets(false, false, false);
     if (ffas_ && current_level_ < fmglevel_) {
       StoreOldDataOctets();
       CalculateFASRHSOctets();
     }
     for (int n=0; n<nsmooth; ++n) {
-      SmoothOctets(0);
-      SetBoundariesOctets(false, false);
-      SmoothOctets(1);
-      SetBoundariesOctets(false, false);
+      SmoothOctets(coffset_);
+      SetBoundariesOctets(false, false, false);
+      if (redblack_) {
+        SmoothOctets(1-coffset_);
+        SetBoundariesOctets(false, false, false);
+      }
     }
     RestrictOctets();
     if (!ffas_ && current_level_ == fmglevel_) {
@@ -659,16 +891,18 @@ void MultigridDriver::OneStepToCoarser(int nsmooth) {
       ZeroClearOctets();
     }
   } else { // uniform root grid
-    mgroot_->pmgbval->ApplyPhysicalBoundaries();
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     if (ffas_ && current_level_ < fmglevel_) {
       mgroot_->StoreOldData();
       mgroot_->CalculateFASRHSBlock();
     }
     for (int n = 0; n < nsmooth; ++n) {
-      mgroot_->SmoothBlock(0);
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
-      mgroot_->SmoothBlock(1);
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
+      mgroot_->SmoothBlock(coffset_);
+      mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
+      if (redblack_) {
+        mgroot_->SmoothBlock(1-coffset_);
+        mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
+      }
     }
     mgroot_->RestrictBlock();
   }
@@ -701,7 +935,7 @@ void MultigridDriver::SolveVCycle(int npresmooth, int npostsmooth) {
 
 void MultigridDriver::SolveFMGCycle() {
   for (fmglevel_ = 0; fmglevel_ < ntotallevel_; fmglevel_++) {
-    SolveVCycle(1, 1);
+    SolveVCycle(npresmooth_, npostsmooth_);
     if (fmglevel_ != ntotallevel_-1)
       FMGProlongate();
   }
@@ -722,23 +956,38 @@ void MultigridDriver::SolveFMGCycle() {
 
 void MultigridDriver::SolveIterative() {
   int n = 0;
-  Real def = 0.0;
-  for (int v = 0; v < nvar_; ++v)
+  Real def = 0.0, defmax = 0.0;
+  for (int v = 0; v < nvar_; ++v) {
     def += CalculateDefectNorm(MGNormType::l2, v);
+//    defmax = std::max(defmax, CalculateDefectNorm(MGNormType::max, v));
+  }
+//  if (Globals::my_rank == 0)
+//    std::cout << "initial defect " << def << " max " << defmax << std::endl;
   while (def > eps_) {
-    SolveVCycle(1, 1);
-    Real olddef = def;
-    def = 0.0;
-    for (int v = 0; v < nvar_; ++v)
+    SolveVCycle(npresmooth_, npostsmooth_);
+    Real olddef = def, oldmax = defmax;
+    def = 0.0, defmax = 0.0;
+    for (int v = 0; v < nvar_; ++v) {
       def += CalculateDefectNorm(MGNormType::l2, v);
-    //if (Globals::my_rank == 0)
-    //  std::cout << "niter " << n << " def " << def << std::endl;
-    if (def/olddef > 0.8) {
+//      defmax = std::max(defmax, CalculateDefectNorm(MGNormType::max, v));
+    }
+//    if (Globals::my_rank == 0)
+//      std::cout << "[debug] niter " << n << " def " << def << " convergence factor "
+//                << def/olddef<< " defmax  "<< defmax << " cf "
+//                <<  defmax/oldmax << std::endl;
+    if (def/olddef > 0.9) {
       if (eps_ == 0.0) break;
       if (Globals::my_rank == 0)
         std::cout << "### Warning in MultigridDriver::SolveIterative" << std::endl
                   << "Slow multigrid convergence : defect norm = " << def
                   << ", convergence factor = " << def/olddef << "." << std::endl;
+      if (def/olddef > 1.0) {
+        if (Globals::my_rank == 0)
+          std::cout << "### Warning in MultigridDriver::SolveIterative" << std::endl
+                    << "Multigrid is diverging: defect norm = " << def
+                    << ", convergence factor = " << def/olddef << "." << std::endl;
+        break;
+      }
     }
     if (n > 100) {
       if (Globals::my_rank == 0) {
@@ -763,11 +1012,14 @@ void MultigridDriver::SolveIterative() {
 
 void MultigridDriver::SolveIterativeFixedTimes() {
   for (int n = 0; n < niter_; ++n)
-    SolveVCycle(1, 1);
+    SolveVCycle(npresmooth_, npostsmooth_);
   if (fsubtract_average_)
     SubtractAverage(MGVariable::u);
+  Real def = 0.0;
   for (int v = 0; v < nvar_; ++v)
-    CalculateDefectNorm(MGNormType::l2, v);
+    def += CalculateDefectNorm(MGNormType::l2, v);
+  if (fshowdef_ && Globals::my_rank == 0)
+    std::cout << "Multigrid defect L2-norm : " << def << std::endl;
 
   return;
 }
@@ -782,7 +1034,7 @@ void MultigridDriver::SolveCoarsestGrid() {
             >> (nrootlevel_-1));
   if (fsubtract_average_ && ni == 1) { // trivial case - all zero
     if (ffas_) {
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
+      mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
       mgroot_->StoreOldData();
     }
     mgroot_->ZeroClearData();
@@ -796,16 +1048,18 @@ void MultigridDriver::SolveCoarsestGrid() {
         mgroot_->SubtractAverage(MGVariable::u, v, ave);
       }
     }
-    mgroot_->pmgbval->ApplyPhysicalBoundaries();
+    mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
     if (ffas_) {
       mgroot_->StoreOldData();
       mgroot_->CalculateFASRHSBlock();
     }
     for (int i = 0; i < ni; ++i) { // iterate ni times
-      mgroot_->SmoothBlock(0);
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
-      mgroot_->SmoothBlock(1);
-      mgroot_->pmgbval->ApplyPhysicalBoundaries();
+      mgroot_->SmoothBlock(coffset_);
+      mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
+      if (redblack_) {
+        mgroot_->SmoothBlock(1-coffset_);
+        mgroot_->pmgbval->ApplyPhysicalBoundaries(0, false);
+      }
     }
     if (fsubtract_average_) {
       Real vol=(mgroot_->size_.x1max-mgroot_->size_.x1min)
@@ -883,8 +1137,9 @@ void MultigridDriver::CalculateOctetCoordinates() {
   csize.nx1 = 1, csize.nx2 = 1, csize.nx3 = 1;
 #pragma omp parallel for num_threads(nthreads_)
   for (int o = 0; o < noctets_[0]; ++o) {
+    MGOctet &oct = octets_[0][o];
     MGCoordinates &coord = mgroot_->coord_[mgroot_->nlevel_-1];
-    LogicalLocation &loc = octets_[0][o].loc;
+    LogicalLocation &loc = oct.loc;
     int i = static_cast<int>(loc.lx1) + ngh;
     int j = static_cast<int>(loc.lx2) + ngh;
     int k = static_cast<int>(loc.lx3) + ngh;
@@ -894,13 +1149,14 @@ void MultigridDriver::CalculateOctetCoordinates() {
     size.x2max = csize.x2max = coord.x2f(j+1);
     size.x3min = csize.x3min = coord.x3f(k);
     size.x3max = csize.x3max = coord.x3f(k+1);
-    octets_[0][o].coord.CalculateMGCoordinates(size, 0, ngh);
-    octets_[0][o].ccoord.CalculateMGCoordinates(csize, 0, ngh);
+    oct.coord.CalculateMGCoordinates(size, 0, ngh);
+    oct.ccoord.CalculateMGCoordinates(csize, 0, ngh);
   }
   for (int l = 1; l < nreflevel_; l++) {
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[l]; ++o) {
-      LogicalLocation &loc = octets_[l][o].loc;
+      MGOctet &oct = octets_[l][o];
+      LogicalLocation &loc = oct.loc;
       LogicalLocation cloc;
       cloc.lx1 = (loc.lx1 >> 1);
       cloc.lx2 = (loc.lx2 >> 1);
@@ -917,8 +1173,8 @@ void MultigridDriver::CalculateOctetCoordinates() {
       size.x2max = csize.x2max = coord.x2f(j+1);
       size.x3min = csize.x3min = coord.x3f(k);
       size.x3max = csize.x3max = coord.x3f(k+1);
-      octets_[l][o].coord.CalculateMGCoordinates(size, 0, ngh);
-      octets_[l][o].ccoord.CalculateMGCoordinates(csize, 0, ngh);
+      oct.coord.CalculateMGCoordinates(size, 0, ngh);
+      oct.ccoord.CalculateMGCoordinates(csize, 0, ngh);
     }
   }
 }
@@ -934,9 +1190,8 @@ void MultigridDriver::RestrictFMGSourceOctets() {
     for (int l = nreflevel_ - 1; l >= 1; --l) {  // fine octets to coarse octets
 #pragma omp parallel for num_threads(nthreads_)
       for (int o = 0; o < noctets_[l]; ++o) {
-        AthenaArray<Real> cbuf;
-        cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-        const LogicalLocation &loc = octets_[l][o].loc;
+        MGOctet &foct = octets_[l][o];
+        const LogicalLocation &loc = foct.loc;
         LogicalLocation cloc;
         cloc.lx1 = (loc.lx1 >> 1);
         cloc.lx2 = (loc.lx2 >> 1);
@@ -946,21 +1201,19 @@ void MultigridDriver::RestrictFMGSourceOctets() {
         int oi = (static_cast<int>(loc.lx1) & 1) + ngh;
         int oj = (static_cast<int>(loc.lx2) & 1) + ngh;
         int ok = (static_cast<int>(loc.lx3) & 1) + ngh;
-        mgroot_->Restrict(cbuf, octets_[l][o].src, ngh, ngh, ngh, ngh, ngh, ngh, false);
+        MGOctet &coct = octets_[l-1][oid];
         for (int v = 0; v < nvar_; ++v)
-          octets_[l-1][oid].src(v, ok, oj, oi) = cbuf(v, ngh, ngh, ngh);
+          coct.src(v, ok, oj, oi) = RestrictOne(foct.src, v, ngh, ngh, ngh);
       }
     }
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[0]; ++o) { // octets to the root grid
-      AthenaArray<Real> cbuf;
-      cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-      const LogicalLocation &loc = octets_[0][o].loc;
-      mgroot_->Restrict(cbuf, octets_[0][o].src, ngh, ngh, ngh, ngh, ngh, ngh, false);
+      MGOctet &oct = octets_[0][o];
+      const LogicalLocation &loc = oct.loc;
       for (int v = 0; v < nvar_; ++v)
         mgroot_->SetData(MGVariable::src, v, static_cast<int>(loc.lx3),
                          static_cast<int>(loc.lx2), static_cast<int>(loc.lx1),
-                         cbuf(v, ngh, ngh, ngh));
+                         RestrictOne(oct.src, v, ngh, ngh, ngh));
     }
   }
 
@@ -979,9 +1232,8 @@ void MultigridDriver::RestrictOctets() {
   if (lev >= 1) { // fine octets to coarse octets
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[lev]; ++o) {
-      AthenaArray<Real> cbuf;
-      cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-      const LogicalLocation &loc = octets_[lev][o].loc;
+      MGOctet &foct = octets_[lev][o];
+      const LogicalLocation &loc = foct.loc;
       LogicalLocation cloc;
       cloc.lx1 = (loc.lx1 >> 1);
       cloc.lx2 = (loc.lx2 >> 1);
@@ -991,35 +1243,33 @@ void MultigridDriver::RestrictOctets() {
       int oi = (static_cast<int>(loc.lx1) & 1) + ngh;
       int oj = (static_cast<int>(loc.lx2) & 1) + ngh;
       int ok = (static_cast<int>(loc.lx3) & 1) + ngh;
-      mgroot_->CalculateDefect(octets_[lev][o].def, octets_[lev][o].u,
-                        octets_[lev][o].src, lev+1, os_, oe_, os_, oe_, os_, oe_, false);
-      mgroot_->Restrict(cbuf, octets_[lev][o].def, ngh, ngh, ngh, ngh, ngh, ngh, false);
+      MGOctet &coct = octets_[lev-1][oid];
+      mgroot_->CalculateDefect(foct.def, foct.u, foct.src, foct.coeff, foct.matrix,
+                               lev+1, os_, oe_, os_, oe_, os_, oe_, false);
       for (int v = 0; v < nvar_; ++v)
-        octets_[lev-1][oid].src(v, ok, oj, oi) = cbuf(v, ngh, ngh, ngh);
+        coct.src(v, ok, oj, oi) = RestrictOne(foct.def, v, ngh, ngh, ngh);
       if (ffas_) {
-        mgroot_->Restrict(cbuf, octets_[lev][o].u, ngh, ngh, ngh, ngh, ngh, ngh, false);
         for (int v = 0; v < nvar_; ++v)
-          octets_[lev-1][oid].u(v, ok, oj, oi) = cbuf(v, ngh, ngh, ngh);
+          coct.u(v, ok, oj, oi) = RestrictOne(foct.u, v, ngh, ngh, ngh);
       }
     }
   } else { // octets to the root grid
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[0]; ++o) {
-      AthenaArray<Real> cbuf;
-      cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-      const LogicalLocation &loc = octets_[0][o].loc;
+      MGOctet &oct = octets_[0][o];
+      const LogicalLocation &loc = oct.loc;
       int ri = static_cast<int>(loc.lx1);
       int rj = static_cast<int>(loc.lx2);
       int rk = static_cast<int>(loc.lx3);
-      mgroot_->CalculateDefect(octets_[0][o].def, octets_[0][o].u,
-                               octets_[0][o].src, 1, os_, oe_, os_, oe_, os_, oe_, false);
-      mgroot_->Restrict(cbuf, octets_[0][o].def, ngh, ngh, ngh, ngh, ngh, ngh, false);
+      mgroot_->CalculateDefect(oct.def, oct.u, oct.src, oct.coeff, oct.matrix,
+                               1, os_, oe_, os_, oe_, os_, oe_, false);
       for (int v = 0; v < nvar_; ++v)
-        mgroot_->SetData(MGVariable::src, v, rk, rj, ri, cbuf(v, ngh, ngh, ngh));
+        mgroot_->SetData(MGVariable::src, v, rk, rj, ri,
+                         RestrictOne(oct.def, v, ngh, ngh, ngh));
       if (ffas_) {
-        mgroot_->Restrict(cbuf, octets_[0][o].u, ngh, ngh, ngh, ngh, ngh, ngh, false);
         for (int v = 0; v < nvar_; ++v)
-          mgroot_->SetData(MGVariable::u, v, rk, rj, ri, cbuf(v, ngh, ngh, ngh));
+          mgroot_->SetData(MGVariable::u, v, rk, rj, ri,
+                           RestrictOne(oct.u, v, ngh, ngh, ngh));
       }
     }
   }
@@ -1028,6 +1278,33 @@ void MultigridDriver::RestrictOctets() {
 }
 
 
+//----------------------------------------------------------------------------------------
+//! \fn void MultigridDriver::CalculateMatrix(Real dt)
+//! \brief Calculate Matrix elements
+
+void MultigridDriver::CalculateMatrix(Real dt) {
+#pragma omp parallel for num_threads(nthreads_)
+  for (auto itr = vmg_.begin(); itr < vmg_.end(); itr++) {
+    Multigrid *pmg = *itr;
+    pmg->CalculateMatrixBlock(dt);
+  }
+  if (nreflevel_ > 0) {
+    const int &ngh = mgroot_->ngh_;
+    for (int l = nreflevel_ - 1; l >= 0; --l) {  // fine octets to coarse octets
+#pragma omp parallel for num_threads(nthreads_)
+      for (int o = 0; o < noctets_[l]; ++o) {
+        MGOctet &oct = octets_[l][o];
+        mgroot_->CalculateMatrix(oct.matrix, oct.coeff, dt, l+1,
+                          os_, oe_, os_, oe_, os_, oe_, false);
+      }
+    }
+  }
+  mgroot_->CalculateMatrixBlock(dt);
+
+  return;
+}
+
+
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::ZeroClearOctets()
 //! \brief zero clear the data in all the octets
@@ -1052,9 +1329,10 @@ void MultigridDriver::StoreOldDataOctets() {
   int lev = current_level_ - nrootlevel_;
 
 #pragma omp parallel for num_threads(nthreads_)
-  for (int o = 0; o < noctets_[lev]; ++o)
-    memcpy(octets_[lev][o].uold.data(), octets_[lev][o].u.data(),
-           octets_[lev][o].u.GetSizeInBytes());
+  for (int o = 0; o < noctets_[lev]; ++o) {
+    MGOctet &oct = octets_[lev][o];
+    memcpy(oct.uold.data(), oct.u.data(), oct.u.GetSizeInBytes());
+  }
 
   return;
 }
@@ -1067,10 +1345,11 @@ void MultigridDriver::CalculateFASRHSOctets() {
   int lev = current_level_ - nrootlevel_;
 
 #pragma omp parallel for num_threads(nthreads_)
-  for (int o = 0; o < noctets_[lev]; ++o)
-    mgroot_->CalculateFASRHS(octets_[lev][o].src, octets_[lev][o].u,
+  for (int o = 0; o < noctets_[lev]; ++o) {
+    MGOctet &oct = octets_[lev][o];
+    mgroot_->CalculateFASRHS(oct.src, oct.u, oct.coeff, oct.matrix,
                              lev+1, os_, oe_, os_, oe_, os_, oe_, false);
-
+  }
   return;
 }
 
@@ -1082,9 +1361,11 @@ void MultigridDriver::SmoothOctets(int color) {
   int lev = current_level_ - nrootlevel_;
 
 #pragma omp parallel for num_threads(nthreads_)
-  for (int o = 0; o < noctets_[lev]; ++o)
-    mgroot_->Smooth(octets_[lev][o].u, octets_[lev][o].src,
+  for (int o = 0; o < noctets_[lev]; ++o) {
+    MGOctet &oct = octets_[lev][o];
+    mgroot_->Smooth(oct.u, oct.src, oct.coeff, oct.matrix,
                     lev+1, os_, oe_, os_, oe_, os_, oe_, color, false);
+  }
   return;
 }
 
@@ -1104,9 +1385,13 @@ void MultigridDriver::ProlongateAndCorrectOctets() {
     const AthenaArray<Real> &uold = mgroot_->GetCurrentOldData();
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[0]; ++o) {
-      AthenaArray<Real> cbuf;
-      cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-      const LogicalLocation &loc = octets_[0][o].loc;
+      int th = 0;
+#ifdef OPENMP_PARALLEL
+      th = omp_get_thread_num();
+#endif
+      AthenaArray<Real> &cbuf = cbuf_[th];
+      MGOctet & oct = octets_[0][o];
+      const LogicalLocation &loc = oct.loc;
       int ri = static_cast<int>(loc.lx1) + ngh - 1;
       int rj = static_cast<int>(loc.lx2) + ngh - 1;
       int rk = static_cast<int>(loc.lx3) + ngh - 1;
@@ -1120,19 +1405,23 @@ void MultigridDriver::ProlongateAndCorrectOctets() {
             }
           }
         }
-        mgroot_->ProlongateAndCorrect(octets_[0][o].u, cbuf,
+        mgroot_->ProlongateAndCorrect(oct.u, cbuf,
                               ngh, ngh, ngh, ngh, ngh, ngh, ngh, ngh, ngh, false);
       } else {
-        mgroot_->ProlongateAndCorrect(octets_[0][o].u, u,
+        mgroot_->ProlongateAndCorrect(oct.u, u,
                               ri+1, ri+1, rj+1, rj+1, rk+1, rk+1, ngh, ngh, ngh, false);
       }
     }
   } else { // from coarse octets to fine octets
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[flev]; ++o) {
-      AthenaArray<Real> cbuf;
-      cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-      const LogicalLocation &loc = octets_[flev][o].loc;
+      int th = 0;
+#ifdef OPENMP_PARALLEL
+      th = omp_get_thread_num();
+#endif
+      AthenaArray<Real> &cbuf = cbuf_[th];
+      MGOctet &foct = octets_[flev][o];
+      const LogicalLocation &loc = foct.loc;
       LogicalLocation cloc;
       cloc.lx1 = (loc.lx1 >> 1);
       cloc.lx2 = (loc.lx2 >> 1);
@@ -1142,8 +1431,9 @@ void MultigridDriver::ProlongateAndCorrectOctets() {
       int ci = (static_cast<int>(loc.lx1) & 1) + ngh - 1;
       int cj = (static_cast<int>(loc.lx2) & 1) + ngh - 1;
       int ck = (static_cast<int>(loc.lx3) & 1) + ngh - 1;
-      const AthenaArray<Real> &uc = octets_[clev][cid].u;
-      const AthenaArray<Real> &ucold = octets_[clev][cid].uold;
+      MGOctet &coct = octets_[clev][cid];
+      const AthenaArray<Real> &uc = coct.u;
+      const AthenaArray<Real> &ucold = coct.uold;
       if (ffas_) {
         for (int v = 0; v < nvar_; ++v) {
           for (int k = 0; k <= 2; ++k) {
@@ -1153,10 +1443,10 @@ void MultigridDriver::ProlongateAndCorrectOctets() {
             }
           }
         }
-        mgroot_->ProlongateAndCorrect(octets_[flev][o].u, cbuf,
+        mgroot_->ProlongateAndCorrect(foct.u, cbuf,
                               ngh, ngh, ngh, ngh, ngh, ngh, ngh, ngh, ngh, false);
       } else {
-        mgroot_->ProlongateAndCorrect(octets_[flev][o].u, uc,
+        mgroot_->ProlongateAndCorrect(foct.u, uc,
                               ci+1, ci+1, cj+1, cj+1, ck+1, ck+1, ngh, ngh, ngh, false);
       }
     }
@@ -1178,17 +1468,19 @@ void MultigridDriver::FMGProlongateOctets() {
   if (flev == 0) {  // from root to octets
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[0]; ++o) {
-      const LogicalLocation &loc = octets_[0][o].loc;
+      MGOctet &oct = octets_[0][o];
+      const LogicalLocation &loc = oct.loc;
       int ri = static_cast<int>(loc.lx1) + ngh;
       int rj = static_cast<int>(loc.lx2) + ngh;
       int rk = static_cast<int>(loc.lx3) + ngh;
-      mgroot_->FMGProlongate(octets_[0][o].u, mgroot_->GetCurrentData(),
+      mgroot_->FMGProlongate(oct.u, mgroot_->GetCurrentData(),
                              ri, ri, rj, rj, rk, rk, ngh, ngh, ngh, false);
     }
   } else { // from coarse octets to fine octets
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[flev]; ++o) {
-      const LogicalLocation &loc = octets_[flev][o].loc;
+      MGOctet &foct = octets_[flev][o];
+      const LogicalLocation &loc = foct.loc;
       LogicalLocation cloc;
       cloc.lx1 = (loc.lx1 >> 1);
       cloc.lx2 = (loc.lx2 >> 1);
@@ -1198,7 +1490,8 @@ void MultigridDriver::FMGProlongateOctets() {
       int ci = (static_cast<int>(loc.lx1) & 1) + ngh;
       int cj = (static_cast<int>(loc.lx2) & 1) + ngh;
       int ck = (static_cast<int>(loc.lx3) & 1) + ngh;
-      mgroot_->FMGProlongate(octets_[flev][o].u, octets_[clev][cid].u,
+      MGOctet &coct = octets_[clev][cid];
+      mgroot_->FMGProlongate(foct.u, coct.u,
                              ci, ci, cj, cj, ck, ck, ngh, ngh, ngh, false);
     }
   }
@@ -1208,23 +1501,26 @@ void MultigridDriver::FMGProlongateOctets() {
 
 
 //----------------------------------------------------------------------------------------
-//! \fn void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata)
-//! \brief Apply boundary conditions for octets
+//! \fn void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata,
+//!                                               bool fcoeff)
+//  \brief Apply boundary conditions for octets
 
-void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata) {
+void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata, bool fcoeff) {
   int lev = current_level_ - nrootlevel_;
 
 #pragma omp parallel for num_threads(nthreads_) schedule(dynamic,1)
   for (int o = 0; o < noctets_[lev]; ++o) {
-    if (fprolong && octets_[lev][o].fleaf == true) continue;
-    AthenaArray<Real> cbuf, cbufold;
-    AthenaArray<bool> ncoarse;
-    cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-    cbufold.NewAthenaArray(nvar_, 3, 3, 3);
-    ncoarse.NewAthenaArray(3, 3, 3);
-    const LogicalLocation &loc = octets_[lev][o].loc;
-    AthenaArray<Real> &u = octets_[lev][o].u;
-    AthenaArray<Real> &uold = octets_[lev][o].uold;
+    MGOctet &oct = octets_[lev][o];
+    if (fprolong && oct.fleaf == true) continue;
+    int th = 0;
+#ifdef OPENMP_PARALLEL
+    th = omp_get_thread_num();
+#endif
+    AthenaArray<Real> &cbuf = cbuf_[th];
+    AthenaArray<Real> &cbufold = cbufold_[th];
+    AthenaArray<bool> &ncoarse = ncoarse_[th];
+    ncoarse.ZeroClear();
+    const LogicalLocation &loc = oct.loc;
     LogicalLocation nloc = loc;
     for (int ox3 = -1; ox3 <= 1; ++ox3) {
       nloc.lx3 = loc.lx3 + ox3;
@@ -1273,10 +1569,13 @@ void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata) {
           }
           if (octetmap_[lev].count(nloc) == 1) { // on the same level
             int nid = octetmap_[lev][nloc];
-            const AthenaArray<Real> &un = octets_[lev][nid].u;
-            const AthenaArray<Real> &unold = octets_[lev][nid].uold;
-            SetOctetBoundarySameLevel(u, un, uold, unold, cbuf, cbufold,
-                                      ox1, ox2, ox3, folddata);
+            MGOctet &noct = octets_[lev][nid];
+            if (!fcoeff)
+              SetOctetBoundarySameLevel(oct.u, noct.u, oct.uold, noct.uold,
+                                        cbuf, cbufold, nvar_, ox1, ox2, ox3, folddata);
+            else
+              SetOctetBoundarySameLevel(oct.coeff, noct.coeff, oct.uold, noct.uold,
+                                        cbuf, cbufold, ncoeff_, ox1, ox2, ox3, false);
           } else if (!fprolong) { // on the coarser level
             // note: prolongation requires neighbors on the same level only
             ncoarse(ox3+1, ox2+1, ox1+1) = true;
@@ -1287,26 +1586,42 @@ void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata) {
               cloc.lx3 = nloc.lx3 >> 1;
               cloc.level = nloc.level - 1;
               int cid = octetmap_[lev-1][cloc];
-              const AthenaArray<Real> &un = octets_[lev-1][cid].u;
-              const AthenaArray<Real> &unold = octets_[lev-1][cid].uold;
-              SetOctetBoundaryFromCoarser(un, unold, cbuf, cbufold,
-                                          loc, ox1, ox2, ox3, false);
+              MGOctet &coct = octets_[lev-1][cid];
+              if (!fcoeff)
+                SetOctetBoundaryFromCoarser(coct.u, coct.uold, cbuf, cbufold,
+                                            nvar_, loc, ox1, ox2, ox3, false);
+              else
+                SetOctetBoundaryFromCoarser(coct.coeff, coct.coeff, cbuf, cbufold,
+                                            ncoeff_, loc, ox1, ox2, ox3, false);
             } else { // from root
-              const AthenaArray<Real> &un = mgroot_->GetCurrentData();
-              const AthenaArray<Real> &unold = mgroot_->GetCurrentOldData();
-              SetOctetBoundaryFromCoarser(un, unold, cbuf, cbufold,
-                                          nloc, ox1, ox2, ox3, false);
+              if (!fcoeff) {
+                const AthenaArray<Real> &un = mgroot_->GetCurrentData();
+                const AthenaArray<Real> &unold = mgroot_->GetCurrentOldData();
+                SetOctetBoundaryFromCoarser(un, unold, cbuf, cbufold,
+                                            nvar_, nloc, ox1, ox2, ox3, false);
+              } else {
+                const AthenaArray<Real> &un = mgroot_->GetCurrentCoefficient();
+                SetOctetBoundaryFromCoarser(un, un, cbuf, cbufold,
+                                            ncoeff_, nloc, ox1, ox2, ox3, false);
+              }
             }
           }
           // note: finer neighbors are not needed here
         }
       }
     }
-    if (!fprolong) {
-      ApplyPhysicalBoundariesOctet(cbuf, loc, octets_[lev][o].ccoord, true);
-      ProlongateOctetBoundariesFluxCons(u, cbuf, ncoarse);
+    if (!fcoeff) {
+      if (!fprolong) {
+        ApplyPhysicalBoundariesOctet(cbuf, loc, oct.ccoord, true, false);
+        ProlongateOctetBoundariesFluxCons(oct.u, cbuf, ncoarse);
+      }
+      ApplyPhysicalBoundariesOctet(oct.u, loc, oct.coord, false, false);
+    } else {
+      ApplyPhysicalBoundariesOctet(cbuf, loc, oct.ccoord, true, true);
+      ProlongateOctetBoundaries(oct.coeff, oct.uold, cbuf, cbufold, ncoeff_,
+                                ncoarse, false);
+      ApplyPhysicalBoundariesOctet(oct.u, loc, oct.coord, false, true);
     }
-    ApplyPhysicalBoundariesOctet(u, loc, octets_[lev][o].coord, false);
   }
 
   return;
@@ -1315,14 +1630,14 @@ void MultigridDriver::SetBoundariesOctets(bool fprolong, bool folddata) {
 
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::SetOctetBoundarySameLevel(AthenaArray<Real> &dst,
-//!  const AthenaArray<Real> &un, AthenaArray<Real> &uold, const AthenaArray<Real> &unold,
-//!  AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
-//!  int ox1, int ox2, int ox3, bool folddata)
-//! \brief set an Octet boundary from a neighbor Octet on the same level
+//   const AthenaArray<Real> &un, AthenaArray<Real> &uold, const AthenaArray<Real> &unold,
+//   AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
+//   int ox1, int ox2, int ox3, bool folddata, bool fcoeff)
+//  \brief set an Octet boundary from a neighbor Octet on the same level
 
 void MultigridDriver::SetOctetBoundarySameLevel(AthenaArray<Real> &dst,
      const AthenaArray<Real> &un, AthenaArray<Real> &uold, const AthenaArray<Real> &unold,
-     AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
+     AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold, int nvar,
      int ox1, int ox2, int ox3, bool folddata) {
   const int ngh = mgroot_->ngh_;
   constexpr Real fac = 0.125;
@@ -1338,7 +1653,7 @@ void MultigridDriver::SetOctetBoundarySameLevel(AthenaArray<Real> &dst,
   else if (ox3 < 0) ks = 0,     ke = ngh-1, nks = ngh+1;
   else              ks = ngh+2, ke = ngh+2, nks = ngh;
   int ci = ox1 + ngh, cj = ox2 + ngh, ck = ox3 + ngh;
-  for (int v = 0; v < nvar_; ++v) {
+  for (int v = 0; v < nvar; ++v) {
     for (int k = ks, nk = nks; k <= ke; ++k, ++nk) {
       for (int j = js, nj = njs; j <= je; ++j, ++nj) {
         for (int i = is, ni = nis; i <= ie; ++i, ++ni)
@@ -1346,11 +1661,11 @@ void MultigridDriver::SetOctetBoundarySameLevel(AthenaArray<Real> &dst,
       }
     }
   }
-  for (int v = 0; v < nvar_; ++v)
+  for (int v = 0; v < nvar; ++v)
     cbuf(v,ck,cj,ci) = fac*(un(v,l,l,l) + un(v,l,l,r) + un(v,l,r,l) + un(v,r,l,l)
                           + un(v,r,r,l) + un(v,r,l,r) + un(v,l,r,r) + un(v,r,r,r));
   if (folddata) {
-    for (int v = 0; v < nvar_; ++v) {
+    for (int v = 0; v < nvar; ++v) {
       for (int k = ks, nk = nks; k <= ke; ++k, ++nk) {
         for (int j = js, nj = njs; j <= je; ++j, ++nj) {
           for (int i = is, ni = nis; i <= ie; ++i, ++ni)
@@ -1358,7 +1673,7 @@ void MultigridDriver::SetOctetBoundarySameLevel(AthenaArray<Real> &dst,
         }
       }
     }
-    for (int v = 0; v < nvar_; ++v)
+    for (int v = 0; v < nvar; ++v)
       cbufold(v,ck,cj,ci) = fac*
              (unold(v,l,l,l)+unold(v,l,l,r) + unold(v,l,r,l) + unold(v,r,l,l)
             + unold(v,r,r,l)+unold(v,r,l,r) + unold(v,l,r,r) + unold(v,r,r,r));
@@ -1370,14 +1685,14 @@ void MultigridDriver::SetOctetBoundarySameLevel(AthenaArray<Real> &dst,
 
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::SetOctetBoundaryFromCoarser(const AthenaArray<Real> &un,
-//!                           const AthenaArray<Real> &unold, AthenaArray<Real> &cbuf,
-//!                           AthenaArray<Real> &cbufold, const LogicalLocation &loc,
-//!                           int ox1, int ox2, int ox3, bool folddata) {
-//! \brief set a boundary in the coarse buffer from a neighbor Octet on the coarser level
+//                    const AthenaArray<Real> &unold, AthenaArray<Real> &cbuf,
+//                    AthenaArray<Real> &cbufold, int nvar, const LogicalLocation &loc,
+//                    int ox1, int ox2, int ox3, bool folddata)
+//  \brief set a boundary in the coarse buffer from a neighbor Octet on the coarser level
 
 void MultigridDriver::SetOctetBoundaryFromCoarser(const AthenaArray<Real> &un,
                       const AthenaArray<Real> &unold, AthenaArray<Real> &cbuf,
-                      AthenaArray<Real> &cbufold, const LogicalLocation &loc,
+                      AthenaArray<Real> &cbufold, int nvar, const LogicalLocation &loc,
                       int ox1, int ox2, int ox3, bool folddata) {
   int ngh = mgroot_->ngh_;
   int ci, cj, ck;
@@ -1399,10 +1714,10 @@ void MultigridDriver::SetOctetBoundaryFromCoarser(const AthenaArray<Real> &un,
     else          ck = (ix3^1) + ngh;
   }
   int i = ngh + ox1, j = ngh + ox2, k = ngh + ox3;
-  for (int v = 0; v < nvar_; ++v)
+  for (int v = 0; v < nvar; ++v)
     cbuf(v, k, j, i) = un(v, ck, cj, ci);
   if (folddata) {
-    for (int v = 0; v < nvar_; ++v)
+    for (int v = 0; v < nvar; ++v)
       cbufold(v, k, j, i) = unold(v, ck, cj, ci);
   }
   return;
@@ -1411,11 +1726,11 @@ void MultigridDriver::SetOctetBoundaryFromCoarser(const AthenaArray<Real> &un,
 
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::ApplyPhysicalBoundariesOctet(AthenaArray<Real> &u,
-//!                   const LogicalLocation &loc, const MGCoordinates &coord, bool fcbuf)
-//! \brief Apply physical boundary conditions for an octet
+//        const LogicalLocation &loc, const MGCoordinates &coord, bool fcbuf, bool fcoeff)
+//  \brief Apply physical boundary conditions for an octet
 
 void MultigridDriver::ApplyPhysicalBoundariesOctet(AthenaArray<Real> &u,
-              const LogicalLocation &loc, const MGCoordinates &coord, bool fcbuf) {
+     const LogicalLocation &loc, const MGCoordinates &coord, bool fcbuf, bool fcoeff) {
   int lev = loc.level - locrootlevel_;
   int ngh = mgroot_->ngh_;
   int l, r;
@@ -1574,33 +1889,30 @@ void MultigridDriver::RestrictOctetsBeforeTransfer() {
   for (int l = nreflevel_ - 1; l >= 1; --l) {  // fine octets to coarse octets
 #pragma omp parallel for num_threads(nthreads_)
     for (int o = 0; o < noctets_[l]; ++o) {
-      AthenaArray<Real> cbuf;
-      cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-      const LogicalLocation &loc = octets_[l][o].loc;
+      MGOctet &foct = octets_[l][o];
+      const LogicalLocation &loc = foct.loc;
       LogicalLocation cloc;
       cloc.lx1 = (loc.lx1 >> 1);
       cloc.lx2 = (loc.lx2 >> 1);
       cloc.lx3 = (loc.lx3 >> 1);
       cloc.level = loc.level - 1;
       int oid = octetmap_[l-1][cloc];
+      MGOctet &coct = octets_[l-1][oid];
       int oi = (static_cast<int>(loc.lx1) & 1) + ngh;
       int oj = (static_cast<int>(loc.lx2) & 1) + ngh;
       int ok = (static_cast<int>(loc.lx3) & 1) + ngh;
-      mgroot_->Restrict(cbuf, octets_[l][o].u, ngh, ngh, ngh, ngh, ngh, ngh, false);
       for (int v = 0; v < nvar_; ++v)
-        octets_[l-1][oid].u(v, ok, oj, oi) = cbuf(v, ngh, ngh, ngh);
+        coct.u(v, ok, oj, oi) = RestrictOne(foct.u, v, ngh, ngh, ngh);
     }
   }
 #pragma omp parallel for num_threads(nthreads_)
   for (int o = 0; o < noctets_[0]; ++o) { // octets to the root grid
-    AthenaArray<Real> cbuf;
-    cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-    const LogicalLocation &loc = octets_[0][o].loc;
-    mgroot_->Restrict(cbuf, octets_[0][o].u, ngh, ngh, ngh, ngh, ngh, ngh, false);
+    MGOctet &oct = octets_[0][o];
+    const LogicalLocation &loc = oct.loc;
     for (int v = 0; v < nvar_; ++v)
       mgroot_->SetData(MGVariable::u, v, static_cast<int>(loc.lx3),
                        static_cast<int>(loc.lx2), static_cast<int>(loc.lx1),
-                       cbuf(v, ngh, ngh, ngh));
+                       RestrictOne(oct.u, v, ngh, ngh, ngh));
   }
 
   return;
@@ -1626,11 +1938,14 @@ void MultigridDriver::SetOctetBoundariesBeforeTransfer(bool folddata) {
     Multigrid *pmg = *itr;
     LogicalLocation loc = pmg->loc_;
     if (loc.level == locrootlevel_) continue;
-    AthenaArray<Real> cbuf, cbufold;
-    AthenaArray<bool> ncoarse;
-    cbuf.NewAthenaArray(nvar_, 3, 3, 3);
-    cbufold.NewAthenaArray(nvar_, 3, 3, 3);
-    ncoarse.NewAthenaArray(3, 3, 3);
+    int th = 0;
+#ifdef OPENMP_PARALLEL
+    th = omp_get_thread_num();
+#endif
+    AthenaArray<Real> &cbuf = cbuf_[th];
+    AthenaArray<Real> &cbufold = cbufold_[th];
+    AthenaArray<bool> &ncoarse = ncoarse_[th];
+    ncoarse.ZeroClear();
     loc.lx1 = loc.lx1 >> 1;
     loc.lx2 = loc.lx2 >> 1;
     loc.lx3 = loc.lx3 >> 1;
@@ -1639,8 +1954,7 @@ void MultigridDriver::SetOctetBoundariesBeforeTransfer(bool folddata) {
     int oid = octetmap_[lev][loc];
     if (octetbflag_[lev][oid] == true) continue;
     octetbflag_[lev][oid] = true;
-    AthenaArray<Real> &u = octets_[lev][oid].u;
-    AthenaArray<Real> &uold = octets_[lev][oid].uold;
+    MGOctet &oct = octets_[lev][oid];
     LogicalLocation nloc = loc;
     for (int ox3 = -1; ox3 <= 1; ++ox3) {
       nloc.lx3 = loc.lx3 + ox3;
@@ -1687,10 +2001,9 @@ void MultigridDriver::SetOctetBoundariesBeforeTransfer(bool folddata) {
           }
           if (octetmap_[lev].count(nloc) == 1) { // same or finer
             int nid = octetmap_[lev][nloc];
-            const AthenaArray<Real> &un = octets_[lev][nid].u;
-            const AthenaArray<Real> &unold = octets_[lev][nid].uold;
-            SetOctetBoundarySameLevel(u, un, uold, unold, cbuf, cbufold,
-                                      ox1, ox2, ox3, folddata);
+            MGOctet &noct = octets_[lev][nid];
+            SetOctetBoundarySameLevel(oct.u, noct.u, oct.uold, noct.uold, cbuf, cbufold,
+                                      nvar_, ox1, ox2, ox3, folddata);
           } else { // coarser
             ncoarse(ox3+1, ox2+1, ox1+1) = true;
             if (lev > 0) { // from octet
@@ -1700,26 +2013,25 @@ void MultigridDriver::SetOctetBoundariesBeforeTransfer(bool folddata) {
               cloc.lx3 = nloc.lx3 >> 1;
               cloc.level = nloc.level - 1;
               int cid = octetmap_[lev-1][cloc];
-              const AthenaArray<Real> &un = octets_[lev-1][cid].u;
-              const AthenaArray<Real> &unold = octets_[lev-1][cid].uold;
-              SetOctetBoundaryFromCoarser(un, unold, cbuf, cbufold,
-                                          loc, ox1, ox2, ox3, folddata);
+              MGOctet & coct = octets_[lev-1][cid];
+              SetOctetBoundaryFromCoarser(coct.u, coct.uold, cbuf, cbufold,
+                                          nvar_, loc, ox1, ox2, ox3, folddata);
             } else { // from root
               const AthenaArray<Real> &un = mgroot_->GetCurrentData();
               const AthenaArray<Real> &unold = mgroot_->GetCurrentOldData();
               SetOctetBoundaryFromCoarser(un, unold, cbuf, cbufold,
-                                          nloc, ox1, ox2, ox3, folddata);
+                                          nvar_, nloc, ox1, ox2, ox3, folddata);
             }
           }
         }
       }
     }
 
-    ApplyPhysicalBoundariesOctet(cbuf, loc, octets_[lev][oid].ccoord, true);
+    ApplyPhysicalBoundariesOctet(cbuf, loc, oct.ccoord, true, false);
     if (folddata)
-      ApplyPhysicalBoundariesOctet(cbufold, loc, octets_[lev][oid].ccoord, true);
-    ProlongateOctetBoundaries(u, uold, cbuf, cbufold, ncoarse, folddata);
-    ApplyPhysicalBoundariesOctet(u, loc, octets_[lev][oid].coord, false);
+      ApplyPhysicalBoundariesOctet(cbufold, loc, oct.ccoord, true, false);
+    ProlongateOctetBoundaries(oct.u, oct.uold, cbuf, cbufold, nvar_, ncoarse, folddata);
+    ApplyPhysicalBoundariesOctet(oct.u, loc, oct.coord, false, false);
   }
   return;
 }
@@ -1727,23 +2039,23 @@ void MultigridDriver::SetOctetBoundariesBeforeTransfer(bool folddata) {
 
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::ProlongateOctetBoundaries(AthenaArray<Real> &u,
-//!          AthenaArray<Real> &uold, AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
-//!          const AthenaArray<bool> &ncoarse,bool folddata)
-//! \brief Prolongate octet boundaries contacting the coarser level
+//           AthenaArray<Real> &uold, AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
+//           int nvar, const AthenaArray<bool> &ncoarse, bool folddata)
+//  \brief Prolongate octet boundaries contacting the coarser level
 
 void MultigridDriver::ProlongateOctetBoundaries(AthenaArray<Real> &u,
      AthenaArray<Real> &uold, AthenaArray<Real> &cbuf, AthenaArray<Real> &cbufold,
-     const AthenaArray<bool> &ncoarse, bool folddata) {
+     int nvar, const AthenaArray<bool> &ncoarse, bool folddata) {
   const int ngh = mgroot_->ngh_;
   const int flim = 2 + ngh;
   constexpr Real fac = 0.125;
   const int l = ngh, r = ngh + 1;
 
-  for (int v = 0; v < nvar_; ++v)
+  for (int v = 0; v < nvar; ++v)
     cbuf(v,ngh,ngh,ngh) = fac*(u(v,l,l,l)+u(v,l,l,r)+u(v,l,r,l)+u(v,r,l,l)
                               +u(v,r,r,l)+u(v,r,l,r)+u(v,l,r,r)+u(v,r,r,r));
   if (folddata) {
-    for (int v = 0; v < nvar_; ++v)
+    for (int v = 0; v < nvar; ++v)
       cbufold(v,ngh,ngh,ngh) = fac*
                              (uold(v,l,l,l)+uold(v,l,l,r)+uold(v,l,r,l)+uold(v,r,l,l)
                              +uold(v,r,r,l)+uold(v,r,l,r)+uold(v,l,r,r)+uold(v,r,r,r));
@@ -1757,7 +2069,7 @@ void MultigridDriver::ProlongateOctetBoundaries(AthenaArray<Real> &u,
         if (ncoarse(ox3+1, ox2+1, ox1+1)) { // coarser
           int i = ox1 + ngh, j = ox2 + ngh, k = ox3 + ngh;
           int fi = ox1*2 + ngh, fj = ox2*2 + ngh, fk = ox3*2 + ngh;
-          for (int v = 0; v < nvar_; ++v) {
+          for (int v = 0; v < nvar; ++v) {
             if (fk >= 0 && fj >= 0 && fi >= 0)
               u(v, fk,   fj,   fi  ) =
                 0.015625*(27.0*cb(v,k,j,i)+cb(v,k-1,j-1,i-1)
@@ -1800,7 +2112,7 @@ void MultigridDriver::ProlongateOctetBoundaries(AthenaArray<Real> &u,
                   +3.0*(cb(v,k+1,j+1,i)+cb(v,k+1,j,i+1)+cb(v,k,j+1,i+1)));
           }
           if (folddata) {
-            for (int v = 0; v < nvar_; ++v) {
+            for (int v = 0; v < nvar; ++v) {
               if (fk >= 0 && fj >= 0 && fi >= 0)
                 uold(v, fk,   fj,   fi  ) =
                   0.015625*(27.0*co(v,k,j,i)+co(v,k-1,j-1,i-1)
@@ -1852,6 +2164,20 @@ void MultigridDriver::ProlongateOctetBoundaries(AthenaArray<Real> &u,
 }
 
 
+//----------------------------------------------------------------------------------------
+//! \fn void MultigridDriver::ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
+//                            AthenaArray<Real> &cbuf, const AthenaArray<bool> &ncoarse)
+//! \brief prolongate octet boundaries using the flux conservation formula
+//         for the base class (just call the normal version)
+
+void MultigridDriver::ProlongateOctetBoundariesFluxCons(AthenaArray<Real> &dst,
+                      AthenaArray<Real> &cbuf, const AthenaArray<bool> &ncoarse) {
+  ProlongateOctetBoundaries(dst, dst, cbuf, cbuf, nvar_, ncoarse, false);
+  return;
+}
+
+
+
 //----------------------------------------------------------------------------------------
 //! \fn void MultigridDriver::AllocateMultipoleCoefficients()
 //! \brief Allocate arrays for multipole expansion coefficients
@@ -1984,3 +2310,4 @@ void MultigridDriver::CalculateCenterOfMass() {
 
   return;
 }
+
diff --git a/src/outputs/athena_hdf5.cpp b/src/outputs/athena_hdf5.cpp
index 7d89ca0ec5..367b8061d4 100644
--- a/src/outputs/athena_hdf5.cpp
+++ b/src/outputs/athena_hdf5.cpp
@@ -24,6 +24,7 @@
 #include "../chem_rad/chem_rad.hpp"
 #include "../chem_rad/integrators/rad_integrators.hpp"
 #include "../coordinates/coordinates.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
 #include "../field/field.hpp"
 #include "../globals.hpp"
 #include "../gravity/gravity.hpp"
@@ -145,6 +146,11 @@ void ATHDF5Output::WriteOutputFile(Mesh *pm, ParameterInput *pin, bool flag) {
     if(CR_ENABLED)
       num_variables[n_dataset] += 13;
 
+    if(CRDIFFUSION_ENABLED) {
+      num_variables[n_dataset] += 2;
+      if (pmb->pcrdiff->output_defect)
+        num_variables[n_dataset] += 1;
+    }
 
     // Passive scalars:
     if (NSCALARS > 0)
diff --git a/src/outputs/outputs.cpp b/src/outputs/outputs.cpp
index 3166ca6d8c..f7e9ea7dff 100644
--- a/src/outputs/outputs.cpp
+++ b/src/outputs/outputs.cpp
@@ -93,6 +93,7 @@
 #include "../chem_rad/integrators/rad_integrators.hpp"
 #include "../coordinates/coordinates.hpp"
 #include "../cr/cr.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
 #include "../field/field.hpp"
 #include "../gravity/gravity.hpp"
 #include "../hydro/hydro.hpp"
@@ -352,6 +353,7 @@ void OutputType::LoadOutputData(MeshBlock *pmb) {
   Field *pfld = pmb->pfield;
   NRRadiation *prad=pmb->pnrrad;
   CosmicRay *pcr=pmb->pcr;
+  CRDiffusion *pcrdiff=pmb->pcrdiff;
   PassiveScalars *psclr = pmb->pscalars;
   ChemRadiation *pchemrad = pmb->pchemrad;
   Gravity *pgrav = pmb->pgrav;
@@ -1141,7 +1143,38 @@ void OutputType::LoadOutputData(MeshBlock *pmb) {
         num_vars_+=3;
       }
     }
-  } // end Cosmic Rays
+  }// end Cosmic Rays
+
+  if (CRDIFFUSION_ENABLED) {
+    if (ContainVariable(output_params.variable, "ecr") ||
+        ContainVariable(output_params.variable, "prim") ||
+        ContainVariable(output_params.variable, "cons")) {
+      pod = new OutputData;
+      pod->type = "SCALARS";
+      pod->name = "ecr";
+      pod->data.InitWithShallowSlice(pcrdiff->ecr,4,0,1);
+      AppendOutputDataNode(pod);
+      num_vars_++;
+      if (pcrdiff->output_defect) {
+        pod = new OutputData;
+        pod->type = "SCALARS";
+        pod->name = "defect-ecr";
+        pod->data.InitWithShallowSlice(pcrdiff->def, 4, 0, 1);
+        AppendOutputDataNode(pod);
+        num_vars_++;
+      }
+    }
+    if (ContainVariable(output_params.variable, "zeta") ||
+        ContainVariable(output_params.variable, "prim") ||
+        ContainVariable(output_params.variable, "cons")) {
+      pod = new OutputData;
+      pod->type = "SCALARS";
+      pod->name = "zeta";
+      pod->data.InitWithShallowSlice(pcrdiff->zeta,4,0,1);
+      AppendOutputDataNode(pod);
+      num_vars_++;
+    }
+  }
 
   // note, the Bcc variables are stored in a separate HDF5 dataset from the above Output
   // nodes, and it must come after those nodes in the linked list
diff --git a/src/outputs/restart.cpp b/src/outputs/restart.cpp
index 3b66da8ae6..54cf97d19f 100644
--- a/src/outputs/restart.cpp
+++ b/src/outputs/restart.cpp
@@ -23,6 +23,7 @@
 #include "../athena_arrays.hpp"
 #include "../chem_rad/chem_rad.hpp"
 #include "../cr/cr.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
 #include "../field/field.hpp"
 #include "../globals.hpp"
 #include "../hydro/hydro.hpp"
@@ -190,6 +191,11 @@ void RestartOutput::WriteOutputFile(Mesh *pm, ParameterInput *pin, bool force_wr
       pdata += pmb->pcr->u_cr.GetSizeInBytes();
     }
 
+    if (CRDIFFUSION_ENABLED) {
+      std::memcpy(pdata,pmb->pcrdiff->ecr.data(),pmb->pcrdiff->ecr.GetSizeInBytes());
+      pdata += pmb->pcrdiff->ecr.GetSizeInBytes();
+    }
+
     // (conserved variable) Passive scalars:
     if (NSCALARS > 0) {
       AthenaArray<Real> &s = pmb->pscalars->s;
diff --git a/src/pgen/cr_diffusion_mg.cpp b/src/pgen/cr_diffusion_mg.cpp
new file mode 100644
index 0000000000..61b4322df1
--- /dev/null
+++ b/src/pgen/cr_diffusion_mg.cpp
@@ -0,0 +1,240 @@
+//======================================================================================
+/* Athena++ astrophysical MHD code
+ * Copyright (C) 2014 James M. Stone  <jmstone@princeton.edu>
+ *
+ * This program is free software: you can redistribute and/or modify it under the terms
+ * of the GNU General Public License (GPL) as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of GNU GPL in the file LICENSE included in the code
+ * distribution.  If not see <http://www.gnu.org/licenses/>.
+ *====================================================================================*/
+
+// C++ headers
+#include <algorithm>  // min
+#include <cmath>      // sqrt
+#include <fstream>
+#include <iostream>   // endl
+#include <sstream>    // stringstream
+#include <stdexcept>  // runtime_error
+#include <string>     // c_str()
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "../athena_arrays.hpp"
+#include "../bvals/bvals.hpp"
+#include "../coordinates/coordinates.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
+#include "../crdiffusion/mg_crdiffusion.hpp"
+#include "../eos/eos.hpp"
+#include "../field/field.hpp"
+#include "../globals.hpp"
+#include "../hydro/hydro.hpp"
+#include "../hydro/srcterms/hydro_srcterms.hpp"
+#include "../mesh/mesh.hpp"
+#include "../parameter_input.hpp"
+
+
+#if !CRDIFFUSION_ENABLED
+#error "The implicit CR diffusion solver must be enabled (-crdiff)."
+#endif
+
+namespace {
+  Real e0;
+}
+
+void CRFixedInnerX1(AthenaArray<Real> &dst, Real time, int nvar,
+                    int is, int ie, int js, int je, int ks, int ke, int ngh,
+                    const MGCoordinates &coord) {
+  for (int n=0; n<nvar; n++) {
+    for (int k=ks; k<=ke; k++) {
+      for (int j=js; j<=je; j++) {
+        for (int i=0; i<ngh; i++)
+          dst(n,k,j,is-i-1) = 2.0*e0 - dst(n,k,j,is);
+      }
+    }
+  }
+  return;
+}
+
+void CRFixedOuterX1(AthenaArray<Real> &dst, Real time, int nvar,
+                    int is, int ie, int js, int je, int ks, int ke, int ngh,
+                    const MGCoordinates &coord) {
+  for (int n=0; n<nvar; n++) {
+    for (int k=ks; k<=ke; k++) {
+      for (int j=js; j<=je; j++) {
+        for (int i=0; i<ngh; i++)
+          dst(n,k,j,ie+i+1) = 2.0*e0 - dst(n,k,j,ie);
+      }
+    }
+  }
+  return;
+}
+
+void CRFixedInnerX2(AthenaArray<Real> &dst, Real time, int nvar,
+                    int is, int ie, int js, int je, int ks, int ke, int ngh,
+                    const MGCoordinates &coord) {
+  for (int n=0; n<nvar; n++) {
+    for (int k=ks; k<=ke; k++) {
+      for (int j=0; j<ngh; j++) {
+        for (int i=is; i<=ie; i++)
+          dst(n,k,js-j-1,i) = 2.0*e0 - dst(n,k,js,i);
+      }
+    }
+  }
+  return;
+}
+
+void CRFixedOuterX2(AthenaArray<Real> &dst, Real time, int nvar,
+                    int is, int ie, int js, int je, int ks, int ke, int ngh,
+                    const MGCoordinates &coord) {
+  for (int n=0; n<nvar; n++) {
+    for (int k=ks; k<=ke; k++) {
+      for (int j=0; j<ngh; j++) {
+        for (int i=is; i<=ie; i++)
+          dst(n,k,je+j+1,i) = 2.0*e0 - dst(n,k,je,i);
+      }
+    }
+  }
+  return;
+}
+
+void CRFixedInnerX3(AthenaArray<Real> &dst, Real time, int nvar,
+                    int is, int ie, int js, int je, int ks, int ke, int ngh,
+                    const MGCoordinates &coord) {
+  for (int n=0; n<nvar; n++) {
+    for (int k=0; k<ngh; k++) {
+      for (int j=js; j<=je; j++) {
+        for (int i=is; i<=ie; i++)
+          dst(n,ks-k-1,j,i) = 2.0*e0 - dst(n,ks,j,i);
+      }
+    }
+  }
+  return;
+}
+
+void CRFixedOuterX3(AthenaArray<Real> &dst, Real time, int nvar,
+                    int is, int ie, int js, int je, int ks, int ke, int ngh,
+                    const MGCoordinates &coord) {
+  for (int n=0; n<nvar; n++) {
+    for (int k=0; k<ngh; k++) {
+      for (int j=js; j<=je; j++) {
+        for (int i=is; i<=ie; i++)
+          dst(n,ke+k+1,j,i) = 2.0*e0 - dst(n,ke,j,i);
+      }
+    }
+  }
+  return;
+}
+
+
+int AMRCondition(MeshBlock *pmb) {
+  if (pmb->block_size.x1min >= 0.25 && pmb->block_size.x1min <=0.251
+  &&  pmb->block_size.x2min >= 0.25 && pmb->block_size.x2min <=0.251
+  &&  pmb->block_size.x3min >= 0.25 && pmb->block_size.x3min <=0.251) {
+    if (pmb->pmy_mesh->ncycle >= pmb->loc.level - 1)
+      return 1;
+  }
+  return 0;
+}
+
+
+//========================================================================================
+//! \fn void Mesh::InitUserMeshData(ParameterInput *pin)
+//  \brief
+//========================================================================================
+
+void Mesh::InitUserMeshData(ParameterInput *pin) {
+  e0 = 1.0;
+  EnrollUserRefinementCondition(AMRCondition);
+  EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace::inner_x1, CRFixedInnerX1);
+  EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace::outer_x1, CRFixedOuterX1);
+  EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace::inner_x2, CRFixedInnerX2);
+  EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace::outer_x2, CRFixedOuterX2);
+  EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace::inner_x3, CRFixedInnerX3);
+  EnrollUserMGCRDiffusionBoundaryFunction(BoundaryFace::outer_x3, CRFixedOuterX3);
+}
+
+
+//======================================================================================
+//! \fn void MeshBlock::ProblemGenerator(ParameterInput *pin)
+//  \brief cosmic ray diffusion test
+//======================================================================================
+
+void MeshBlock::ProblemGenerator(ParameterInput *pin) {
+  Real gamma = peos->GetGamma();
+  Real r0 = 0.2, rho0 = 1.0;
+
+  for(int k=ks; k<=ke; ++k) {
+    Real x3 = pcoord->x3v(k);
+    for (int j=js; j<=je; ++j) {
+      Real x2 = pcoord->x2v(j);
+      for (int i=is; i<=ie; ++i) {
+        Real x1 = pcoord->x1v(i);
+        Real r2 = SQR(x1)+SQR(x2)+SQR(x3);
+        phydro->u(IDN,k,j,i) = 1.0;//rho0/std::min(r2,r0*r0);
+        phydro->u(IM1,k,j,i) = 0.0;
+        phydro->u(IM2,k,j,i) = 0.0;
+        phydro->u(IM3,k,j,i) = 0.0;
+        if (NON_BAROTROPIC_EOS)
+          phydro->u(IEN,k,j,i) = phydro->u(IDN,k,j,i)/(gamma-1.0);
+      }
+    }
+  }
+  if (MAGNETIC_FIELDS_ENABLED) {
+    for (int k=ks; k<=ke; ++k) {
+      for (int j=js; j<=je; ++j) {
+        for (int i=is; i<=ie+1; ++i) {
+          pfield->b.x1f(k,j,i) = 1.0;
+        }
+      }
+    }
+    if (block_size.nx2 > 1) {
+      for (int k=ks; k<=ke; ++k) {
+        for (int j=js; j<=je+1; ++j) {
+          for (int i=is; i<=ie; ++i) {
+            pfield->b.x2f(k,j,i) = 1.0;
+          }
+        }
+      }
+    }
+    if (block_size.nx3 > 1) {
+      for (int k=ks; k<=ke+1; ++k) {
+        for (int j=js; j<=je; ++j) {
+          for (int i=is; i<=ie; ++i) {
+            pfield->b.x3f(k,j,i) = 0.0;
+          }
+        }
+      }
+    }
+
+    pfield->CalculateCellCenteredField(pfield->b,pfield->bcc,pcoord,is,ie,js,je,ks,ke);
+
+    if (NON_BAROTROPIC_EOS) {
+      for(int k=ks; k<=ke; ++k) {
+        for(int j=js; j<=je; ++j) {
+          for(int i=is; i<=ie; ++i) {
+            phydro->u(IEN,k,j,i) +=
+              0.5*(SQR((pfield->bcc(IB1,k,j,i)))
+                 + SQR((pfield->bcc(IB2,k,j,i)))
+                 + SQR((pfield->bcc(IB3,k,j,i))));
+          }
+        }
+      }
+    }
+  }
+
+  for(int k=ks; k<=ke; ++k) {
+    for(int j=js; j<=je; ++j) {
+      for(int i=is; i<=ie; ++i)
+        pcrdiff->ecr(k,j,i) = 1.0;
+    }
+  }
+
+  return;
+}
+
diff --git a/src/task_list/crdiffusion_task_list.cpp b/src/task_list/crdiffusion_task_list.cpp
new file mode 100644
index 0000000000..3154faa82d
--- /dev/null
+++ b/src/task_list/crdiffusion_task_list.cpp
@@ -0,0 +1,128 @@
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file grav_task_list.cpp
+//! \brief function implementation for CRDiffusionBoundaryTaskList
+
+// C headers
+
+// C++ headers
+#include <iostream>   // endl
+#include <sstream>    // sstream
+#include <stdexcept>  // runtime_error
+#include <string>     // c_str()
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "../crdiffusion/crdiffusion.hpp"
+#include "../mesh/mesh.hpp"
+#include "../parameter_input.hpp"
+#include "crdiffusion_task_list.hpp"
+#include "task_list.hpp"
+
+//----------------------------------------------------------------------------------------
+//! CRDiffusionBoundaryTaskList constructor
+
+CRDiffusionBoundaryTaskList::CRDiffusionBoundaryTaskList(ParameterInput *pin, Mesh *pm) {
+  // Now assemble list of tasks for each stage of time integrator
+  {using namespace CRDiffusionBoundaryTaskNames; // NOLINT (build/namespace)
+    AddTask(SEND_CRDIFF_BND,NONE);
+    AddTask(RECV_CRDIFF_BND,NONE);
+    AddTask(SETB_CRDIFF_BND,(RECV_CRDIFF_BND|SEND_CRDIFF_BND));
+    if (pm->multilevel) {
+      AddTask(PROLONG_CRDIFF_BND,SETB_CRDIFF_BND);
+      AddTask(CRDIFF_PHYS_BND,PROLONG_CRDIFF_BND);
+    } else {
+      AddTask(CRDIFF_PHYS_BND,SETB_CRDIFF_BND);
+    }
+    AddTask(CLEAR_CRDIFF, CRDIFF_PHYS_BND);
+  } // end of using namespace block
+}
+
+//----------------------------------------------------------------------------------------
+//! \fn void CRDiffusionBoundaryTaskList::AddTask(const TaskID& id, const TaskID& dep)
+//! \brief Sets id and dependency for "ntask" member of task_list_ array, then iterates
+//! value of ntask.
+
+void CRDiffusionBoundaryTaskList::AddTask(const TaskID& id, const TaskID& dep) {
+  task_list_[ntasks].task_id=id;
+  task_list_[ntasks].dependency=dep;
+
+  using namespace CRDiffusionBoundaryTaskNames; // NOLINT (build/namespace)
+  if (id == CLEAR_CRDIFF) {
+    task_list_[ntasks].TaskFunc=
+        static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
+        (&CRDiffusionBoundaryTaskList::ClearCRDiffusionBoundary);
+  } else if (id == SEND_CRDIFF_BND) {
+    task_list_[ntasks].TaskFunc=
+        static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
+        (&CRDiffusionBoundaryTaskList::SendCRDiffusionBoundary);
+  } else if (id == RECV_CRDIFF_BND) {
+    task_list_[ntasks].TaskFunc=
+        static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
+        (&CRDiffusionBoundaryTaskList::ReceiveCRDiffusionBoundary);
+  } else if (id == SETB_CRDIFF_BND) {
+    task_list_[ntasks].TaskFunc=
+        static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
+        (&CRDiffusionBoundaryTaskList::SetCRDiffusionBoundary);
+  } else if (id == PROLONG_CRDIFF_BND) {
+    task_list_[ntasks].TaskFunc=
+        static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
+        (&CRDiffusionBoundaryTaskList::ProlongateCRDiffusionBoundary);
+  } else if (id == CRDIFF_PHYS_BND) {
+    task_list_[ntasks].TaskFunc=
+        static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
+        (&CRDiffusionBoundaryTaskList::PhysicalBoundary);
+  } else {
+    std::stringstream msg;
+    msg << "### FATAL ERROR in CRDiffusionBoundaryTaskList::AddTask" << std::endl
+        << "Invalid Task is specified" << std::endl;
+    ATHENA_ERROR(msg);
+  }
+  ntasks++;
+  return;
+}
+
+void CRDiffusionBoundaryTaskList::StartupTaskList(MeshBlock *pmb, int stage) {
+  pmb->pcrdiff->crbvar.StartReceiving(BoundaryCommSubset::all);
+  return;
+}
+
+TaskStatus CRDiffusionBoundaryTaskList::ClearCRDiffusionBoundary(MeshBlock *pmb,
+                                                                 int stage) {
+  pmb->pcrdiff->crbvar.ClearBoundary(BoundaryCommSubset::all);
+  return TaskStatus::success;
+}
+
+TaskStatus CRDiffusionBoundaryTaskList::SendCRDiffusionBoundary(MeshBlock *pmb,
+                                                                int stage) {
+  pmb->pcrdiff->crbvar.SendBoundaryBuffers();
+  return TaskStatus::success;
+}
+
+TaskStatus CRDiffusionBoundaryTaskList::ReceiveCRDiffusionBoundary(MeshBlock *pmb,
+                                                                   int stage) {
+  bool ret = pmb->pcrdiff->crbvar.ReceiveBoundaryBuffers();
+  if (!ret)
+    return TaskStatus::fail;
+  return TaskStatus::success;
+}
+
+TaskStatus CRDiffusionBoundaryTaskList::SetCRDiffusionBoundary(MeshBlock *pmb,
+                                                               int stage) {
+  pmb->pcrdiff->crbvar.SetBoundaries();
+  return TaskStatus::success;
+}
+
+TaskStatus CRDiffusionBoundaryTaskList::ProlongateCRDiffusionBoundary(MeshBlock *pmb,
+                                                                      int stage) {
+  pmb->pbval->ProlongateBoundariesPostMG(&(pmb->pcrdiff->crbvar));
+  return TaskStatus::success;
+}
+
+TaskStatus CRDiffusionBoundaryTaskList::PhysicalBoundary(MeshBlock *pmb, int stage) {
+  pmb->pcrdiff->crbvar.ExpandPhysicalBoundaries();
+  return TaskStatus::next;
+}
diff --git a/src/task_list/crdiffusion_task_list.hpp b/src/task_list/crdiffusion_task_list.hpp
new file mode 100644
index 0000000000..a5b68d894e
--- /dev/null
+++ b/src/task_list/crdiffusion_task_list.hpp
@@ -0,0 +1,58 @@
+#ifndef TASK_LIST_CRDIFFUSION_TASK_LIST_HPP_
+#define TASK_LIST_CRDIFFUSION_TASK_LIST_HPP_
+//========================================================================================
+// Athena++ astrophysical MHD code
+// Copyright(C) 2014 James M. Stone <jmstone@princeton.edu> and other code contributors
+// Licensed under the 3-clause BSD License, see LICENSE file for details
+//========================================================================================
+//! \file grav_task_list.hpp
+//! \brief define CRDiffusionBoundaryTaskList
+
+// C headers
+
+// C++ headers
+#include <cstdint>      // std::uint64_t
+
+// Athena++ headers
+#include "../athena.hpp"
+#include "task_list.hpp"
+
+// forward declarations
+class Mesh;
+class MeshBlock;
+
+//----------------------------------------------------------------------------------------
+//! \class CRDiffusionBoundaryTaskList
+//! \brief data and function definitions for CRDiffusionBoundaryTaskList derived class
+
+class CRDiffusionBoundaryTaskList : public TaskList {
+ public:
+  CRDiffusionBoundaryTaskList(ParameterInput *pin, Mesh *pm);
+
+  // functions
+  TaskStatus ClearCRDiffusionBoundary(MeshBlock *pmb, int stage);
+  TaskStatus SendCRDiffusionBoundary(MeshBlock *pmb, int stage);
+  TaskStatus ReceiveCRDiffusionBoundary(MeshBlock *pmb, int stage);
+  TaskStatus SetCRDiffusionBoundary(MeshBlock *pmb, int stage);
+  TaskStatus ProlongateCRDiffusionBoundary(MeshBlock *pmb, int stage);
+  TaskStatus PhysicalBoundary(MeshBlock *pmb, int stage);
+
+ private:
+  void AddTask(const TaskID& id, const TaskID& dep) override;
+  void StartupTaskList(MeshBlock *pmb, int stage) override;
+};
+
+
+//----------------------------------------------------------------------------------------
+//! 64-bit integers with "1" in different bit positions used to ID  each hydro task.
+namespace CRDiffusionBoundaryTaskNames {
+const TaskID NONE(0);
+const TaskID CLEAR_CRDIFF(1);
+
+const TaskID SEND_CRDIFF_BND(2);
+const TaskID RECV_CRDIFF_BND(3);
+const TaskID SETB_CRDIFF_BND(4);
+const TaskID PROLONG_CRDIFF_BND(5);
+const TaskID CRDIFF_PHYS_BND(6);
+}
+#endif // TASK_LIST_CRDIFFUSION_TASK_LIST_HPP_
diff --git a/src/task_list/grav_task_list.cpp b/src/task_list/grav_task_list.cpp
index 88ce29dd56..cbfd49f2c5 100644
--- a/src/task_list/grav_task_list.cpp
+++ b/src/task_list/grav_task_list.cpp
@@ -16,11 +16,7 @@
 
 // Athena++ headers
 #include "../athena.hpp"
-#include "../eos/eos.hpp"
-#include "../field/field.hpp"
 #include "../gravity/gravity.hpp"
-#include "../hydro/hydro.hpp"
-#include "../hydro/srcterms/hydro_srcterms.hpp"
 #include "../mesh/mesh.hpp"
 #include "../parameter_input.hpp"
 #include "grav_task_list.hpp"
@@ -120,14 +116,14 @@ TaskStatus GravityBoundaryTaskList::SetGravityBoundary(MeshBlock *pmb, int stage
 
 TaskStatus GravityBoundaryTaskList::ProlongateGravityBoundary(MeshBlock *pmb,
                                                               int stage) {
-  pmb->pbval->ProlongateGravityBoundaries(pmb->pmy_mesh->time, 0.0);
+  pmb->pbval->ProlongateBoundariesPostMG(&(pmb->pgrav->gbvar));
   return TaskStatus::success;
 }
 
 TaskStatus GravityBoundaryTaskList::PhysicalBoundary(MeshBlock *pmb, int stage) {
   if (pmb->pgrav->fill_ghost) {
     pmb->pgrav->RestoreFaceBoundaries();
-    pmb->pgrav->ExpandPhysicalBoundaries();
+    pmb->pgrav->gbvar.ExpandPhysicalBoundaries();
   }
   return TaskStatus::next;
 }
diff --git a/src/task_list/mg_task_list.cpp b/src/task_list/mg_task_list.cpp
index 1c87cc8e4d..f9cee279bb 100644
--- a/src/task_list/mg_task_list.cpp
+++ b/src/task_list/mg_task_list.cpp
@@ -264,7 +264,7 @@ TaskStatus MultigridTaskList::CalculateFASRHS(Multigrid *pmg) {
 }
 
 TaskStatus MultigridTaskList::PhysicalBoundary(Multigrid *pmg) {
-  pmg->pmgbval->ApplyPhysicalBoundaries();
+  pmg->pmgbval->ApplyPhysicalBoundaries(0, false);
   return TaskStatus::next;
 }
 
@@ -275,7 +275,7 @@ TaskStatus MultigridTaskList::ProlongateBoundary(Multigrid *pmg) {
 
 
 TaskStatus MultigridTaskList::ProlongateBoundaryForProlongation(Multigrid *pmg) {
-  pmg->pmgbval->ProlongateMultigridBoundaries(pmg->pmy_driver_->ffas_);
+  pmg->pmgbval->ProlongateMultigridBoundaries(pmg->pmy_driver_->ffas_, false);
   return TaskStatus::success;
 }
 
@@ -318,18 +318,22 @@ void MultigridTaskList::SetMGTaskListToFiner(int nsmooth, int ngh, int flag) {
       AddMultigridTask(MG_PHYSBND1R, MG_SENDBND1R|MG_RECVBND1R);
     }
     AddMultigridTask(MG_SMOOTH1R,    MG_PHYSBND1R);
-    AddMultigridTask(MG_CLEARBND1R,  MG_SMOOTH1R);
-    AddMultigridTask(MG_STARTRECV1B, MG_CLEARBND1R);
-    AddMultigridTask(MG_SENDBND1B,   MG_STARTRECV1B);
-    AddMultigridTask(MG_RECVBND1B,   MG_STARTRECV1B);
-    if (multilevel) {
-      AddMultigridTask(MG_PRLNGFC1B, MG_SENDBND1B|MG_RECVBND1B);
-      AddMultigridTask(MG_PHYSBND1B, MG_PRLNGFC1B);
+    if (pmy_mgdriver_->redblack_) {
+      AddMultigridTask(MG_CLEARBND1R,  MG_SMOOTH1R);
+      AddMultigridTask(MG_STARTRECV1B, MG_CLEARBND1R);
+      AddMultigridTask(MG_SENDBND1B,   MG_STARTRECV1B);
+      AddMultigridTask(MG_RECVBND1B,   MG_STARTRECV1B);
+      if (multilevel) {
+        AddMultigridTask(MG_PRLNGFC1B, MG_SENDBND1B|MG_RECVBND1B);
+        AddMultigridTask(MG_PHYSBND1B, MG_PRLNGFC1B);
+      } else {
+        AddMultigridTask(MG_PHYSBND1B, MG_SENDBND1B|MG_RECVBND1B);
+      }
+      AddMultigridTask(MG_SMOOTH1B,    MG_PHYSBND1B);
+      AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1B);
     } else {
-      AddMultigridTask(MG_PHYSBND1B, MG_SENDBND1B|MG_RECVBND1B);
+      AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1R);
     }
-    AddMultigridTask(MG_SMOOTH1B,    MG_PHYSBND1B);
-    AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1B);
   }
   if (nsmooth==2) {
     AddMultigridTask(MG_STARTRECV2R, MG_CLEARBND1B);
@@ -342,18 +346,22 @@ void MultigridTaskList::SetMGTaskListToFiner(int nsmooth, int ngh, int flag) {
       AddMultigridTask(MG_PHYSBND2R, MG_SENDBND2R|MG_RECVBND2R);
     }
     AddMultigridTask(MG_SMOOTH2R,    MG_PHYSBND2R);
-    AddMultigridTask(MG_CLEARBND2R,  MG_SMOOTH2R);
-    AddMultigridTask(MG_STARTRECV2B, MG_CLEARBND2R);
-    AddMultigridTask(MG_SENDBND2B,   MG_STARTRECV2B);
-    AddMultigridTask(MG_RECVBND2B,   MG_STARTRECV2B);
-    if (multilevel) {
-      AddMultigridTask(MG_PRLNGFC2B, MG_SENDBND2B|MG_RECVBND2B);
-      AddMultigridTask(MG_PHYSBND2B, MG_PRLNGFC2B);
+    if (pmy_mgdriver_->redblack_) {
+      AddMultigridTask(MG_CLEARBND2R,  MG_SMOOTH2R);
+      AddMultigridTask(MG_STARTRECV2B, MG_CLEARBND2R);
+      AddMultigridTask(MG_SENDBND2B,   MG_STARTRECV2B);
+      AddMultigridTask(MG_RECVBND2B,   MG_STARTRECV2B);
+      if (multilevel) {
+        AddMultigridTask(MG_PRLNGFC2B, MG_SENDBND2B|MG_RECVBND2B);
+        AddMultigridTask(MG_PHYSBND2B, MG_PRLNGFC2B);
+      } else {
+        AddMultigridTask(MG_PHYSBND2B, MG_SENDBND2B|MG_RECVBND2B);
+      }
+      AddMultigridTask(MG_SMOOTH2B,    MG_PHYSBND2B);
+      AddMultigridTask(MG_CLEARBND2B,  MG_SMOOTH2B);
     } else {
-      AddMultigridTask(MG_PHYSBND2B, MG_SENDBND2B|MG_RECVBND2B);
+      AddMultigridTask(MG_CLEARBND2B,  MG_SMOOTH2R);
     }
-    AddMultigridTask(MG_SMOOTH2B,    MG_PHYSBND2B);
-    AddMultigridTask(MG_CLEARBND2B,  MG_SMOOTH2B);
   }
   if (flag==2) { // last
     if (nsmooth==0)
@@ -417,18 +425,22 @@ void MultigridTaskList::SetMGTaskListToCoarser(int nsmooth, int ngh) {
     } else {
       AddMultigridTask(MG_SMOOTH1R,   MG_PHYSBND1R);
     }
-    AddMultigridTask(MG_CLEARBND1R,  MG_SMOOTH1R);
-    AddMultigridTask(MG_STARTRECV1B, MG_CLEARBND1R);
-    AddMultigridTask(MG_SENDBND1B,   MG_STARTRECV1B);
-    AddMultigridTask(MG_RECVBND1B,   MG_STARTRECV1B);
-    if (multilevel) {
-      AddMultigridTask(MG_PRLNGFC1B, MG_SENDBND1B|MG_RECVBND1B);
-      AddMultigridTask(MG_PHYSBND1B, MG_PRLNGFC1B);
+    if (pmy_mgdriver_->redblack_) {
+      AddMultigridTask(MG_CLEARBND1R,  MG_SMOOTH1R);
+      AddMultigridTask(MG_STARTRECV1B, MG_CLEARBND1R);
+      AddMultigridTask(MG_SENDBND1B,   MG_STARTRECV1B);
+      AddMultigridTask(MG_RECVBND1B,   MG_STARTRECV1B);
+      if (multilevel) {
+        AddMultigridTask(MG_PRLNGFC1B, MG_SENDBND1B|MG_RECVBND1B);
+        AddMultigridTask(MG_PHYSBND1B, MG_PRLNGFC1B);
+      } else {
+        AddMultigridTask(MG_PHYSBND1B, MG_SENDBND1B|MG_RECVBND1B);
+      }
+      AddMultigridTask(MG_SMOOTH1B,    MG_PHYSBND1B);
+      AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1B);
     } else {
-      AddMultigridTask(MG_PHYSBND1B, MG_SENDBND1B|MG_RECVBND1B);
+      AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1R);
     }
-    AddMultigridTask(MG_SMOOTH1B,    MG_PHYSBND1B);
-    AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1B);
 
     AddMultigridTask(MG_STARTRECV0 , MG_CLEARBND1B);
     AddMultigridTask(MG_SENDBND0,    MG_STARTRECV0);
@@ -457,18 +469,22 @@ void MultigridTaskList::SetMGTaskListToCoarser(int nsmooth, int ngh) {
     } else {
       AddMultigridTask(MG_SMOOTH1R,   MG_PHYSBND1R);
     }
-    AddMultigridTask(MG_CLEARBND1R,  MG_SMOOTH1R);
-    AddMultigridTask(MG_STARTRECV1B, MG_CLEARBND1R);
-    AddMultigridTask(MG_SENDBND1B,   MG_STARTRECV1B);
-    AddMultigridTask(MG_RECVBND1B,   MG_STARTRECV1B);
-    if (multilevel) {
-      AddMultigridTask(MG_PRLNGFC1B, MG_SENDBND1B|MG_RECVBND1B);
-      AddMultigridTask(MG_PHYSBND1B, MG_PRLNGFC1B);
+    if (pmy_mgdriver_->redblack_) {
+      AddMultigridTask(MG_CLEARBND1R,  MG_SMOOTH1R);
+      AddMultigridTask(MG_STARTRECV1B, MG_CLEARBND1R);
+      AddMultigridTask(MG_SENDBND1B,   MG_STARTRECV1B);
+      AddMultigridTask(MG_RECVBND1B,   MG_STARTRECV1B);
+      if (multilevel) {
+        AddMultigridTask(MG_PRLNGFC1B, MG_SENDBND1B|MG_RECVBND1B);
+        AddMultigridTask(MG_PHYSBND1B, MG_PRLNGFC1B);
+      } else {
+        AddMultigridTask(MG_PHYSBND1B, MG_SENDBND1B|MG_RECVBND1B);
+      }
+      AddMultigridTask(MG_SMOOTH1B,    MG_PHYSBND1B);
+      AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1B);
     } else {
-      AddMultigridTask(MG_PHYSBND1B, MG_SENDBND1B|MG_RECVBND1B);
+      AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1R);
     }
-    AddMultigridTask(MG_SMOOTH1B,    MG_PHYSBND1B);
-    AddMultigridTask(MG_CLEARBND1B,  MG_SMOOTH1B);
     AddMultigridTask(MG_STARTRECV2R, MG_CLEARBND1B);
     AddMultigridTask(MG_SENDBND2R,   MG_STARTRECV2R);
     AddMultigridTask(MG_RECVBND2R,   MG_STARTRECV2R);
@@ -479,18 +495,22 @@ void MultigridTaskList::SetMGTaskListToCoarser(int nsmooth, int ngh) {
       AddMultigridTask(MG_PHYSBND2R, MG_SENDBND2R|MG_RECVBND2R);
     }
     AddMultigridTask(MG_SMOOTH2R,    MG_PHYSBND2R);
-    AddMultigridTask(MG_CLEARBND2R,  MG_SMOOTH2R);
-    AddMultigridTask(MG_STARTRECV2B, MG_CLEARBND2R);
-    AddMultigridTask(MG_SENDBND2B,   MG_STARTRECV2B);
-    AddMultigridTask(MG_RECVBND2B,   MG_STARTRECV2B);
-    if (multilevel) {
-      AddMultigridTask(MG_PRLNGFC2B, MG_SENDBND2B|MG_RECVBND2B);
-      AddMultigridTask(MG_PHYSBND2B, MG_PRLNGFC2B);
+    if (pmy_mgdriver_->redblack_) {
+      AddMultigridTask(MG_CLEARBND2R,  MG_SMOOTH2R);
+      AddMultigridTask(MG_STARTRECV2B, MG_CLEARBND2R);
+      AddMultigridTask(MG_SENDBND2B,   MG_STARTRECV2B);
+      AddMultigridTask(MG_RECVBND2B,   MG_STARTRECV2B);
+      if (multilevel) {
+        AddMultigridTask(MG_PRLNGFC2B, MG_SENDBND2B|MG_RECVBND2B);
+        AddMultigridTask(MG_PHYSBND2B, MG_PRLNGFC2B);
+      } else {
+        AddMultigridTask(MG_PHYSBND2B, MG_SENDBND2B|MG_RECVBND2B);
+      }
+      AddMultigridTask(MG_SMOOTH2B,    MG_PHYSBND2B);
+      AddMultigridTask(MG_CLEARBND2B,  MG_SMOOTH2B);
     } else {
-      AddMultigridTask(MG_PHYSBND2B, MG_SENDBND2B|MG_RECVBND2B);
+      AddMultigridTask(MG_CLEARBND2B,  MG_SMOOTH2R);
     }
-    AddMultigridTask(MG_SMOOTH2B,    MG_PHYSBND2B);
-    AddMultigridTask(MG_CLEARBND2B,  MG_SMOOTH2B);
     AddMultigridTask(MG_STARTRECV0,  MG_CLEARBND2B);
     AddMultigridTask(MG_SENDBND0,    MG_STARTRECV0);
     AddMultigridTask(MG_RECVBND0,    MG_STARTRECV0);
@@ -528,3 +548,22 @@ void MultigridTaskList::SetMGTaskListFMGProlongate(int flag) {
     AddMultigridTask(MG_CLEARBNDP,  MG_FMGPROLONG);
   }
 }
+
+
+//----------------------------------------------------------------------------------------
+//! \fn void MultigridTaskList::SetMGTaskListBoundaryCommunication()
+//! \brief Set the task list for boundary communication
+
+void MultigridTaskList::SetMGTaskListBoundaryCommunication() {
+  ClearTaskList();
+  AddMultigridTask(MG_STARTRECVL, NONE);
+  AddMultigridTask(MG_SENDBNDL,   MG_STARTRECVL);
+  AddMultigridTask(MG_RECVBNDL,   MG_STARTRECVL);
+  if (pmy_mgdriver_->nreflevel_ > 0) {
+    AddMultigridTask(MG_PRLNGFCL, MG_SENDBNDL|MG_RECVBNDL);
+    AddMultigridTask(MG_PHYSBNDL, MG_PRLNGFCL);
+  } else {
+    AddMultigridTask(MG_PHYSBNDL, MG_RECVBNDL|MG_SENDBNDL);
+  }
+  AddMultigridTask(MG_CLEARBNDL,  MG_PHYSBNDL);
+}
diff --git a/src/task_list/mg_task_list.hpp b/src/task_list/mg_task_list.hpp
index 6c67d2bd0d..16b2a416b6 100644
--- a/src/task_list/mg_task_list.hpp
+++ b/src/task_list/mg_task_list.hpp
@@ -74,6 +74,7 @@ class MultigridTaskList {
   void SetMGTaskListToFiner(int nsmooth, int ngh, int flag = 0);
   void SetMGTaskListToCoarser(int nsmooth, int ngh);
   void SetMGTaskListFMGProlongate(int flag = 0);
+  void SetMGTaskListBoundaryCommunication();
 
  private:
   MultigridDriver* pmy_mgdriver_;
diff --git a/src/utils/show_config.cpp b/src/utils/show_config.cpp
index f2dae42369..17f3adb919 100644
--- a/src/utils/show_config.cpp
+++ b/src/utils/show_config.cpp
@@ -56,6 +56,11 @@ void ShowConfig() {
   } else {
     std::cout<<"  Cosmic Ray Transport:       OFF" << std::endl;
   }
+  if (CRDIFFUSION_ENABLED) {
+    std::cout<<"  Cosmic Ray Diffusion:       ON" << std::endl;
+  } else {
+    std::cout<<"  Cosmic Ray Diffusion:       OFF" << std::endl;
+  }
 
   // configure.py output: "Frame transformations"
   if (SELF_GRAVITY_ENABLED == 1) {
diff --git a/tst/regression/scripts/tests/pgen/pgen_compile.py b/tst/regression/scripts/tests/pgen/pgen_compile.py
index 8e683f9c23..d19778b047 100644
--- a/tst/regression/scripts/tests/pgen/pgen_compile.py
+++ b/tst/regression/scripts/tests/pgen/pgen_compile.py
@@ -27,19 +27,21 @@
 mhd_probs = set(['hb3', 'hgb', 'jgg', 'cpaw', 'field_loop',
                  'orszag_tang', 'rotor', 'resist', 'magnoh'])
 grav_mg_probs = set(['binary_gravity', 'collapse'])
+crdiff_probs = set(['cr_diffusion_mg'])
 # Chemistry problems
 chem_probs = set([pgen for pgen in pgen_choices if pgen[0:5] == 'chem_'])
 # Newtonian Hydro-only or MHD-optional problems are all leftover pgen/ files
 # --rsolver=hllc by default
-hydro_probs = pgen_choices - gr_probs - mhd_probs - grav_mg_probs - chem_probs
+hydro_probs = pgen_choices - gr_probs - mhd_probs - grav_mg_probs \
+            - chem_probs - crdiff_probs
 # Curvilinear problems
-
 # Define configure flags for each set:
 gr_args = ['g', 't', '-coord=minkowski']
 mhd_args = ['b']
 grav_mg_args = ['-grav=mg']
 chem_args = ['-chemistry=H2', '-chem_ode_solver=forward_euler']
 hydro_args = []
+crdiff_args = ['b', 'crdiff']
 
 
 # Prepare Athena++
@@ -48,20 +50,23 @@ def prepare(**kwargs):
     # Check that code compiles all pgen files in single or double precision
     for single_precision in [True, False]:
         for pgen_set, args in zip([gr_probs, mhd_probs, grav_mg_probs,
-                                   chem_probs, hydro_probs],
+                                   chem_probs, crdiff_probs, hydro_probs],
                                   [gr_args, mhd_args, grav_mg_args,
-                                   chem_args, hydro_args]):
+                                   chem_args, crdiff_args, hydro_args]):
             args_lcl = list(args)
             if single_precision:
                 args_lcl.extend(['float'])
             # "make clean" and link into executable only for the first problem
             # in the set that shares ./configure.py flags (except --pgen)
-            pgen = pgen_set.pop()
-            athena.configure(*args_lcl, prob=pgen, **kwargs)
-            athena.make(clean_first=True, obj_only=False)
+            first = True
             for pgen in pgen_set:
-                athena.configure(*args_lcl, prob=pgen, **kwargs)
-                athena.make(clean_first=False, obj_only=True)
+                if first:
+                    athena.configure(*args_lcl, prob=pgen, **kwargs)
+                    athena.make(clean_first=True, obj_only=False)
+                    first = False
+                else:
+                    athena.configure(*args_lcl, prob=pgen, **kwargs)
+                    athena.make(clean_first=False, obj_only=True)
 
 
 # Run Athena++