diff --git a/src/monio/AtlasReader.cc b/src/monio/AtlasReader.cc
index 6ea2924..804f362 100644
--- a/src/monio/AtlasReader.cc
+++ b/src/monio/AtlasReader.cc
@@ -84,30 +84,6 @@ void monio::AtlasReader::populateFieldWithDataContainer(atlas::Field& field,
   }
 }
 
-void monio::AtlasReader::populateFieldSetWithData(atlas::FieldSet& fieldSet,
-                                                  const Data& data) {
-  oops::Log::debug() << "AtlasReader::populateFieldSetWithData()" << std::endl;
-  if (mpiCommunicator_.rank() == mpiRankOwner_) {
-    for (auto& field : fieldSet) {
-      populateFieldWithDataContainer(field, data.getContainer(field.name()));
-    }
-  }
-}
-
-void monio::AtlasReader::populateFieldSetWithData(atlas::FieldSet& fieldSet,
-                                                  const Data& data,
-                                                  const std::vector<std::string>& fieldNames) {
-  oops::Log::debug() << "AtlasReader::populateFieldSetWithData()" << std::endl;
-  if (mpiCommunicator_.rank() == mpiRankOwner_) {
-    auto fieldNameIt = fieldNames.begin();
-    for (auto& field : fieldSet) {
-      populateFieldWithDataContainer(field, data.getContainer(*fieldNameIt));
-      ++fieldNameIt;
-    }
-  }
-}
-
-
 template<typename T>
 void monio::AtlasReader::populateField(atlas::Field& field,
                                        const std::vector<T>& dataVec,
diff --git a/src/monio/AtlasReader.h b/src/monio/AtlasReader.h
index 3792de2..700e66b 100644
--- a/src/monio/AtlasReader.h
+++ b/src/monio/AtlasReader.h
@@ -43,18 +43,12 @@ class AtlasReader {
   void populateFieldWithDataContainer(atlas::Field& field,
                                 const std::shared_ptr<monio::DataContainerBase>& dataContainer,
                                 const std::vector<size_t>& lfricToAtlasMap,
-                                const bool copyFirstLevel = false);  // Monio::readBackground
+                                const bool copyFirstLevel = false);
 
   void populateFieldWithDataContainer(atlas::Field& field,
                                 const std::shared_ptr<monio::DataContainerBase>& dataContainer);
 
-  void populateFieldSetWithData(atlas::FieldSet& fieldSet, const Data& data);
-  void populateFieldSetWithData(atlas::FieldSet& fieldSet,
-                          const Data& data,
-                          const std::vector<std::string>& fieldNames);
-
  private:
-  // AtlasWriter::populateFieldWithDataContainer
   template<typename T> void populateField(atlas::Field& field,
                                     const std::vector<T>& dataVec,
                                     const std::vector<size_t>& lfricToAtlasMap,
diff --git a/src/monio/AtlasWriter.cc b/src/monio/AtlasWriter.cc
index 6b573ec..05ab98f 100644
--- a/src/monio/AtlasWriter.cc
+++ b/src/monio/AtlasWriter.cc
@@ -189,64 +189,12 @@ void monio::AtlasWriter::populateDataContainerWithField(
   }
 }
 
-template<typename T>
-void monio::AtlasWriter::populateDataVec(std::vector<T>& dataVec,
-                                         const atlas::Field& field,
-                                         const std::vector<size_t>& lfricToAtlasMap) {
-  oops::Log::debug() << "AtlasWriter::populateDataVec() " << field.name() << std::endl;
-  atlas::idx_t numLevels = field.levels();
-  if ((lfricToAtlasMap.size() * numLevels) != dataVec.size()) {
-    utils::throwException("AtlasWriter::populateDataVec()> "
-                             "Data container is not configured for the expected data...");
-  }
-  auto fieldView = atlas::array::make_view<T, 2>(field);
-  for (std::size_t i = 0; i < lfricToAtlasMap.size(); ++i) {
-    for (atlas::idx_t j = 0; j < numLevels; ++j) {
-      int index = lfricToAtlasMap[i] + (j * lfricToAtlasMap.size());
-      dataVec[index] = fieldView(i, j);
-    }
-  }
-}
-
-template void monio::AtlasWriter::populateDataVec<double>(std::vector<double>& dataVec,
-                                                    const atlas::Field& field,
-                                                    const std::vector<size_t>& lfricToAtlasMap);
-template void monio::AtlasWriter::populateDataVec<float>(std::vector<float>& dataVec,
-                                                   const atlas::Field& field,
-                                                   const std::vector<size_t>& lfricToAtlasMap);
-template void monio::AtlasWriter::populateDataVec<int>(std::vector<int>& dataVec,
-                                                 const atlas::Field& field,
-                                                 const std::vector<size_t>& lfricToAtlasMap);
-
-template<typename T>
-void monio::AtlasWriter::populateDataVec(std::vector<T>& dataVec,
-                                   const atlas::Field& field,
-                                   const std::vector<int>& dimensions) {
-  oops::Log::debug() << "AtlasWriter::populateDataVec()" << std::endl;
-  auto fieldView = atlas::array::make_view<T, 2>(field);
-  for (atlas::idx_t i = 0; i < dimensions[consts::eHorizontal]; ++i) {  // Horizontal dimension
-    for (atlas::idx_t j = 0; j < dimensions[consts::eVertical]; ++j) {  // Levels dimension
-      int index = j + (i * dimensions[consts::eVertical]);
-      dataVec[index] = fieldView(i, j);
-    }
-  }
-}
-
-template void monio::AtlasWriter::populateDataVec<double>(std::vector<double>& dataVec,
-                                                          const atlas::Field& field,
-                                                          const std::vector<int>& dimensions);
-template void monio::AtlasWriter::populateDataVec<float>(std::vector<float>& dataVec,
-                                                         const atlas::Field& field,
-                                                         const std::vector<int>& dimensions);
-template void monio::AtlasWriter::populateDataVec<int>(std::vector<int>& dataVec,
-                                                       const atlas::Field& field,
-                                                       const std::vector<int>& dimensions);
-
-void monio::AtlasWriter::populateMetadataAndDataWithFieldSet(Metadata& metadata,
-                                                             Data& data,
-                                                       const atlas::FieldSet& fieldSet) {
+void monio::AtlasWriter::populateFileDataWithFieldSet(FileData& fileData,
+                                                const atlas::FieldSet& fieldSet) {
   oops::Log::debug() << "AtlasWriter::populateMetadataAndDataWithFieldSet()" << std::endl;
   if (mpiCommunicator_.rank() == mpiRankOwner_) {
+    Metadata& metadata = fileData.getMetadata();
+    Data& data = fileData.getData();
     int dimCount = 0;
     bool createdLonLat = false;
     for (const auto& field : fieldSet) {
@@ -258,7 +206,7 @@ void monio::AtlasWriter::populateMetadataAndDataWithFieldSet(Metadata& metadata,
         std::string dimName = metadata.getDimensionName(dimSize);
         if (dimName == consts::kNotFoundError) {
           dimName = "dim" + std::to_string(dimCount);
-          metadata.addDimension(dimName, dimSize);
+          fileData.getMetadata().addDimension(dimName, dimSize);
           dimCount++;
         }
       }
@@ -288,18 +236,18 @@ void monio::AtlasWriter::populateMetadataAndDataWithFieldSet(Metadata& metadata,
 
       std::shared_ptr<monio::AttributeString> producedByAttr =
               std::make_shared<AttributeString>(producedByName, producedByString);
-      metadata.addGlobalAttr(producedByName, producedByAttr);
+      fileData.getMetadata().addGlobalAttr(producedByName, producedByAttr);
     }
   }
 }
 
-void monio::AtlasWriter::populateMetadataAndDataWithLfricFieldSet(
-                                               Metadata& metadata,
-                                               Data& data,
+void monio::AtlasWriter::populateFileDataWithLfricFieldSet(FileData& fileData,
                                          const std::vector<consts::FieldMetadata>& fieldMetadataVec,
                                                atlas::FieldSet& fieldSet,
                                          const std::vector<size_t>& lfricToAtlasMap) {
   oops::Log::debug() << "AtlasWriter::populateMetadataAndDataWithLfricFieldSet()" << std::endl;
+  Metadata& metadata = fileData.getMetadata();
+  Data& data = fileData.getData();
   // Dimensions
   metadata.addDimension(std::string(consts::kHorizontalName), lfricToAtlasMap.size());
   metadata.addDimension(std::string(consts::kVerticalFullName), consts::kVerticalFullSize);
@@ -318,7 +266,7 @@ void monio::AtlasWriter::populateMetadataAndDataWithLfricFieldSet(
 
   std::shared_ptr<monio::AttributeString> producedByAttr =
           std::make_shared<AttributeString>(producedByName, producedByString);
-  metadata.addGlobalAttr(producedByName, producedByAttr);
+  fileData.getMetadata().addGlobalAttr(producedByName, producedByAttr);
 }
 
 void monio::AtlasWriter::populateDataWithField(Data& data,
@@ -339,3 +287,56 @@ void monio::AtlasWriter::populateDataWithField(Data& data,
   populateDataContainerWithField(dataContainer, field, dimensions);
   data.addContainer(dataContainer);
 }
+
+template<typename T>
+void monio::AtlasWriter::populateDataVec(std::vector<T>& dataVec,
+                                         const atlas::Field& field,
+                                         const std::vector<size_t>& lfricToAtlasMap) {
+  oops::Log::debug() << "AtlasWriter::populateDataVec() " << field.name() << std::endl;
+  atlas::idx_t numLevels = field.levels();
+  if ((lfricToAtlasMap.size() * numLevels) != dataVec.size()) {
+    utils::throwException("AtlasWriter::populateDataVec()> "
+                             "Data container is not configured for the expected data...");
+  }
+  auto fieldView = atlas::array::make_view<T, 2>(field);
+  for (std::size_t i = 0; i < lfricToAtlasMap.size(); ++i) {
+    for (atlas::idx_t j = 0; j < numLevels; ++j) {
+      int index = lfricToAtlasMap[i] + (j * lfricToAtlasMap.size());
+      dataVec[index] = fieldView(i, j);
+    }
+  }
+}
+
+template void monio::AtlasWriter::populateDataVec<double>(std::vector<double>& dataVec,
+                                                    const atlas::Field& field,
+                                                    const std::vector<size_t>& lfricToAtlasMap);
+template void monio::AtlasWriter::populateDataVec<float>(std::vector<float>& dataVec,
+                                                   const atlas::Field& field,
+                                                   const std::vector<size_t>& lfricToAtlasMap);
+template void monio::AtlasWriter::populateDataVec<int>(std::vector<int>& dataVec,
+                                                 const atlas::Field& field,
+                                                 const std::vector<size_t>& lfricToAtlasMap);
+
+template<typename T>
+void monio::AtlasWriter::populateDataVec(std::vector<T>& dataVec,
+                                   const atlas::Field& field,
+                                   const std::vector<int>& dimensions) {
+  oops::Log::debug() << "AtlasWriter::populateDataVec()" << std::endl;
+  auto fieldView = atlas::array::make_view<T, 2>(field);
+  for (atlas::idx_t i = 0; i < dimensions[consts::eHorizontal]; ++i) {  // Horizontal dimension
+    for (atlas::idx_t j = 0; j < dimensions[consts::eVertical]; ++j) {  // Levels dimension
+      int index = j + (i * dimensions[consts::eVertical]);
+      dataVec[index] = fieldView(i, j);
+    }
+  }
+}
+
+template void monio::AtlasWriter::populateDataVec<double>(std::vector<double>& dataVec,
+                                                          const atlas::Field& field,
+                                                          const std::vector<int>& dimensions);
+template void monio::AtlasWriter::populateDataVec<float>(std::vector<float>& dataVec,
+                                                         const atlas::Field& field,
+                                                         const std::vector<int>& dimensions);
+template void monio::AtlasWriter::populateDataVec<int>(std::vector<int>& dataVec,
+                                                       const atlas::Field& field,
+                                                       const std::vector<int>& dimensions);
diff --git a/src/monio/AtlasWriter.h b/src/monio/AtlasWriter.h
index d6366c5..856b1be 100644
--- a/src/monio/AtlasWriter.h
+++ b/src/monio/AtlasWriter.h
@@ -14,8 +14,7 @@
 #include <vector>
 
 #include "Constants.h"
-#include "Data.h"
-#include "Metadata.h"
+#include "FileData.h"
 
 #include "atlas/array/DataType.h"
 #include "atlas/field.h"
@@ -36,16 +35,15 @@ class AtlasWriter {
   AtlasWriter& operator=( AtlasWriter&&)      = delete;  //!< Deleted move assignment
   AtlasWriter& operator=(const AtlasWriter&)  = delete;  //!< Deleted copy assignment
 
-  void populateMetadataAndDataWithFieldSet(Metadata& metadata,
-                                           Data& data,
-                                     const atlas::FieldSet& fieldSet);
+  void populateFileDataWithFieldSet(FileData& fileData,
+                              const atlas::FieldSet& fieldSet);
 
-  void populateMetadataAndDataWithLfricFieldSet(Metadata& metadata,
-                                               Data& data,
-                                         const std::vector<consts::FieldMetadata>& fieldMetadataVec,
-                                               atlas::FieldSet& fieldSet,
-                                         const std::vector<size_t>& lfricToAtlasMap);
+  void populateFileDataWithLfricFieldSet(FileData& fileData,
+                                   const std::vector<consts::FieldMetadata>& fieldMetadataVec,
+                                         atlas::FieldSet& fieldSet,
+                                   const std::vector<size_t>& lfricToAtlasMap);
 
+ private:
   void populateMetadataWithField(Metadata& metadata,
                            const atlas::Field& field,
                            const consts::FieldMetadata* fieldMetadata = nullptr,
@@ -60,15 +58,6 @@ class AtlasWriter {
                                 const atlas::Field& field,
                                 const std::vector<int>& dimensions);
 
-  template<typename T> void populateDataVec(std::vector<T>& dataVec,
-                                      const atlas::Field& field,
-                                      const std::vector<size_t>& lfricToAtlasMap);
-
-  template<typename T> void populateDataVec(std::vector<T>& dataVec,
-                                      const atlas::Field& field,
-                                      const std::vector<int>& dimensions);
-
- private:
   void populateDataWithField(Data& data,
                        const atlas::Field& field,
                        const std::vector<size_t>& lfricToAtlasMap,
@@ -78,6 +67,14 @@ class AtlasWriter {
                        const atlas::Field& field,
                        const std::vector<int> dimensions);
 
+  template<typename T> void populateDataVec(std::vector<T>& dataVec,
+                                      const atlas::Field& field,
+                                      const std::vector<size_t>& lfricToAtlasMap);
+
+  template<typename T> void populateDataVec(std::vector<T>& dataVec,
+                                      const atlas::Field& field,
+                                      const std::vector<int>& dimensions);
+
   const eckit::mpi::Comm& mpiCommunicator_;
   const std::size_t mpiRankOwner_;
 };
diff --git a/src/monio/File.cc b/src/monio/File.cc
index d2dec9a..506c977 100644
--- a/src/monio/File.cc
+++ b/src/monio/File.cc
@@ -246,12 +246,10 @@ void monio::File::readAttributes(Metadata& metadata) {
 
 template<typename T>
 void monio::File::readSingleDatum(const std::string& varName,
-                                  const int varSize,
                                   std::vector<T>& dataVec) {
   oops::Log::debug() << "File::readData()" << std::endl;
   if (fileMode_ == netCDF::NcFile::read) {
     auto var = getFile().getVar(varName);
-    dataVec.resize(varSize, 0);
     var.getVar(dataVec.data());
   } else {
     utils::throwException("File::readSingleDatum()> Write file accessed for reading...");
@@ -259,25 +257,20 @@ void monio::File::readSingleDatum(const std::string& varName,
 }
 
 template void monio::File::readSingleDatum<double>(const std::string& varName,
-                                                   const int varSize,
                                                    std::vector<double>& dataVec);
 template void monio::File::readSingleDatum<float>(const std::string& varName,
-                                                  const int varSize,
                                                   std::vector<float>& dataVec);
 template void monio::File::readSingleDatum<int>(const std::string& varName,
-                                                const int varSize,
                                                 std::vector<int>& dataVec);
 
 template<typename T>
 void monio::File::readFieldDatum(const std::string& fieldName,
-                                 const int varSize,
                                  const std::vector<size_t>& startVec,
                                  const std::vector<size_t>& countVec,
                                  std::vector<T>& dataVec) {
   oops::Log::debug() << "File::readFieldDatum()" << std::endl;
   if (fileMode_ == netCDF::NcFile::read) {
     auto var = getFile().getVar(fieldName);
-    dataVec.resize(varSize, 0);
     var.getVar(startVec, countVec, dataVec.data());
   } else {
     utils::throwException("File::readFieldDatum()> Write file accessed for reading...");
@@ -285,17 +278,14 @@ void monio::File::readFieldDatum(const std::string& fieldName,
 }
 
 template void monio::File::readFieldDatum<double>(const std::string& varName,
-                                                  const int varSize,
                                                   const std::vector<size_t>& startVec,
                                                   const std::vector<size_t>& countVec,
                                                   std::vector<double>& dataVec);
 template void monio::File::readFieldDatum<float>(const std::string& varName,
-                                                 const int varSize,
                                                  const std::vector<size_t>& startVec,
                                                  const std::vector<size_t>& countVec,
                                                  std::vector<float>& dataVec);
 template void monio::File::readFieldDatum<int>(const std::string& varName,
-                                               const int varSize,
                                                const std::vector<size_t>& startVec,
                                                const std::vector<size_t>& countVec,
                                                std::vector<int>& dataVec);
diff --git a/src/monio/File.h b/src/monio/File.h
index 0cb9058..7404bea 100644
--- a/src/monio/File.h
+++ b/src/monio/File.h
@@ -36,11 +36,9 @@ class File {
               const std::vector<std::string>& varNames);
 
   template<typename T> void readSingleDatum(const std::string& varName,
-                                            const int varSize,
                                             std::vector<T>& dataVec);
 
   template<typename T> void readFieldDatum(const std::string& fieldName,
-                                           const int varSize,
                                            const std::vector<size_t>& startVec,
                                            const std::vector<size_t>& countVec,
                                            std::vector<T>& dataVec);
diff --git a/src/monio/Monio.cc b/src/monio/Monio.cc
index 2e67e39..1445b85 100644
--- a/src/monio/Monio.cc
+++ b/src/monio/Monio.cc
@@ -51,7 +51,7 @@ void monio::Monio::readBackground(atlas::FieldSet& localFieldSet,
       auto& functionSpace = globalField.functionspace();
       auto& grid = atlas::functionspace::NodeColumns(functionSpace).mesh().grid();
 
-      // Initialise background file
+      // Initialise file
       if (fileDataExists(grid.name()) == false) {
         FileData& fileData = createFileData(grid.name(), filePath, dateTime);
         reader_.openFile(fileData);
@@ -100,7 +100,7 @@ void monio::Monio::readIncrements(atlas::FieldSet& localFieldSet,
       auto& functionSpace = globalField.functionspace();
       auto& grid = atlas::functionspace::NodeColumns(functionSpace).mesh().grid();
 
-      // Initialise background file
+      // Initialise file
       if (fileDataExists(grid.name()) == false) {
         FileData& fileData = createFileData(grid.name(), filePath);
         reader_.openFile(fileData);
@@ -140,38 +140,35 @@ void monio::Monio::writeIncrements(const atlas::FieldSet& localFieldSet,
     FileData fileData = getFileData(grid.name());
 
     if (filePath.length() != 0) {
-      monio::Metadata& readMetadata = fileData.getMetadata();
-      monio::Data& readData = fileData.getData();
       std::vector<size_t>& lfricAtlasMap = fileData.getLfricAtlasMap();
 
-      readMetadata.clearGlobalAttributes();
+      fileData.getMetadata().clearGlobalAttributes();
 
-      readMetadata.deleteDimension(std::string(consts::kTimeDimName));
-      readMetadata.deleteDimension(std::string(consts::kTileDimName));
+      fileData.getMetadata().deleteDimension(std::string(consts::kTimeDimName));
+      fileData.getMetadata().deleteDimension(std::string(consts::kTileDimName));
 
-      readData.deleteContainer(std::string(consts::kTimeVarName));
-      readData.deleteContainer(std::string(consts::kTileVarName));
+      fileData.getData().deleteContainer(std::string(consts::kTimeVarName));
+      fileData.getData().deleteContainer(std::string(consts::kTileVarName));
 
       // Reconcile Metadata with Data
       oops::Log::debug() << "AtlasWriter::reconcileMetadataWithData()" << std::endl;
-      std::vector<std::string> metadataVarNames = readMetadata.getVariableNames();
-      std::vector<std::string> dataContainerNames = readData.getDataContainerNames();
+      std::vector<std::string> metadataVarNames = fileData.getMetadata().getVariableNames();
+      std::vector<std::string> dataContainerNames = fileData.getData().getDataContainerNames();
 
       for (const auto& metadataVarName : metadataVarNames) {
         auto it = std::find(begin(dataContainerNames), end(dataContainerNames), metadataVarName);
         if (it == std::end(dataContainerNames)) {
-          readMetadata.deleteVariable(metadataVarName);
+          fileData.getMetadata().deleteVariable(metadataVarName);
         }
       }
       // Add data and metadata for increments in fieldSet
-      atlasWriter_.populateMetadataAndDataWithLfricFieldSet(readMetadata, readData,
-                                                            fieldMetadataVec, globalFieldSet,
-                                                            lfricAtlasMap);
+      atlasWriter_.populateFileDataWithLfricFieldSet(fileData, fieldMetadataVec,
+                                                     globalFieldSet, lfricAtlasMap);
       monio::Writer writer(atlas::mpi::comm(),
                            consts::kMPIRankOwner,
                            filePath);
-      writer.writeMetadata(readMetadata);
-      writer.writeVariablesData(readMetadata, readData);
+      writer.writeMetadata(fileData.getMetadata());
+      writer.writeVariablesData(fileData);
     } else {
       oops::Log::info() << "AtlasWriter::writeFieldSetToFile() No outputFilePath supplied. "
                            "NetCDF writing will not take place." << std::endl;
@@ -185,14 +182,13 @@ void monio::Monio::writeFieldSet(const atlas::FieldSet& localFieldSet,
   atlas::FieldSet globalFieldSet = utilsatlas::getGlobalFieldSet(localFieldSet);
   if (atlas::mpi::rank() == consts::kMPIRankOwner) {
     if (outputFilePath.length() != 0) {
-      monio::Metadata metadata;
-      monio::Data data;
+      FileData fileData;
       monio::AtlasWriter atlasWriter(atlas::mpi::comm(),
                                      consts::kMPIRankOwner);
-      atlasWriter.populateMetadataAndDataWithFieldSet(metadata, data, globalFieldSet);
+      atlasWriter.populateFileDataWithFieldSet(fileData, globalFieldSet);
       monio::Writer writer(atlas::mpi::comm(), consts::kMPIRankOwner, outputFilePath);
-      writer.writeMetadata(metadata);
-      writer.writeVariablesData(metadata, data);
+      writer.writeMetadata(fileData.getMetadata());
+      writer.writeVariablesData(fileData);
     } else {
       oops::Log::info() << "Monio::writeFieldSet() No outputFilePath supplied. "
                            "NetCDF writing will not take place." << std::endl;
diff --git a/src/monio/Reader.cc b/src/monio/Reader.cc
index 2dfa122..8c680d2 100644
--- a/src/monio/Reader.cc
+++ b/src/monio/Reader.cc
@@ -24,17 +24,6 @@
 #include "oops/util/Duration.h"
 #include "oops/util/Logger.h"
 
-namespace {
-bool isStringInVector(std::string searchStr, const std::vector<std::string>& strVec) {
-  oops::Log::debug() << "isStringInVector()" << std::endl;
-  std::vector<std::string>::const_iterator it = std::find(strVec.begin(), strVec.end(), searchStr);
-  if (it != strVec.end())
-    return true;
-  else
-    return false;
-}
-}  // anonymous namespace
-
 monio::Reader::Reader(const eckit::mpi::Comm& mpiCommunicator,
                       const atlas::idx_t mpiRankOwner,
                       const FileData& fileData):
@@ -73,36 +62,6 @@ void monio::Reader::readMetadata(FileData& fileData) {
   }
 }
 
-void monio::Reader::readAllData(FileData& fileData) {
-  oops::Log::debug() << "Reader::readAllData()" << std::endl;
-  if (mpiCommunicator_.rank() == mpiRankOwner_) {
-    std::vector<std::string> varNames = fileData.getMetadata().getVariableNames();
-    readFullData(fileData, varNames);
-  }
-}
-
-//  void monio::Reader::readDataAtTime(FileData& fileData,
-//                                    const std::vector<std::string>& varNames,
-//                                    const std::string& dateString,
-//                                    const std::string& timeDimName) {
-//    oops::Log::debug() << "Reader::readFieldData()" << std::endl;
-//    util::DateTime dateToRead(dateString);
-//    readDataAtTime(fileData, varNames, dateToRead, timeDimName);
-//  }
-
-//  void monio::Reader::readDataAtTime(FileData& fileData,
-//                                    const std::vector<std::string>& varNames,
-//                                    const util::DateTime& dateToRead,
-//                                    const std::string& timeDimName) {
-//    oops::Log::debug() << "Reader::readFieldData()" << std::endl;
-//    if (mpiCommunicator_.rank() == mpiRankOwner_) {
-//      size_t timeStep = findTimeStep(fileData, dateToRead);
-//      for (auto& varName : varNames) {
-//        readDatumAtTime(fileData, varName, timeStep, timeDimName);
-//      }
-//    }
-//  }
-
 void monio::Reader::readDatumAtTime(FileData& fileData,
                                    const std::string& varName,
                                    const util::DateTime& dateToRead,
@@ -146,24 +105,24 @@ void monio::Reader::readDatumAtTime(FileData& fileData,
         case consts::eDataTypes::eDouble: {
           std::shared_ptr<DataContainerDouble> dataContainerDouble =
                                       std::make_shared<DataContainerDouble>(varName);
-          getFile().readFieldDatum(varName, varSizeNoTime,
-                              startVec, countVec, dataContainerDouble->getData());
+          dataContainerDouble->setSize(varSizeNoTime);
+          getFile().readFieldDatum(varName, startVec, countVec, dataContainerDouble->getData());
           dataContainer = std::static_pointer_cast<DataContainerBase>(dataContainerDouble);
           break;
         }
         case consts::eDataTypes::eFloat: {
           std::shared_ptr<DataContainerFloat> dataContainerFloat =
                                       std::make_shared<DataContainerFloat>(varName);
-          getFile().readFieldDatum(varName, varSizeNoTime,
-                               startVec, countVec, dataContainerFloat->getData());
+          dataContainerFloat->setSize(varSizeNoTime);
+          getFile().readFieldDatum(varName, startVec, countVec, dataContainerFloat->getData());
           dataContainer = std::static_pointer_cast<DataContainerBase>(dataContainerFloat);
           break;
         }
         case consts::eDataTypes::eInt: {
         std::shared_ptr<DataContainerInt> dataContainerInt =
                                       std::make_shared<DataContainerInt>(varName);
-          getFile().readFieldDatum(varName, varSizeNoTime,
-                               startVec, countVec, dataContainerInt->getData());
+          dataContainerInt->setSize(varSizeNoTime);
+          getFile().readFieldDatum(varName, startVec, countVec, dataContainerInt->getData());
           dataContainer = std::static_pointer_cast<DataContainerBase>(dataContainerInt);
           break;
         }
@@ -182,6 +141,14 @@ void monio::Reader::readDatumAtTime(FileData& fileData,
   }
 }
 
+void monio::Reader::readAllData(FileData& fileData) {
+  oops::Log::debug() << "Reader::readAllData()" << std::endl;
+  if (mpiCommunicator_.rank() == mpiRankOwner_) {
+    std::vector<std::string> varNames = fileData.getMetadata().getVariableNames();
+    readFullData(fileData, varNames);
+  }
+}
+
 void monio::Reader::readFullData(FileData& fileData,
                                  const std::vector<std::string>& varNames) {
   oops::Log::debug() << "Reader::readSingleData()" << std::endl;
@@ -203,24 +170,24 @@ void monio::Reader::readFullDatum(FileData& fileData,
       case consts::eDataTypes::eDouble: {
         std::shared_ptr<DataContainerDouble> dataContainerDouble =
                             std::make_shared<DataContainerDouble>(varName);
-        getFile().readSingleDatum(varName,
-            variable->getTotalSize(), dataContainerDouble->getData());
+        dataContainerDouble->setSize(variable->getTotalSize());
+        getFile().readSingleDatum(varName, dataContainerDouble->getData());
         dataContainer = std::static_pointer_cast<DataContainerBase>(dataContainerDouble);
         break;
       }
       case consts::eDataTypes::eFloat: {
         std::shared_ptr<DataContainerFloat> dataContainerFloat =
                             std::make_shared<DataContainerFloat>(varName);
-        getFile().readSingleDatum(varName,
-            variable->getTotalSize(), dataContainerFloat->getData());
+        dataContainerFloat->setSize(variable->getTotalSize());
+        getFile().readSingleDatum(varName, dataContainerFloat->getData());
         dataContainer = std::static_pointer_cast<DataContainerBase>(dataContainerFloat);
         break;
       }
       case consts::eDataTypes::eInt: {
         std::shared_ptr<DataContainerInt> dataContainerInt =
                             std::make_shared<DataContainerInt>(varName);
-        getFile().readSingleDatum(varName,
-            variable->getTotalSize(), dataContainerInt->getData());
+        dataContainerInt->setSize(variable->getTotalSize());
+        getFile().readSingleDatum(varName, dataContainerInt->getData());
         dataContainer = std::static_pointer_cast<DataContainerBase>(dataContainerInt);
         break;
       }
@@ -265,7 +232,7 @@ std::vector<std::shared_ptr<monio::DataContainerBase>> monio::Reader::getCoordDa
       std::map<std::string, std::shared_ptr<DataContainerBase>>& dataContainers =
                                                             fileData.getData().getContainers();
       for (auto& dataPair : dataContainers) {
-        if (isStringInVector(dataPair.first, coordNames) == true) {
+        if (utils::findInVector(coordNames, dataPair.first) == true) {
           std::shared_ptr<DataContainerBase> dataContainer = dataContainers.at(dataPair.first);
           coordContainers.push_back(dataContainer);
         }
@@ -277,28 +244,6 @@ std::vector<std::shared_ptr<monio::DataContainerBase>> monio::Reader::getCoordDa
   }
 }
 
-size_t monio::Reader::getSizeOwned(const FileData& fileData, const std::string& varName) {
-  oops::Log::debug() << "Reader::getSizeOwned()" << std::endl;
-  size_t totalSize;
-  if (mpiCommunicator_.rank() == mpiRankOwner_) {
-    std::shared_ptr<Variable> variable = fileData.getMetadata().getVariable(varName);
-    totalSize = variable->getTotalSize();
-  }
-  mpiCommunicator_.broadcast(totalSize, mpiRankOwner_);
-  return totalSize;
-}
-
-int monio::Reader::getVarDataType(const FileData& fileData, const std::string& varName) {
-  oops::Log::debug() << "Reader::getVarDataType()" << std::endl;
-  int dataType;
-  if (mpiCommunicator_.rank() == mpiRankOwner_) {
-    std::shared_ptr<Variable> variable = fileData.getMetadata().getVariable(varName);
-    dataType = variable->getType();
-  }
-  mpiCommunicator_.broadcast(dataType, mpiRankOwner_);
-  return dataType;
-}
-
 size_t monio::Reader::findTimeStep(const FileData& fileData, const util::DateTime& dateTime) {
   oops::Log::debug() << "Reader::findTimeStep()" << std::endl;
   if (fileData.getDateTimes().size() == 0) {
diff --git a/src/monio/Reader.h b/src/monio/Reader.h
index 220c685..8cced91 100644
--- a/src/monio/Reader.h
+++ b/src/monio/Reader.h
@@ -22,8 +22,7 @@
 #include "FileData.h"
 
 namespace monio {
-/// \brief Top-level class uses File, Metadata,
-/// and Data to read from a NetCDF file
+/// \brief Top-level class reads from a NetCDF file and populates FileData
 class Reader {
  public:
   Reader(const eckit::mpi::Comm& mpiCommunicator,
@@ -39,34 +38,23 @@ class Reader {
   Reader& operator=(Reader&&)      = delete;  //!< Deleted move assignment
   Reader& operator=(const Reader&) = delete;  //!< Deleted copy assignment
 
-  void openFile(const FileData& fileData);  // Monio::readBackground
-  void readMetadata(FileData& fileData);    // Monio::readBackground
+  void openFile(const FileData& fileData);
+  void readMetadata(FileData& fileData);
+
+  void readAllData(FileData& fileData);
   void readFullData(FileData& fileData,
-                    const std::vector<std::string>& varNames);  // Monio::readBackground
-  void readFullDatum(FileData& fileData, const std::string& varName);  // Monio::readBackground
+                    const std::vector<std::string>& varNames);
+  void readFullDatum(FileData& fileData, const std::string& varName);
 
   void readDatumAtTime(FileData& fileData,
                       const std::string& variableName,
                       const util::DateTime& dateToRead,
-                      const std::string& timeDimName);  // Monio::readBackground
+                      const std::string& timeDimName);
 
   void readDatumAtTime(FileData& fileData,
                       const std::string& variableName,
                       const size_t timeStep,
-                      const std::string& timeDimName);  // Reader::readDatumAtTime -- private?
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////
-  void readAllData(FileData& fileData);
-
-  void readDataAtTime(FileData& fileData,
-                     const std::vector<std::string>& variableNames,
-                     const std::string& dateString,
-                     const std::string& timeDimName);
-
-  void readDataAtTime(FileData& fileData,
-                     const std::vector<std::string>& variableNames,
-                     const util::DateTime& dateToRead,
-                     const std::string& timeDimName);
+                      const std::string& timeDimName);
 
   std::vector<std::string> getVarStrAttrs(const FileData& fileData,
                                           const std::vector<std::string>& varNames,
@@ -76,8 +64,6 @@ class Reader {
                                                   const std::vector<std::string>& coordNames);
 
  private:
-  size_t getSizeOwned(const FileData& fileData, const std::string& varName);
-  int getVarDataType(const FileData& fileData, const std::string& varName);
   size_t findTimeStep(const FileData& fileData, const util::DateTime& dateTime);
 
   File& getFile();
diff --git a/src/monio/Writer.cc b/src/monio/Writer.cc
index 890a34e..bb5ff1f 100644
--- a/src/monio/Writer.cc
+++ b/src/monio/Writer.cc
@@ -38,9 +38,9 @@ monio::Writer::Writer(const eckit::mpi::Comm& mpiCommunicator,
   }
 }
 
-void monio::Writer::writeData(const Metadata& metadata, const Data& data) {
-  writeMetadata(metadata);
-  writeVariablesData(metadata, data);
+void monio::Writer::writeData(const FileData& fileData) {
+  writeMetadata(fileData.getMetadata());
+  writeVariablesData(fileData);
 }
 
 void monio::Writer::writeMetadata(const Metadata& metadata) {
@@ -50,38 +50,38 @@ void monio::Writer::writeMetadata(const Metadata& metadata) {
   }
 }
 
-void monio::Writer::writeVariablesData(const Metadata& metadata, const Data& data) {
+void monio::Writer::writeVariablesData(const FileData& fileData) {
   oops::Log::debug() << "Writer::writeVariablesData()" << std::endl;
   if (mpiCommunicator_.rank() == mpiRankOwner_) {
     const std::map<std::string, std::shared_ptr<DataContainerBase>>& dataContainerMap =
-                                                                     data.getContainers();
+                                                                fileData.getData().getContainers();
     for (const auto& dataContainerPair : dataContainerMap) {
       std::string varName = dataContainerPair.first;
       // Checks variable exists in metadata
-      metadata.getVariable(varName);
+      fileData.getMetadata().getVariable(varName);
       std::shared_ptr<DataContainerBase> dataContainer = dataContainerPair.second;
       int dataType = dataContainerPair.second->getType();
       switch (dataType) {
-      case consts::eDataTypes::eDouble: {
-        std::shared_ptr<DataContainerDouble> dataContainerDouble =
-            std::static_pointer_cast<DataContainerDouble>(dataContainer);
-        getFile().writeSingleDatum(varName, dataContainerDouble->getData());
-        break;
-      }
-      case consts::eDataTypes::eFloat: {
-        std::shared_ptr<DataContainerFloat> dataContainerFloat =
-            std::static_pointer_cast<DataContainerFloat>(dataContainer);
-        getFile().writeSingleDatum(varName, dataContainerFloat->getData());
-        break;
-      }
-      case consts::eDataTypes::eInt: {
-        std::shared_ptr<DataContainerInt> dataContainerInt =
-            std::static_pointer_cast<DataContainerInt>(dataContainer);
-        getFile().writeSingleDatum(varName, dataContainerInt->getData());
-        break;
-      }
-      default:
-        utils::throwException("Writer::writeVariablesData()> Data type not coded for...");
+        case consts::eDataTypes::eDouble: {
+          std::shared_ptr<DataContainerDouble> dataContainerDouble =
+              std::static_pointer_cast<DataContainerDouble>(dataContainer);
+          getFile().writeSingleDatum(varName, dataContainerDouble->getData());
+          break;
+        }
+        case consts::eDataTypes::eFloat: {
+          std::shared_ptr<DataContainerFloat> dataContainerFloat =
+              std::static_pointer_cast<DataContainerFloat>(dataContainer);
+          getFile().writeSingleDatum(varName, dataContainerFloat->getData());
+          break;
+        }
+        case consts::eDataTypes::eInt: {
+          std::shared_ptr<DataContainerInt> dataContainerInt =
+              std::static_pointer_cast<DataContainerInt>(dataContainer);
+          getFile().writeSingleDatum(varName, dataContainerInt->getData());
+          break;
+        }
+        default:
+          utils::throwException("Writer::writeVariablesData()> Data type not coded for...");
       }
     }
   }
diff --git a/src/monio/Writer.h b/src/monio/Writer.h
index 0d436cf..1dd8ec9 100644
--- a/src/monio/Writer.h
+++ b/src/monio/Writer.h
@@ -18,11 +18,11 @@
 
 #include "Data.h"
 #include "File.h"
+#include "FileData.h"
 #include "Metadata.h"
 
 namespace monio {
-/// \brief Top-level class uses File, Metadata, AtlasData,
-/// and Data to write to a NetCDF file
+/// \brief Top-level class uses FileData and its contents to write to a NetCDF file
 class Writer {
  public:
   explicit Writer(const eckit::mpi::Comm& mpiCommunicator,
@@ -35,9 +35,9 @@ class Writer {
   Writer& operator=(Writer&&)      = delete;  //!< Deleted move assign
   Writer& operator=(const Writer&) = delete;  //!< Deleted copy assign
 
-  void writeData(const Metadata& metadata, const Data& data);
+  void writeData(const FileData& fileData);
   void writeMetadata(const Metadata& metadata);
-  void writeVariablesData(const Metadata& metadata, const Data& data);
+  void writeVariablesData(const FileData& fileData);
 
  private:
   File& getFile();
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 12a1cd6..d363640 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -47,13 +47,13 @@ ecbuild_add_test(TARGET monio_coding_norms
                        ${PROJECT_SOURCE_DIR}/src
                        ${PROJECT_SOURCE_DIR}/test)
 
-ecbuild_add_test(TARGET  test_state_basic
+ecbuild_add_test(TARGET  test_monio_state_basic
                  SOURCES mains/TestStateBasic.cc
                  ARGS    "testinput/state_basic.yaml"
                  LIBS    monio
                  MPI     4)
 
-ecbuild_add_test(TARGET  test_state_full
+ecbuild_add_test(TARGET  test_monio_state_full
                  SOURCES mains/TestStateFull.cc
                  ARGS    "testinput/state_full.yaml"
                  LIBS    monio
diff --git a/test/monio/StateBasic.h b/test/monio/StateBasic.h
index 889a494..71e5b2f 100644
--- a/test/monio/StateBasic.h
+++ b/test/monio/StateBasic.h
@@ -57,7 +57,7 @@ void testFunction() {
     monio::Writer writer(atlas::mpi::comm(),
                          monio::consts::kMPIRankOwner,
                          outputFilePath);
-    writer.writeData(firstFileData.getMetadata(), firstFileData.getData());
+    writer.writeData(firstFileData);
 
     monio::FileData secondFileData(outputFilePath);
     reader.openFile(secondFileData);