testing_utilities.h

 
#pragma once
 
// STL includes
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>
 
#include "../system_tests/system_tester.h"  // provide systemTest class
#include "../utils/basic_structs.h"
 
// =============================================================================
// NOTE: Global variables are declared as extern at the end of this file
// =============================================================================
 
namespace testing_utilities
{
// =========================================================================
int64_t ulpsDistanceDbl(double const &a, double const &b);
// =========================================================================
 
// =========================================================================
bool nearlyEqualDbl(double const &a, double const &b, double &absoluteDiff, int64_t &ulpsDiff,
                    double const &fixedEpsilon = 1E-14, int64_t const &ulpsEpsilon = 4);
// =========================================================================
 
void wrapperEqual(int i, int j, int k, std::string const &dataSetName, double test_value, double fid_value,
                  double fixedEpsilon);
 
void analyticConstant(system_test::SystemTestRunner testObject, std::string const &dataSetName, double value);
 
void analyticSine(system_test::SystemTestRunner testObject, std::string const &dataSetName, double constant,
                  double amplitude, double kx, double ky, double kz, double phase, double tolerance);
 
// =========================================================================
template <int checkType = 0>
void Check_Results(double fiducialNumber, double testNumber, std::string const &outString, double fixedEpsilon = -999,
                   int64_t ulpsEpsilon = -999)
{
  // Check for equality and if not equal return difference
  double absoluteDiff;
  int64_t ulpsDiff;
  bool areEqual;
 
  if ((fixedEpsilon < 0) and (ulpsEpsilon < 0)) {
    areEqual = testing_utilities::nearlyEqualDbl(fiducialNumber, testNumber, absoluteDiff, ulpsDiff);
  } else if ((fixedEpsilon > 0) and (ulpsEpsilon < 0)) {
    areEqual = testing_utilities::nearlyEqualDbl(fiducialNumber, testNumber, absoluteDiff, ulpsDiff, fixedEpsilon);
  } else {
    areEqual = testing_utilities::nearlyEqualDbl(fiducialNumber, testNumber, absoluteDiff, ulpsDiff, fixedEpsilon,
                                                 ulpsEpsilon);
  }
 
  std::stringstream outputMessage;
  outputMessage << std::setprecision(std::numeric_limits<double>::max_digits10) << "Difference in " << outString
                << std::endl
                << "The fiducial value is:       " << fiducialNumber << std::endl
                << "The test value is:           " << testNumber << std::endl
                << "The absolute difference is:  " << absoluteDiff << std::endl
                << "The ULP difference is:       " << ulpsDiff << std::endl;
 
  if (checkType == 0) {
    EXPECT_TRUE(areEqual) << outputMessage.str();
  } else if (checkType == 1) {
    ASSERT_TRUE(areEqual) << outputMessage.str();
  } else {
    throw std::runtime_error(
        "Incorrect template argument passed to "
        "Check_Results. Options are 0 and 1 but " +
        std::to_string(checkType) + " was passed");
  }
}
// =========================================================================
 
// =========================================================================
class GlobalString
{
 private:
  std::string _string;
 
 public:
  void init(std::string const &inputPath) { _string = inputPath; };
 
  std::string getString() { return _string; };
  GlobalString()  = default;
  ~GlobalString() = default;
};
// =========================================================================
 
void inline Check_Interface(reconstruction::InterfaceState const &test_data,
                            reconstruction::InterfaceState const &fiducial_data, size_t const direction)
{
  std::string const message = "Direction " + std::to_string(direction);
 
  testing_utilities::Check_Results(test_data.density, fiducial_data.density, "density " + message);
  testing_utilities::Check_Results(test_data.energy, fiducial_data.energy, "energy " + message);
  testing_utilities::Check_Results(test_data.pressure, fiducial_data.pressure, "pressure " + message);
  testing_utilities::Check_Results(test_data.velocity.x(), fiducial_data.velocity.x(), "velocity.x " + message);
  testing_utilities::Check_Results(test_data.velocity.y(), fiducial_data.velocity.y(), "velocity.y " + message);
  testing_utilities::Check_Results(test_data.velocity.z(), fiducial_data.velocity.z(), "velocity.z " + message);
  testing_utilities::Check_Results(test_data.momentum.x(), fiducial_data.momentum.x(), "momentum.x " + message);
  testing_utilities::Check_Results(test_data.momentum.y(), fiducial_data.momentum.y(), "momentum.y " + message);
  testing_utilities::Check_Results(test_data.momentum.z(), fiducial_data.momentum.z(), "momentum.z " + message);
 
#ifdef MHD
  testing_utilities::Check_Results(test_data.total_pressure, fiducial_data.total_pressure, "total_pressure" + message);
  testing_utilities::Check_Results(test_data.magnetic.x(), fiducial_data.magnetic.x(), "magnetic.x " + message);
  testing_utilities::Check_Results(test_data.magnetic.y(), fiducial_data.magnetic.y(), "magnetic.y " + message);
  testing_utilities::Check_Results(test_data.magnetic.z(), fiducial_data.magnetic.z(), "magnetic.z " + message);
#endif  // MHD
}
}  // namespace testing_utilities
 
// Declare the global string variables so everything that imports this file
// has access to them
extern testing_utilities::GlobalString globalChollaRoot;
extern testing_utilities::GlobalString globalChollaBuild;
extern testing_utilities::GlobalString globalChollaMachine;
extern testing_utilities::GlobalString globalMpiLauncher;
extern bool globalRunCholla;
extern bool globalCompareSystemTestResults;