adds FFTCalculator

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

@@ -2,44 +2,13 @@
 #define CALCULATOR_H
 
 #include <memory>
-#include <vector>
-#include <fftw3.h>
 
 class Results;
-class EvaluationParameter;
+class TestResults;
 
-class Calulator {
+class Calculator {
 public:
-	Calulator(std::shared_ptr<Results> simResults, std::shared_ptr<EvaluationParameter> evaPara);
-
-
-	double calcNu();
-	double calcNuDiff(double nu);
-	double calcPhiDiff();
-
-private:
-	std::vector<double> calcLinReg(std::vector<double> y);
-	void calcLogAmplitudeForAllTimeSteps();
-	void calcAmplitudeForAllTimeSteps();
-	void calcPhiForAllTimeSteps();
-	void calcFFT2D(unsigned int timeStep);
-	void initDataForFFT(fftw_complex* input, unsigned int timeStep);
-	void setFFTResults(fftw_complex* result, unsigned int timeStep);
-
-	std::shared_ptr<Results> simResults;
-
-	std::vector<std::vector<double>> data;
-	std::vector<std::vector<double>> fftResultsIm;
-	std::vector<std::vector<double>> fftResultsRe;
-	std::vector<double> phi;
-	std::vector<double> amplitude;
-	std::vector<double> logAmplitude;
-
-	bool fftCalculated;
-
-	double lx, lz;
-	double timeStepLength;
-	double vis;
-	int numberOfTimeSteps;
+	virtual void calcAndCopyToTestResults() = 0;
+	virtual void setSimulationResults(std::shared_ptr<Results> simResults) = 0;
 };
-#endif
+#endif
\ No newline at end of file

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

-#include "Calculator.h"
+#include "FFTCalculator.h"
 
 #include "Utilities\Results\Results.h"
+#include "Utilities\TestResults\PhiAndNuTestResults.h"
 #include "Utilities\EvaluationParameter\EvaluationParameter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <stdlib.h>
 
-Calulator::Calulator(std::shared_ptr<Results> simResults, std::shared_ptr<EvaluationParameter> evaPara):simResults(simResults)
+void FFTCalculator::calcAndCopyToTestResults()
 {
-	if (evaPara->getDataToCalculate() == "vX")
-		data = simResults->getVx();
-	if (evaPara->getDataToCalculate() == "vZ")
-		data = simResults->getVz();
+	init();
 
+	nu = calcNu();
+	nudiff = calcNuDiff(nu);
+	phidiff = calcPhiDiff();
+
+	testResults->add(nudiff, phidiff, lx);
+}
+
+void FFTCalculator::setSimulationResults(std::shared_ptr<Results> simResults)
+{
+	this->simResults = simResults;
+}
+
+void FFTCalculator::init()
+{
+	setVectorToCalc();
 	lz = (double)simResults->getZNodes();
 	lx = (double)simResults->getXNodes();
 	timeStepLength = simResults->getTimeStepLength();
-	vis = evaPara->getViscosity();
 	numberOfTimeSteps = simResults->getNumberOfTimeSteps();
 	fftCalculated = false;
 }
 
-double Calulator::calcNu()
+FFTCalculator::FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults) : vis(viscosity), testResults(testResults)
+{
+
+}
+
+double FFTCalculator::calcNu()
 {
 	calcLogAmplitudeForAllTimeSteps();
 	std::vector<double> linReg = calcLinReg(logAmplitude);
@@ -31,13 +48,13 @@ double Calulator::calcNu()
 	return nu;
 }
 
-double Calulator::calcNuDiff(double nu)
+double FFTCalculator::calcNuDiff(double nu)
 {
 	double nudiff = abs((nu - vis) / vis);
 	return nudiff;
 }
 
-double Calulator::calcPhiDiff()
+double FFTCalculator::calcPhiDiff()
 {
 	calcPhiForAllTimeSteps();
 	std::vector<double> linReg = calcLinReg(phi);
@@ -45,7 +62,7 @@ double Calulator::calcPhiDiff()
 	return linReg.at(0);
 }
 
-void Calulator::calcLogAmplitudeForAllTimeSteps()
+void FFTCalculator::calcLogAmplitudeForAllTimeSteps()
 {
 	calcAmplitudeForAllTimeSteps();
 	logAmplitude.resize(amplitude.size());
@@ -53,7 +70,7 @@ void Calulator::calcLogAmplitudeForAllTimeSteps()
 		logAmplitude.at(tS) = log(amplitude.at(tS));
 }
 
-std::vector<double> Calulator::calcLinReg(std::vector<double> y)
+std::vector<double> FFTCalculator::calcLinReg(std::vector<double> y)
 {
 	std::vector<double> result;
 	std::vector<double> x(y.size());
@@ -92,7 +109,7 @@ std::vector<double> Calulator::calcLinReg(std::vector<double> y)
 	return result;
 }
 
-void Calulator::calcAmplitudeForAllTimeSteps()
+void FFTCalculator::calcAmplitudeForAllTimeSteps()
 {
 	if (fftCalculated == false) {
 		for (int timeStep = 0; timeStep < numberOfTimeSteps; timeStep++)
@@ -104,7 +121,7 @@ void Calulator::calcAmplitudeForAllTimeSteps()
 		amplitude.push_back(4.0 / (lx * lz)  * sqrt(fftResultsRe.at(timeStep).at(pos) * fftResultsRe.at(timeStep).at(pos) + fftResultsIm.at(timeStep).at(pos) * fftResultsIm.at(timeStep).at(pos)));
 }
 
-void Calulator::calcPhiForAllTimeSteps()
+void FFTCalculator::calcPhiForAllTimeSteps()
 {
 	if (fftCalculated == false) {
 		for (int timeStep = 0; timeStep < numberOfTimeSteps; timeStep++)
@@ -116,7 +133,7 @@ void Calulator::calcPhiForAllTimeSteps()
 		phi.push_back(atan(fftResultsIm.at(timeStep).at(pos) / fftResultsRe.at(timeStep).at(pos)));
 }
 
-void Calulator::calcFFT2D(unsigned int timeStep)
+void FFTCalculator::calcFFT2D(unsigned int timeStep)
 {
 	fftw_complex *in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * lx * lz);
 	fftw_complex *out = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * lx * lz);
@@ -133,7 +150,7 @@ void Calulator::calcFFT2D(unsigned int timeStep)
 	fftw_free(out);
 }
 
-void Calulator::initDataForFFT(fftw_complex * input, unsigned int timeStep)
+void FFTCalculator::initDataForFFT(fftw_complex * input, unsigned int timeStep)
 {
 	for (int i = 0; i < data.at(timeStep).size(); i++)
 	{
@@ -142,7 +159,7 @@ void Calulator::initDataForFFT(fftw_complex * input, unsigned int timeStep)
 	}
 }
 
-void Calulator::setFFTResults(fftw_complex * result, unsigned int timeStep)
+void FFTCalculator::setFFTResults(fftw_complex * result, unsigned int timeStep)
 {
 	std::vector<double> fftRe, fftIm;
 	fftRe.resize(data.at(timeStep).size());

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

+#ifndef FFTCALCULATOR_H
+#define FFTCALCULATOR_H
+
+#include "../Calculator.h"
+
+#include <memory>
+#include <vector>
+#include <fftw3.h>
+
+class Results;
+class EvaluationParameter;
+class TestResults;
+class PhiAndNuTestResults;
+
+class FFTCalculator : public Calculator
+{
+public:
+	void calcAndCopyToTestResults();
+	void setSimulationResults(std::shared_ptr<Results> simResults);
+
+protected:
+	FFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+	virtual void setVectorToCalc() = 0;
+
+	std::shared_ptr<Results> simResults;
+	std::vector<std::vector<double>> data;
+
+private:
+	void init();
+	double calcNu();
+	double calcNuDiff(double nu);
+	double calcPhiDiff();
+	std::vector<double> calcLinReg(std::vector<double> y);
+	void calcLogAmplitudeForAllTimeSteps();
+	void calcAmplitudeForAllTimeSteps();
+	void calcPhiForAllTimeSteps();
+	void calcFFT2D(unsigned int timeStep);
+	void initDataForFFT(fftw_complex* input, unsigned int timeStep);
+	void setFFTResults(fftw_complex* result, unsigned int timeStep);
+
+	std::shared_ptr<PhiAndNuTestResults> testResults;
+	std::vector<std::vector<double>> fftResultsIm;
+	std::vector<std::vector<double>> fftResultsRe;
+	std::vector<double> phi;
+	std::vector<double> amplitude;
+	std::vector<double> logAmplitude;
+
+	bool fftCalculated;
+
+	double lx, lz;
+	double vis;
+	double timeStepLength;
+	int numberOfTimeSteps;
+
+	double nu;
+	double nudiff, phidiff;
+};
+#endif

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

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

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

+#ifndef VXFFTCALCULATOR_H
+#define VXFFTCALCULATOR_H
+
+#include "../FFTCalculator.h"
+
+class VxFFTCalculator : public FFTCalculator
+{
+public:
+	static std::shared_ptr<VxFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+
+protected:
+	void setVectorToCalc();
+private:
+	VxFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+};
+#endif 
\ No newline at end of file

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

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

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

+#ifndef VZFFTCALCULATOR_H
+#define VZFFTCALCULATOR_H
+
+#include "../FFTCalculator.h"
+
+class VzFFTCalculator : public FFTCalculator
+{
+public:
+	static std::shared_ptr<VzFFTCalculator> getNewInstance(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+
+protected:
+	void setVectorToCalc();
+private:
+	VzFFTCalculator(double viscosity, std::shared_ptr<PhiAndNuTestResults> testResults);
+};
+#endif 
\ No newline at end of file