diff --git a/src/tools/other/ioda2nc/ioda2nc.cc b/src/tools/other/ioda2nc/ioda2nc.cc
index 6e2d57c25b..905cd32efe 100644
--- a/src/tools/other/ioda2nc/ioda2nc.cc
+++ b/src/tools/other/ioda2nc/ioda2nc.cc
@@ -37,6 +37,7 @@
 
 #include "main.h"
 #include "apply_mask.h"
+#include "ioda.h"
 #include "ioda2nc_conf_info.h"
 #include "vx_log.h"
 #include "vx_nc_util.h"
@@ -60,20 +61,11 @@ using namespace netCDF;
 // Constants
 //
 
-static const char *DEF_CONFIG_NAME = "MET_BASE/config/IODA2NCConfig_default";
+static constexpr char DEF_CONFIG_NAME[] = "MET_BASE/config/IODA2NCConfig_default";
 
-static const char *program_name = "ioda2nc";
+static constexpr char program_name[] = "ioda2nc";
 
-static const int REJECT_DEBUG_LEVEL = 9;
-static const int string_data_len = 512;
-
-static const char *metadata_group_name = "MetaData";
-static const char *qc_group_name = "QCFlags";
-static const char *qc_postfix = "PreQC";
-static const char *obs_group_name = "ObsValue";
-static const char *derived_obs_group_name = "DerivedObsValue";
-
-enum class e_ioda_format { v1, v2 };
+static constexpr  int REJECT_DEBUG_LEVEL = 9;
 
 ////////////////////////////////////////////////////////////////////////
 
@@ -101,7 +93,8 @@ static MaskPoly    mask_poly;
 static StringArray mask_sid;
 
 // Beginning and ending retention times
-static unixtime valid_beg_ut, valid_end_ut;
+static unixtime valid_beg_ut;
+static unixtime valid_end_ut;
 
 // Number of IODA messages to process from the command line
 static int nmsg = -1;
@@ -133,12 +126,13 @@ static vector<Observation> observations;
 // Output NetCDF file, dimensions, and variables
 //
 static NcFile *f_out = (NcFile *) nullptr;
+static iodaFile ioda_file;
 
 ////////////////////////////////////////////////////////////////////////
 
 static void initialize();
 static void process_command_line(int, char **);
-static void open_netcdf();
+static void open_netcdf_output();
 static void process_ioda_file(int);
 static void write_netcdf_hdr_data();
 static void clean_up();
@@ -146,7 +140,7 @@ static void clean_up();
 static void addObservation(const float *obs_arr, const ConcatString &hdr_typ,
       const ConcatString &hdr_sid, const time_t hdr_vld,
       const float hdr_lat, const float hdr_lon, const float hdr_elv,
-      const float quality_mark, const int buf_size);
+      const float quality_mark);
 
 static bool keep_message_type(const char *);
 static bool keep_station_id(const char *);
@@ -167,17 +161,15 @@ static void set_valid_end_time(const StringArray &);
 static void set_verbosity(const StringArray &);
 
 static bool check_core_data(const bool, const bool,
-                            StringArray &, StringArray &, e_ioda_format);
-static bool check_missing_thresh(float value);
+                            const StringArray &, const StringArray &, e_ioda_format);
 static ConcatString find_meta_name(string meta_key, StringArray available_names);
 static bool get_meta_data_float(NcFile *, StringArray &, const char *, float *,
                                 const int);
 static bool get_meta_data_strings(NcVar &, char *);
 static bool get_meta_data_strings(NcVar &, char **);
-static bool get_obs_data_float(NcFile *, const ConcatString, NcVar *,
+static bool get_obs_data_float(NcFile *, const ConcatString &, NcVar *,
                                float *, int *, const int, const e_ioda_format);
 static bool has_postfix(const std::string &, std::string const &);
-static bool is_in_metadata_map(string metadata_key, StringArray &available_list);
 
 ////////////////////////////////////////////////////////////////////////
 
@@ -191,11 +183,10 @@ int met_main(int argc, char *argv[]) {
    process_command_line(argc, argv);
 
    // Open the NetCDF file
-   open_netcdf();
+   open_netcdf_output();
 
    // Process each IODA file
    for(int i=0; i<ioda_files.n_elements(); i++) {
-      //process_ioda_file_metadata(i);
       process_ioda_file(i);
    }
 
@@ -216,13 +207,13 @@ int met_main(int argc, char *argv[]) {
 
 ////////////////////////////////////////////////////////////////////////
 
-const string get_tool_name() {
+string get_tool_name() {
    return "ioda2nc";
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void initialize() {
+static void initialize() {
 
    n_total_obs = 0;
 
@@ -235,7 +226,6 @@ void initialize() {
    core_dims_v1.add("nvars");
    core_dims_v1.add("nlocs");
    core_dims_v1.add("nstring");
-   //core_dims_v1.add("ndatetime");
 
    core_meta_vars.clear();
    core_meta_vars.add("datetime");
@@ -248,7 +238,7 @@ void initialize() {
 
 ////////////////////////////////////////////////////////////////////////
 
-void process_command_line(int argc, char **argv) {
+static void process_command_line(int argc, char **argv) {
    CommandLine cline;
    static const char *method_name = "process_command_line() -> ";
    
@@ -293,7 +283,7 @@ void process_command_line(int argc, char **argv) {
    ConcatString default_config_file = replace_path(DEF_CONFIG_NAME);
 
    // List the config files and read the config files
-   if(0 < config_file.length()) {
+   if(config_file.nonempty()) {
       if( !file_exists(config_file.c_str()) ) {
          mlog << Error << "\n" << method_name
               << "file does not exist \"" << config_file << "\"\n\n";
@@ -313,7 +303,7 @@ void process_command_line(int argc, char **argv) {
    // Check that valid_end_ut >= valid_beg_ut
    if(valid_beg_ut != (unixtime) 0 && valid_end_ut != (unixtime) 0
       && valid_beg_ut > valid_end_ut) {
-      mlog << Error << "\nprocess_command_line() -> "
+      mlog << Error << "\n" << method_name
            << "the ending time (" << unix_to_yyyymmdd_hhmmss(valid_end_ut)
            << ") must be greater than the beginning time ("
            << unix_to_yyyymmdd_hhmmss(valid_beg_ut) << ").\n\n";
@@ -324,12 +314,13 @@ void process_command_line(int argc, char **argv) {
    if(do_summary) save_summary_only = !conf_info.getSummaryInfo().raw_data;
    else save_summary_only = false;
 
+   ioda_file.set_data_config(&conf_info);
    return;
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void open_netcdf() {
+static void open_netcdf_output() {
 
    // Create the output netCDF file for writing
    mlog << Debug(1) << "Creating NetCDF File:\t\t" << ncfile << "\n";
@@ -337,7 +328,7 @@ void open_netcdf() {
 
    // Check for a valid file
    if(IS_INVALID_NC_P(f_out)) {
-      mlog << Error << "\nopen_netcdf() -> "
+      mlog << Error << "\nopen_netcdf_output() -> "
            << "trouble opening output file: " << ncfile << "\n\n";
 
       delete f_out;
@@ -360,36 +351,52 @@ void open_netcdf() {
 
 ////////////////////////////////////////////////////////////////////////
 
-void process_ioda_file(int i_pb) {
-   int npbmsg, npbmsg_total;
-   int idx, i_msg, i_read, n_file_obs, n_hdr_obs;
-   int rej_typ, rej_sid, rej_vld, rej_grid, rej_poly;
-   int rej_elv, rej_nobs;
-   double   x, y;
+static void process_ioda_file(int i_pb) {
+   int npbmsg;
+   int npbmsg_total;
+   int idx;
+   int i_msg;
+   int n_file_obs;
+   int n_hdr_obs;
+   int rej_typ;
+   int rej_sid;
+   int rej_vld;
+   int rej_grid;
+   int rej_poly;
+   int rej_elv;
+   int rej_nobs;
+   double x;
+   double y;
 
-   bool status;
-   bool is_time_offset = false;
-   bool is_time_string = false;
    unixtime file_ut;
    unixtime adjusted_file_ut;
-   unixtime msg_ut, beg_ut, end_ut;
-   unixtime min_msg_ut, max_msg_ut;
+   unixtime msg_ut;
+   unixtime beg_ut;
+   unixtime end_ut;
+   unixtime min_msg_ut;
+   unixtime max_msg_ut;
 
-   ConcatString file_name, blk_prefix, blk_file, log_message;
+   ConcatString log_message;
    ConcatString prefix;
-   ConcatString  start_time_str, end_time_str;
-   char     min_time_str[max_str_len], max_time_str[max_str_len];
+   ConcatString start_time_str;
+   ConcatString end_time_str;
+   char     max_time_str[max_str_len];
+   char     min_time_str[max_str_len];
 
    char     hdr_typ[max_str_len];
    ConcatString hdr_sid;
    char     modified_hdr_typ[max_str_len];
-   double   hdr_lat, hdr_lon, hdr_elv;
+   double   hdr_lat;
+   double   hdr_lon;
+   double   hdr_elv;
    unixtime hdr_vld_ut;
    float    obs_arr[OBS_ARRAY_LEN];
 
    const int debug_level_for_performance = 3;
-   int start_t, end_t, method_start, method_end;
-   start_t = end_t = method_start = method_end = clock();
+   clock_t start_t;
+   clock_t end_t;
+   clock_t method_start;
+   clock_t method_end;
 
    IntArray diff_file_times;
    int diff_file_time_count;
@@ -403,6 +410,8 @@ void process_ioda_file(int i_pb) {
                            conf_info.area_mask.ny() > 0);
    bool apply_poly_mask = (conf_info.poly_mask.n_points() > 0);
 
+   start_t = end_t = method_start = method_end = clock();
+
    // List the IODA file being processed
    mlog << Debug(1) << "Processing IODA File:\t" << ioda_files[i_pb]<< "\n";
 
@@ -415,153 +424,41 @@ void process_ioda_file(int i_pb) {
            << "\" for reading.\n\n";
       delete f_in;
       f_in = (NcFile *) nullptr;
+      clean_up();
 
       exit(1);
    }
 
-   // Initialize
-   hdr_typ[0] = 0;
-   file_ut = beg_ut = end_ut = hdr_vld_ut = (unixtime) 0;
-   filtered_times.clear();
-   min_msg_ut = max_msg_ut = (unixtime) 0;
-   min_time_str[0] = 0;
-   max_time_str[0] = 0;
-   modified_hdr_typ[0] = 0;
-
-   // Set the file name for the IODA file
-   file_name << ioda_files[i_pb];
-
-   int nrecs = 0;
-   int nlocs = 0;
-   int nstring = 0;
-   int nvars = 0;
-   StringArray dim_names;
-   StringArray metadata_vars;
-   StringArray obs_value_vars;
-   bool error_out = true;
-   e_ioda_format ioda_format = e_ioda_format::v2;
-
-   get_dim_names(f_in, &dim_names);
-   ConcatString nlocs_name = find_meta_name("nlocs", dim_names);
-   if(0 < nlocs_name.length()) nlocs = get_dim_value(f_in, nlocs_name.c_str(), error_out); // number of locations
-
-   nvars = bad_data_int ;
-   nstring = string_data_len;
-   if (! has_nc_group(f_in, obs_group_name)) ioda_format = e_ioda_format::v1;
-
-   if ( ioda_format == e_ioda_format::v1 ) {
-      StringArray var_names;
-      get_var_names(f_in, &var_names);
-      for(idx=0; idx<var_names.n(); idx++) {
-         if(has_postfix(var_names[idx], "@MetaData")) {
-            metadata_vars.add(var_names[idx].substr(0, var_names[idx].find('@')));
-         }
-         if(has_postfix(var_names[idx], "@ObsValue") || has_postfix(var_names[idx], "@DerivedObsValue")) {
-            obs_value_vars.add(var_names[idx].substr(0, var_names[idx].find('@')));
-         }
-      }
-      if(mlog.verbosity_level() >= 8) {
-         for(idx=0; idx<var_names.n(); idx++)
-            mlog << Debug(8) << method_name << "var_name: " << var_names[idx] << "\n";
-      }
-
-      ConcatString nvars_ = find_meta_name("nvars", dim_names);
-      if(has_dim(f_in, nvars_.c_str())) {
-         nvars = get_dim_value(f_in, nvars_.c_str(), error_out); // number of variables
-         ConcatString nstring_ = find_meta_name("nstring", dim_names);
-         if(dim_names.has(nstring_)) nstring = get_dim_value(f_in, nstring_.c_str(), error_out);
-
-         ConcatString nrecs_ = find_meta_name("nrecs", dim_names);
-         if(dim_names.has(nrecs_)) nrecs = get_dim_value(f_in, nrecs_.c_str(), false);
-         else {
-            nrecs = nvars * nlocs;
-            mlog << Debug(3) << "\n" << method_name
-                 << "nrecs dimension does not exist, so computed\n";
-         }
-      }
-   }
-   else {
-      StringArray group_names;
-      group_names.add(metadata_group_name);
-      get_var_names(f_in, &metadata_vars, group_names);
-      group_names.clear();
-      group_names.add("ObsValue");
-      group_names.add("DerivedObsValue");
-      get_var_names(f_in, &obs_value_vars, group_names);
-   }
-   if(mlog.verbosity_level() >= 6) {
-      for(idx=0; idx<dim_names.n(); idx++)
-         mlog << Debug(8) << method_name << "dim_name: " << dim_names[idx] << "\n";
-      for(idx=0; idx<metadata_vars.n(); idx++)
-         mlog << Debug(8) << method_name << "metadata: " << metadata_vars[idx] << "\n";
-      for(idx=0; idx<obs_value_vars.n(); idx++)
-         mlog << Debug(8) << method_name << "ObsValue or Derived: " << obs_value_vars[idx] << "\n";
-   }
-
-   ConcatString msg_type_name = find_meta_name(conf_key_message_type, metadata_vars);
-   ConcatString station_id_name = find_meta_name(conf_key_station_id, metadata_vars);
-   ConcatString datetime_name = find_meta_name(conf_key_datetime, metadata_vars);
-   ConcatString lon_name = find_meta_name("longitude", metadata_vars);
-   ConcatString lat_name = find_meta_name("latitude", metadata_vars);
+   ioda_file.read_ioda_header(f_in);
 
-   bool has_msg_type = 0 < msg_type_name.length();
-   bool has_station_id = 0 < station_id_name.length();
+   bool has_msg_type = ioda_file.msg_type_name.nonempty();
+   bool has_station_id = ioda_file.station_id_name.nonempty();
    bool is_netcdf_ready = check_core_data(has_msg_type, has_station_id,
-                                          dim_names, metadata_vars, ioda_format);
-
+                                          ioda_file.dim_names, ioda_file.metadata_vars,
+                                          ioda_file.ioda_format);
    if(!is_netcdf_ready) {
       mlog << Error << "\n" << method_name
            << "Please check the IODA file (required dimensions or meta variables are missing).\n\n";
       delete f_in;
       f_in = (NcFile *) nullptr;
+      clean_up();
       exit(1);
    }
-   
-   // Compute the number of IODA records in the current file.
 
-   unixtime base_ut;
-   int sec_per_unit;
-   int ndatetime = 1;
-   bool no_leap_year = false;
-   NcVar in_hdr_lat_var = get_var(f_in, lat_name.c_str(), metadata_group_name);
-   NcVar in_hdr_lon_var = get_var(f_in, lon_name.c_str(), metadata_group_name);
-   NcVar in_hdr_vld_var = get_var(f_in, datetime_name.c_str(), metadata_group_name);
-
-   base_ut = sec_per_unit = 0;
-   if (IS_INVALID_NC(in_hdr_vld_var)) {
-      mlog << Error << "\n" << method_name << "Fail to get datetime variable\n\n";
-      exit(-1);
-   }
-   else {
+   // Initialize
+   hdr_typ[0] = 0;
+   file_ut = beg_ut = end_ut = hdr_vld_ut = (unixtime) 0;
+   filtered_times.clear();
+   min_msg_ut = max_msg_ut = (unixtime) 0;
+   min_time_str[0] = 0;
+   max_time_str[0] = 0;
+   modified_hdr_typ[0] = 0;
 
-      if (NC_STRING == GET_NC_TYPE_ID(in_hdr_vld_var)) {
-         is_time_string = true;
-      }
-      else if (NC_CHAR == GET_NC_TYPE_ID(in_hdr_vld_var)) {
-         if(dim_names.has("ndatetime")) ndatetime = get_dim_value(f_in, "ndatetime", error_out);
-         else {
-            NcDim datetime_dim = get_nc_dim(&in_hdr_vld_var, 1);
-            ndatetime = IS_VALID_NC(datetime_dim) ? get_dim_size(&datetime_dim) : nstring;
-            mlog << Debug(3) << "\n" << method_name
-                 << "ndatetime dimension does not exist!\n";
-         }
-         mlog << Debug(5) << method_name << "dimensions: nvars=" << nvars << ", nlocs=" << nlocs
-              << ", nrecs=" << nrecs << ", nstring=" << nstring << ", ndatetime=" << ndatetime << "\n";
-      }
-      else {
-         ConcatString units;
-         is_time_offset = true;
-         no_leap_year = get_att_no_leap_year(&in_hdr_vld_var);
-         if (get_var_units(&in_hdr_vld_var, units) && (0 < units.length())) {
-            parse_cf_time_string(units.c_str(), base_ut, sec_per_unit);
-         }
-         else {
-            mlog << Error << "\n" << method_name << "Fail to get time units from "
-                 << GET_NC_NAME(in_hdr_vld_var) << "\n\n";
-            exit(-1);
-         }
-      }
-   }
+   int nlocs = ioda_file.nlocs;
+   int nstring = ioda_file.nstring;
+   e_ioda_format ioda_format = ioda_file.ioda_format;
+
+   // Compute the number of IODA records in the current file.
 
    npbmsg_total = npbmsg = nlocs;
 
@@ -572,95 +469,20 @@ void process_ioda_file(int i_pb) {
                ? (npbmsg * nmsg_percent / 100) : nmsg;
    }
 
-   vector<float> hdr_lat_arr  (nlocs);
-   vector<float> hdr_lon_arr  (nlocs);
-   vector<float> hdr_elv_arr  (nlocs);
-   vector<float> obs_pres_arr (nlocs);
-   vector<float> obs_hght_arr (nlocs);
-   vector<float> hdr_time_arr (nlocs);
-   char *hdr_vld_block = new char[nlocs*ndatetime];
-   char *hdr_msg_types = nullptr;
-   char *hdr_station_ids = nullptr;
-   char **hdr_vld_block2 = nullptr;
-   char **hdr_msg_types2 = nullptr;
-   char **hdr_station_ids2 = nullptr;
    vector<int *> v_qc_data;
    vector<float *> v_obs_data;
 
-   if (is_time_string) {
-      hdr_vld_block2 = (char**) calloc(nlocs, sizeof(char*));
-      for (int i=0; i<nlocs; i++ ) hdr_vld_block2[i] = (char*)calloc(nstring, sizeof(char));
-   }
-   
-   get_meta_data_float(f_in, metadata_vars, "pressure", obs_pres_arr.data(), nlocs);
-   get_meta_data_float(f_in, metadata_vars, "height",   obs_hght_arr.data(), nlocs);
-   get_meta_data_float(f_in, metadata_vars, "elevation", hdr_elv_arr.data(), nlocs);
-
-   if(has_msg_type) {
-      NcVar msg_type_var = get_var(f_in, msg_type_name.c_str(), metadata_group_name);
-      if (NC_STRING == GET_NC_TYPE_ID(msg_type_var)) {
-         hdr_msg_types2 = (char**) calloc(nlocs, sizeof(char*));
-         for (int i=0; i<nlocs; i++ ) hdr_msg_types2[i] = (char*)calloc(nstring, sizeof(char));
-         get_nc_data(&msg_type_var, hdr_msg_types2);
-      }
-      else {
-         hdr_msg_types = new char[nlocs*nstring];
-         get_meta_data_strings(msg_type_var, hdr_msg_types);
-      }
-   }
-   else {
-      mlog << Debug(1) << method_name
-           << "The metadata variable for message type does not exist!\n";
-   }
-
-   if(has_station_id) {
-      NcVar sid_var = get_var(f_in, station_id_name.c_str(), metadata_group_name);
-      if (NC_STRING == GET_NC_TYPE_ID(sid_var)) {
-         hdr_station_ids2 = (char**) calloc(nlocs, sizeof(char*));
-         for (int i=0; i<nlocs; i++ ) hdr_station_ids2[i] = (char*)calloc(nstring, sizeof(char));
-         get_nc_data(&sid_var, hdr_station_ids2);
-      }
-      else {
-         hdr_station_ids = new char[nlocs*nstring];
-         get_meta_data_strings(sid_var, hdr_station_ids);
-      }
-   }
-   else {
-      mlog << Debug(1) << method_name
-           << "The metadata variable for station ID does not exist!\n";
-   }
-
-   if(!get_nc_data(&in_hdr_lat_var, hdr_lat_arr.data(), nlocs)) {
-      mlog << Error << "\n" << method_name
-           << "trouble getting latitude\n\n";
-      exit(1);
-   }
-   if(!get_nc_data(&in_hdr_lon_var, hdr_lon_arr.data(), nlocs)) {
-      mlog << Error << "\n" << method_name
-           << "trouble getting longitude\n\n";
-      exit(1);
-   }
-
-   status = is_time_offset ? get_nc_data(&in_hdr_vld_var, hdr_time_arr.data())
-                           : is_time_string
-                             ? get_nc_data(&in_hdr_vld_var, hdr_vld_block2)
-                             : get_nc_data(&in_hdr_vld_var, hdr_vld_block);
-   if(!status) {
-      mlog << Error << "\n" << method_name
-           << "trouble getting datetime\n\n";
-      exit(1);
-   }
-
    StringArray raw_var_names;
-   if(do_all_vars || obs_var_names.n() == 0) raw_var_names = obs_value_vars;
+   if(do_all_vars || obs_var_names.n() == 0) raw_var_names = ioda_file.obs_value_vars;
    else raw_var_names = obs_var_names;
 
-   NcVar obs_var, qc_var;
+   NcVar obs_var;
+   NcVar qc_var;
    ConcatString unit_attr;
    ConcatString desc_attr;
    for(idx=0; idx<raw_var_names.n(); idx++ ) {
-      int *qc_data = new int[nlocs];
-      float *obs_data = new float[nlocs];
+      auto qc_data = new int[nlocs];
+      auto obs_data = new float[nlocs];
 
       for (int idx2=0; idx2<nlocs; idx2++) {
          qc_data[idx2] = bad_data_int;
@@ -710,8 +532,7 @@ void process_ioda_file(int i_pb) {
    }
    mlog << Debug(2) << "Processing " << npbmsg << log_message << "...\n";
 
-   int      bin_count = nint(npbmsg/20.0);
-   unixtime prev_hdr_vld_ut = (unixtime) 0;
+   int bin_count = nint(npbmsg/20.0);
    map<ConcatString, ConcatString> message_type_map = conf_info.getMessageTypeMap();
 
    // Initialize
@@ -720,41 +541,21 @@ void process_ioda_file(int i_pb) {
    for(idx=0; idx<OBS_ARRAY_LEN; idx++) obs_arr[idx] = 0;
 
    // Loop through the IODA messages from the input file
-   bool do_set_time_config = true;
-   for(i_read=0; i_read<npbmsg; i_read++) {
-
-      if(mlog.verbosity_level() > 0) {
-         if(bin_count > 0 && (i_read+1)%bin_count == 0) {
-            cout << nint((double) (i_read+1)/npbmsg*100.0) << "% " << flush;
-            showed_progress = true;
-            if(mlog.verbosity_level() >= debug_level_for_performance) {
-               end_t = clock();
-               cout << (end_t-start_t)/double(CLOCKS_PER_SEC)
-                    << " seconds\n";
-               start_t = clock();
-            }
+   for(int i_read=0; i_read<npbmsg; i_read++) {
+
+      if(mlog.verbosity_level() > 0 && bin_count > 0
+         && (i_read+1)%bin_count == 0) {
+         cout << nint((double) (i_read+1)/npbmsg*100.0) << "% " << flush;
+         showed_progress = true;
+         if(mlog.verbosity_level() >= debug_level_for_performance) {
+            end_t = clock();
+            cout << (end_t-start_t)/double(CLOCKS_PER_SEC)
+                 << " seconds\n";
+            start_t = clock();
          }
       }
 
-      if (is_time_offset) {
-         msg_ut = add_to_unixtime(base_ut, sec_per_unit,
-                                  hdr_time_arr[i_read], no_leap_year);
-      }
-      else if (is_time_string) {
-         char valid_time[nstring+1];
-
-         m_strncpy(valid_time, (const char *)hdr_vld_block2[i_read],
-                   nstring, method_name_s, "valid_time", true);
-         valid_time[nstring] = 0;
-         msg_ut = yyyymmddThhmmss_to_unix(valid_time);
-      }
-      else {
-         char valid_time[ndatetime+1];
-         m_strncpy(valid_time, (const char *)(hdr_vld_block + (i_read * ndatetime)),
-                   ndatetime, method_name_s, "valid_time", true);
-         valid_time[ndatetime] = 0;
-         msg_ut = yyyymmddThhmmss_to_unix(valid_time);
-      }
+      msg_ut = ioda_file.vld_arr[i_read];
 
       // Check to make sure that the message time hasn't changed
       // from one IODA message to the next
@@ -800,13 +601,8 @@ void process_ioda_file(int i_pb) {
       }
 
       if(has_msg_type) {
-         if (nullptr != hdr_msg_types2) {
-            m_strncpy(hdr_typ, hdr_msg_types2[i_read], nstring, method_name_s, "hdr_typ2");
-         }
-         else {
-            m_strncpy(hdr_typ, hdr_msg_types+(i_read*nstring), nstring, method_name_s, "hdr_typ");
-
-         }
+         m_strncpy(hdr_typ, ioda_file.msg_types.data()+(i_read*nstring),
+                   nstring, method_name_s, "hdr_typ");
          m_rstrip(hdr_typ, nstring);
 
          // If the message type is not listed in the configuration
@@ -832,12 +628,8 @@ void process_ioda_file(int i_pb) {
 
       if(has_station_id) {
          char tmp_sid[nstring+1];
-         if (nullptr != hdr_station_ids2) {
-            m_strncpy(tmp_sid, hdr_station_ids2[i_read], nstring, method_name_s, "tmp_sid2");
-         }
-         else {
-            m_strncpy(tmp_sid, hdr_station_ids+(i_read*nstring), nstring, method_name_s, "tmp_sid");
-         }
+         m_strncpy(tmp_sid, ioda_file.station_ids.data()+(i_read*nstring),
+                   nstring, method_name_s, "tmp_sid");
          m_rstrip(tmp_sid, nstring, false);
          m_replace_char(tmp_sid, ' ', '_');
          hdr_sid = tmp_sid;
@@ -856,13 +648,13 @@ void process_ioda_file(int i_pb) {
       //    LON LAT DHR ELV TYP T29 ITP
 
       // Longitude
-      hdr_lon = hdr_lon_arr[i_read];
+      hdr_lon = ioda_file.lon_arr[i_read];
 
       // Latitude
-      hdr_lat = hdr_lat_arr[i_read];
+      hdr_lat = ioda_file.lat_arr[i_read];
 
       // Elevation
-      hdr_elv = hdr_elv_arr[i_read];
+      hdr_elv = ioda_file.elv_arr[i_read];
 
       // Compute the valid time and check if it is within the
       // specified valid range
@@ -912,7 +704,7 @@ void process_ioda_file(int i_pb) {
 
       // Check if the message elevation is within the specified range.
       // Missing data values for elevation are retained.
-      if(!check_missing_thresh(hdr_elv) &&
+      if(!ioda_file.check_missing_thresh(hdr_elv) &&
          (hdr_elv < conf_info.beg_elev || hdr_elv > conf_info.end_elev) ) {
          rej_elv++;
          continue;
@@ -931,12 +723,11 @@ void process_ioda_file(int i_pb) {
             continue;
          }
          obs_arr[1] = var_idx;
-         obs_arr[2] = obs_pres_arr[i_read];
-         obs_arr[3] = obs_hght_arr[i_read];
+         obs_arr[2] = ioda_file.obs_pres_arr[i_read];
+         obs_arr[3] = ioda_file.obs_hght_arr[i_read];
          obs_arr[4] = v_obs_data[idx][i_read];
          addObservation(obs_arr, (string)hdr_typ, (string)hdr_sid, hdr_vld_ut,
-               hdr_lat, hdr_lon, hdr_elv, (float)v_qc_data[idx][i_read],
-               OBS_BUFFER_SIZE);
+               hdr_lat, hdr_lon, hdr_elv, (float)v_qc_data[idx][i_read]);
 
          // Increment the current and total observations counts
          n_file_obs++;
@@ -1014,22 +805,7 @@ void process_ioda_file(int i_pb) {
       }
    }
    
-   delete [] hdr_vld_block;
-
-   if (hdr_msg_types) delete [] hdr_msg_types;
-   if (hdr_station_ids) delete [] hdr_station_ids;
-   if (nullptr != hdr_msg_types2) {
-      for (int i=0; i<nlocs; i++ ) delete hdr_msg_types2[i];
-      delete [] hdr_msg_types2;
-   }
-   if (nullptr != hdr_station_ids2) {
-      for (int i=0; i<nlocs; i++ ) delete hdr_station_ids2[i];
-      delete [] hdr_station_ids2;
-   }
-   if (nullptr != hdr_vld_block2) {
-      for (int i=0; i<nlocs; i++ ) delete hdr_vld_block2[i];
-      delete [] hdr_vld_block2;
-   }
+   ioda_file.clear();
 
    for(idx=0; idx<v_obs_data.size(); idx++ ) delete [] v_obs_data[idx];
    for(idx=0; idx<v_qc_data.size(); idx++ ) delete [] v_qc_data[idx];
@@ -1060,24 +836,26 @@ void process_ioda_file(int i_pb) {
 
 ////////////////////////////////////////////////////////////////////////
 
-void write_netcdf_hdr_data() {
-   int obs_cnt, hdr_cnt;
-   static const string method_name = "\nwrite_netcdf_hdr_data()";
+static void write_netcdf_hdr_data() {
+   int obs_cnt;
+   int hdr_cnt;
 
    nc_point_obs.get_hdr_index();
-   nc_point_obs.set_nc_out_data(observations, summary_obs, conf_info.getSummaryInfo());
    nc_point_obs.get_dim_counts(&obs_cnt, &hdr_cnt);
-   nc_point_obs.init_netcdf(obs_cnt, hdr_cnt, program_name);
 
    // Check for no messages retained
    if(hdr_cnt <= 0) {
-      mlog << Error << method_name << " -> "
+      static const string method_name = "write_netcdf_hdr_data()";
+      mlog << Error << "\n" << method_name << " -> "
            << "No IODA records retained.  Nothing to write.\n\n";
       // Delete the NetCDF file
       remove_temp_file(ncfile);
       exit(1);
    }
 
+   nc_point_obs.set_nc_out_data(observations, summary_obs, conf_info.getSummaryInfo());
+   nc_point_obs.init_netcdf(obs_cnt, hdr_cnt, program_name);
+
    // Make sure all obs data is processed before handling header
    StringArray nc_var_name_arr;
    StringArray nc_var_unit_arr;
@@ -1105,30 +883,30 @@ void write_netcdf_hdr_data() {
 
 ////////////////////////////////////////////////////////////////////////
 
-void addObservation(const float *obs_arr, const ConcatString &hdr_typ,
+static void addObservation(const float *obs_arr, const ConcatString &hdr_typ,
       const ConcatString &hdr_sid, const time_t hdr_vld,
       const float hdr_lat, const float hdr_lon, const float hdr_elv,
-      const float quality_mark, const int buf_size)
+      const float quality_mark)
 {
    // Write the quality flag to the netCDF file
    ConcatString obs_qty;
-   if(check_missing_thresh(quality_mark))
+   if(ioda_file.check_missing_thresh(quality_mark))
       obs_qty.add("NA");
    else obs_qty.format("%d", nint(quality_mark));
 
-   int var_index = obs_arr[1];
+   auto var_index = (int)obs_arr[1];
    map<ConcatString,ConcatString> name_map = conf_info.getObsVarMap();
    string var_name = obs_var_names[var_index];
    string out_name = name_map[var_name];
-   Observation obs = Observation(hdr_typ.text(),
-                                 hdr_sid.text(),
-                                 hdr_vld,
-                                 hdr_lat, hdr_lon, hdr_elv,
-                                 obs_qty.text(),
-                                 var_index,
-                                 obs_arr[2], obs_arr[3], obs_arr[4],
-                                 (0<out_name.length() ? out_name : var_name));
-   obs.setHeaderIndex(obs_arr[0]);
+   auto obs = Observation(hdr_typ.text(),
+                          hdr_sid.text(),
+                          hdr_vld,
+                          hdr_lat, hdr_lon, hdr_elv,
+                          obs_qty.text(),
+                          var_index,
+                          obs_arr[2], obs_arr[3], obs_arr[4],
+                          (0<out_name.length() ? out_name : var_name));
+   obs.setHeaderIndex(int(obs_arr[0]));
    observations.push_back(obs);
    if(do_summary) summary_obs->addObservationObj(obs);
    return;
@@ -1136,7 +914,7 @@ void addObservation(const float *obs_arr, const ConcatString &hdr_typ,
 
 ////////////////////////////////////////////////////////////////////////
 
-void clean_up() {
+static void clean_up() {
 
    nc_point_obs.close();
 
@@ -1150,7 +928,7 @@ void clean_up() {
 
 ////////////////////////////////////////////////////////////////////////
 
-bool keep_message_type(const char *mt_str) {
+static bool keep_message_type(const char *mt_str) {
    bool keep = conf_info.message_type.n_elements() == 0 ||
                conf_info.message_type.has(mt_str, false);
 
@@ -1163,7 +941,7 @@ bool keep_message_type(const char *mt_str) {
 
 ////////////////////////////////////////////////////////////////////////
 
-bool keep_station_id(const char *sid_str) {
+static bool keep_station_id(const char *sid_str) {
 
    bool keep = (conf_info.station_id.n_elements() == 0 ||
                 conf_info.station_id.has(sid_str, false));
@@ -1177,8 +955,8 @@ bool keep_station_id(const char *sid_str) {
 
 ////////////////////////////////////////////////////////////////////////
 
-bool keep_valid_time(const unixtime ut,
-                     const unixtime min_ut, const unixtime max_ut) {
+static bool keep_valid_time(const unixtime ut,
+                            const unixtime min_ut, const unixtime max_ut) {
    bool keep = true;
 
    // If min_ut and max_ut both set, check the range
@@ -1204,34 +982,32 @@ bool keep_valid_time(const unixtime ut,
 
 ////////////////////////////////////////////////////////////////////////
 
-bool check_core_data(const bool has_msg_type, const bool has_station_id,
-                     StringArray &dim_names, StringArray &metadata_vars,
-                     e_ioda_format ioda_format) {
+static bool check_core_data(const bool has_msg_type, const bool has_station_id,
+                            const StringArray &dim_names, const StringArray &metadata_vars,
+                            e_ioda_format ioda_format) {
    bool is_netcdf_ready = true;
    static const char *method_name = "check_core_data() -> ";
 
    StringArray &t_core_dims = (ioda_format == e_ioda_format::v2)
                               ? core_dims : core_dims_v1;
    for(int idx=0; idx<t_core_dims.n(); idx++) {
-      if (!is_in_metadata_map(t_core_dims[idx], dim_names)) {
+      if (!ioda_file.is_in_metadata_map(t_core_dims[idx], dim_names)) {
          mlog << Error << "\n" << method_name << "-> "
               << "core dimension \"" << t_core_dims[idx] << "\" is missing.\n\n";
          is_netcdf_ready = false;
       }
    }
 
-   if (ioda_format == e_ioda_format::v1) {
-      if(has_msg_type || has_station_id) {
-         if (!is_in_metadata_map("nstring", dim_names)) {
-            mlog << Error << "\n" << method_name << "-> "
-                 << "core dimension \"nstring\" is missing.\n\n";
-            is_netcdf_ready = false;
-         }
+   if ((ioda_format == e_ioda_format::v1) && (has_msg_type || has_station_id)) {
+      if (!ioda_file.is_in_metadata_map("nstring", dim_names)) {
+         mlog << Error << "\n" << method_name << "-> "
+              << "core dimension \"nstring\" is missing.\n\n";
+         is_netcdf_ready = false;
       }
    }
 
    for(int idx=0; idx<core_meta_vars.n(); idx++) {
-      if(!is_in_metadata_map(core_meta_vars[idx], metadata_vars)) {
+      if(!ioda_file.is_in_metadata_map(core_meta_vars[idx], metadata_vars)) {
          mlog << Error << "\n" << method_name << "-> "
               << "core variable  \"" << core_meta_vars[idx] << "\" is missing.\n\n";
          is_netcdf_ready = false;
@@ -1242,68 +1018,7 @@ bool check_core_data(const bool has_msg_type, const bool has_station_id,
 
 ////////////////////////////////////////////////////////////////////////
 
-bool check_missing_thresh(float value) {
-   bool check = false;
-   for(int idx=0; idx<conf_info.missing_thresh.n(); idx++) {
-      if(conf_info.missing_thresh[idx].check(value)) {
-          check = true;
-          break;
-      }
-   }
-   return check;
-}
-
-////////////////////////////////////////////////////////////////////////
-
-ConcatString find_meta_name(string meta_key, StringArray available_names) {
-   ConcatString metadata_name;
-   if (available_names.has(meta_key)) metadata_name = meta_key;
-   else {
-      StringArray alt_names = conf_info.metadata_map[meta_key];
-      for (int idx =0; idx<alt_names.n(); idx++) {
-         if (available_names.has(alt_names[idx])) {
-            metadata_name = alt_names[idx];
-            break;
-         }
-      }
-   }
-   return metadata_name;
-}
-
-////////////////////////////////////////////////////////////////////////
-
-bool get_meta_data_float(NcFile *f_in, StringArray &metadata_vars,
-                         const char *metadata_key, float *metadata_buf,
-                         const int nlocs) {
-   bool status = false;
-   static const char *method_name = "get_meta_data_float() -> ";
-   
-   ConcatString metadata_name = find_meta_name(metadata_key, metadata_vars);
-
-   if(metadata_name.length() > 0) {
-      NcVar meta_var = get_var(f_in, metadata_name.c_str(), metadata_group_name);
-      if(IS_VALID_NC(meta_var)) {
-         status = get_nc_data(&meta_var, metadata_buf, nlocs);
-         if(!status) mlog << Debug(3) << method_name
-                           << "trouble getting " << metadata_name << "\n";
-      }
-   }
-   else mlog << Debug(4) << method_name
-             << "Metadata for " << metadata_key << " does not exist!\n";
-   if(status) {
-      for(int idx=0; idx<nlocs; idx++)
-         if(check_missing_thresh(metadata_buf[idx])) metadata_buf[idx] = bad_data_float;
-   }
-   else {
-      for(int idx=0; idx<nlocs; idx++)
-         metadata_buf[idx] = bad_data_float;
-   }
-   return status;
-}
-
-////////////////////////////////////////////////////////////////////////
-
-bool get_meta_data_strings(NcVar &var, char *metadata_buf) {
+static bool get_meta_data_strings(NcVar &var, char *metadata_buf) {
    bool status = false;
    static const char *method_name = "get_meta_data_strings() -> ";
 
@@ -1320,9 +1035,9 @@ bool get_meta_data_strings(NcVar &var, char *metadata_buf) {
 
 ////////////////////////////////////////////////////////////////////////
 
-bool get_obs_data_float(NcFile *f_in, const ConcatString var_name,
-                        NcVar *obs_var, float *obs_buf, int *qc_buf,
-                        const int nlocs, const e_ioda_format ioda_format) {
+static bool get_obs_data_float(NcFile *f_in, const ConcatString &var_name,
+                               NcVar *obs_var, float *obs_buf, int *qc_buf,
+                               const int nlocs, const e_ioda_format ioda_format) {
    bool status = false;
    static const char *method_name = "get_obs_data_float() -> ";
    
@@ -1330,7 +1045,7 @@ bool get_obs_data_float(NcFile *f_in, const ConcatString var_name,
       status = get_nc_data(obs_var, obs_buf, nlocs);
       if(status) {
          for(int idx=0; idx<nlocs; idx++)
-            if(check_missing_thresh(obs_buf[idx])) obs_buf[idx] = bad_data_float;
+            if(ioda_file.check_missing_thresh(obs_buf[idx])) obs_buf[idx] = bad_data_float;
       }
       else mlog << Error << "\n" << method_name
                 << "trouble getting " << var_name << "\n\n";
@@ -1340,7 +1055,7 @@ bool get_obs_data_float(NcFile *f_in, const ConcatString var_name,
    if(!status) exit(1);
    
    status = false;
-   if(var_name.length() > 0) {
+   if(var_name.nonempty()) {
       ConcatString qc_name = var_name;
       ConcatString qc_group = qc_postfix;
       if (ioda_format == e_ioda_format::v2) {
@@ -1370,7 +1085,7 @@ bool get_obs_data_float(NcFile *f_in, const ConcatString var_name,
    }
    if(status) {
       for(int idx=0; idx<nlocs; idx++)
-         if(check_missing_thresh(qc_buf[idx])) qc_buf[idx] = bad_data_float;
+         if(ioda_file.check_missing_thresh(qc_buf[idx])) qc_buf[idx] = bad_data_float;
    }
    else {
       for(int idx=0; idx<nlocs; idx++)
@@ -1381,36 +1096,7 @@ bool get_obs_data_float(NcFile *f_in, const ConcatString var_name,
 
 ////////////////////////////////////////////////////////////////////////
 
-bool has_postfix(const std::string &str_buf, std::string const &postfix) {
-   auto buf_len = str_buf.length();
-   auto postfix_len = postfix.length();
-   if(buf_len >= postfix_len) {
-      return (0 == str_buf.compare(buf_len - postfix_len, postfix_len, postfix));
-   } else {
-      return false;
-   }
-}
-
-////////////////////////////////////////////////////////////////////////
-
-bool is_in_metadata_map(std::string metadata_key, StringArray &available_list) {
-   bool found = available_list.has(metadata_key);
-
-   if (!found) {
-      StringArray alt_names = conf_info.metadata_map[metadata_key];
-      if (alt_names.n() > 0) {
-         for (int idx=0; idx<alt_names.n(); idx++) {
-            found = available_list.has(alt_names[idx]);
-            if (found) break;
-         }
-      }
-   }
-   return found;
-}
-
-////////////////////////////////////////////////////////////////////////
-
-void usage() {
+static void usage() {
 
    cout << "\n*** Model Evaluation Tools (MET" << met_version
         << ") ***\n\n"
@@ -1470,28 +1156,28 @@ void usage() {
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_ioda_files(const StringArray & a)
+static void set_ioda_files(const StringArray & a)
 {
    ioda_files.add(a[0]);
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_valid_beg_time(const StringArray & a)
+static void set_valid_beg_time(const StringArray & a)
 {
    valid_beg_ut = timestring_to_unix(a[0].c_str());
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_valid_end_time(const StringArray & a)
+static void set_valid_end_time(const StringArray & a)
 {
    valid_end_ut = timestring_to_unix(a[0].c_str());
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_nmsg(const StringArray & a)
+static void set_nmsg(const StringArray & a)
 {
    nmsg = atoi(a[0].c_str());
    int tmp_len = a[0].length();
@@ -1504,13 +1190,13 @@ void set_nmsg(const StringArray & a)
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_config(const StringArray & a) {
+static void set_config(const StringArray & a) {
    config_file = a[0];
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_mask_grid(const StringArray & a) {
+static void set_mask_grid(const StringArray & a) {
 
    // List the grid masking file
    mlog << Debug(1)
@@ -1526,7 +1212,7 @@ void set_mask_grid(const StringArray & a) {
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_mask_poly(const StringArray & a) {
+static void set_mask_poly(const StringArray & a) {
    ConcatString mask_name;
 
    // List the poly masking file
@@ -1555,7 +1241,7 @@ void set_mask_poly(const StringArray & a) {
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_mask_sid(const StringArray & a) {
+static void set_mask_sid(const StringArray & a) {
 
    // List the station ID mask
    mlog << Debug(1) << "Station ID Mask: " << a[0] << "\n";
@@ -1570,7 +1256,7 @@ void set_mask_sid(const StringArray & a) {
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_obs_var(const StringArray & a)
+static void set_obs_var(const StringArray & a)
 {
    if("_all_" == a[0] || "all" == a[0]) do_all_vars = true;
    else {
@@ -1581,7 +1267,7 @@ void set_obs_var(const StringArray & a)
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_logfile(const StringArray & a)
+static void set_logfile(const StringArray & a)
 {
    ConcatString filename;
 
@@ -1592,14 +1278,14 @@ void set_logfile(const StringArray & a)
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_verbosity(const StringArray & a)
+static void set_verbosity(const StringArray & a)
 {
    mlog.set_verbosity_level(atoi(a[0].c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-void set_compress(const StringArray & a) {
+static void set_compress(const StringArray & a) {
    compress_level = atoi(a[0].c_str());
 }