renames PhiAndNuTestResult to PhiandNuTest

targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.cpp

+#include "PhiAndNuTest.h"
+
+#include "Utilities/TestCout/TestCoutImp.h"
+#include "PhiAndNuTest.h"
+
+std::shared_ptr<PhiAndNuTest> PhiAndNuTest::getNewInstance(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut)
+{
+	return std::shared_ptr<PhiAndNuTest>(new PhiAndNuTest(aTestName, minOrderOfAccuracy, testOut));
+}
+
+void PhiAndNuTest::evaluate()
+{
+	orderOfAccuracyNuDiff = calcOrderOfAccuracy(nuDiff);
+	orderOfAccuracyPhiDiff = calcOrderOfAccuracy(phiDiff);
+
+	nuDiffTestPassed = checkTestPassed(orderOfAccuracyNuDiff);
+	phiDiffTestPassed = checkTestPassed(orderOfAccuracyPhiDiff);
+	
+	if (orderOfAccuracyNuDiff.size() > 0 && orderOfAccuracyPhiDiff.size() > 0)
+		makeLastTestOutput();
+}
+
+void PhiAndNuTest::makeFinalOutput()
+{
+	for (int i = 1; i < lx.size(); i++) {
+		testOut->makeTestOutput(nuDiffTestPassed.at(i - 1), testName, lx.at(i - 1), lx.at(i), "NuDiff", "NuDiff", "OrderOfAccuracy", nuDiff.at(i - 1), nuDiff.at(i), orderOfAccuracyNuDiff.at(i - 1));
+		testOut->makeTestOutput(phiDiffTestPassed.at(i - 1), testName, lx.at(i - 1), lx.at(i), "PhiDiff", "PhiDiff", "OrderOfAccuracy", phiDiff.at(i - 1), phiDiff.at(i), orderOfAccuracyPhiDiff.at(i - 1));
+	}
+}
+
+void PhiAndNuTest::add(double phiDiff, double nuDiff, double lx)
+{
+	this->nuDiff.push_back(nuDiff);
+	this->phiDiff.push_back(phiDiff);
+	this->lx.push_back(lx);
+}
+
+std::string PhiAndNuTest::getOutput()
+{
+	std::ostringstream oss;
+	oss << "#################################################" << std::endl;
+	oss << "#" << std::setfill(' ') << std::right << std::setw(24 + testName.length() / 2) << testName << std::setw(24 - testName.length() / 2) << "#" << std::endl;
+	oss << "#################################################" << std::endl;
+
+	oss << "L" << "\t" << std::setfill(' ') << std::left << std::setw(15) << "NuDiff" << "Order of Accuracy" << std::endl;
+	oss << lx.at(0) << "\t" << nuDiff.at(0) << std::endl;
+	for (int i = 0; i < nuDiff.size() - 1; i++) {
+		oss << std::setfill(' ') << std::setw(23) << " " << orderOfAccuracyNuDiff.at(i) << std::endl;
+		oss << lx.at(i + 1) << "\t" << nuDiff.at(i + 1) << std::endl;
+	}
+	oss << std::endl;
+
+	oss << "L" << "\t" << std::setfill(' ') << std::left << std::setw(15) << "PhiDiff" << "Order of Accuracy" << std::endl;
+	oss << lx.at(0) << "\t" << phiDiff.at(0) << std::endl;
+	for (int i = 0; i < phiDiff.size() - 1; i++) {
+		oss << std::setfill(' ') << std::setw(23) << " " << orderOfAccuracyPhiDiff.at(i) << std::endl;
+		oss << lx.at(i + 1) << "\t" << phiDiff.at(i + 1) << std::endl;
+	}
+	oss << std::endl;
+
+	return oss.str();
+}
+
+PhiAndNuTest::PhiAndNuTest(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut) : testName(aTestName), minOrderOfAccuracy(minOrderOfAccuracy), testOut(testOut)
+{
+	phiDiff.resize(0);
+	nuDiff.resize(0);
+	lx.resize(0);
+	orderOfAccuracyPhiDiff.resize(0);
+	orderOfAccuracyNuDiff.resize(0);
+	nuDiffTestPassed.resize(0);
+	phiDiffTestPassed.resize(0);
+}
+
+void PhiAndNuTest::makeLastTestOutput()
+{
+	testOut->makeTestOutput(nuDiffTestPassed.back(), testName, lx.at(lx.size() - 1), lx.back(), "NuDiff", "NuDiff", "OrderOfAccuracy", nuDiff.at(nuDiff.size() - 1), nuDiff.back(), orderOfAccuracyNuDiff.at(orderOfAccuracyNuDiff.size() - 1));
+	testOut->makeTestOutput(phiDiffTestPassed.back(), testName, lx.at(lx.size() - 1), lx.back(), "PhiDiff", "PhiDiff", "OrderOfAccuracy", phiDiff.at(phiDiff.size() - 1), phiDiff.back(), orderOfAccuracyPhiDiff.at(orderOfAccuracyPhiDiff.size() - 1));
+}
+
+std::vector<double> PhiAndNuTest::calcOrderOfAccuracy(std::vector<double> data)
+{
+	std::vector<double> result;
+	for (int i = 1; i < lx.size(); i++) {
+		double ooa = log(data.at(i - 1) / data.at(i)) / log(lx.at(i) / lx.at(i - 1));
+		result.push_back(ooa);
+	}
+	return result;
+}
+
+std::vector<bool> PhiAndNuTest::checkTestPassed(std::vector<double> orderOfAccuracy)
+{
+	std::vector<bool> result;
+	for (int i = 0; i < orderOfAccuracy.size(); i++) 
+		result.push_back(orderOfAccuracy.at(i) > minOrderOfAccuracy);
+	return result;
+}

targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.h → targets/tests/TestingHULC/Tests/PhiAndNuTest/PhiAndNuTest.h

-#ifndef PHIANDNUTESTRESULTS_H
-#define PHIANDNUTESTRESULTS_H
+#ifndef PHI_AND_NU_TEST_RESULTS_H
+#define PHI_AND_NU_TEST_RESULTS_H
+
+#include "Utilities/TestResults/TestResults.h"
+#include "Utilities/LogFileInformation/LogFileInformation.h"
 
-#include "TestResults.h"
 #include <memory>
 #include <vector>
 #include <iostream>
 
-class PhiAndNuTestResults : public TestResults
+class TestCout;
+
+class PhiAndNuTest : public TestResults, public LogFileInformation
 {
 public:
-	static std::shared_ptr<PhiAndNuTestResults> getNewInstance(std::string aTestName);
+	static std::shared_ptr<PhiAndNuTest> getNewInstance(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut);
 	void evaluate();
+	void makeFinalOutput();
 	void add(double phiDiff, double nuDiff, double lx);
+	std::string getOutput();
 
 private:
-	PhiAndNuTestResults(std::string aTestName);
+	PhiAndNuTest(std::string aTestName, double minOrderOfAccuracy, std::shared_ptr<TestCout> testOut);
 	void makeLastTestOutput();
+	std::vector<double> calcOrderOfAccuracy(std::vector<double> data);
+	std::vector<bool> checkTestPassed(std::vector<double> orderOfAccuracy);
 
 	std::vector<double> phiDiff;
 	std::vector<double> nuDiff;
 	std::vector<double> lx;
 	std::vector<double> orderOfAccuracyPhiDiff;
 	std::vector<double> orderOfAccuracyNuDiff;
-
+	std::vector<bool> phiDiffTestPassed;
+	std::vector<bool> nuDiffTestPassed;
+		
+	double minOrderOfAccuracy;
 	std::string testName;
+
+	std::shared_ptr<TestCout> testOut;
 };
-#endif // !PHIANDNUTESTRESULTS
+#endif

targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.cpp

 #include "FFTCalculator.h"
 
 #include "Utilities\Results\Results.h"
-#include "Utilities\TestResults\PhiAndNuTestResults.h"
+#include "Tests/PhiAndNuTest/PhiAndNuTest.h"
 #include "Utilities\EvaluationParameter\EvaluationParameter.h"
 
 #define _USE_MATH_DEFINES
@@ -34,7 +34,7 @@ void FFTCalculator::init()
 	fftCalculated = false;
 }
 
-FFTCalculator::FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : vis(viscosity), testResults(testResults)
+FFTCalculator::FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults) : vis(viscosity), testResults(testResults)
 {
 
 }

targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/FFTCalculator.h

@@ -10,7 +10,7 @@
 class Results;
 class EvaluationParameter;
 class TestResults;
-class PhiAndNuTestResults;
+class PhiAndNuTest;
 
 class FFTCalculator : public Calculator
 {
@@ -19,7 +19,7 @@ public:
 	void setSimulationResults(std::shared_ptr<Results> simResults);
 
 protected:
-	FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 	virtual void setVectorToCalc() = 0;
 
 	std::shared_ptr<Results> simResults;
@@ -38,7 +38,7 @@ private:
 	void initDataForFFT(fftw_complex* input, unsigned int timeStep);
 	void setFFTResults(fftw_complex* result, unsigned int timeStep);
 
-	std::shared_ptr<PhiAndNuTestResults> testResults;
+	std::shared_ptr<PhiAndNuTest> testResults;
 	std::vector<std::vector<double>> fftResultsIm;
 	std::vector<std::vector<double>> fftResultsRe;
 	std::vector<double> phi;

targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.cpp

@@ -2,7 +2,7 @@
 
 #include "Utilities\Results\Results.h"
 
-std::shared_ptr<VxFFTCalculator> VxFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults)
+std::shared_ptr<VxFFTCalculator> VxFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults)
 {
 	return std::shared_ptr<VxFFTCalculator>(new VxFFTCalculator(viscosity, testResults));
 }
@@ -12,7 +12,7 @@ void VxFFTCalculator::setVectorToCalc()
 	data = simResults->getVx();
 }
 
-VxFFTCalculator::VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : FFTCalculator(viscosity, testResults)
+VxFFTCalculator::VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults) : FFTCalculator(viscosity, testResults)
 {
 	
 }
\ No newline at end of file

targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VxFFTCalculator/VxFFTCalculator.h

@@ -6,11 +6,11 @@
 class VxFFTCalculator : public FFTCalculator
 {
 public:
-	static std::shared_ptr<VxFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	static std::shared_ptr<VxFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 
 protected:
 	void setVectorToCalc();
 private:
-	VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 };
 #endif 
\ No newline at end of file

targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.cpp

@@ -3,7 +3,7 @@
 #include "Utilities\Results\Results.h"
 
 
-std::shared_ptr<VzFFTCalculator> VzFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults)
+std::shared_ptr<VzFFTCalculator> VzFFTCalculator::getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults)
 {
 	return std::shared_ptr<VzFFTCalculator>(new VzFFTCalculator(viscosity, testResults));
 }
@@ -13,6 +13,6 @@ void VzFFTCalculator::setVectorToCalc()
 	data = simResults->getVz();
 }
 
-VzFFTCalculator::VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : FFTCalculator(viscosity, testResults)
+VzFFTCalculator::VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults) : FFTCalculator(viscosity, testResults)
 {
 }

targets/tests/TestingHULC/Utilities/Calculator/FFTCalculator/VzFFTCalculator/VzFFTCalculator.h

@@ -6,11 +6,11 @@
 class VzFFTCalculator : public FFTCalculator
 {
 public:
-	static std::shared_ptr<VzFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	static std::shared_ptr<VzFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 
 protected:
 	void setVectorToCalc();
 private:
-	VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTest> testResults);
 };
 #endif 
\ No newline at end of file

targets/tests/TestingHULC/Utilities/TestResults/PhiAndNuTestResults.cpp

-#include "PhiAndNuTestResults.h"
-
-std::shared_ptr<PhiAndNuTestResults> PhiAndNuTestResults::getNewInstance(std::string aTestName)
-{
-	return std::shared_ptr<PhiAndNuTestResults>(new PhiAndNuTestResults(aTestName));
-}
-
-void PhiAndNuTestResults::evaluate()
-{
-	if (nuDiff.size() > 1 && phiDiff.size() > 1) {
-		const int sizeNuDiff = nuDiff.size();
-		double ordOfAccNuDiff = log(nuDiff.end()[-1] / nuDiff.back()) / log(lx.back() / lx.end()[-1]);
-		double ordOfAccPhiDiff = log(phiDiff.end()[-1] / phiDiff.back()) / log(lx.back()/ lx.end()[-1]);
-		orderOfAccuracyNuDiff.push_back(ordOfAccNuDiff);
-		orderOfAccuracyPhiDiff.push_back(ordOfAccPhiDiff);
-		makeLastTestOutput();
-	}
-}
-
-void PhiAndNuTestResults::add(double phiDiff, double nuDiff, double lx)
-{
-	this->nuDiff.push_back(nuDiff);
-	this->phiDiff.push_back(phiDiff);
-	this->lx.push_back(lx);
-}
-
-PhiAndNuTestResults::PhiAndNuTestResults(std::string aTestName) :testName(aTestName)
-{
-	phiDiff.resize(0);
-	nuDiff.resize(0);
-	lx.resize(0);
-	orderOfAccuracyPhiDiff.resize(0);
-	orderOfAccuracyNuDiff.resize(0);
-}
-
-void PhiAndNuTestResults::makeLastTestOutput()
-{
-	for (int i = 0; i < orderOfAccuracyNuDiff.size(); i++) {
-		std::cout << orderOfAccuracyNuDiff.at(i) << std::endl;
-	}
-}