diff --git a/applications/periodic_channel.cc b/applications/periodic_channel.cc
index c26740e..87cd05d 100644
--- a/applications/periodic_channel.cc
+++ b/applications/periodic_channel.cc
@@ -266,7 +266,7 @@ PeriodicChannelProblem<dim>::local_compute_force(
         {
           vel_values.submit_value(force, q);
         }
-      vel_values.integrate(true, false);
+      vel_values.integrate(EvaluationFlags::values);
       vel_values.distribute_local_to_global(dst);
     }
 }
diff --git a/include/adaflo/sharp_interface.h b/include/adaflo/sharp_interface.h
index 2537f90..bf2c8c2 100644
--- a/include/adaflo/sharp_interface.h
+++ b/include/adaflo/sharp_interface.h
@@ -717,7 +717,7 @@ class FrontTrackingSolver : public SharpInterfaceSolver
                      navier_stokes_solver.get_matrix().begin_densities(cell)[q]);
                 phi.submit_value(force, q);
               }
-            phi.integrate_scatter(true, false, vec);
+            phi.integrate_scatter(EvaluationFlags::values, vec);
           }
       },
       navier_stokes_solver.user_rhs.block(0),
@@ -1040,7 +1040,7 @@ class MixedLevelSetSolver : public SharpInterfaceSolver
                      navier_stokes_solver.get_matrix().begin_densities(cell)[q]);
                 phi.submit_value(force, q);
               }
-            phi.integrate_scatter(true, false, vec);
+            phi.integrate_scatter(EvaluationFlags::values, vec);
           }
       },
       navier_stokes_solver.user_rhs.block(0),
diff --git a/include/adaflo/sharp_interface_util.h b/include/adaflo/sharp_interface_util.h
index 1f47914..4750a67 100644
--- a/include/adaflo/sharp_interface_util.h
+++ b/include/adaflo/sharp_interface_util.h
@@ -1008,13 +1008,13 @@ compute_force_vector_regularized(const MatrixFree<dim, double> &matrix_free,
         {
           level_set.reinit(cell);
           level_set.read_dof_values_plain(level_set_as_heaviside);
-          level_set.evaluate(false, true);
+          level_set.evaluate(EvaluationFlags::gradients);
 
           surface_tension.reinit(cell);
 
           curvature.reinit(cell);
           curvature.read_dof_values_plain(curvature_solution);
-          curvature.evaluate(true, false);
+          curvature.evaluate(EvaluationFlags::values);
 
           for (unsigned int q_index = 0; q_index < surface_tension.n_q_points; ++q_index)
             {
@@ -1023,7 +1023,7 @@ compute_force_vector_regularized(const MatrixFree<dim, double> &matrix_free,
                                              curvature.get_value(q_index),
                                            q_index);
             }
-          surface_tension.integrate_scatter(true, false, force_rhs);
+          surface_tension.integrate_scatter(EvaluationFlags::values, force_rhs);
         }
     },
     force_rhs,
diff --git a/source/level_set_okz.cc b/source/level_set_okz.cc
index 15a6848..6e629b9 100644
--- a/source/level_set_okz.cc
+++ b/source/level_set_okz.cc
@@ -286,13 +286,13 @@ LevelSetOKZSolver<dim>::local_projection_matrix(
           for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
             phi.begin_dof_values()[j] = VectorizedArray<double>();
           phi.begin_dof_values()[i] = 1.;
-          phi.evaluate(true, true);
+          phi.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
           for (unsigned int q = 0; q < phi.n_q_points; ++q)
             {
               phi.submit_value(phi.get_value(q), q);
               phi.submit_gradient(phi.get_gradient(q) * damping, q);
             }
-          phi.integrate(true, true);
+          phi.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
           for (unsigned int v = 0; v < data.n_active_entries_per_cell_batch(cell); ++v)
             for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
               scratch.matrices[v](phi.get_shape_info().lexicographic_numbering[j],
@@ -353,7 +353,7 @@ LevelSetOKZSolver<dim>::local_compute_force(
           vector_t *densities = this->navier_stokes.get_matrix().begin_densities(cell);
           vector_t *viscosities =
             this->navier_stokes.get_matrix().begin_viscosities(cell);
-          ls_values.evaluate(true, false);
+          ls_values.evaluate(EvaluationFlags::values);
           for (unsigned int q = 0; q < ls_values.n_q_points; ++q)
             {
               densities[q] = this->parameters.density +
@@ -374,14 +374,14 @@ LevelSetOKZSolver<dim>::local_compute_force(
                                    ls_values.get_dof_value(j);
               pre_values.submit_dof_value(projected_value, i);
             }
-          pre_values.evaluate(false, true);
+          pre_values.evaluate(EvaluationFlags::gradients);
         }
       else
-        ls_values.evaluate(false, true);
+        ls_values.evaluate(EvaluationFlags::gradients);
 
       // evaluate curvature and level set gradient
       curv_values.read_dof_values_plain(this->solution.block(1));
-      curv_values.evaluate(true, false);
+      curv_values.evaluate(EvaluationFlags::values);
 
       // evaluate surface tension force and gravity force
       for (unsigned int q = 0; q < curv_values.n_q_points; ++q)
@@ -402,7 +402,7 @@ LevelSetOKZSolver<dim>::local_compute_force(
 
           vel_values.submit_value(force, q);
         }
-      vel_values.integrate(true, false);
+      vel_values.integrate(EvaluationFlags::values);
 
       vel_values.distribute_local_to_global(dst);
     }
diff --git a/source/level_set_okz_advance_concentration.cc b/source/level_set_okz_advance_concentration.cc
index d02ce5b..cd898e8 100644
--- a/source/level_set_okz_advance_concentration.cc
+++ b/source/level_set_okz_advance_concentration.cc
@@ -234,7 +234,8 @@ LevelSetOKZSolverAdvanceConcentration<dim>::local_advance_concentration(
         &evaluated_convection[cell * ls_values.n_q_points];
       ls_values.reinit(cell);
 
-      ls_values.gather_evaluate(src, true, true);
+      ls_values.gather_evaluate(src,
+                                EvaluationFlags::values | EvaluationFlags::gradients);
 
       for (unsigned int q = 0; q < ls_values.n_q_points; ++q)
         {
@@ -246,7 +247,11 @@ LevelSetOKZSolverAdvanceConcentration<dim>::local_advance_concentration(
           if (this->parameters.convection_stabilization)
             ls_values.submit_gradient(artificial_viscosities[cell] * ls_grad, q);
         }
-      ls_values.integrate_scatter(true, this->parameters.convection_stabilization, dst);
+      ls_values.integrate_scatter(EvaluationFlags::values |
+                                    (this->parameters.convection_stabilization ?
+                                       EvaluationFlags::gradients :
+                                       EvaluationFlags::nothing),
+                                  dst);
     }
 }
 
@@ -327,12 +332,12 @@ LevelSetOKZSolverAdvanceConcentration<dim>::local_advance_concentration_rhs(
       ls_values_old.read_dof_values_plain(this->solution_old);
       ls_values_old_old.read_dof_values_plain(this->solution_old_old);
 
-      vel_values.evaluate(true, false);
-      vel_values_old.evaluate(true, false);
-      vel_values_old_old.evaluate(true, false);
-      ls_values.evaluate(true, true);
-      ls_values_old.evaluate(true, true);
-      ls_values_old_old.evaluate(true, true);
+      vel_values.evaluate(EvaluationFlags::values);
+      vel_values_old.evaluate(EvaluationFlags::values);
+      vel_values_old_old.evaluate(EvaluationFlags::values);
+      ls_values.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
+      ls_values_old.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
+      ls_values_old_old.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
 
       if (this->parameters.convection_stabilization)
         {
@@ -381,7 +386,11 @@ LevelSetOKZSolverAdvanceConcentration<dim>::local_advance_concentration_rhs(
             ls_values.submit_gradient(-artificial_viscosities[cell] * ls_grad, q);
           velocities[q] = vel_values.get_value(q);
         }
-      ls_values.integrate_scatter(true, this->parameters.convection_stabilization, dst);
+      ls_values.integrate_scatter(EvaluationFlags::values |
+                                    (this->parameters.convection_stabilization ?
+                                       EvaluationFlags::gradients :
+                                       EvaluationFlags::nothing),
+                                  dst);
     }
 }
 
diff --git a/source/level_set_okz_compute_curvature.cc b/source/level_set_okz_compute_curvature.cc
index 194fcd5..eb4b049 100644
--- a/source/level_set_okz_compute_curvature.cc
+++ b/source/level_set_okz_compute_curvature.cc
@@ -103,7 +103,10 @@ LevelSetOKZSolverComputeCurvature<dim>::local_compute_curvature(
       phi.read_dof_values(src);
       // If diffusion_setting is true a damping term is added to the weak form
       //  i.e. diffusion_setting=1 => diffusion_setting%2 == 1 is true.
-      phi.evaluate(diffusion_setting < 2, diffusion_setting % 2 == 1);
+      phi.evaluate(
+        ((diffusion_setting < 2) ? EvaluationFlags::values : EvaluationFlags::nothing) |
+        ((diffusion_setting % 2 == 1) ? EvaluationFlags::gradients :
+                                        EvaluationFlags::nothing));
       const VectorizedArray<double> damping =
         diffusion_setting % 2 == 1 ?
           Utilities::fixed_power<2>(
@@ -117,7 +120,10 @@ LevelSetOKZSolverComputeCurvature<dim>::local_compute_curvature(
           if (diffusion_setting % 2 == 1)
             phi.submit_gradient(phi.get_gradient(q) * damping, q);
         }
-      phi.integrate(diffusion_setting < 2, diffusion_setting % 2 == 1);
+      phi.integrate(
+        ((diffusion_setting < 2) ? EvaluationFlags::values : EvaluationFlags::nothing) |
+        ((diffusion_setting % 2 == 1) ? EvaluationFlags::gradients :
+                                        EvaluationFlags::nothing));
       phi.distribute_local_to_global(dst);
     }
 }
@@ -239,10 +245,10 @@ LevelSetOKZSolverComputeCurvature<dim>::local_compute_curvature_rhs(
 
       if (all_zero == false)
         {
-          normal_values.evaluate(false, true, false);
+          normal_values.evaluate(EvaluationFlags::gradients);
           for (unsigned int q = 0; q < normal_values.n_q_points; ++q)
             curv_values.submit_value(-get_divergence(normal_values, q), q);
-          curv_values.integrate(true, false);
+          curv_values.integrate(EvaluationFlags::values);
           curv_values.distribute_local_to_global(dst);
         }
     }
diff --git a/source/level_set_okz_compute_normal.cc b/source/level_set_okz_compute_normal.cc
index a8bb9dd..edecfaa 100644
--- a/source/level_set_okz_compute_normal.cc
+++ b/source/level_set_okz_compute_normal.cc
@@ -101,7 +101,7 @@ LevelSetOKZSolverComputeNormal<dim>::local_compute_normal(
     {
       phi.reinit(cell);
       phi.read_dof_values(src);
-      phi.evaluate(true, true);
+      phi.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
       const VectorizedArray<Number> damping =
         Number(parameters.damping_scale_factor) *
         Utilities::fixed_power<2>(
@@ -111,7 +111,7 @@ LevelSetOKZSolverComputeNormal<dim>::local_compute_normal(
           phi.submit_value(phi.get_value(q), q);
           phi.submit_gradient(phi.get_gradient(q) * damping, q);
         }
-      phi.integrate(true, true);
+      phi.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
       phi.distribute_local_to_global(dst);
     }
 }
@@ -143,12 +143,12 @@ LevelSetOKZSolverComputeNormal<dim>::local_compute_normal_rhs(
       ls_values.reinit(cell);
 
       ls_values.read_dof_values_plain(this->level_set_solution);
-      ls_values.evaluate(false, true, false);
+      ls_values.evaluate(EvaluationFlags::gradients);
 
       for (unsigned int q = 0; q < normal_values.n_q_points; ++q)
         normal_values.submit_value(ls_values.get_gradient(q), q);
 
-      normal_values.integrate(true, false);
+      normal_values.integrate(EvaluationFlags::values);
       normal_values.distribute_local_to_global(dst);
     }
 }
diff --git a/source/level_set_okz_preconditioner.cc b/source/level_set_okz_preconditioner.cc
index c9363a1..cb6d0a3 100644
--- a/source/level_set_okz_preconditioner.cc
+++ b/source/level_set_okz_preconditioner.cc
@@ -146,13 +146,13 @@ initialize_projection_matrix(
           for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)                          \
             phi.begin_dof_values()[j] = VectorizedArray<double>();                      \
           phi.begin_dof_values()[i] = 1.;                                               \
-          phi.evaluate(true, true);                                                     \
+          phi.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);           \
           for (unsigned int q = 0; q < phi.n_q_points; ++q)                             \
             {                                                                           \
               phi.submit_value(phi.get_value(q), q);                                    \
               phi.submit_gradient(phi.get_gradient(q) * damping, q);                    \
             }                                                                           \
-          phi.integrate(true, true);                                                    \
+          phi.integrate(EvaluationFlags::values | EvaluationFlags::gradients);          \
           for (unsigned int v = 0; v < data.n_active_entries_per_cell_batch(cell); ++v) \
             for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)                        \
               scratch.matrices[v](phi.get_shape_info().lexicographic_numbering[j],      \
diff --git a/source/level_set_okz_reinitialization.cc b/source/level_set_okz_reinitialization.cc
index ee1fdea..cce9d7e 100644
--- a/source/level_set_okz_reinitialization.cc
+++ b/source/level_set_okz_reinitialization.cc
@@ -76,7 +76,7 @@ LevelSetOKZSolverReinitialization<dim>::local_reinitialize(
     {
       phi.reinit(cell);
       phi.read_dof_values(src);
-      phi.evaluate(true, true, false);
+      phi.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
 
       VectorizedArray<double> cell_diameter = this->cell_diameters[cell];
       VectorizedArray<double> diffusion =
@@ -99,7 +99,7 @@ LevelSetOKZSolverReinitialization<dim>::local_reinitialize(
             phi.submit_gradient(phi.get_gradient(q) * diffusion, q);
           }
 
-      phi.integrate(true, true);
+      phi.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
       phi.distribute_local_to_global(dst);
     }
 }
@@ -148,11 +148,11 @@ LevelSetOKZSolverReinitialization<dim>::local_reinitialize_rhs(
     {
       phi.reinit(cell);
       phi.read_dof_values_plain(this->solution);
-      phi.evaluate(true, true, false);
+      phi.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
 
       normals.reinit(cell);
       normals.read_dof_values_plain(this->normal_vector_field);
-      normals.evaluate(true, false, false);
+      normals.evaluate(EvaluationFlags::values);
 
       VectorizedArray<double> cell_diameter = this->cell_diameters[cell];
       VectorizedArray<double> diffusion =
@@ -182,7 +182,7 @@ LevelSetOKZSolverReinitialization<dim>::local_reinitialize_rhs(
             phi.submit_gradient(-diffusion * phi.get_gradient(q), q);
           }
 
-      phi.integrate(false, true);
+      phi.integrate(EvaluationFlags::gradients);
       phi.distribute_local_to_global(dst);
     }
 }
diff --git a/source/navier_stokes_matrix.cc b/source/navier_stokes_matrix.cc
index 9adad59..82b0c99 100644
--- a/source/navier_stokes_matrix.cc
+++ b/source/navier_stokes_matrix.cc
@@ -664,17 +664,24 @@ NavierStokesMatrix<dim>::local_operation(
       else
         get_velocity_values(velocity, src);
 
-      velocity.evaluate(parameters.physical_type != FlowParameters::stokes, true);
+      velocity.evaluate(((parameters.physical_type != FlowParameters::stokes) ?
+                           EvaluationFlags::values :
+                           EvaluationFlags::nothing) |
+                        EvaluationFlags::gradients);
 
       if (LocalOps == NavierStokesOps::residual &&
           parameters.physical_type == FlowParameters::incompressible)
         {
           old.reinit(cell);
           old.read_dof_values_plain(solution_old.block(0));
-          old.evaluate(true, need_extrapolated_velocity);
+          old.evaluate(EvaluationFlags::values |
+                       (need_extrapolated_velocity ? EvaluationFlags::gradients :
+                                                     EvaluationFlags::nothing));
           old_old.reinit(cell);
           old_old.read_dof_values_plain(solution_old_old.block(0));
-          old_old.evaluate(true, need_extrapolated_velocity);
+          old_old.evaluate(EvaluationFlags::values |
+                           (need_extrapolated_velocity ? EvaluationFlags::gradients :
+                                                         EvaluationFlags::nothing));
         }
 
       // get pressure part
@@ -685,7 +692,7 @@ NavierStokesMatrix<dim>::local_operation(
             get_pressure_values_plain(pressure, src);
           else
             get_pressure_values(pressure, src);
-          pressure.evaluate(true, false);
+          pressure.evaluate(EvaluationFlags::values);
         }
 
       // loop over all quadrature points and implement the Navier-Stokes
@@ -886,12 +893,15 @@ NavierStokesMatrix<dim>::local_operation(
 
       // finally, integrate velocity and pressure and increase pointers to
       // linearization data and rho and mu values
-      velocity.integrate(parameters.physical_type != FlowParameters::stokes, true);
+      velocity.integrate(((parameters.physical_type != FlowParameters::stokes) ?
+                            EvaluationFlags::values :
+                            EvaluationFlags::nothing) |
+                         EvaluationFlags::gradients);
       distribute_velocity_ltg(velocity, dst);
       if (LocalOps != NavierStokesOps::vmult_velocity &&
           parameters.linearization != FlowParameters::projection)
         {
-          pressure.integrate(true, false);
+          pressure.integrate(EvaluationFlags::values);
           distribute_pressure_ltg(pressure, dst);
         }
       linearized += velocity.n_q_points;
@@ -930,7 +940,7 @@ NavierStokesMatrix<dim>::local_divergence(
         velocity.read_dof_values_plain(src);
       else
         velocity.read_dof_values(src);
-      velocity.evaluate(false, true, false);
+      velocity.evaluate(EvaluationFlags::gradients);
 
       for (unsigned int q = 0; q < velocity.n_q_points; ++q)
         {
@@ -944,7 +954,7 @@ NavierStokesMatrix<dim>::local_divergence(
           pressure.submit_value(weight * velocity.get_divergence(q), q);
         }
 
-      pressure.integrate(true, false);
+      pressure.integrate(EvaluationFlags::values);
       pressure.distribute_local_to_global(dst);
     }
 }
@@ -976,7 +986,7 @@ NavierStokesMatrix<dim>::local_pressure_poisson(
         {
           pressure.reinit(cell);
           get_pressure_values(pressure, src);
-          pressure.evaluate(false, true, false);
+          pressure.evaluate(EvaluationFlags::gradients);
 
           for (unsigned int q = 0; q < pressure.n_q_points; ++q)
             pressure.submit_gradient(pressure.get_gradient(q) *
@@ -984,7 +994,7 @@ NavierStokesMatrix<dim>::local_pressure_poisson(
                                               begin_densities(cell)[q])),
                                      q);
 
-          pressure.integrate(false, true);
+          pressure.integrate(EvaluationFlags::gradients);
           pressure.distribute_local_to_global(dst);
         }
     }
@@ -998,7 +1008,7 @@ NavierStokesMatrix<dim>::local_pressure_poisson(
         {
           pressure.reinit(cell);
           get_pressure_values(pressure, src);
-          pressure.evaluate(false, true, false);
+          pressure.evaluate(EvaluationFlags::gradients);
 
           const vector_t rho_value =
             use_variable_coefficients ?
@@ -1014,7 +1024,7 @@ NavierStokesMatrix<dim>::local_pressure_poisson(
           for (unsigned int q = 0; q < pressure.n_q_points; ++q)
             pressure.submit_gradient(pressure.get_gradient(q) * coefficient, q);
 
-          pressure.integrate(false, true);
+          pressure.integrate(EvaluationFlags::gradients);
           pressure.distribute_local_to_global(dst);
         }
     }
@@ -1040,7 +1050,7 @@ NavierStokesMatrix<dim>::local_pressure_mass(
     {
       pressure.reinit(cell);
       get_pressure_values(pressure, src);
-      pressure.evaluate(true, false, false);
+      pressure.evaluate(EvaluationFlags::values);
 
       const vector_t mu_value = use_variable_coefficients ?
                                   begin_viscosities(cell)[data.get_n_q_points(0) / 2] :
@@ -1054,7 +1064,7 @@ NavierStokesMatrix<dim>::local_pressure_mass(
       for (unsigned int q = 0; q < pressure.n_q_points; ++q)
         pressure.submit_value(pressure.get_value(q) * coefficient, q);
 
-      pressure.integrate(true, false);
+      pressure.integrate(EvaluationFlags::values);
       pressure.distribute_local_to_global(dst);
     }
 }
@@ -1078,7 +1088,7 @@ NavierStokesMatrix<dim>::local_pressure_mass_weight(
       one = 1.;
       for (unsigned int q = 0; q < pressure.n_q_points; ++q)
         pressure.submit_value(one, q);
-      pressure.integrate(true, false);
+      pressure.integrate(EvaluationFlags::values);
       pressure.distribute_local_to_global(dst);
     }
 }
@@ -1107,7 +1117,7 @@ NavierStokesMatrix<dim>::local_pressure_convdiff(
     {
       pressure.reinit(cell);
       get_pressure_values(pressure, src);
-      pressure.evaluate(false, true, false);
+      pressure.evaluate(EvaluationFlags::gradients);
 
       const vector_t mu_value = use_variable_coefficients ?
                                   begin_viscosities(cell)[pressure.n_q_points / 2] :
@@ -1121,7 +1131,7 @@ NavierStokesMatrix<dim>::local_pressure_convdiff(
           // pressure.submit_value(pres_grad*linearized[q].first, q);
         }
 
-      pressure.integrate(false, true);
+      pressure.integrate(EvaluationFlags::gradients);
       distribute_pressure_ltg(pressure, dst);
 
       linearized += pressure.n_q_points;
diff --git a/source/phase_field_local.cc b/source/phase_field_local.cc
index e1d8f4d..9fc144b 100644
--- a/source/phase_field_local.cc
+++ b/source/phase_field_local.cc
@@ -75,7 +75,7 @@ PhaseFieldSolver<dim>::local_compute_force(
       // set variable parameters
       if (use_variable_parameters)
         {
-          ls_values.evaluate(true, false);
+          ls_values.evaluate(EvaluationFlags::values);
           vector_t *densities = this->navier_stokes.get_matrix().begin_densities(cell);
           vector_t *viscosities =
             this->navier_stokes.get_matrix().begin_viscosities(cell);
@@ -104,8 +104,8 @@ PhaseFieldSolver<dim>::local_compute_force(
 
       // evaluate curvature and level set gradient
       curv_values.read_dof_values(this->solution.block(1));
-      curv_values.evaluate(true, false);
-      pre_values.evaluate(false, true);
+      curv_values.evaluate(EvaluationFlags::values);
+      pre_values.evaluate(EvaluationFlags::gradients);
 
       // evaluate surface tension force and gravity force
       for (unsigned int q = 0; q < curv_values.n_q_points; ++q)
@@ -123,7 +123,7 @@ PhaseFieldSolver<dim>::local_compute_force(
 
           vel_values.submit_value(force, q);
         }
-      vel_values.integrate(true, false);
+      vel_values.integrate(EvaluationFlags::values);
 
       vel_values.distribute_local_to_global(dst);
     }
@@ -171,12 +171,12 @@ PhaseFieldSolver<dim>::local_residual(
       old_old_c_values.read_dof_values_plain(this->solution_old_old.block(0));
       vel_values.read_dof_values_plain(*velocity_vector);
 
-      vel_values.evaluate(true, false);
-      old_old_c_values.evaluate(true, false);
-      old_c_values.evaluate(true, false);
+      vel_values.evaluate(EvaluationFlags::values);
+      old_old_c_values.evaluate(EvaluationFlags::values);
+      old_c_values.evaluate(EvaluationFlags::values);
 
-      c_values.evaluate(true, true);
-      phi_values.evaluate(true, true);
+      c_values.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
+      phi_values.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
 
       for (unsigned int q = 0; q < c_values.n_q_points; ++q)
         {
@@ -205,9 +205,9 @@ PhaseFieldSolver<dim>::local_residual(
           phi_values.submit_gradient(make_vectorized_array(-factor_4) * c_grad, q);
         }
 
-      c_values.integrate(true, true);
+      c_values.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
       c_values.distribute_local_to_global(dst.block(0));
-      phi_values.integrate(true, true);
+      phi_values.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
       phi_values.distribute_local_to_global(dst.block(1));
     }
 }
@@ -243,8 +243,8 @@ PhaseFieldSolver<dim>::local_vmult(
 
       phi_values.read_dof_values(src.block(1));
       c_values.read_dof_values(src.block(0));
-      c_values.evaluate(true, true);
-      phi_values.evaluate(true, true);
+      c_values.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
+      phi_values.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
 
       for (unsigned int q = 0; q < c_values.n_q_points; ++q)
         {
@@ -264,9 +264,9 @@ PhaseFieldSolver<dim>::local_vmult(
           phi_values.submit_gradient(make_vectorized_array(-factor_4) * c_grad, q);
         }
 
-      c_values.integrate(true, true);
+      c_values.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
       c_values.distribute_local_to_global(dst.block(0));
-      phi_values.integrate(true, true);
+      phi_values.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
       phi_values.distribute_local_to_global(dst.block(1));
     }
 }
@@ -287,10 +287,10 @@ PhaseFieldSolver<dim>::local_mass(
     {
       c_values.reinit(cell);
       c_values.read_dof_values(src);
-      c_values.evaluate(true, false);
+      c_values.evaluate(EvaluationFlags::values);
       for (unsigned int q = 0; q < c_values.n_q_points; ++q)
         c_values.submit_value(c_values.get_value(q), q);
-      c_values.integrate(true, false);
+      c_values.integrate(EvaluationFlags::values);
       c_values.distribute_local_to_global(dst);
     }
 }