diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.cpp b/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8f5b363ac2eed06c38bc69fcf81f4d70fc2879e
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.cpp
@@ -0,0 +1,173 @@
+#include "L2NormMathematicaAssistant.h"
+
+#include "Tests/L2Norm/LogFileData/L2NormLogFileData.h"
+#include "Utilities/LogFileData/LogFileData.h"
+#include "Utilities/LogFileData/LogFileDataGroup/LogFileDataGroup.h"
+
+#include <sstream>
+
+
+std::shared_ptr<L2NormMathematicaAssistant> L2NormMathematicaAssistant::getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory)
+{
+ return std::shared_ptr<L2NormMathematicaAssistant>(new L2NormMathematicaAssistant(functionFactory));
+}
+
+void L2NormMathematicaAssistant::makeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile)
+{
+ std::shared_ptr<SortedDataL2Norm> mySortedData = sortLogFileData(logFileData);
+
+ makeL2NormDiffMathematicaOutput(aMathmaticaFile, mySortedData);
+ makeL2NormBasicTimeStepMathematicaOutput(aMathmaticaFile, mySortedData);
+ makeL2NormDivergentTimeStepMathematicaOutput(aMathmaticaFile, mySortedData);
+}
+
+L2NormMathematicaAssistant::L2NormMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : MathematicaAssistantImp(functionFactory)
+{
+}
+
+bool L2NormMathematicaAssistant::checkTestParameter(std::shared_ptr<L2NormLogFileData> logFileData1, std::shared_ptr<L2NormLogFileData> logFileData2)
+{
+ if (logFileData1->getDataToCalc() != logFileData2->getDataToCalc())
+ return false;
+ if (logFileData1->getNormalizeData() != logFileData2->getNormalizeData())
+ return false;
+ if (logFileData1->getBasicTimeStep() != logFileData2->getBasicTimeStep())
+ return false;
+ if (logFileData1->getDivergentTimeStep() != logFileData2->getDivergentTimeStep())
+ return false;
+
+
+ return true;
+}
+
+std::shared_ptr<SortedDataL2Norm> L2NormMathematicaAssistant::sortLogFileData(std::shared_ptr<LogFileDataGroup> logFileData)
+{
+ std::vector<std::vector<std::shared_ptr<L2NormLogFileData> > > testLogFileData;
+ std::vector<std::vector<std::string> > basicListNames;
+ for (int i = 0; i < logFileData->getLogFileData(0)->getL2NormLogFileData().size(); i++) {
+ std::vector<std::shared_ptr<L2NormLogFileData> > aTestLogFileDataGroup;
+ aTestLogFileDataGroup.push_back(logFileData->getLogFileData(0)->getL2NormLogFileData().at(i));
+ std::vector<std::string> aListNameGroup;
+ aListNameGroup.push_back(logFileData->getLogFileData(0)->getSimulationSigniture());
+ basicListNames.push_back(aListNameGroup);
+ }
+ for (int i = 0; i < logFileData->getGroupSize(); i++) {
+ for (int j = 0; j < logFileData->getLogFileData(i)->getL2NormLogFileData().size(); j++) {
+ std::string dataToCalc = logFileData->getLogFileData(i)->getL2NormLogFileData().at(j)->getDataToCalc();
+ bool added = false;
+ for (int k = 0; k < testLogFileData.size(); k++) {
+ if (checkTestParameter(logFileData->getLogFileData(i)->getL2NormLogFileData().at(j), testLogFileData.at(k).at(0))) {
+ testLogFileData.at(k).push_back(logFileData->getLogFileData(i)->getL2NormLogFileData().at(j));
+ basicListNames.at(k).push_back(logFileData->getLogFileData(i)->getSimulationSigniture());
+ added = true;
+ }
+ }
+ if (!added) {
+ std::vector<std::shared_ptr<L2NormLogFileData> > aTestLogFileDataGroup;
+ aTestLogFileDataGroup.push_back(logFileData->getLogFileData(i)->getL2NormLogFileData().at(j));
+ testLogFileData.push_back(aTestLogFileDataGroup);
+ std::vector<std::string> aListNameGroup;
+ aListNameGroup.push_back(logFileData->getLogFileData(i)->getSimulationSigniture());
+ basicListNames.push_back(aListNameGroup);
+ }
+ }
+ }
+ std::shared_ptr<SortedDataL2Norm> mySortedData = std::shared_ptr<SortedDataL2Norm>(new SortedDataL2Norm);
+ mySortedData->basicListNames = basicListNames;
+ mySortedData->testLogFileData = testLogFileData;
+
+ return mySortedData;
+}
+
+void L2NormMathematicaAssistant::makeL2NormDiffMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ std::vector<std::vector<double> > gridLengths;
+ std::vector<std::vector<double> > l2NormDiff;
+ std::vector<std::string> aBasicListNamesList;
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ l2NormDiff.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormDiff());
+ aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+ }
+ std::vector<std::string> finalListNames = finalizeListNames(aBasicListNamesList, "L2NormDiff", sortedData->testLogFileData.at(i).at(0)->getDataToCalc(), sortedData->testLogFileData.at(i).at(0)->getNormalizeData());
+
+ addSecondOrderOfAccuracyRef(gridLengths, l2NormDiff, finalListNames);
+ addFourthOrderOfAccuracyRef(gridLengths, l2NormDiff, finalListNames);
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, l2NormDiff, "L[dx]", "L2NormDiff[-]");
+ }
+}
+
+void L2NormMathematicaAssistant::makeL2NormAllTimeStepsMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ std::vector<std::vector<double> > gridLengths;
+ std::vector<std::vector<double> > l2Norm;
+ std::vector<std::string> aBasicListNamesList;
+ std::vector<std::string> basicTimeSteps;
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ l2Norm.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormForBasicTimeStep());
+ l2Norm.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormForDivergentTimeStep());
+ aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+ aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+ std::ostringstream aBasicTimeStep;
+ aBasicTimeStep << "TimeStep" << sortedData->testLogFileData.at(i).at(j)->getBasicTimeStep();
+ basicTimeSteps.push_back(aBasicTimeStep.str());
+ std::ostringstream aDivTimeStep;
+ aDivTimeStep << "TimeStep" << sortedData->testLogFileData.at(i).at(j)->getDivergentTimeStep();
+ basicTimeSteps.push_back(aDivTimeStep.str());
+ }
+
+ std::vector<std::string> finalListNamesBasic = finalizeListNames(aBasicListNamesList, "L2NormAllTimeSteps", sortedData->testLogFileData.at(i).at(0)->getDataToCalc(), sortedData->testLogFileData.at(i).at(0)->getNormalizeData(), basicTimeSteps);
+
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNamesBasic, gridLengths, l2Norm, "L[dx]", "L2Norm[-]");
+ }
+}
+
+void L2NormMathematicaAssistant::makeL2NormBasicTimeStepMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ std::vector<std::vector<double> > gridLengths;
+ std::vector<std::vector<double> > l2NormBasic;
+ std::vector<std::string> aBasicListNamesList;
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ l2NormBasic.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormForBasicTimeStep());
+ aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+ }
+ std::ostringstream basicTimeStep;
+ basicTimeStep << "TimeStep" << sortedData->testLogFileData.at(i).at(0)->getBasicTimeStep();
+ std::vector<std::string> finalListNamesBasic = finalizeListNames(aBasicListNamesList, "L2Norm", sortedData->testLogFileData.at(i).at(0)->getDataToCalc(), sortedData->testLogFileData.at(i).at(0)->getNormalizeData(), basicTimeStep.str());
+
+ addSecondOrderOfAccuracyRef(gridLengths, l2NormBasic, finalListNamesBasic);
+ addFourthOrderOfAccuracyRef(gridLengths, l2NormBasic, finalListNamesBasic);
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNamesBasic, gridLengths, l2NormBasic, "L[dx]", "L2Norm[-]");
+ }
+}
+
+void L2NormMathematicaAssistant::makeL2NormDivergentTimeStepMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ std::vector<std::vector<double> > gridLengths;
+ std::vector<std::vector<double> > l2NormDivergent;
+ std::vector<std::string> aBasicListNamesList;
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ l2NormDivergent.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormForDivergentTimeStep());
+ aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+ }
+ std::ostringstream divTimeStep;
+ divTimeStep << "TimeStep" << sortedData->testLogFileData.at(i).at(0)->getDivergentTimeStep();
+ std::vector<std::string> finalListNamesDiv = finalizeListNames(aBasicListNamesList, "L2Norm", sortedData->testLogFileData.at(i).at(0)->getDataToCalc(), sortedData->testLogFileData.at(i).at(0)->getNormalizeData(), divTimeStep.str());
+
+ addSecondOrderOfAccuracyRef(gridLengths, l2NormDivergent, finalListNamesDiv);
+ addFourthOrderOfAccuracyRef(gridLengths, l2NormDivergent, finalListNamesDiv);
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNamesDiv, gridLengths, l2NormDivergent, "L[dx]", "L2Norm[-]");
+ }
+}
+
+L2NormMathematicaAssistant::L2NormMathematicaAssistant()
+{
+}
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.h b/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.h
new file mode 100644
index 0000000000000000000000000000000000000000..92e38b57f985f33f40d7f55b4c8eb3f3309daa54
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.h
@@ -0,0 +1,36 @@
+#ifndef L2NORM_MATHEMATICA_ASSISTANT_H
+#define L2NORM_MATHEMATICA_ASSISTANT_H
+
+#include "Utilities/MathematicaAssistant/MathematicaAssistantImp.h"
+
+class MathematicaFunctionFactory;
+class L2NormLogFileData;
+
+struct SortedDataL2Norm {
+ std::vector<std::vector<std::shared_ptr<L2NormLogFileData> > > testLogFileData;
+ std::vector<std::vector<std::string> > basicListNames;
+};
+
+class L2NormMathematicaAssistant : public MathematicaAssistantImp
+{
+public:
+ static std::shared_ptr<L2NormMathematicaAssistant> getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ void makeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile);
+
+
+private:
+ L2NormMathematicaAssistant();
+ L2NormMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ bool checkTestParameter(std::shared_ptr<L2NormLogFileData> logFileData1, std::shared_ptr<L2NormLogFileData> logFileData2);
+ std::shared_ptr<SortedDataL2Norm> sortLogFileData(std::shared_ptr<LogFileDataGroup> logFileData);
+
+ void makeL2NormDiffMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData);
+ void makeL2NormAllTimeStepsMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData);
+ void makeL2NormBasicTimeStepMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData);
+ void makeL2NormDivergentTimeStepMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2Norm> sortedData);
+
+
+};
+#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/package.include b/targets/tests/NumericalTestPostProcessing/Tests/L2Norm/MathematicaAssistant/package.include
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileData.h b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileData.h
index 69c08f0a145c6c6a1c7183722ae8c66eb379b449..218f4777b741e4f3ebb956172341338486cf11f9 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileData.h
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileData.h
@@ -9,6 +9,7 @@ class L2NormBetweenKernelsLogFileData
public:
virtual std::vector<double> getBasicGridLengths() = 0;
virtual std::string getBasicKernel() = 0;
+ virtual std::string getDivergentKernel() = 0;
virtual std::string getDataToCalculate() = 0;
virtual int getTimeStep() = 0;
virtual std::vector<double> getL2NormForBasicKernel() = 0;
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.cpp b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.cpp
index 958da95676a35e45f200bd6d8ed80b99fe4e2927..cbe8a52088377a16b27f45a6f5e7361d1cd2470c 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.cpp
@@ -15,6 +15,11 @@ std::string L2NormBetweenKernelsLogFileDataImp::getBasicKernel()
return basicKernel;
}
+std::string L2NormBetweenKernelsLogFileDataImp::getDivergentKernel()
+{
+ return divergentKernel;
+}
+
std::string L2NormBetweenKernelsLogFileDataImp::getDataToCalculate()
{
return dataToCalc;
@@ -55,6 +60,11 @@ void L2NormBetweenKernelsLogFileDataImp::setBasicKernel(std::string basicKernel)
this->basicKernel = basicKernel;
}
+void L2NormBetweenKernelsLogFileDataImp::setDivergentKernel(std::string divergentKernel)
+{
+ this->divergentKernel = divergentKernel;
+}
+
void L2NormBetweenKernelsLogFileDataImp::setDataToCalculate(std::string dataToCalc)
{
this->dataToCalc = dataToCalc;
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.h b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.h
index b5ec2c9d21a464a236369ee732428625e54378be..2e18bb248581eca4e356c26d68779f48e471cb9d 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.h
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileDataImp.h
@@ -12,6 +12,7 @@ public:
std::vector<double> getBasicGridLengths();
std::string getBasicKernel();
+ std::string getDivergentKernel();
std::string getDataToCalculate();
int getTimeStep();
std::vector<double> getL2NormForBasicKernel();
@@ -21,6 +22,7 @@ public:
void setBasicGridLengths(std::vector<double> basicGridLengths);
void setBasicKernel(std::string basicKernel);
+ void setDivergentKernel(std::string divergentKernel);
void setDataToCalculate(std::string dataToCalc);
void setTimeStep(int timeStep);
void setL2NormForBasicKernel(std::vector<double> l2Norm);
@@ -35,6 +37,7 @@ private:
std::vector<double> basicGridLengths;
std::string basicKernel;
+ std::string divergentKernel;
std::string dataToCalc;
int timeStep;
std::vector<double> l2NormForBasicKernel;
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.cpp b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..21babc559d9dab0af80c6fa2675c7749449288fc
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.cpp
@@ -0,0 +1,139 @@
+#include "L2NormBetweenKernelsMathematicaAssistant.h"
+
+#include "Tests/L2NormBetweenKernels/LogFileData/L2NormBetweenKernelsLogFileData.h"
+#include "Utilities/LogFileData/LogFileData.h"
+#include "Utilities/LogFileData/LogFileDataGroup/LogFileDataGroup.h"
+
+#include <sstream>
+
+
+std::shared_ptr<L2NormBetweenKernelsMathematicaAssistant> L2NormBetweenKernelsMathematicaAssistant::getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory)
+{
+ return std::shared_ptr<L2NormBetweenKernelsMathematicaAssistant>(new L2NormBetweenKernelsMathematicaAssistant(functionFactory));
+}
+
+void L2NormBetweenKernelsMathematicaAssistant::makeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile)
+{
+ std::shared_ptr<SortedDataL2NormBetweenKernels> mySortedData = sortLogFileData(logFileData);
+
+ makeL2NormMathematicaOutput(aMathmaticaFile, mySortedData);
+ makeL2NormBetweenKernelsMathematicaOutput(aMathmaticaFile, mySortedData);
+}
+
+L2NormBetweenKernelsMathematicaAssistant::L2NormBetweenKernelsMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : MathematicaAssistantImp(functionFactory)
+{
+}
+
+bool L2NormBetweenKernelsMathematicaAssistant::checkTestParameter(std::shared_ptr<L2NormBetweenKernelsLogFileData> logFileData1, std::shared_ptr<L2NormBetweenKernelsLogFileData> logFileData2)
+{
+ if (logFileData1->getBasicKernel() != logFileData2->getBasicKernel())
+ return false;
+ if (logFileData1->getNormalizeData() != logFileData2->getNormalizeData())
+ return false;
+ if (logFileData1->getTimeStep() != logFileData2->getTimeStep())
+ return false;
+ if (logFileData1->getDataToCalculate() != logFileData2->getDataToCalculate())
+ return false;
+
+
+ return true;
+}
+
+std::shared_ptr<SortedDataL2NormBetweenKernels> L2NormBetweenKernelsMathematicaAssistant::sortLogFileData(std::shared_ptr<LogFileDataGroup> logFileData)
+{
+ std::vector<std::vector<std::shared_ptr<L2NormBetweenKernelsLogFileData> > > testLogFileData;
+ std::vector<std::vector<std::string> > basicListNames;
+ for (int i = 0; i < logFileData->getLogFileData(0)->getL2NormBetweenKernelsLogFileData().size(); i++) {
+ std::vector<std::shared_ptr<L2NormBetweenKernelsLogFileData> > aTestLogFileDataGroup;
+ aTestLogFileDataGroup.push_back(logFileData->getLogFileData(0)->getL2NormBetweenKernelsLogFileData().at(i));
+ std::vector<std::string> aListNameGroup;
+ aListNameGroup.push_back(logFileData->getLogFileData(0)->getSimulationSigniture());
+ basicListNames.push_back(aListNameGroup);
+ }
+ for (int i = 0; i < logFileData->getGroupSize(); i++) {
+ for (int j = 0; j < logFileData->getLogFileData(i)->getL2NormBetweenKernelsLogFileData().size(); j++) {
+ std::string dataToCalc = logFileData->getLogFileData(i)->getL2NormBetweenKernelsLogFileData().at(j)->getDataToCalculate();
+ bool added = false;
+ for (int k = 0; k < testLogFileData.size(); k++) {
+ if (checkTestParameter(logFileData->getLogFileData(i)->getL2NormBetweenKernelsLogFileData().at(j), testLogFileData.at(k).at(0))) {
+ testLogFileData.at(k).push_back(logFileData->getLogFileData(i)->getL2NormBetweenKernelsLogFileData().at(j));
+ basicListNames.at(k).push_back(logFileData->getLogFileData(i)->getSimulationSigniture());
+ added = true;
+ }
+ }
+ if (!added) {
+ std::vector<std::shared_ptr<L2NormBetweenKernelsLogFileData> > aTestLogFileDataGroup;
+ aTestLogFileDataGroup.push_back(logFileData->getLogFileData(i)->getL2NormBetweenKernelsLogFileData().at(j));
+ testLogFileData.push_back(aTestLogFileDataGroup);
+ std::vector<std::string> aListNameGroup;
+ aListNameGroup.push_back(logFileData->getLogFileData(i)->getSimulationSigniture());
+ basicListNames.push_back(aListNameGroup);
+ }
+ }
+ }
+ std::shared_ptr<SortedDataL2NormBetweenKernels> mySortedData = std::shared_ptr<SortedDataL2NormBetweenKernels>(new SortedDataL2NormBetweenKernels);
+ mySortedData->basicListNames = basicListNames;
+ mySortedData->testLogFileData = testLogFileData;
+
+ return mySortedData;
+}
+
+void L2NormBetweenKernelsMathematicaAssistant::makeL2NormMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2NormBetweenKernels> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ std::vector<std::vector<double> > gridLengths;
+ std::vector<std::vector<double> > l2Norm;
+ std::vector<std::string> aListNamesList;
+ std::vector<std::string> timeSteps;
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ l2Norm.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormForBasicKernel());
+ l2Norm.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormForDivergentKernel());
+ aListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+
+ std::string divergentKernel = sortedData->basicListNames.at(i).at(j);
+ int sizeOfString = sortedData->testLogFileData.at(i).at(j)->getDivergentKernel().size();
+ divergentKernel.erase(divergentKernel.begin(), divergentKernel.begin() + sizeOfString);
+ divergentKernel = sortedData->testLogFileData.at(i).at(j)->getBasicKernel() + divergentKernel;
+ aListNamesList.push_back(divergentKernel);
+
+ std::ostringstream timeStep;
+ timeStep << "TimeStep" << sortedData->testLogFileData.at(i).at(j)->getTimeStep();
+ timeSteps.push_back(timeStep.str());
+ timeSteps.push_back(timeStep.str());
+ }
+
+ std::vector<std::string> finalListNames = finalizeListNames(aListNamesList, "L2Norm", sortedData->testLogFileData.at(i).at(0)->getDataToCalculate(), sortedData->testLogFileData.at(i).at(0)->getNormalizeData(), timeSteps);
+
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, l2Norm, "L[dx]", "L2Norm[-]");
+ }
+}
+
+void L2NormBetweenKernelsMathematicaAssistant::makeL2NormBetweenKernelsMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2NormBetweenKernels> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ std::vector<std::vector<double> > gridLengths;
+ std::vector<std::vector<double> > l2NormBK;
+ std::vector<std::string> aListNamesList;
+ std::vector<std::string> timeSteps;
+ std::vector<std::string> basicKernel;
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ gridLengths.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicGridLengths());
+ l2NormBK.push_back(sortedData->testLogFileData.at(i).at(j)->getL2NormBetweenKernels());
+ aListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
+ basicKernel.push_back(sortedData->testLogFileData.at(i).at(j)->getBasicKernel());
+ std::ostringstream timeStep;
+ timeStep << "TimeStep" << sortedData->testLogFileData.at(i).at(j)->getTimeStep();
+ timeSteps.push_back(timeStep.str());
+ }
+
+ std::vector<std::string> finalListNames = finalizeListNames(aListNamesList, "L2NormBetweenKernels", sortedData->testLogFileData.at(i).at(0)->getDataToCalculate(), sortedData->testLogFileData.at(i).at(0)->getNormalizeData(), timeSteps, basicKernel);
+
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, l2NormBK, "L[dx]", "L2Norm[-]");
+ }
+}
+
+L2NormBetweenKernelsMathematicaAssistant::L2NormBetweenKernelsMathematicaAssistant()
+{
+}
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.h b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0a329876ecd43719d4a7f8a63b03d234fff0923
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.h
@@ -0,0 +1,34 @@
+#ifndef L2NORM_BK_MATHEMATICA_ASSISTANT_H
+#define L2NORM_BK_MATHEMATICA_ASSISTANT_H
+
+#include "Utilities/MathematicaAssistant/MathematicaAssistantImp.h"
+
+class MathematicaFunctionFactory;
+class L2NormBetweenKernelsLogFileData;
+
+struct SortedDataL2NormBetweenKernels {
+ std::vector<std::vector<std::shared_ptr<L2NormBetweenKernelsLogFileData> > > testLogFileData;
+ std::vector<std::vector<std::string> > basicListNames;
+};
+
+class L2NormBetweenKernelsMathematicaAssistant : public MathematicaAssistantImp
+{
+public:
+ static std::shared_ptr<L2NormBetweenKernelsMathematicaAssistant> getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ void makeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile);
+
+
+private:
+ L2NormBetweenKernelsMathematicaAssistant();
+ L2NormBetweenKernelsMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ bool checkTestParameter(std::shared_ptr<L2NormBetweenKernelsLogFileData> logFileData1, std::shared_ptr<L2NormBetweenKernelsLogFileData> logFileData2);
+ std::shared_ptr<SortedDataL2NormBetweenKernels> sortLogFileData(std::shared_ptr<LogFileDataGroup> logFileData);
+
+ void makeL2NormMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2NormBetweenKernels> sortedData);
+ void makeL2NormBetweenKernelsMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataL2NormBetweenKernels> sortedData);
+
+
+};
+#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/package.include b/targets/tests/NumericalTestPostProcessing/Tests/L2NormBetweenKernels/MathematicaAssistant/package.include
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.cpp b/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.cpp
index 2827ce438069abee1580372d2563cf051bc22717..4a976bd0db12fd3208b09a090802a955b4dd32e0 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.cpp
@@ -19,7 +19,7 @@ void NyMathematicaAssistant::makeMathematicaOutput(std::shared_ptr<LogFileDataGr
makeNyDiffMathematicaOutput(aMathmaticaFile, mySortedData);
}
-NyMathematicaAssistant::NyMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : functionFactory(functionFactory)
+NyMathematicaAssistant::NyMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : MathematicaAssistantImp(functionFactory)
{
}
@@ -74,34 +74,6 @@ std::shared_ptr<SortedDataNy> NyMathematicaAssistant::sortLogFileData(std::share
return mySortedData;
}
-void NyMathematicaAssistant::addListLogLogPlotToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::string> listNames, std::vector<std::vector<double> > xAxesData, std::vector<std::vector<double> > yAxesData, std::string labelXAxes, std::string labelYAxes)
-{
- std::vector<std::vector<std::shared_ptr<DataPoint> > > dataPointGroup;
-
- for (int i = 0; i < xAxesData.size(); i++) {
- std::vector<std::shared_ptr<DataPoint> > dataPoints;
- for (int j = 0; j < xAxesData.at(i).size(); j++)
- dataPoints.push_back(DataPoint::getNewInstance(xAxesData.at(i).at(j), yAxesData.at(i).at(j)));
- dataPointGroup.push_back(dataPoints);
- }
- std::vector<std::shared_ptr<MathematicaPointList> > pointList;
- for (int i = 0; i < dataPointGroup.size(); i++) {
- std::shared_ptr<MathematicaPointList> aPointList = functionFactory->makeMathematicaPointList(aMathmaticaFile, listNames.at(i), dataPointGroup.at(i));
- pointList.push_back(aPointList);
- }
- std::shared_ptr<MathematicaListPlot> listLogLogPlot = functionFactory->makeMathematicaListPlot(aMathmaticaFile, pointList, "ListLogLogPlot", labelXAxes, labelYAxes);
-}
-
-std::vector<std::string> NyMathematicaAssistant::finalizeListNames(std::vector<std::string> basicListNames, std::string dataToCalc, std::string testName)
-{
- std::vector<std::string> finalListNames;
-
- for (int i = 0; i < basicListNames.size(); i++)
- finalListNames.push_back(testName + basicListNames.at(i) + dataToCalc);
-
- return finalListNames;
-}
-
void NyMathematicaAssistant::makeNyDiffMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataNy> sortedData)
{
for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
@@ -113,8 +85,25 @@ void NyMathematicaAssistant::makeNyDiffMathematicaOutput(std::shared_ptr<Mathema
nyDiff.push_back(sortedData->testLogFileData.at(i).at(j)->getNyDiff());
aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
}
- std::vector<std::string> finalListNames = finalizeListNames(aBasicListNamesList, sortedData->testLogFileData.at(i).at(0)->getDataToCalc(), "NyDiff");
- addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, nyDiff, "L[dx]", "Err Ny");
+
+ std::vector<std::string> finalListNames = finalizeListNames(aBasicListNamesList, "NyDiff", sortedData->testLogFileData.at(i).at(0)->getDataToCalc());
+ addSecondOrderOfAccuracyRef(gridLengths, nyDiff, finalListNames);
+ addFourthOrderOfAccuracyRef(gridLengths, nyDiff, finalListNames);
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, nyDiff, "L[dx]", "Err Ny[-]");
+ }
+}
+
+void NyMathematicaAssistant::makeOrderOfAccuracyMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataNy> sortedData)
+{
+ for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ std::vector<std::vector<double>> ooA = sortedData->testLogFileData.at(i).at(j)->getOrderOfAccuracy();
+ std::string basicListName = sortedData->basicListNames.at(i).at(j);
+ std::string dataToCalc = sortedData->testLogFileData.at(i).at(j)->getDataToCalc();
+ std::string finalListName = finalizeListName(basicListName, "NyDiffOrderOfAccuracy", dataToCalc);
+
+ addListOfListsToMathematicaFile(aMathmaticaFile, finalListName, ooA);
+ }
}
}
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.h b/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.h
index 575d9884c0cac55f00542c5cc583a60198b0e5b1..591cfd47220345883ce1e08084d6fc08bf4be4b7 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.h
+++ b/targets/tests/NumericalTestPostProcessing/Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.h
@@ -25,10 +25,9 @@ private:
bool checkTestParameter(std::shared_ptr<NyLogFileData> logFileData1, std::shared_ptr<NyLogFileData> logFileData2);
std::shared_ptr<SortedDataNy> sortLogFileData(std::shared_ptr<LogFileDataGroup> logFileData);
- void addListLogLogPlotToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::string> listNames, std::vector<std::vector<double> > xAxesData, std::vector<std::vector<double> > yAxesData, std::string labelXAxes, std::string labelYAxes);
- std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string dataToCalc, std::string testName);
+
void makeNyDiffMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataNy> sortedData);
+ void makeOrderOfAccuracyMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataNy> sortedData);
- std::shared_ptr<MathematicaFunctionFactory> functionFactory;
};
#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.cpp b/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.cpp
index d94434b8066a8e9651f505629bc81c90dae7b919..9fd24e63d07321be1e0591c58370ca8dfd13786f 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.cpp
@@ -1,11 +1,9 @@
#include "PhiMathematicaAssistant.h"
#include "Tests/PhiTest/LogFileData/PhiLogFileData.h"
-
-#include "Utilities/DataPoint/DataPoint.h"
#include "Utilities/LogFileData/LogFileData.h"
#include "Utilities/LogFileData/LogFileDataGroup/LogFileDataGroup.h"
-#include "Utilities/MathematicaFunctionFactory/MathematicaFunctionFactory.h"
+
std::shared_ptr<PhiMathematicaAssistant> PhiMathematicaAssistant::getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory)
{
@@ -17,9 +15,11 @@ void PhiMathematicaAssistant::makeMathematicaOutput(std::shared_ptr<LogFileDataG
std::shared_ptr<SortedDataPhi> mySortedData = sortLogFileData(logFileData);
makePhiDiffMathematicaOutput(aMathmaticaFile, mySortedData);
+ makeOrderOfAccuracyMathematicaOutput(aMathmaticaFile, mySortedData);
+
}
-PhiMathematicaAssistant::PhiMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : functionFactory(functionFactory)
+PhiMathematicaAssistant::PhiMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : MathematicaAssistantImp(functionFactory)
{
}
@@ -74,39 +74,6 @@ std::shared_ptr<SortedDataPhi> PhiMathematicaAssistant::sortLogFileData(std::sha
return mySortedData;
}
-void PhiMathematicaAssistant::addListLogLogPlotToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::string> listNames, std::vector<std::vector<double> > xAxesData, std::vector<std::vector<double> > yAxesData, std::string labelXAxes, std::string labelYAxes)
-{
- std::vector<std::vector<std::shared_ptr<DataPoint> > > dataPointGroup;
-
- for (int i = 0; i < xAxesData.size(); i++) {
- std::vector<std::shared_ptr<DataPoint> > dataPoints;
- for (int j = 0; j < xAxesData.at(i).size(); j++)
- dataPoints.push_back(DataPoint::getNewInstance(xAxesData.at(i).at(j), yAxesData.at(i).at(j)));
- dataPointGroup.push_back(dataPoints);
- }
- std::vector<std::shared_ptr<MathematicaPointList> > pointList;
- for (int i = 0; i < dataPointGroup.size(); i++) {
- std::shared_ptr<MathematicaPointList> aPointList = functionFactory->makeMathematicaPointList(aMathmaticaFile, listNames.at(i), dataPointGroup.at(i));
- pointList.push_back(aPointList);
- }
- std::shared_ptr<MathematicaListPlot> listLogLogPlot = functionFactory->makeMathematicaListPlot(aMathmaticaFile, pointList, "ListLogLogPlot", labelXAxes, labelYAxes);
-}
-
-void PhiMathematicaAssistant::addListOfListsToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::string listNames, std::vector<std::vector<double>> listOfLists)
-{
- functionFactory->makeMathematicaListOfLists(aMathmaticaFile, listNames, listOfLists);
-}
-
-std::vector<std::string> PhiMathematicaAssistant::finalizeListNames(std::vector<std::string> basicListNames, std::string dataToCalc, std::string testName)
-{
- std::vector<std::string> finalListNames;
-
- for (int i = 0; i < basicListNames.size(); i++)
- finalListNames.push_back(testName + basicListNames.at(i) + dataToCalc);
-
- return finalListNames;
-}
-
void PhiMathematicaAssistant::makePhiDiffMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataPhi> sortedData)
{
for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
@@ -118,15 +85,24 @@ void PhiMathematicaAssistant::makePhiDiffMathematicaOutput(std::shared_ptr<Mathe
phiDiff.push_back(sortedData->testLogFileData.at(i).at(j)->getPhiDiff());
aBasicListNamesList.push_back(sortedData->basicListNames.at(i).at(j));
}
- std::vector<std::string> finalListNames = finalizeListNames(aBasicListNamesList, sortedData->testLogFileData.at(i).at(0)->getDataToCalc(), "PhiDiff");
- addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, phiDiff, "L[dx]", "Err Phi");
+ std::vector<std::string> finalListNames = finalizeListNames(aBasicListNamesList, "PhiDiff", sortedData->testLogFileData.at(i).at(0)->getDataToCalc());
+ addSecondOrderOfAccuracyRef(gridLengths, phiDiff, finalListNames);
+ addFourthOrderOfAccuracyRef(gridLengths, phiDiff, finalListNames);
+ addListLogLogPlotToMathematicaFile(aMathmaticaFile, finalListNames, gridLengths, phiDiff, "L[dx]", "Err Phi[-]");
}
}
void PhiMathematicaAssistant::makeOrderOfAccuracyMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataPhi> sortedData)
{
for (int i = 0; i < sortedData->testLogFileData.size(); i++) {
-
+ for (int j = 0; j < sortedData->testLogFileData.at(i).size(); j++) {
+ std::vector<std::vector<double>> ooA = sortedData->testLogFileData.at(i).at(j)->getOrderOfAccuracy();
+ std::string basicListName = sortedData->basicListNames.at(i).at(j);
+ std::string dataToCalc = sortedData->testLogFileData.at(i).at(j)->getDataToCalc();
+ std::string finalListName = finalizeListName(basicListName, "PhiDiffOrderOfAccuracy", dataToCalc);
+
+ addListOfListsToMathematicaFile(aMathmaticaFile, finalListName, ooA);
+ }
}
}
diff --git a/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.h b/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.h
index a8696261d006c5e3eeec18626d949a89d96dd54d..f84d6c1ba726458af54a30d44916e41247a09368 100644
--- a/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.h
+++ b/targets/tests/NumericalTestPostProcessing/Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.h
@@ -25,12 +25,10 @@ private:
bool checkTestParameter(std::shared_ptr<PhiLogFileData> logFileData1, std::shared_ptr<PhiLogFileData> logFileData2);
std::shared_ptr<SortedDataPhi> sortLogFileData(std::shared_ptr<LogFileDataGroup> logFileData);
- void addListLogLogPlotToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::string> listNames, std::vector<std::vector<double> > xAxesData, std::vector<std::vector<double> > yAxesData, std::string labelXAxes, std::string labelYAxes);
- void addListOfListsToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::string listNames, std::vector<std::vector<double> > listOfLists);
- std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string dataToCalc, std::string testName);
+
+
void makePhiDiffMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataPhi> sortedData);
void makeOrderOfAccuracyMathematicaOutput(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::shared_ptr<SortedDataPhi> sortedData);
- std::shared_ptr<MathematicaFunctionFactory> functionFactory;
};
#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistant.h b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistant.h
index 035eaf74aeb16c2037b9c7aec35f28597ba9f333..b1d7f7417e9e149689bcbfb4afc7bb41134bf5ed 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistant.h
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistant.h
@@ -6,13 +6,15 @@
#include <memory>
#include <vector>
+enum DataCombination{ EqualSimulationsForDifferentKernels , EqualKernelSimulationsForDifferentViscosities};
+
class LogFileData;
class LogFileDataGroup;
class LogFileDataAssistant
{
public:
- virtual std::vector<std::shared_ptr<LogFileDataGroup> > findEqualSimulationsForDifferentKernels(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation) = 0;
- virtual std::vector<std::shared_ptr<LogFileDataGroup> > findEqualKernelSimulationsForDifferentViscosities(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation) = 0;
+ virtual std::vector<std::shared_ptr<LogFileDataGroup> > findDataCombination(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation, DataCombination combination) = 0;
+
};
#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.cpp
index 69c743f6b9ec9de69ce20f55faaf3674e6287004..da3b2a198dbe1e8fb7790f1645790590e05204a6 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.cpp
@@ -96,6 +96,25 @@ std::shared_ptr<LogFileDataAssistant> LogFileDataAssistantImp::getNewInstance()
return std::shared_ptr<LogFileDataAssistant>(new LogFileDataAssistantImp());
}
+std::vector<std::shared_ptr<LogFileDataGroup>> LogFileDataAssistantImp::findDataCombination(std::vector<std::shared_ptr<LogFileData>> allLogFileData, BasicSimulation simulation, DataCombination combination)
+{
+ std::vector<std::shared_ptr<LogFileDataGroup>> myLogFileDataGroup;
+
+ switch (combination)
+ {
+ case EqualSimulationsForDifferentKernels:
+ myLogFileDataGroup = findEqualSimulationsForDifferentKernels(allLogFileData, simulation);
+ break;
+ case EqualKernelSimulationsForDifferentViscosities:
+ myLogFileDataGroup = findEqualKernelSimulationsForDifferentViscosities(allLogFileData, simulation);
+ break;
+ default:
+ break;
+ }
+
+ return myLogFileDataGroup;
+}
+
std::vector<std::shared_ptr<LogFileDataGroup>> LogFileDataAssistantImp::findEqualSimulationsForDifferentKernels(std::vector<std::shared_ptr<LogFileData>> allLogFileData, BasicSimulation simulation)
{
std::shared_ptr<LogFileDataAssistantStrategy> strategy = assistentStrategyFactory->makeLogFileDataAssistantStrategy(simulation);
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.h b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.h
index f54e357d9d8becd8bb521252f509a5066895a89e..1783a104c4a56bfeddf79aef2778d380964d392c 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.h
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileDataAssistant/LogFileDataAssistantImp.h
@@ -11,13 +11,17 @@ class LogFileDataAssistantImp : public LogFileDataAssistant
public:
static std::shared_ptr<LogFileDataAssistant> getNewInstance();
- std::vector<std::shared_ptr<LogFileDataGroup> > findEqualSimulationsForDifferentKernels(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation);
- std::vector<std::shared_ptr<LogFileDataGroup> > findEqualKernelSimulationsForDifferentViscosities(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation);
+
+ std::vector<std::shared_ptr<LogFileDataGroup> > findDataCombination(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation, DataCombination combination);
+
protected:
LogFileDataAssistantImp();
+ std::vector<std::shared_ptr<LogFileDataGroup> > findEqualSimulationsForDifferentKernels(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation);
+ std::vector<std::shared_ptr<LogFileDataGroup> > findEqualKernelSimulationsForDifferentViscosities(std::vector<std::shared_ptr<LogFileData> > allLogFileData, BasicSimulation simulation);
+
std::vector<std::shared_ptr<LogFileData> > getSimulationGroupLogFileData(std::string simName, std::vector<std::shared_ptr<LogFileData> > allLogFileData);
std::vector<std::vector<std::shared_ptr<LogFileData> > > sortLogFileDataAfterKernels(std::vector<std::shared_ptr<LogFileData> > logFileData);
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileReader/LogFileReader.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileReader/LogFileReader.cpp
index f1dc47d8d90644eafa27a02e952c771e3326b463..1e80f43264758dda06907d7db566632639ccf661 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/LogFileReader/LogFileReader.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/LogFileReader/LogFileReader.cpp
@@ -52,6 +52,8 @@ std::shared_ptr<LogFileData> LogFileReader::readLogFileToLogFileData(std::string
logFileData->setSimName(StringUtil::toString(input->getValue("SimulationName")));
+
+
std::ostringstream simSigniture;
if (logFileData->getSimName() == "ShearWave") {
std::vector<double> shearWaveLx = StringUtil::toDoubleVector(input->getValue("Lx"));
@@ -143,7 +145,7 @@ std::shared_ptr<LogFileData> LogFileReader::readLogFileToLogFileData(std::string
simTime.push_back(StringUtil::toInt(simTimeString));
resultsCheckTime.push_back(StringUtil::toDouble(resultCheckTimeString));
testTime.push_back(StringUtil::toDouble(testTimeString));
- analyticalVTKWritingTimeString.push_back(StringUtil::toInt(analyticalVTKWritingTimeString));
+ analyticalVTKWritingTime.push_back(StringUtil::toInt(analyticalVTKWritingTimeString));
}
logFileData->setVTKFileWriting(StringUtil::toBool(input->getValue("VTKFileWriting")));
@@ -185,7 +187,6 @@ std::shared_ptr<LogFileData> LogFileReader::readLogFileToLogFileData(std::string
phiDiff.push_back(StringUtil::toDouble(input->getValue(phiDiffString.str())));
}
-
for (int k = j + 1; k < logFileData->getBasicGridLengths().size(); k++) {
std::vector<double> aOrderOfAccuracyGroup;
std::ostringstream phiDiffOOA, phiDiffBasicOOA;
@@ -346,14 +347,16 @@ std::shared_ptr<LogFileData> LogFileReader::readLogFileToLogFileData(std::string
std::vector<std::string> normalizeData = StringUtil::toStringVector(input->getValue("NormalizeWith_L2Norm_BK"));
std::vector<std::string> failL2Norm = StringUtil::toStringVector(input->getValue("FailTests_L2Norm_BK"));
- std::vector<double> l2NormBasicKernel;
- std::vector<double> l2NormDivergentKernel;
- std::vector<double> l2NormBetweenKernels;
+
for (int i = 0; i < dataToCalc.size(); i++) {
for (int j = 0; j < timeSteps.size(); j++) {
for (int k = 0; k < normalizeData.size(); k++) {
+ std::vector<double> l2NormBasicKernel;
+ std::vector<double> l2NormDivergentKernel;
+ std::vector<double> l2NormBetweenKernels;
std::shared_ptr<L2NormBetweenKernelsLogFileDataImp> aL2NormLogFileData = L2NormBetweenKernelsLogFileDataImp::getNewInstance();
aL2NormLogFileData->setBasicKernel(StringUtil::toString(input->getValue("BasicKernel_L2Norm_BK")));
+ aL2NormLogFileData->setDivergentKernel(logFileData->getKernel());
aL2NormLogFileData->setDataToCalculate(dataToCalc.at(i));
aL2NormLogFileData->setTimeStep(timeSteps.at(j));
aL2NormLogFileData->setNormalizeData(normalizeData.at(k));
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistant.h b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistant.h
index 96d38560aad89df94286a58eebdc574440ccb31c..7d6f326366f2f7001ba3db1192ee7472ba0a9041 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistant.h
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistant.h
@@ -4,6 +4,8 @@
#include <memory>
#include <vector>
+enum Assistant{Phi, Ny, L2Norm, L2NormBetweenKernels, Time };
+
class LogFileDataGroup;
class MathematicaFile;
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactory.h b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactory.h
new file mode 100644
index 0000000000000000000000000000000000000000..9afdf455b948fe669d9a95f33e66668db77fae81
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactory.h
@@ -0,0 +1,17 @@
+#ifndef MATHEMATICA_ASSISTANT_FACTORY_H
+#define MATHEMATICA_ASSISTANT_FACTORY_H
+
+#include "../MathematicaAssistant.h"
+
+#include <memory>
+#include <vector>
+
+class MathematicaFunctionFactory;
+
+class MathematicaAssistantFactory
+{
+public:
+ virtual std::vector<std::shared_ptr<MathematicaAssistant> > makeMathematicaAssistants(std::vector<Assistant> types, std::shared_ptr<MathematicaFunctionFactory> functionFactory) = 0;
+
+};
+#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86d6262c71d2c35b85649de1fe744e1085ad7c1e
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.cpp
@@ -0,0 +1,52 @@
+#include "MathematicaAssistantFactoryImp.h"
+
+#include "Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.h"
+#include "Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.h"
+#include "Tests/L2Norm/MathematicaAssistant/L2NormMathematicaAssistant.h"
+#include "Tests/L2NormBetweenKernels/MathematicaAssistant/L2NormBetweenKernelsMathematicaAssistant.h"
+
+#include "Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.h"
+
+std::shared_ptr<MathematicaAssistantFactory> MathematicaAssistantFactoryImp::getNewInstance()
+{
+ return std::shared_ptr<MathematicaAssistantFactory>(new MathematicaAssistantFactoryImp());
+}
+
+std::vector<std::shared_ptr<MathematicaAssistant>> MathematicaAssistantFactoryImp::makeMathematicaAssistants(std::vector<Assistant> types, std::shared_ptr<MathematicaFunctionFactory> functionFactory)
+{
+ std::vector<std::shared_ptr<MathematicaAssistant>> myAssistants;
+
+ for(int i = 0; i < types.size(); i++){
+ switch (types.at(i))
+ {
+ case Phi:
+ myAssistants.push_back(PhiMathematicaAssistant::getNewInstance(functionFactory));
+ break;
+ case Ny:
+ myAssistants.push_back(NyMathematicaAssistant::getNewInstance(functionFactory));
+ break;
+ case L2Norm:
+ myAssistants.push_back(L2NormMathematicaAssistant::getNewInstance(functionFactory));
+ break;
+ case L2NormBetweenKernels:
+ myAssistants.push_back(L2NormBetweenKernelsMathematicaAssistant::getNewInstance(functionFactory));
+ break;
+ case Time:
+ myAssistants.push_back(TimeMathematicaAssistant::getNewInstance(functionFactory));
+ break;
+ default:
+ break;
+ }
+
+ }
+
+
+ return myAssistants;
+}
+
+MathematicaAssistantFactoryImp::MathematicaAssistantFactoryImp()
+{
+}
+
+
+
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.h b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.h
new file mode 100644
index 0000000000000000000000000000000000000000..6acacadc59ce1db5c3b9590b8e1ef663e0084398
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.h
@@ -0,0 +1,16 @@
+#ifndef MATHEMATICA_ASSISTANT_FACTORY_IMP_H
+#define MATHEMATICA_ASSISTANT_FACTORY_IMP_H
+
+#include "MathematicaAssistantFactory.h"
+
+class MathematicaAssistantFactoryImp : public MathematicaAssistantFactory
+{
+public:
+ static std::shared_ptr<MathematicaAssistantFactory> getNewInstance();
+
+ std::vector<std::shared_ptr<MathematicaAssistant> > makeMathematicaAssistants(std::vector<Assistant> types, std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+private:
+ MathematicaAssistantFactoryImp();
+};
+#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/package.include b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantFactory/package.include
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.cpp
index 3aa5bbf326d0f4955cd456d296c6fedc78dd0679..cc12fbe77914e9757e560e7c108b4ac51de5cb90 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.cpp
@@ -1,5 +1,148 @@
#include "MathematicaAssistantImp.h"
+#include "Utilities/DataPoint/DataPoint.h"
+#include "Utilities/MathematicaFunctionFactory/MathematicaFunctionFactory.h"
+
MathematicaAssistantImp::MathematicaAssistantImp()
{
}
+
+MathematicaAssistantImp::MathematicaAssistantImp(std::shared_ptr<MathematicaFunctionFactory> functionFactory)
+{
+ this->functionFactory = functionFactory;
+}
+
+std::vector<std::string> MathematicaAssistantImp::finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc)
+{
+ std::vector<std::string> finalListNames;
+
+ for (int i = 0; i < basicListNames.size(); i++)
+ finalListNames.push_back(finalizeListName(basicListNames.at(i), testName, dataToCalc));
+
+ return finalListNames;
+}
+
+std::vector<std::string> MathematicaAssistantImp::finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData)
+{
+ std::vector<std::string> finalListNames;
+
+ for (int i = 0; i < basicListNames.size(); i++)
+ finalListNames.push_back(testName + basicListNames.at(i) + dataToCalc + normalizeData);
+
+ return finalListNames;
+}
+
+std::vector<std::string> MathematicaAssistantImp::finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData, std::string timeStep)
+{
+ std::vector<std::string> finalListNames;
+
+ for (int i = 0; i < basicListNames.size(); i++)
+ finalListNames.push_back(testName + basicListNames.at(i) + dataToCalc + normalizeData + timeStep);
+
+ return finalListNames;
+}
+
+std::vector<std::string> MathematicaAssistantImp::finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData, std::vector<std::string> timeSteps)
+{
+ std::vector<std::string> finalListNames;
+
+ for (int i = 0; i < basicListNames.size(); i++)
+ finalListNames.push_back(testName + basicListNames.at(i) + dataToCalc + normalizeData + timeSteps.at(i));
+
+ return finalListNames;
+}
+
+std::vector<std::string> MathematicaAssistantImp::finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData, std::vector<std::string> timeSteps, std::vector<std::string> basicKernels)
+{
+ std::vector<std::string> finalListNames;
+
+ for (int i = 0; i < basicListNames.size(); i++)
+ finalListNames.push_back(testName + basicListNames.at(i) + dataToCalc + normalizeData + timeSteps.at(i) + basicKernels.at(i));
+
+ return finalListNames;
+}
+
+std::string MathematicaAssistantImp::finalizeListName(std::string basicListName, std::string testName, std::string dataToCalc)
+{
+ return testName + basicListName + dataToCalc;
+}
+
+void MathematicaAssistantImp::addListLogLogPlotToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::string> listNames, std::vector<std::vector<double>> xAxesData, std::vector<std::vector<double>> yAxesData, std::string labelXAxes, std::string labelYAxes)
+{
+ std::vector<std::vector<std::shared_ptr<DataPoint> > > dataPointGroup;
+
+ for (int i = 0; i < xAxesData.size(); i++) {
+ std::vector<std::shared_ptr<DataPoint> > dataPoints;
+ for (int j = 0; j < xAxesData.at(i).size(); j++)
+ dataPoints.push_back(DataPoint::getNewInstance(xAxesData.at(i).at(j), yAxesData.at(i).at(j)));
+ dataPointGroup.push_back(dataPoints);
+ }
+ std::vector<std::shared_ptr<MathematicaPointList> > pointList;
+ for (int i = 0; i < dataPointGroup.size(); i++) {
+ std::shared_ptr<MathematicaPointList> aPointList = functionFactory->makeMathematicaPointList(aMathmaticaFile, listNames.at(i), dataPointGroup.at(i));
+ pointList.push_back(aPointList);
+ }
+ std::shared_ptr<MathematicaListPlot> listLogLogPlot = functionFactory->makeMathematicaListPlot(aMathmaticaFile, pointList, "ListLogLogPlot", labelXAxes, labelYAxes);
+}
+
+void MathematicaAssistantImp::addListOfListsToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::string listNames, std::vector<std::vector<double>> listOfLists)
+{
+ functionFactory->makeMathematicaListOfLists(aMathmaticaFile, listNames, listOfLists);
+}
+
+void MathematicaAssistantImp::addSecondOrderOfAccuracyRef(std::vector<std::vector<double>>& xAxesData, std::vector<std::vector<double>>& yAxesData, std::vector<std::string>& listNames)
+{
+ int maxLength = 0;
+ int maxLengthAtNumber = 0;
+ for (int i = 0; i < xAxesData.size(); i++) {
+ if (xAxesData.at(i).size() > maxLength) {
+ maxLength = xAxesData.at(i).size();
+ maxLengthAtNumber = i;
+ }
+ }
+ std::vector<double> x = xAxesData.at(maxLengthAtNumber);
+
+ double maxData = 0.0;
+ for (int i = 0; i < yAxesData.size(); i++) {
+ for (int j = 0; j < yAxesData.at(i).size(); j++) {
+ if (yAxesData.at(i).at(j) > maxData)
+ maxData = yAxesData.at(i).at(j);
+ }
+ }
+
+ std::vector<double> sec = { maxData * 10.0 };
+ for (int l = 1; l < x.size(); l++)
+ sec.push_back(sec.at(l - 1) / exp(-2.0 * log(x.at(l - 1) / x.at(l))));
+ xAxesData.push_back(x);
+ yAxesData.push_back(sec);
+ listNames.push_back("SecondOrderOfAccuracy");
+}
+
+void MathematicaAssistantImp::addFourthOrderOfAccuracyRef(std::vector<std::vector<double>>& xAxesData, std::vector<std::vector<double>>& yAxesData, std::vector<std::string>& listNames)
+{
+ int maxLength = 0;
+ int maxLengthAtNumber = 0;
+ for (int i = 0; i < xAxesData.size(); i++) {
+ if (xAxesData.at(i).size() > maxLength) {
+ maxLength = xAxesData.at(i).size();
+ maxLengthAtNumber = i;
+ }
+ }
+ std::vector<double> x = xAxesData.at(maxLengthAtNumber);
+
+ double maxData = 0.0;
+ for (int i = 0; i < yAxesData.size(); i++) {
+ for (int j = 0; j < yAxesData.at(i).size(); j++) {
+ if (yAxesData.at(i).at(j) > maxData)
+ maxData = yAxesData.at(i).at(j);
+ }
+ }
+ std::vector<double> fourth = { maxData / 100.0 };
+ for (int l = 1; l < x.size(); l++)
+ fourth.push_back(fourth.at(l - 1) / exp(-4.0 * log(x.at(l - 1) / x.at(l))));
+
+
+ xAxesData.push_back(x);
+ yAxesData.push_back(fourth);
+ listNames.push_back("FourthOrderOfAccuracy");
+}
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.h b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.h
index b508f01ae9cd1c3b10891e21873146d33303b16f..ab0970dd331cf899cb8fb19e60da87f6415bc767 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.h
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/MathematicaAssistantImp.h
@@ -3,6 +3,8 @@
#include "MathematicaAssistant.h"
+class MathematicaFunctionFactory;
+
class MathematicaAssistantImp : public MathematicaAssistant
{
public:
@@ -10,5 +12,21 @@ public:
protected:
MathematicaAssistantImp();
+ MathematicaAssistantImp(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc);
+ std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData);
+ std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData, std::string timeStep);
+ std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData, std::vector<std::string> timeSteps);
+ std::vector<std::string> finalizeListNames(std::vector<std::string> basicListNames, std::string testName, std::string dataToCalc, std::string normalizeData, std::vector<std::string> timeSteps, std::vector<std::string> basicKernels);
+ std::string finalizeListName(std::string basicListName, std::string testName, std::string dataToCalc);
+
+ void addListLogLogPlotToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::string> listNames, std::vector<std::vector<double> > xAxesData, std::vector<std::vector<double> > yAxesData, std::string labelXAxes, std::string labelYAxes);
+ void addListOfListsToMathematicaFile(std::shared_ptr<MathematicaFile> aMathmaticaFile, std::string listName, std::vector<std::vector<double> > listOfLists);
+
+ void addSecondOrderOfAccuracyRef(std::vector<std::vector<double> > &xAxesData, std::vector<std::vector<double> > &yAxesData, std::vector<std::string> &listNames);
+ void addFourthOrderOfAccuracyRef(std::vector<std::vector<double> > &xAxesData, std::vector<std::vector<double> > &yAxesData, std::vector<std::string> &listNames);
+
+ std::shared_ptr<MathematicaFunctionFactory> functionFactory;
};
#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..816171a00ed88a596a7b5efe6bc525de6e3eaf77
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.cpp
@@ -0,0 +1,83 @@
+#include "TimeMathematicaAssistant.h"
+
+#include "Utilities/LogFileData/LogFileDataGroup/LogFileDataGroup.h"
+#include "Utilities/LogFileData/LogFileData.h"
+
+#include "Utilities/DataPoint/DataPoint.h"
+#include "Utilities/MathematicaFunctionFactory/MathematicaFunctionFactory.h"
+
+std::shared_ptr<TimeMathematicaAssistant> TimeMathematicaAssistant::getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory)
+{
+ return std::shared_ptr<TimeMathematicaAssistant>(new TimeMathematicaAssistant(functionFactory));
+}
+
+TimeMathematicaAssistant::TimeMathematicaAssistant()
+{
+
+}
+
+TimeMathematicaAssistant::TimeMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory) : MathematicaAssistantImp(functionFactory)
+{
+
+}
+
+void TimeMathematicaAssistant::makeSimulationTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile)
+{
+ std::vector<std::vector<double> > simTimes(logFileData->getGroupSize());
+ for (int i = 0; i < logFileData->getGroupSize(); i++)
+ for(int j = 0; j < logFileData->getLogFileData(i)->getSimTime().size(); j++)
+ simTimes.at(i).push_back((double)logFileData->getLogFileData(i)->getSimTime().at(j));
+
+ makeTimeMathematicaOutput(logFileData, aMathmaticaFile, simTimes, "SimulationTime");
+}
+
+void TimeMathematicaAssistant::makeTestTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile)
+{
+ std::vector<std::vector<double> > testTimes;
+ for (int i = 0; i < logFileData->getGroupSize(); i++)
+ testTimes.push_back(logFileData->getLogFileData(i)->getTestTime());
+
+ makeTimeMathematicaOutput(logFileData, aMathmaticaFile, testTimes, "TestTime");
+}
+
+void TimeMathematicaAssistant::makeAnalyticalWriteTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile)
+{
+ std::vector<std::vector<double> > analyticalWriteTime(logFileData->getGroupSize());
+ for (int i = 0; i < logFileData->getGroupSize(); i++)
+ for (int j = 0; j < logFileData->getLogFileData(i)->getAnalyticalVTKWritingTime().size(); j++)
+ analyticalWriteTime.at(i).push_back((double)logFileData->getLogFileData(i)->getAnalyticalVTKWritingTime().at(j));
+
+ makeTimeMathematicaOutput(logFileData, aMathmaticaFile, analyticalWriteTime, "AnalyticalVTKWritingTime");
+}
+
+void TimeMathematicaAssistant::makeTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::vector<double>> times, std::string timeName)
+{
+ std::vector<std::vector<double> > grids;
+ std::vector<std::string> listNames;
+ for (int i = 0; i < logFileData->getGroupSize(); i++) {
+ grids.push_back(logFileData->getLogFileData(i)->getBasicGridLengths());
+ listNames.push_back(logFileData->getLogFileData(i)->getSimulationSigniture() + timeName);
+ }
+
+ std::vector<std::vector<std::shared_ptr<DataPoint> > > dataPointGroup;
+
+ for (int j = 0; j < grids.size(); j++) {
+ std::vector<std::shared_ptr<DataPoint> > dataPoints;
+ for (int k = 0; k < times.at(j).size(); k++)
+ dataPoints.push_back(DataPoint::getNewInstance(grids.at(j).at(k), times.at(j).at(k)));
+ dataPointGroup.push_back(dataPoints);
+ }
+ std::vector<std::shared_ptr<MathematicaPointList> > pointList;
+ for (int j = 0; j < dataPointGroup.size(); j++) {
+ std::shared_ptr<MathematicaPointList> aPointList = functionFactory->makeMathematicaPointList(aMathmaticaFile, listNames.at(j), dataPointGroup.at(j));
+ pointList.push_back(aPointList);
+ }
+ std::shared_ptr<MathematicaListPlot> listLogLogPlot = functionFactory->makeMathematicaListPlot(aMathmaticaFile, pointList, "ListLogLogPlot", "L[dx]", "Time [sec]");
+}
+
+void TimeMathematicaAssistant::makeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile)
+{
+ makeSimulationTimeMathematicaOutput(logFileData, aMathmaticaFile);
+ makeTestTimeMathematicaOutput(logFileData, aMathmaticaFile);
+ makeAnalyticalWriteTimeMathematicaOutput(logFileData, aMathmaticaFile);
+}
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.h b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.h
new file mode 100644
index 0000000000000000000000000000000000000000..46daab517d6e614531a2c4ffab2345a486c75a3c
--- /dev/null
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/TimeMathematicaAssistant.h
@@ -0,0 +1,27 @@
+#ifndef TIME_MATHEMATICA_ASSISTANT_H
+#define TIME_MATHEMATICA_ASSISTANT_H
+
+#include "Utilities/MathematicaAssistant/MathematicaAssistantImp.h"
+
+class MathematicaFunctionFactory;
+class MathematicaFile;
+
+class TimeMathematicaAssistant : public MathematicaAssistantImp
+{
+public:
+ static std::shared_ptr<TimeMathematicaAssistant> getNewInstance(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ void makeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile);
+
+private:
+ TimeMathematicaAssistant();
+ TimeMathematicaAssistant(std::shared_ptr<MathematicaFunctionFactory> functionFactory);
+
+ void makeSimulationTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile);
+ void makeTestTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile);
+ void makeAnalyticalWriteTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile);
+
+ void makeTimeMathematicaOutput(std::shared_ptr<LogFileDataGroup> logFileData, std::shared_ptr<MathematicaFile> aMathmaticaFile, std::vector<std::vector<double> > times, std::string timeName);
+
+};
+#endif
\ No newline at end of file
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/package.include b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaAssistant/TimeAssistant/package.include
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/LinePlot/MathematicaListPlotImp.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/LinePlot/MathematicaListPlotImp.cpp
index 0e940e22751d7097affe2ad28b7e3faf1fb6e19e..e8508061686cba1092f0f85012d3a9b81b6fc439 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/LinePlot/MathematicaListPlotImp.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/LinePlot/MathematicaListPlotImp.cpp
@@ -23,7 +23,7 @@ MathematicaListPlotImp::MathematicaListPlotImp(std::vector<std::shared_ptr<Mathe
else
mathematicaFunction << pointList.at(i)->getListName() << "\"}";
}
- mathematicaFunction << ", AxesLabel -> {" << xAxes << ", " << yAxes << "}, Joined -> True, PlotMarkers->Automatic, PlotStyle -> Dashed]";
+ mathematicaFunction << ", AxesLabel -> {\"" << xAxes << "\", \"" << yAxes << "\"}, Joined -> True, PlotMarkers->Automatic, PlotStyle -> Dashed]";
}
MathematicaListPlotImp::MathematicaListPlotImp()
diff --git a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/ListOfLists/MathematicaListOfListsImp.cpp b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/ListOfLists/MathematicaListOfListsImp.cpp
index bc236d6495fc82e9c87a5e10fe33684306dbecd0..58a4128fbd1ae54f59c625cb7b7ca4f851885962 100644
--- a/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/ListOfLists/MathematicaListOfListsImp.cpp
+++ b/targets/tests/NumericalTestPostProcessing/Utilities/MathematicaFunction/ListOfLists/MathematicaListOfListsImp.cpp
@@ -17,16 +17,16 @@ MathematicaListOfListsImp::MathematicaListOfListsImp(std::string listName, std::
mathematicaFunction << std::fixed << std::setprecision(std::numeric_limits<double>::digits10 + 1);
mathematicaFunction << listName << "= {";
- for (int i = 0; listOfLists.size(); i++) {
+ for (int i = 0; i < listOfLists.size(); i++) {
mathematicaFunction << "{";
- if (i > 0)
- mathematicaFunction << ", ";
for (int j = 0; j < listOfLists.at(i).size(); j++){
- if (i > 0)
+ if (j > 0)
mathematicaFunction << ", ";
mathematicaFunction << listOfLists.at(i).at(j);
}
mathematicaFunction << "}";
+ if(i < listOfLists.size() - 1)
+ mathematicaFunction << ", ";
}
mathematicaFunction << "};";
}
diff --git a/targets/tests/NumericalTestPostProcessing/main.cpp b/targets/tests/NumericalTestPostProcessing/main.cpp
index 3122355776a3c973ca6bc797376afc630a810011..1ffb891cae9c8a936d82f85cead2442706dc25b4 100644
--- a/targets/tests/NumericalTestPostProcessing/main.cpp
+++ b/targets/tests/NumericalTestPostProcessing/main.cpp
@@ -1,7 +1,5 @@
#include "Simulation/BasicSimulation.h"
-#include "Tests/PhiTest/MathematicaAssistant/PhiMathematicaAssistant.h"
-#include "Tests/NyTest/MathematicaAssistant/NyMathematicaAssistant.h"
#include "Utilities/LogFileData/LogFileData.h"
#include "Utilities/LogFileData/LogFileDataGroup/LogFileDataGroup.h"
@@ -9,6 +7,8 @@
#include "Utilities/LogFileDataAssistant/LogFileDataAssistantImp.h"
#include "Utilities/MathematicaFile/MathematicaFile.h"
#include "Utilities/MathematicaFunctionFactory/MathematicaFunctionFactoryImp.h"
+#include "Utilities/MathematicaAssistant/MathematicaAssistantFactory/MathematicaAssistantFactoryImp.h"
+#include "Utilities/MathematicaAssistant/MathematicaAssistant.h"
#include <memory>
#include <cfloat>
@@ -22,28 +22,44 @@
int main(int argc, char **argv)
{
- BasicSimulation simulation = ShearWave;
- //BasicSimulation simulation = TaylorGreenVortexUx;
- //BasicSimulation simulation = TaylorGreenVortexUz;
+ std::vector<BasicSimulation> simulation;
+ simulation.push_back(ShearWave);
+ //simulation.push_back(TaylorGreenVortexUx);
+ //simulation.push_back(TaylorGreenVortexUz);
- std::shared_ptr<LogFileReader> logFileReader = LogFileReader::getInstance();
- //std::shared_ptr<LogFileData> logFileData = logFileReader->readLogFileToLogFileData("C:/Users/Timon/Documents/studienarbeitIRMB/logFiles/NumericalTestLogFiles/TaylorGreenVortexUx/viscosity_0.001/ux_ 0.016_Amplitude_ 0.005/CumulantAA2016CompSP27/logfile_20190211_153133_CumulantAA2016CompSP27_vis_0.001.txt");
- std::vector<std::shared_ptr<LogFileData> > logFileDataVector = logFileReader->readLogFilesInDirectoryToLogFileData("C:/Users/Timon/Desktop/logFiles");
+ std::vector<Assistant> assistants;
+ //assistants.push_back(Phi);
+ //assistants.push_back(Ny);
+ //assistants.push_back(L2Norm);
+ //assistants.push_back(L2NormBetweenKernels);
+ assistants.push_back(Time);
+
+ std::vector<DataCombination> combination;
+ combination.push_back(EqualSimulationsForDifferentKernels);
+ //combination.push_back(EqualKernelSimulationsForDifferentViscosities);
- std::shared_ptr<LogFileDataAssistant> assistent = LogFileDataAssistantImp::getNewInstance();
- std::vector<std::shared_ptr<LogFileDataGroup> > logFileDataSorted = assistent->findEqualSimulationsForDifferentKernels(logFileDataVector, simulation);
- //std::vector<std::vector<std::shared_ptr<LogFileData> > > logFileDataSorted = assistent->findEqualKernelSimulationsForDifferentViscosities(logFileDataVector, simulation);
+
+ std::shared_ptr<LogFileReader> logFileReader = LogFileReader::getInstance();
+ std::vector<std::shared_ptr<LogFileData> > logFileDataVector = logFileReader->readLogFilesInDirectoryToLogFileData("C:/Users/Timon/Documents/studienarbeitIRMB/logFiles");
std::shared_ptr<MathematicaFile> aMathmaticaFile = MathematicaFile::getNewInstance("C:/Users/Timon/Desktop");
+
+ std::shared_ptr<LogFileDataAssistant> assistentLogFile = LogFileDataAssistantImp::getNewInstance();
+
std::shared_ptr<MathematicaFunctionFactory> functionFactory = MathematicaFunctionFactoryImp::getNewInstance();
+ std::shared_ptr<MathematicaAssistantFactory> assistantFactory = MathematicaAssistantFactoryImp::getNewInstance();
+ std::vector<std::shared_ptr<MathematicaAssistant> > mathematicaAssistants = assistantFactory->makeMathematicaAssistants(assistants, functionFactory);
- std::shared_ptr<PhiMathematicaAssistant> mathematicaAssistantPhi = PhiMathematicaAssistant::getNewInstance(functionFactory);
- std::shared_ptr<NyMathematicaAssistant> mathematicaAssistantNy = NyMathematicaAssistant::getNewInstance(functionFactory);
-
- for (int i = 0; i < logFileDataSorted.size(); i++) {
- mathematicaAssistantPhi->makeMathematicaOutput(logFileDataSorted.at(i), aMathmaticaFile);
- mathematicaAssistantNy->makeMathematicaOutput(logFileDataSorted.at(i), aMathmaticaFile);
+ for (int sim = 0; sim < simulation.size(); sim++) {
+ for (int comb = 0; comb < combination.size(); comb++) {
+ std::vector<std::shared_ptr<LogFileDataGroup> > logFileDataSorted = assistentLogFile->findDataCombination(logFileDataVector, simulation.at(sim), combination.at(comb));
+ for (int i = 0; i < logFileDataSorted.size(); i++) {
+ for (int j = 0; j < mathematicaAssistants.size(); j++)
+ mathematicaAssistants.at(j)->makeMathematicaOutput(logFileDataSorted.at(i), aMathmaticaFile);
+ }
+ }
}
+
aMathmaticaFile->finishFile();
return 0;