diff --git a/src/hdf5_interface.cpp b/src/hdf5_interface.cpp
index a81f26e231..7133ad51ac 100644
--- a/src/hdf5_interface.cpp
+++ b/src/hdf5_interface.cpp
@@ -452,7 +452,7 @@ read_nd_vector(hid_t obj_id, const char* name, std::vector<double>& result,
                bool must_have)
 {
   if (object_exists(obj_id, name)) {
-    read_double(obj_id, name, &result[0], true);
+    read_double(obj_id, name, result.data(), true);
   } else if (must_have) {
     fatal_error(std::string("Must provide " + std::string(name) + "!"));
   }
@@ -466,8 +466,8 @@ read_nd_vector(hid_t obj_id, const char* name,
   if (object_exists(obj_id, name)) {
     int dim1 = result.size();
     int dim2 = result[0].size();
-    std::vector<double> temp_arr = std::vector<double>(dim1 * dim2);
-    read_double(obj_id, name, &temp_arr[0], true);
+    double temp_arr[dim1 * dim2];
+    read_double(obj_id, name, temp_arr, true);
 
     int temp_idx = 0;
     for (int i = 0; i < dim1; i++) {
@@ -488,8 +488,8 @@ read_nd_vector(hid_t obj_id, const char* name,
   if (object_exists(obj_id, name)) {
     int dim1 = result.size();
     int dim2 = result[0].size();
-    std::vector<int> temp_arr = std::vector<int>(dim1 * dim2);
-    read_int(obj_id, name, &temp_arr[0], true);
+    int temp_arr[dim1 * dim2];
+    read_int(obj_id, name, temp_arr, true);
 
     int temp_idx = 0;
     for (int i = 0; i < dim1; i++) {
@@ -512,8 +512,8 @@ read_nd_vector(hid_t obj_id, const char* name,
     int dim1 = result.size();
     int dim2 = result[0].size();
     int dim3 = result[0][0].size();
-    std::vector<double> temp_arr = std::vector<double>(dim1 * dim2 * dim3);
-    read_double(obj_id, name, &temp_arr[0], true);
+    double temp_arr[dim1 * dim2 * dim3];
+    read_double(obj_id, name, temp_arr, true);
 
     int temp_idx = 0;
     for (int i = 0; i < dim1; i++) {
@@ -537,8 +537,8 @@ read_nd_vector(hid_t obj_id, const char* name,
     int dim1 = result.size();
     int dim2 = result[0].size();
     int dim3 = result[0][0].size();
-    std::vector<int> temp_arr = std::vector<int>(dim1 * dim2 * dim3);
-    read_int(obj_id, name, &temp_arr[0], true);
+    int temp_arr[dim1 * dim2 * dim3];
+    read_int(obj_id, name, temp_arr, true);
 
     int temp_idx = 0;
     for (int i = 0; i < dim1; i++) {
@@ -563,9 +563,8 @@ read_nd_vector(hid_t obj_id, const char* name,
     int dim2 = result[0].size();
     int dim3 = result[0][0].size();
     int dim4 = result[0][0][0].size();
-    std::vector<double> temp_arr = std::vector<double>(
-         dim1 * dim2 * dim3 * dim4);
-    read_double(obj_id, name, &temp_arr[0], true);
+    double temp_arr[dim1 * dim2 * dim3 * dim4];
+    read_double(obj_id, name, temp_arr, true);
 
     int temp_idx = 0;
     for (int i = 0; i < dim1; i++) {
@@ -593,9 +592,8 @@ read_nd_vector(hid_t obj_id, const char* name,
     int dim3 = result[0][0].size();
     int dim4 = result[0][0][0].size();
     int dim5 = result[0][0][0][0].size();
-    std::vector<double> temp_arr = std::vector<double>(
-         dim1 * dim2 * dim3 * dim4 * dim5);
-    read_double(obj_id, name, &temp_arr[0], true);
+    double temp_arr[dim1 * dim2 * dim3 * dim4 * dim5];
+    read_double(obj_id, name, temp_arr, true);
 
     int temp_idx = 0;
     for (int i = 0; i < dim1; i++) {
diff --git a/src/mgxs.cpp b/src/mgxs.cpp
index 748e7e9498..3e84f63072 100644
--- a/src/mgxs.cpp
+++ b/src/mgxs.cpp
@@ -1,5 +1,19 @@
+#include <cmath>
+#include <cstdlib>
+#include <algorithm>
+#include <valarray>
+
+ #ifdef _OPENMP
+ # include <omp.h>
+ #endif
+
+#include "error.h"
+#include "math_functions.h"
+#include "random_lcg.h"
+#include "string_functions.h"
 #include "mgxs.h"
 
+
 namespace openmc {
 
 // Storage for the MGXS data
@@ -39,14 +53,7 @@ Mgxs::init(const std::string& in_name, double in_awr,
   int n_threads = 1;
 #endif
   cache.resize(n_threads);
-  for (int thread = 0; thread < n_threads; thread++) {
-    cache[thread].sqrtkT = 0.;
-    cache[thread].t = 0;
-    cache[thread].a = 0;
-    cache[thread].u = 0.;
-    cache[thread].v = 0.;
-    cache[thread].w = 0.;
-  }
+  // std::vector.resize() will value-initialize the members of cache[:]
 }
 
 //==============================================================================
@@ -59,7 +66,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, int in_num_groups,
   // get name
   char char_name[MAX_WORD_LEN];
   get_name(xs_id, char_name);
-  std::string in_name(char_name, std::strlen(char_name));
+  std::string in_name {char_name};
   // remove the leading '/'
   in_name = in_name.substr(1);
 
@@ -85,6 +92,9 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, int in_num_groups,
 
     // convert eV to Kelvin
     available_temps[i] /= K_BOLTZMANN;
+
+    // Done with dset_names, so delete it
+    delete[] dset_names[i];
   }
   std::sort(available_temps.begin(), available_temps.end());
 
@@ -92,7 +102,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, int in_num_groups,
   // interpolation
   if ((num_temps == 1) && (method == TEMPERATURE_INTERPOLATION)) {
     warning("Cross sections for " + strtrim(name) + " are only available " +
-            "at one temperature.  Reverying to the nearest temperature " +
+            "at one temperature.  Reverting to the nearest temperature " +
             "method.");
     method = TEMPERATURE_NEAREST;
   }
@@ -190,7 +200,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, int in_num_groups,
   if (attribute_exists(xs_id, "fissionable")) {
     int int_fiss;
     read_attr_int(xs_id, "fissionable", &int_fiss);
-    in_fissionable = (bool)int_fiss;
+    in_fissionable = int_fiss;
   } else {
     fatal_error("Fissionable element must be set!");
   }
@@ -208,7 +218,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, int in_num_groups,
   // moment). Adjust for that. Histogram and Tabular formats dont need this
   // adjustment.
   if (in_scatter_format == ANGLE_LEGENDRE) {
-    order_dim = order_dim + 1;
+    ++order_dim;
   }
 
   // Get the angular information
@@ -220,7 +230,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, int in_num_groups,
     read_attr_string(xs_id, "representation", MAX_WORD_LEN, &temp_str[0]);
     to_lower(strtrim(temp_str));
     if (temp_str.compare(0, 5, "angle") == 0) {
-      in_is_isotropic =  false;
+      in_is_isotropic = false;
     } else if (temp_str.compare(0, 9, "isotropic") != 0) {
       fatal_error("Invalid Data Representation!");
     }
@@ -326,7 +336,7 @@ Mgxs::Mgxs(const std::string& in_name, const double_1dvec& mat_kTs,
 
   // Create the xs data for each temperature
   for (int t = 0; t < mat_kTs.size(); t++) {
-    xs[t]= XsData(in_num_groups, in_num_delayed_groups, in_fissionable,
+    xs[t] = XsData(in_num_groups, in_num_delayed_groups, in_fissionable,
        in_scatter_format, in_polar.size(), in_azimuthal.size());
 
     // Find the right temperature index to use
@@ -433,28 +443,16 @@ Mgxs::get_xs(int xstype, int gin, int* gout, double* mu, int* dg)
     val = xs_t->total[a][gin];
     break;
   case MG_GET_XS_NU_FISSION:
-    if (fissionable) {
-      val = xs_t->nu_fission[a][gin];
-    } else {
-      val = 0.;
-    }
+    val = fissionable ? xs_t->nu_fission[a][gin] : 0.;
     break;
   case MG_GET_XS_ABSORPTION:
     val = xs_t->absorption[a][gin];
     break;
   case MG_GET_XS_FISSION:
-    if (fissionable) {
-      val = xs_t->fission[a][gin];
-    } else {
-      val = 0.;
-    }
+    val = fissionable ? xs_t->fission[a][gin] : 0.;
     break;
   case MG_GET_XS_KAPPA_FISSION:
-    if (fissionable) {
-      val = xs_t->kappa_fission[a][gin];
-    } else {
-      val = 0.;
-    }
+    val = fissionable ? xs_t->kappa_fission[a][gin] : 0.;
     break;
   case MG_GET_XS_SCATTER:
   case MG_GET_XS_SCATTER_MULT:
@@ -463,11 +461,7 @@ Mgxs::get_xs(int xstype, int gin, int* gout, double* mu, int* dg)
     val = xs_t->scatter[a]->get_xs(xstype, gin, gout, mu);
     break;
   case MG_GET_XS_PROMPT_NU_FISSION:
-    if (fissionable) {
-      val = xs_t->prompt_nu_fission[a][gin];
-    } else {
-      val = 0.;
-    }
+    val = fissionable ? xs_t->prompt_nu_fission[a][gin] : 0.;
     break;
   case MG_GET_XS_DELAYED_NU_FISSION:
     if (fissionable) {
@@ -638,11 +632,7 @@ Mgxs::calculate_xs(int gin, double sqrtkT, const double uvw[3],
   total_xs = xs_t->total[cache[tid].a][gin];
   abs_xs = xs_t->absorption[cache[tid].a][gin];
 
-  if (fissionable) {
-    nu_fiss_xs = xs_t->nu_fission[cache[tid].a][gin];
-  } else {
-    nu_fiss_xs = 0.;
-  }
+  nu_fiss_xs = fissionable ? xs_t->nu_fission[cache[tid].a][gin] : 0.;
 }
 
 //==============================================================================
@@ -650,18 +640,13 @@ Mgxs::calculate_xs(int gin, double sqrtkT, const double uvw[3],
 bool
 Mgxs::equiv(const Mgxs& that)
 {
-  bool match = false;
-
-  if ((num_delayed_groups == that.num_delayed_groups) &&
-      (num_groups == that.num_groups) &&
-      (n_pol == that.n_pol) &&
-      (n_azi == that.n_azi) &&
-      (std::equal(polar.begin(), polar.end(), that.polar.begin())) &&
-      (std::equal(azimuthal.begin(), azimuthal.end(), that.azimuthal.begin())) &&
-      (scatter_format == that.scatter_format)) {
-    match = true;
-  }
-  return match;
+  return ((num_delayed_groups == that.num_delayed_groups) &&
+       (num_groups == that.num_groups) &&
+       (n_pol == that.n_pol) &&
+       (n_azi == that.n_azi) &&
+       (std::equal(polar.begin(), polar.end(), that.polar.begin())) &&
+       (std::equal(azimuthal.begin(), azimuthal.end(), that.azimuthal.begin())) &&
+       (scatter_format == that.scatter_format));
 }
 
 //==============================================================================
diff --git a/src/mgxs.h b/src/mgxs.h
index 8ef174269a..0434bd55d5 100644
--- a/src/mgxs.h
+++ b/src/mgxs.h
@@ -4,23 +4,11 @@
 #ifndef MGXS_H
 #define MGXS_H
 
-#include <cmath>
-#include <cstdlib>
-#include <algorithm>
 #include <string>
-#include <valarray>
 #include <vector>
 
- #ifdef _OPENMP
- # include <omp.h>
- #endif
-
 #include "constants.h"
 #include "hdf5_interface.h"
-#include "math_functions.h"
-#include "random_lcg.h"
-#include "scattdata.h"
-#include "string_functions.h"
 #include "xsdata.h"
 
 
diff --git a/src/mgxs_interface.cpp b/src/mgxs_interface.cpp
index a96f530084..d875987791 100644
--- a/src/mgxs_interface.cpp
+++ b/src/mgxs_interface.cpp
@@ -1,5 +1,10 @@
+#include <string>
+
+#include "error.h"
+#include "math_functions.h"
 #include "mgxs_interface.h"
 
+
 namespace openmc {
 
 //==============================================================================
@@ -12,11 +17,8 @@ add_mgxs_c(hid_t file_id, const char* name, int energy_groups,
      int max_order, bool legendre_to_tabular, int legendre_to_tabular_points,
      int& method)
 {
-  //!! mgxs_data.F90 will be modified to just create the list of names
-  //!! in the order needed
   // Convert temps to a vector for the from_hdf5 function
-  double_1dvec temperature;
-  temperature.assign(temps, temps + n_temps);
+  double_1dvec temperature(temps, temps + n_temps);
 
   write_message("Loading " + std::string(name) + " data...", 6);
 
@@ -33,6 +35,7 @@ add_mgxs_c(hid_t file_id, const char* name, int energy_groups,
           max_order, legendre_to_tabular, legendre_to_tabular_points, method);
 
   nuclides_MG.push_back(mg);
+  close_group(xs_grp);
 }
 
 //==============================================================================
@@ -56,12 +59,11 @@ create_macro_xs_c(const char* mat_name, int n_nuclides, const int i_nuclides[],
 {
   if (n_temps > 0) {
     // // Convert temps to a vector
-    double_1dvec temperature;
-    temperature.assign(temps, temps + n_temps);
+    double_1dvec temperature(temps, temps + n_temps);
 
     // Convert atom_densities to a vector
-    double_1dvec atom_densities_vec;
-    atom_densities_vec.assign(atom_densities, atom_densities + n_nuclides);
+    double_1dvec atom_densities_vec(atom_densities,
+         atom_densities + n_nuclides);
 
     // Build array of pointers to nuclides_MG's Mgxs objects needed for this
     // material
@@ -72,11 +74,11 @@ create_macro_xs_c(const char* mat_name, int n_nuclides, const int i_nuclides[],
 
     Mgxs macro(mat_name, temperature, mgxs_ptr, atom_densities_vec,
          tolerance, method);
-    macro_xs.push_back(macro);
+    macro_xs.emplace_back(macro);
   } else {
     // Preserve the ordering of materials by including a blank entry
     Mgxs macro;
-    macro_xs.push_back(macro);
+    macro_xs.emplace_back(macro);
   }
 }
 
diff --git a/src/mgxs_interface.h b/src/mgxs_interface.h
index 2cdd2889a5..65afd20f9c 100644
--- a/src/mgxs_interface.h
+++ b/src/mgxs_interface.h
@@ -4,7 +4,7 @@
 #ifndef MGXS_INTERFACE_H
 #define MGXS_INTERFACE_H
 
-#include "error.h"
+#include "hdf5_interface.h"
 #include "mgxs.h"
 
 
diff --git a/src/scattdata.cpp b/src/scattdata.cpp
index ad6ae21a63..a316eba46d 100644
--- a/src/scattdata.cpp
+++ b/src/scattdata.cpp
@@ -1,3 +1,11 @@
+#include <algorithm>
+#include <numeric>
+#include <cmath>
+
+#include "constants.h"
+#include "math_functions.h"
+#include "random_lcg.h"
+#include "error.h"
 #include "scattdata.h"
 
 namespace openmc {
@@ -35,7 +43,6 @@ ScattData::base_init(int order, const int_1dvec& in_gmin,
     dist[gin].resize(in_gmax[gin] - in_gmin[gin] + 1);
     for (auto& v : dist[gin]) {
       v.resize(order);
-      for (auto& n : v) n = 0.;
     }
   }
 }
@@ -193,27 +200,22 @@ ScattData::get_xs(int xstype, int gin, const int* gout, const double* mu)
     i_gout = *gout - gmin[gin];
   }
 
-  double val = 0.;
+  double val = scattxs[gin];
   switch(xstype) {
   case MG_GET_XS_SCATTER:
-    if (gout != nullptr) {
-      val = scattxs[gin] * energy[gin][i_gout];
-    } else {
-      val = scattxs[gin];
-    }
+    if (gout != nullptr) val *= energy[gin][i_gout];
     break;
   case MG_GET_XS_SCATTER_MULT:
     if (gout != nullptr) {
-      val = scattxs[gin] * energy[gin][i_gout] / mult[gin][i_gout];
+      val *= energy[gin][i_gout] / mult[gin][i_gout];
     } else {
-      val = scattxs[gin] /
-           std::inner_product(mult[gin].begin(), mult[gin].end(),
-           energy[gin].begin(), 0.0);
+      val /= std::inner_product(mult[gin].begin(), mult[gin].end(),
+                                energy[gin].begin(), 0.0);
     }
     break;
   case MG_GET_XS_SCATTER_FMU_MULT:
     if ((gout != nullptr) && (mu != nullptr)) {
-      val = scattxs[gin] * energy[gin][i_gout] * calc_f(gin, *gout, *mu);
+      val *= energy[gin][i_gout] * calc_f(gin, *gout, *mu);
     } else {
       // This is not an expected path (asking for f_mu without asking for a
       // group or mu is not useful
@@ -222,8 +224,7 @@ ScattData::get_xs(int xstype, int gin, const int* gout, const double* mu)
     break;
   case MG_GET_XS_SCATTER_FMU:
     if ((gout != nullptr) && (mu != nullptr)) {
-      val = scattxs[gin] * energy[gin][i_gout] * calc_f(gin, *gout, *mu) /
-           mult[gin][i_gout];
+      val *= energy[gin][i_gout] * calc_f(gin, *gout, *mu) / mult[gin][i_gout];
     } else {
       // This is not an expected path (asking for f_mu without asking for a
       // group or mu is not useful
@@ -674,8 +675,7 @@ ScattDataTabular::init(const int_1dvec& in_gmin, const int_1dvec& in_gmax,
   }
 
   // Build the energy transfer matrix from data in the variable matrix
-  double_2dvec in_energy;
-  in_energy.resize(groups);
+  double_2dvec in_energy(groups);
   for (int gin = 0; gin < groups; gin++) {
     int num_groups = in_gmax[gin] - in_gmin[gin] + 1;
     in_energy[gin].resize(num_groups);
diff --git a/src/scattdata.h b/src/scattdata.h
index 888f960521..72ebaf6771 100644
--- a/src/scattdata.h
+++ b/src/scattdata.h
@@ -4,19 +4,11 @@
 #ifndef SCATTDATA_H
 #define SCATTDATA_H
 
-#include <algorithm>
-#include <numeric>
 #include <vector>
-#include <cmath>
-
-#include "constants.h"
-#include "math_functions.h"
-#include "random_lcg.h"
-#include "error.h"
 
 namespace openmc {
 
-// temporary declaations so we can name our friend functions
+// forward declarations so we can name our friend functions
 class ScattDataLegendre;
 class ScattDataTabular;
 
diff --git a/src/xsdata.cpp b/src/xsdata.cpp
index 98df2d67d1..712fe7b0ff 100644
--- a/src/xsdata.cpp
+++ b/src/xsdata.cpp
@@ -1,5 +1,15 @@
+#include <cmath>
+#include <cstdlib>
+#include <algorithm>
+#include <numeric>
+
+#include "constants.h"
+#include "error.h"
+#include "math_functions.h"
+#include "random_lcg.h"
 #include "xsdata.h"
 
+
 namespace openmc {
 
 //==============================================================================
@@ -44,14 +54,17 @@ XsData::XsData(int energy_groups, int num_delayed_groups, bool fissionable,
          double_2dvec(energy_groups, double_1dvec(num_delayed_groups, 0.))));
   }
 
-  scatter.resize(n_ang);
+
   for (int a = 0; a < n_ang; a++) {
     if (scatter_format == ANGLE_HISTOGRAM) {
-      scatter[a] = new ScattDataHistogram;
+      // scatter[a] = std::make_unique(ScattDataHistogram);
+      scatter.emplace_back(new ScattDataHistogram);
     } else if (scatter_format == ANGLE_TABULAR) {
-      scatter[a] = new ScattDataTabular;
+      // scatter[a] = std::make_unique(ScattDataTabular);
+      scatter.emplace_back(new ScattDataTabular);
     } else if (scatter_format == ANGLE_LEGENDRE) {
-      scatter[a] = new ScattDataLegendre;
+      // scatter[a] = std::make_unique(ScattDataLegendre);
+      scatter.emplace_back(new ScattDataLegendre);
     }
   }
 }
@@ -131,7 +144,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
     if (ndims == 3) {
       // Beta is input as [delayed group]
-      double_1dvec temp_arr = double_1dvec(n_pol * n_azi * delayed_groups);
+      double_1dvec temp_arr(n_pol * n_azi * delayed_groups);
       read_nd_vector(xsdata_grp, "beta", temp_arr);
 
       // Broadcast to all incoming groups
@@ -155,7 +168,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
   // If chi is provided, set chi-prompt and chi-delayed
   if (object_exists(xsdata_grp, "chi")) {
-    double_2dvec temp_arr = double_2dvec(n_ang, double_1dvec(energy_groups));
+    double_2dvec temp_arr(n_ang, double_1dvec(energy_groups));
     read_nd_vector(xsdata_grp, "chi", temp_arr);
 
     for (int a = 0; a < n_ang; a++) {
@@ -277,7 +290,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
   // If chi-prompt is provided, set chi-prompt
   if (object_exists(xsdata_grp, "chi-prompt")) {
-    double_2dvec temp_arr = double_2dvec(n_ang, double_1dvec(energy_groups));
+    double_2dvec temp_arr(n_ang, double_1dvec(energy_groups));
     read_nd_vector(xsdata_grp, "chi-prompt", temp_arr);
 
     for (int a = 0; a < n_ang; a++) {
@@ -309,7 +322,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
     if (ndims == 3) {
       // chi-delayed is a [in group] vector
-      double_2dvec temp_arr = double_2dvec(n_ang, double_1dvec(energy_groups));
+      double_2dvec temp_arr(n_ang, double_1dvec(energy_groups));
       read_nd_vector(xsdata_grp, "chi-delayed", temp_arr);
 
       for (int a = 0; a < n_ang; a++) {
@@ -371,7 +384,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
     } else if (ndims == 4) {
       // prompt nu fission is a matrix,
       // so set prompt_nu_fiss & chi_prompt
-      double_3dvec temp_arr = double_3dvec(n_ang, double_2dvec(energy_groups,
+      double_3dvec temp_arr(n_ang, double_2dvec(energy_groups,
            double_1dvec(energy_groups)));
       read_nd_vector(xsdata_grp, "prompt-nu-fission", temp_arr);
 
@@ -414,7 +427,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
         fatal_error("cannot set delayed-nu-fission with a 1D array if "
                     "beta is not provided");
       }
-      double_2dvec temp_arr = double_2dvec(n_ang, double_1dvec(energy_groups));
+      double_2dvec temp_arr(n_ang, double_1dvec(energy_groups));
       read_nd_vector(xsdata_grp, "delayed-nu-fission", temp_arr);
 
       for (int a = 0; a < n_ang; a++) {
@@ -433,7 +446,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
     } else if (ndims == 5) {
       // This will contain delayed-nu-fision and chi-delayed data
-      double_4dvec temp_arr = double_4dvec(n_ang, double_3dvec(energy_groups,
+      double_4dvec temp_arr(n_ang, double_3dvec(energy_groups,
            double_2dvec(energy_groups, double_1dvec(delayed_groups))));
       read_nd_vector(xsdata_grp, "delayed-nu-fission", temp_arr);
 
@@ -491,9 +504,9 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
   hid_t scatt_grp = open_group(xsdata_grp, "scatter_data");
 
   // Get the outgoing group boundary indices
-  int_2dvec gmin = int_2dvec(n_ang, int_1dvec(energy_groups));
+  int_2dvec gmin(n_ang, int_1dvec(energy_groups));
   read_nd_vector(scatt_grp, "g_min", gmin, true);
-  int_2dvec gmax = int_2dvec(n_ang, int_1dvec(energy_groups));
+  int_2dvec gmax(n_ang, int_1dvec(energy_groups));
   read_nd_vector(scatt_grp, "g_max", gmax, true);
 
   // Make gmin and gmax start from 0 vice 1 as they do in the library
@@ -512,7 +525,7 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
       length += order_data * (gmax[a][gin] - gmin[a][gin] + 1);
     }
   }
-  double_1dvec temp_arr = double_1dvec(length);
+  double_1dvec temp_arr(length);
   read_nd_vector(scatt_grp, "scatter_matrix", temp_arr, true);
 
   // Compare the number of orders given with the max order of the problem;
@@ -526,8 +539,7 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
   // convert the flattened temp_arr to a jagged array for passing to
   // scatt data
-  double_4dvec input_scatt =
-       double_4dvec(n_ang, double_3dvec(energy_groups));
+  double_4dvec input_scatt(n_ang, double_3dvec(energy_groups));
 
   int temp_idx = 0;
   for (int a = 0; a < n_ang; a++) {
@@ -546,7 +558,7 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
   temp_arr.clear();
 
   // Get multiplication matrix
-  double_3dvec temp_mult = double_3dvec(n_ang, double_2dvec(energy_groups));
+  double_3dvec temp_mult(n_ang, double_2dvec(energy_groups));
   if (object_exists(scatt_grp, "multiplicity_matrix")) {
     temp_arr.resize(length / order_data);
     read_nd_vector(scatt_grp, "multiplicity_matrix", temp_arr);
@@ -584,7 +596,7 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
 
       // Now create a tabular version of legendre_scatt
       convert_legendre_to_tabular(legendre_scatt,
-           *static_cast<ScattDataTabular*>(scatter[a]),
+           *static_cast<ScattDataTabular*>(scatter[a].get()),
            legendre_to_tabular_points);
 
       scatter_format = final_scatter_format;
@@ -676,7 +688,7 @@ XsData::combine(const std::vector<XsData*>& those_xs,
     // Build vector of the scattering objects to incorporate
     std::vector<ScattData*> those_scatts(those_xs.size());
     for (int i = 0; i < those_xs.size(); i++) {
-      those_scatts[i] = those_xs[i]->scatter[a];
+      those_scatts[i] = those_xs[i]->scatter[a].get();
     }
 
     // Now combine these guys
@@ -689,12 +701,8 @@ XsData::combine(const std::vector<XsData*>& those_xs,
 bool
 XsData::equiv(const XsData& that)
 {
-  bool match = false;
-  if ((absorption.size() == that.absorption.size()) &&
-      (absorption[0].size() == that.absorption[0].size())) {
-    match = true;
-  }
-  return match;
+  return ((absorption.size() == that.absorption.size()) &&
+      (absorption[0].size() == that.absorption[0].size()));
 }
 
 } //namespace openmc
diff --git a/src/xsdata.h b/src/xsdata.h
index 36aacc1784..c855c67d89 100644
--- a/src/xsdata.h
+++ b/src/xsdata.h
@@ -4,15 +4,10 @@
 #ifndef XSDATA_H
 #define XSDATA_H
 
-#include <cmath>
-#include <cstdlib>
-#include <algorithm>
+#include <memory>
 #include <vector>
 
-#include "constants.h"
 #include "hdf5_interface.h"
-#include "math_functions.h"
-#include "random_lcg.h"
 #include "scattdata.h"
 
 
@@ -61,7 +56,7 @@ class XsData {
     // [angle][incoming group][outgoing group][delayed group]
     double_4dvec chi_delayed;
     // scatter has the following dimensions: [angle]
-    std::vector<ScattData*> scatter;
+    std::vector<std::shared_ptr<ScattData> > scatter;
 
     XsData() = default;