system_tester.h

 
#pragma once
 
// STL includes
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
// External Libraries and Headers
#include <H5Cpp.h>
 
#include "../io/io.h"  // to_string_exact
 
namespace system_test
{
 
class ParamArgListBuilder
{
  std::string s_;
 
  ParamArgListBuilder &update_(std::string_view name, std::string_view val)
  {
    s_.reserve(s_.size() + 2 + name.size() + val.size());
    s_ += ' ';
    s_ += name;
    s_ += '=';
    s_ += val;
    return *this;
  }
 
 public:
  const std::string &getCombinedArgList() const { return s_; }
 
  // we may need to add more overloads over time
 
  ParamArgListBuilder &param(std::string_view name, int val) { return update_(name, std::to_string(val)); }
  ParamArgListBuilder &param(std::string_view name, size_t val) { return update_(name, std::to_string(val)); }
  ParamArgListBuilder &param(std::string_view name, float val) { return update_(name, to_string_exact(val)); }
  ParamArgListBuilder &param(std::string_view name, double val) { return update_(name, to_string_exact(val)); }
  ParamArgListBuilder &param(std::string_view name, std::string_view val)
  {
    // for now, this is simple. This will get more complex if we require strings to be quoted
    return update_(name, val);
  }
};
 
class SystemTestRunner;
}  // namespace system_test
 
class system_test::SystemTestRunner
{
 public:
  size_t numMpiRanks = 1;
 
  system_test::ParamArgListBuilder chollaLaunchParams;
 
  void runTest(bool const &compute_L2_norm_only = false, double const &maxAllowedL1Error = 0.0,
               double const &maxAllowedError = 0.0);
 
  void runL1ErrorTest(double const &maxAllowedL1Error, double const &maxAllowedError = 1E-7);
 
  void launchCholla();
 
  void openHydroTestData();
 
  std::string getChollaPath() { return _chollaPath; };
 
  std::string getChollaSettingsFilePath() { return _chollaSettingsPath; };
 
  double getL2Norm() { return L2Norm_; };
 
  std::string getOutputDirectory() { return _outputDirectory; };
 
  std::string getConsoleOutputPath() { return _consoleOutputPath; };
 
  H5::H5File getFiducialFile() { return _fiducialFile; };
 
  H5::H5File getTestFile(size_t const &i = 0) { return _testHydroFieldsFileVec[i]; };
 
  std::vector<std::string> getDataSetsToTest() { return _fiducialDataSetNames; };
 
  void setFixedEpsilon(double const &newVal) { _fixedEpsilon = newVal; };
 
  void setDataSetsToTest(std::vector<std::string> const &dataSetNames) { _fiducialDataSetNames = dataSetNames; };
 
  void setCompareNumTimeSteps(bool const &compare) { _compareNumTimeSteps = compare; };
 
  void setFiducialData(std::string const &fieldName, std::vector<double> const &dataVec);
 
  void setFiducialNumTimeSteps(int const &numTimeSteps) { _numFiducialTimeSteps = numTimeSteps; };
 
  std::vector<double> generateConstantData(double const &value, size_t const &nx = 1, size_t const &ny = 1,
                                           size_t const &nz = 1);
 
  std::vector<double> loadTestFieldData(std::string dataSetName, std::vector<size_t> &testDims,
                                        std::vector<H5::H5File> file = {});
 
  std::vector<double> generateSineData(double const &offset, double const &amplitude, double const &kx,
                                       double const &ky, double const &kz, double const &phase, size_t const &nx = 1,
                                       size_t const &ny = 1, size_t const &nz = 1);
 
  // Constructor and Destructor
  SystemTestRunner(bool const &particleData = false, bool const &hydroData = true, bool const &useFiducialFile = true,
                   bool const &useSettingsFile = true, bool const &gravityData = false);
  ~SystemTestRunner();
 
 private:
  H5::H5File _fiducialFile;
  std::vector<H5::H5File> _testHydroFieldsFileVec;
  std::vector<H5::H5File> _testParticlesFileVec;
  std::vector<H5::H5File> _testGravityFileVec;
 
  std::string _chollaPath;
  std::string _fullTestFileName;
  std::string _chollaSettingsPath;
  std::string _fiducialFilePath;
  std::string _outputDirectory;
  std::string _consoleOutputPath;
 
  std::vector<std::string> _fiducialDataSetNames;
  std::vector<std::string> _testDataSetNames;
 
  int _numFiducialTimeSteps;
  std::unordered_map<std::string, std::vector<double>> _fiducialDataSets;
 
  std::vector<double> _testParticleIDs;
  size_t _testTotalNumParticles = 0;
  std::vector<double> _fiducialParticleIDs;
  size_t _fiducialTotalNumParticles = 0;
 
  double _fixedEpsilon = 5.0E-12;
 
  double L2Norm_;
 
  bool _fiducialFileExists = false;
  bool _compareNumTimeSteps = true;
 
  bool _hydroDataExists = true;
  bool _particleDataExists = false;
 
  bool _gravityDataExists = false;
 
  void _checkNumTimeSteps();
 
  std::vector<double> _loadTestParticleData(std::string const &dataSetName);
 
  std::vector<double> _loadFiducialFieldData(std::string const &dataSetName);
 
  std::vector<double> _loadGravityPotential(H5::H5File const &data_file);
 
  std::vector<double> _loadFiducialParticleData(std::string const &dataSetName);
 
  std::vector<std::string> _findDataSetNames(H5::H5File const &inputFile);
};  // End of class system_test::SystemTestRunner