VirtualFluids 0.2.0
Parallel CFD LBM Solver
Loading...
Searching...
No Matches
LogFileDataAssistantImp.cpp
Go to the documentation of this file.
1//=======================================================================================
2// ____ ____ __ ______ __________ __ __ __ __
3// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
4// \ \ | | | | | |_) | | | | | | | / \ | |
5// \ \ | | | | | _ / | | | | | | / /\ \ | |
6// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
7// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
8// \ \ | | ________________________________________________________________
9// \ \ | | | ______________________________________________________________|
10// \ \| | | | __ __ __ __ ______ _______
11// \ | | |_____ | | | | | | | | | _ \ / _____)
12// \ | | _____| | | | | | | | | | | \ \ \_______
13// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
14// \ _____| |__| |________| \_______/ |__| |______/ (_______/
15//
16// This file is part of VirtualFluids. VirtualFluids is free software: you can
17// redistribute it and/or modify it under the terms of the GNU General Public
18// License as published by the Free Software Foundation, either version 3 of
19// the License, or (at your option) any later version.
20//
21// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
22// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
23// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24// for more details.
25//
26// SPDX-License-Identifier: GPL-3.0-or-later
27// SPDX-FileCopyrightText: Copyright © VirtualFluids Project contributors, see AUTHORS.md in root folder
28//
32//=======================================================================================
34
39
40
41#include <iostream>
42
43std::vector<std::vector<std::shared_ptr<LogFileData>>> LogFileDataAssistantImp::sortLogFileDataAfterKernels(std::vector<std::shared_ptr<LogFileData>> logFileData)
44{
45 std::vector<std::string> kernelNames;
46 for (int i = 0; i < logFileData.size(); i++) {
47 if (i == 0)
48 kernelNames.push_back(logFileData.at(i)->getKernel());
49 else
50 {
51 bool newKernel = true;
52 for (int j = 0; j < kernelNames.size(); j++) {
53 if (kernelNames.at(i) == logFileData.at(i)->getKernel())
54 newKernel = false;
55 }
56 if (newKernel)
57 kernelNames.push_back(logFileData.at(i)->getKernel());
58 }
59 }
60
61 std::vector<std::vector<std::shared_ptr<LogFileData> > > logFileDataAfterKernels;
63 for (int i = 0; i < kernelNames.size(); i++) {
64 for (int j = 0; j < logFileData.size(); j++) {
65 if (kernelNames.at(i) == logFileData.at(j)->getKernel())
66 logFileDataAfterKernels.at(i).push_back(logFileData.at(j));
67 }
68 }
70}
71
72bool LogFileDataAssistantImp::checkEqualSimulationData(std::shared_ptr<LogFileData> logFileData1, std::shared_ptr<LogFileData> logFileData2)
73{
74 if (logFileData1->getNumberOfTimeSteps() != logFileData2->getNumberOfTimeSteps())
75 return false;
76 if (logFileData1->getBasisTimeStepLength() != logFileData2->getBasisTimeStepLength())
77 return false;
78
79 return true;
80}
81
82bool LogFileDataAssistantImp::checkEqualViscosity(std::shared_ptr<LogFileData> logFileData1, std::shared_ptr<LogFileData> logFileData2)
83{
84 if (!equalDouble(logFileData1->getViscosity(), logFileData2->getViscosity()))
85 return false;
86
87 return true;
88}
89
90bool LogFileDataAssistantImp::checkEqualKernel(std::shared_ptr<LogFileData> logFileData1, std::shared_ptr<LogFileData> logFileData2)
91{
92 if (logFileData1->getKernel() != logFileData2->getKernel())
93 return false;
94
95 return true;
96}
97
98bool LogFileDataAssistantImp::checkBasicSimulationIsInLogFiles(std::vector<std::shared_ptr<LogFileData>> allLogFileData, std::string simName)
99{
100 bool isInLogFileData = false;
101 for (int i = 0; i < allLogFileData.size(); i++) {
102 if (allLogFileData.at(i)->getSimName() == simName)
103 return true;
104 }
105 return false;
106}
107
108std::vector<std::shared_ptr<LogFileDataGroup>> LogFileDataAssistantImp::castToLogFileDataGroup(std::vector<std::shared_ptr<LogFileDataGroupImp>> data)
109{
110 std::vector<std::shared_ptr<LogFileDataGroup>> casted;
111
112 for (int i = 0; i < data.size(); i++)
113 casted.push_back(data.at(i));
114 return casted;
115}
116
118{
120
121 if (lhs.AlmostEquals(rhs))
122 return true;
123 return false;
124}
125
126std::vector<std::shared_ptr<LogFileData>> LogFileDataAssistantImp::getSimulationGroupLogFileData(std::string simName, std::vector<std::shared_ptr<LogFileData>> allLogFileData)
127{
128 std::vector<std::shared_ptr<LogFileData>> simGroupLogFileData;
129
130 for (int i = 0; i < allLogFileData.size(); i++) {
131 if (allLogFileData.at(i)->getSimName() == simName)
132 simGroupLogFileData.push_back(allLogFileData.at(i));
133 }
134
135 return simGroupLogFileData;
136}
137
138std::shared_ptr<LogFileDataAssistant> LogFileDataAssistantImp::getNewInstance()
139{
140 return std::shared_ptr<LogFileDataAssistant>(new LogFileDataAssistantImp());
141}
142
143std::vector<std::shared_ptr<LogFileDataGroup>> LogFileDataAssistantImp::findDataCombination(std::vector<std::shared_ptr<LogFileData>> allLogFileData, std::shared_ptr<LogFileDataAssistantStrategy> strategy, DataCombination combination)
144{
145 std::vector<std::shared_ptr<LogFileDataGroup>> myLogFileDataGroup;
146 if (checkBasicSimulationIsInLogFiles(allLogFileData, strategy->getSimulationName())) {
147 if (allLogFileData.size() > 1) {
148 switch (combination)
149 {
152 break;
155 break;
156 default:
157 break;
158 }
159 }
160 else {
161 std::shared_ptr<LogFileDataGroupImp> newGroup = LogFileDataGroupImp::getNewInstance();
162 newGroup->addLogFileData(allLogFileData.at(0));
163 myLogFileDataGroup.push_back(newGroup);
164 }
165 }
166 return myLogFileDataGroup;
167}
168
169std::vector<std::shared_ptr<LogFileDataGroup>> LogFileDataAssistantImp::findEqualSimulationsForDifferentKernels(std::vector<std::shared_ptr<LogFileData>> allLogFileData, std::shared_ptr<LogFileDataAssistantStrategy> strategy)
170{
171 std::vector<std::shared_ptr<LogFileData>> myLogFileData = getSimulationGroupLogFileData(strategy->getSimulationName(), allLogFileData);
172
173 std::vector<std::shared_ptr<LogFileDataGroupImp> > kernelGroups;
175 kernelGroups.at(0)->addLogFileData(myLogFileData.at(0));
176
177 for (int i = 1; i < myLogFileData.size(); i++) {
178 bool added = false;
179 for (int j = 0; j < kernelGroups.size(); j++) {
180 if (checkEqualSimulationData(myLogFileData.at(i), kernelGroups.at(j)->getLogFileData(0))) {
181 if (checkEqualViscosity(myLogFileData.at(i), kernelGroups.at(j)->getLogFileData(0))) {
182 if (strategy->checkSimulationParameter(myLogFileData.at(i), kernelGroups.at(j)->getLogFileData(0))) {
183 kernelGroups.at(j)->addLogFileData(myLogFileData.at(i));
184 added = true;
185 }
186 }
187 }
188 }
189 if (!added) {
190 std::shared_ptr<LogFileDataGroupImp> newGroup = LogFileDataGroupImp::getNewInstance();
191 newGroup->addLogFileData(myLogFileData.at(i));
192 kernelGroups.push_back(newGroup);
193 }
194 }
195
197}
198
199std::vector<std::shared_ptr<LogFileDataGroup> > LogFileDataAssistantImp::findEqualKernelSimulationsForDifferentViscosities(std::vector<std::shared_ptr<LogFileData>> allLogFileData, std::shared_ptr<LogFileDataAssistantStrategy> strategy)
200{
201 std::vector<std::shared_ptr<LogFileData>> myLogFileData = getSimulationGroupLogFileData(strategy->getSimulationName(), allLogFileData);
202
203 std::vector<std::shared_ptr<LogFileDataGroupImp> > viscosityGroups;
205 viscosityGroups.at(0)->addLogFileData(myLogFileData.at(0));
206
207 for (int i = 1; i < myLogFileData.size(); i++) {
208 bool added = false;
209 for (int j = 0; j < viscosityGroups.size(); j++) {
210 if (checkEqualSimulationData(myLogFileData.at(i), viscosityGroups.at(j)->getLogFileData(0))) {
211 if (checkEqualKernel(myLogFileData.at(i), viscosityGroups.at(j)->getLogFileData(0))) {
212 if (strategy->checkSimulationParameter(myLogFileData.at(i), viscosityGroups.at(j)->getLogFileData(0))) {
213 viscosityGroups.at(j)->addLogFileData(myLogFileData.at(i));
214 added = true;
215 }
216 }
217 }
218 }
219 if (!added) {
220 std::shared_ptr<LogFileDataGroupImp> newGroup = LogFileDataGroupImp::getNewInstance();
221 newGroup->addLogFileData(myLogFileData.at(i));
222 viscosityGroups.push_back(newGroup);
223 }
224 }
225
227}
228
LogFileDataAssistantImp()
std::vector< std::shared_ptr< LogFileDataGroup > > findDataCombination(std::vector< std::shared_ptr< LogFileData > > allLogFileData, std::shared_ptr< LogFileDataAssistantStrategy > strategy, DataCombination combination)
std::vector< std::shared_ptr< LogFileDataGroup > > findEqualKernelSimulationsForDifferentViscosities(std::vector< std::shared_ptr< LogFileData > > allLogFileData, std::shared_ptr< LogFileDataAssistantStrategy > strategy)
std::vector< std::vector< std::shared_ptr< LogFileData > > > sortLogFileDataAfterKernels(std::vector< std::shared_ptr< LogFileData > > logFileData)
bool checkEqualViscosity(std::shared_ptr< LogFileData > logFileData1, std::shared_ptr< LogFileData > logFileData2)
DataCombination
static std::shared_ptr< LogFileDataAssistant > getNewInstance()
bool checkEqualKernel(std::shared_ptr< LogFileData > logFileData1, std::shared_ptr< LogFileData > logFileData2)
std::vector< std::shared_ptr< LogFileDataGroup > > findEqualSimulationsForDifferentKernels(std::vector< std::shared_ptr< LogFileData > > allLogFileData, std::shared_ptr< LogFileDataAssistantStrategy > strategy)
bool checkBasicSimulationIsInLogFiles(std::vector< std::shared_ptr< LogFileData > > allLogFileData, std::string simName)
std::vector< std::shared_ptr< LogFileData > > getSimulationGroupLogFileData(std::string simName, std::vector< std::shared_ptr< LogFileData > > allLogFileData)
bool equalDouble(double num1, double num2)
static std::shared_ptr< LogFileDataGroupImp > getNewInstance()
std::vector< std::shared_ptr< LogFileDataGroup > > castToLogFileDataGroup(std::vector< std::shared_ptr< LogFileDataGroupImp > > data)
bool checkEqualSimulationData(std::shared_ptr< LogFileData > logFileData1, std::shared_ptr< LogFileData > logFileData2)
@ EqualSimulationsForDifferentKernels
@ EqualKernelSimulationsForDifferentViscosities
std::shared_ptr< T > SPtr