From 1f42d0b723f09b03b04dc1ae68928a920032977d Mon Sep 17 00:00:00 2001
From: Anna Wellmann <a.wellmann@tu-braunschweig.de>
Date: Mon, 6 Nov 2023 15:38:42 +0000
Subject: [PATCH] Use const& LBMSimulationParameter instead of shared pointer
---
.../VirtualFluids_GPU/Output/FileWriter.cpp | 48 +++----
.../Output/WriterUtilities.cpp | 38 ++---
.../Output/WriterUtilities.h | 6 +-
.../Output/WriterUtilitiesTest.cpp | 132 +++++++++---------
.../VirtualFluids_GPU/Parameter/Parameter.cpp | 8 +-
.../VirtualFluids_GPU/Parameter/Parameter.h | 4 +-
6 files changed, 118 insertions(+), 118 deletions(-)
diff --git a/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp b/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp
index 5bf066a73..ea53eaf93 100644
--- a/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp
+++ b/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp
@@ -237,50 +237,50 @@ std::vector<std::string> FileWriter::writeUnstructuredGridLT(std::shared_ptr<Par
//////////////////////////////////////////////////////////////////////////
for (unsigned int pos = startPosition; pos < endPosition; pos++) {
- const LBMSimulationParameter* parH = para->getParHConst(level).get();
- if (parH->typeOfGridNode[pos] == GEO_FLUID) {
+ const LBMSimulationParameter& parH = para->getParHConst(level);
+ if (parH.typeOfGridNode[pos] == GEO_FLUID) {
//////////////////////////////////////////////////////////////////////////
- double x1 = parH->coordinateX[pos];
- double x2 = parH->coordinateY[pos];
- double x3 = parH->coordinateZ[pos];
+ double x1 = parH.coordinateX[pos];
+ double x2 = parH.coordinateY[pos];
+ double x3 = parH.coordinateZ[pos];
//////////////////////////////////////////////////////////////////////////
relPosInPart = pos - startPosition;
//////////////////////////////////////////////////////////////////////////
nodes[relPosInPart] = (makeUbTuple((float)(x1), (float)(x2), (float)(x3)));
- nodeData[0][relPosInPart] = (double)parH->pressure[pos] / (double)3.0 * (double)para->getDensityRatio() * (double)para->getVelocityRatio() * (double)para->getVelocityRatio();
- nodeData[1][relPosInPart] = (double)parH->rho[pos] / (double)3.0 * (double)para->getDensityRatio() * (double)para->getVelocityRatio() * (double)para->getVelocityRatio();
- nodeData[2][relPosInPart] = (double)parH->velocityX[pos] * (double)para->getVelocityRatio();
- nodeData[3][relPosInPart] = (double)parH->velocityY[pos] * (double)para->getVelocityRatio();
- nodeData[4][relPosInPart] = (double)parH->velocityZ[pos] * (double)para->getVelocityRatio();
- nodeData[5][relPosInPart] = (double)parH->typeOfGridNode[pos];
+ nodeData[0][relPosInPart] = (double)parH.pressure[pos] / (double)3.0 * (double)para->getDensityRatio() * (double)para->getVelocityRatio() * (double)para->getVelocityRatio();
+ nodeData[1][relPosInPart] = (double)parH.rho[pos] / (double)3.0 * (double)para->getDensityRatio() * (double)para->getVelocityRatio() * (double)para->getVelocityRatio();
+ nodeData[2][relPosInPart] = (double)parH.velocityX[pos] * (double)para->getVelocityRatio();
+ nodeData[3][relPosInPart] = (double)parH.velocityY[pos] * (double)para->getVelocityRatio();
+ nodeData[4][relPosInPart] = (double)parH.velocityZ[pos] * (double)para->getVelocityRatio();
+ nodeData[5][relPosInPart] = (double)parH.typeOfGridNode[pos];
if(para->getDiffOn())
- nodeData[firstConcNode][relPosInPart] = (double)parH->concentration[pos];
+ nodeData[firstConcNode][relPosInPart] = (double)parH.concentration[pos];
if(para->getIsBodyForce())
{
- nodeData[firstBodyForceNode ][relPosInPart] = (double)parH->forceX_SP[pos] * (double)para->getScaledForceRatio(level);
- nodeData[firstBodyForceNode + 1][relPosInPart] = (double)parH->forceY_SP[pos] * (double)para->getScaledForceRatio(level);
- nodeData[firstBodyForceNode + 2][relPosInPart] = (double)parH->forceZ_SP[pos] * (double)para->getScaledForceRatio(level);
+ nodeData[firstBodyForceNode ][relPosInPart] = (double)parH.forceX_SP[pos] * (double)para->getScaledForceRatio(level);
+ nodeData[firstBodyForceNode + 1][relPosInPart] = (double)parH.forceY_SP[pos] * (double)para->getScaledForceRatio(level);
+ nodeData[firstBodyForceNode + 2][relPosInPart] = (double)parH.forceZ_SP[pos] * (double)para->getScaledForceRatio(level);
}
if(para->getUseTurbulentViscosity())
{
- nodeData[firstNutNode][relPosInPart] = (double)parH->turbViscosity[pos] * (double)para->getScaledViscosityRatio(level);
+ nodeData[firstNutNode][relPosInPart] = (double)parH.turbViscosity[pos] * (double)para->getScaledViscosityRatio(level);
}
if (para->getCalcTurbulenceIntensity()) {
- nodeData[firstTurbulenceNode ][relPosInPart] = (double)parH->vxx[pos];
- nodeData[firstTurbulenceNode + 1][relPosInPart] = (double)parH->vyy[pos];
- nodeData[firstTurbulenceNode + 2][relPosInPart] = (double)parH->vzz[pos];
- nodeData[firstTurbulenceNode + 3][relPosInPart] = (double)parH->vxy[pos];
- nodeData[firstTurbulenceNode + 4][relPosInPart] = (double)parH->vxz[pos];
- nodeData[firstTurbulenceNode + 5][relPosInPart] = (double)parH->vyz[pos];
+ nodeData[firstTurbulenceNode ][relPosInPart] = (double)parH.vxx[pos];
+ nodeData[firstTurbulenceNode + 1][relPosInPart] = (double)parH.vyy[pos];
+ nodeData[firstTurbulenceNode + 2][relPosInPart] = (double)parH.vzz[pos];
+ nodeData[firstTurbulenceNode + 3][relPosInPart] = (double)parH.vxy[pos];
+ nodeData[firstTurbulenceNode + 4][relPosInPart] = (double)parH.vxz[pos];
+ nodeData[firstTurbulenceNode + 5][relPosInPart] = (double)parH.vyz[pos];
}
//////////////////////////////////////////////////////////////////////////
- WriterUtilities::getIndicesOfAllNodesInOct(indicesOfOct, pos, para->getParHConst(level).get());
+ WriterUtilities::getIndicesOfAllNodesInOct(indicesOfOct, pos, para->getParHConst(level));
if (WriterUtilities::isPeriodicCell(parH, indicesOfOct[0], indicesOfOct[6])) {
continue;
@@ -390,7 +390,7 @@ std::vector<std::string> FileWriter::writeUnstructuredGridMedianLT(std::shared_p
dn7 = number7 - startPosition;
dn8 = number8 - startPosition;
//////////////////////////////////////////////////////////////////////////
- if (WriterUtilities::isPeriodicCell(para->getParHConst(level).get(), number1, number7))
+ if (WriterUtilities::isPeriodicCell(para->getParHConst(level), number1, number7))
continue;
//////////////////////////////////////////////////////////////////////////
if (neighborsFluid == true) cells.push_back(makeUbTuple(dn1, dn2, dn3, dn4, dn5, dn6, dn7, dn8));
diff --git a/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.cpp b/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.cpp
index 4db1b7efc..71177522d 100644
--- a/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.cpp
+++ b/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.cpp
@@ -10,43 +10,43 @@ std::string WriterUtilities::makePartFileNameEnding(uint level, int ID, int part
uint WriterUtilities::calculateNumberOfParts(const Parameter* parameter, uint level)
{
- return (uint)parameter->getParHConst(level)->numberOfNodes / parameter->getLimitOfNodesForVTK() + 1;
+ return (uint)parameter->getParHConst(level).numberOfNodes / parameter->getLimitOfNodesForVTK() + 1;
}
-bool WriterUtilities::isPeriodicCell(const LBMSimulationParameter* parH, unsigned int baseNodeOfCell,
+bool WriterUtilities::isPeriodicCell(const LBMSimulationParameter& parH, unsigned int baseNodeOfCell,
unsigned int otherNodeInCell)
{
const real distance = sqrt(
- pow(parH->coordinateX[otherNodeInCell] - parH->coordinateX[baseNodeOfCell], 2.) +
- pow(parH->coordinateY[otherNodeInCell] - parH->coordinateY[baseNodeOfCell], 2.) +
- pow(parH->coordinateZ[otherNodeInCell] - parH->coordinateZ[baseNodeOfCell], 2.));
- return distance > 1.01 * sqrt(3 * pow(parH->gridSpacing, 2.));
+ pow(parH.coordinateX[otherNodeInCell] - parH.coordinateX[baseNodeOfCell], 2.) +
+ pow(parH.coordinateY[otherNodeInCell] - parH.coordinateY[baseNodeOfCell], 2.) +
+ pow(parH.coordinateZ[otherNodeInCell] - parH.coordinateZ[baseNodeOfCell], 2.));
+ return distance > 1.01 * sqrt(3 * pow(parH.gridSpacing, 2.));
}
uint WriterUtilities::calculateNumberOfNodesInPart(const Parameter* para, uint level, uint part)
{
if (part >= WriterUtilities::calculateNumberOfParts(para, level))
throw std::runtime_error("The number of nodes for a non-existing part can not be calculated");
- if (((part + 1) * para->getLimitOfNodesForVTK()) > (uint)para->getParHConst(level)->numberOfNodes)
- return (uint)para->getParHConst(level)->numberOfNodes - (part * para->getLimitOfNodesForVTK());
+ if (((part + 1) * para->getLimitOfNodesForVTK()) > (uint)para->getParHConst(level).numberOfNodes)
+ return (uint)para->getParHConst(level).numberOfNodes - (part * para->getLimitOfNodesForVTK());
return para->getLimitOfNodesForVTK();
}
void WriterUtilities::getIndicesOfAllNodesInOct(std::array<uint, 8>& nodeIndices, uint baseNodeOfOct,
- const LBMSimulationParameter* parH)
+ const LBMSimulationParameter& parH)
{
nodeIndices[0] = baseNodeOfOct;
- nodeIndices[1] = parH->neighborX[nodeIndices[0]];
- nodeIndices[2] = parH->neighborY[nodeIndices[1]];
- nodeIndices[3] = parH->neighborY[nodeIndices[0]];
- nodeIndices[4] = parH->neighborZ[nodeIndices[0]];
- nodeIndices[5] = parH->neighborZ[nodeIndices[1]];
- nodeIndices[6] = parH->neighborZ[nodeIndices[2]];
- nodeIndices[7] = parH->neighborZ[nodeIndices[3]];
+ nodeIndices[1] = parH.neighborX[nodeIndices[0]];
+ nodeIndices[2] = parH.neighborY[nodeIndices[1]];
+ nodeIndices[3] = parH.neighborY[nodeIndices[0]];
+ nodeIndices[4] = parH.neighborZ[nodeIndices[0]];
+ nodeIndices[5] = parH.neighborZ[nodeIndices[1]];
+ nodeIndices[6] = parH.neighborZ[nodeIndices[2]];
+ nodeIndices[7] = parH.neighborZ[nodeIndices[3]];
}
void WriterUtilities::calculateRelativeNodeIndexInPart(std::array<uint, 8>& relativePositionInPart,
- const std::array<uint, 8>& indicesOfOct, uint startPositionOfPart)
+ const std::array<uint, 8>& indicesOfOct, uint startPositionOfPart)
{
for (size_t i = 0; i < relativePositionInPart.size(); i++) {
relativePositionInPart[i] = indicesOfOct[i] - startPositionOfPart;
@@ -54,10 +54,10 @@ void WriterUtilities::calculateRelativeNodeIndexInPart(std::array<uint, 8>& rela
}
bool WriterUtilities::areAllNodesInOctValidForWriting(const std::array<uint, 8>& indicesOfOct,
- const LBMSimulationParameter* parH, uint endPositionOfPart)
+ const LBMSimulationParameter& parH, uint endPositionOfPart)
{
const bool neighborsAreFluid = std::all_of(indicesOfOct.begin(), indicesOfOct.end(),
- [&](uint index) { return parH->typeOfGridNode[index] == GEO_FLUID; });
+ [&](uint index) { return parH.typeOfGridNode[index] == GEO_FLUID; });
const bool neighborIsOutOfPart =
(std::any_of(indicesOfOct.begin(), indicesOfOct.end(), [&](uint index) { return index > endPositionOfPart; }));
diff --git a/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.h b/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.h
index eaa26dd54..dcdcd59fb 100644
--- a/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.h
+++ b/src/gpu/VirtualFluids_GPU/Output/WriterUtilities.h
@@ -13,13 +13,13 @@ class WriterUtilities
public:
static uint calculateNumberOfParts(const Parameter* para, uint level);
static uint calculateNumberOfNodesInPart(const Parameter* para, uint level, uint part);
- static bool isPeriodicCell(const LBMSimulationParameter* parH, unsigned int baseNodeOfCell,
+ static bool isPeriodicCell(const LBMSimulationParameter& parH, unsigned int baseNodeOfCell,
unsigned int otherNodeInCell);
static void getIndicesOfAllNodesInOct(std::array<uint, 8>& nodeIndices, uint baseNodeOfOct,
- const LBMSimulationParameter* parH);
+ const LBMSimulationParameter& parH);
static void calculateRelativeNodeIndexInPart(std::array<uint, 8>& relativePositionInPart,
const std::array<uint, 8>& indicesOfOct, uint startPositionOfPart);
- static bool areAllNodesInOctValidForWriting(const std::array<uint, 8>& indicesOfOct, const LBMSimulationParameter* parH,
+ static bool areAllNodesInOctValidForWriting(const std::array<uint, 8>& indicesOfOct, const LBMSimulationParameter& parH,
uint endPositionOfPart);
static std::string makePartFileNameEnding(uint level, int processID, int part, int timestep);
diff --git a/src/gpu/VirtualFluids_GPU/Output/WriterUtilitiesTest.cpp b/src/gpu/VirtualFluids_GPU/Output/WriterUtilitiesTest.cpp
index e2aaa2ca7..056022427 100644
--- a/src/gpu/VirtualFluids_GPU/Output/WriterUtilitiesTest.cpp
+++ b/src/gpu/VirtualFluids_GPU/Output/WriterUtilitiesTest.cpp
@@ -40,7 +40,7 @@ TEST(WriterUtilitiesTest, calculateNumberOfNodesInPart)
class WriterUtilitiesPeriodicCellTest : public testing::Test
{
protected:
- std::unique_ptr<LBMSimulationParameter> parH = std::make_unique<LBMSimulationParameter>();
+ LBMSimulationParameter parH = LBMSimulationParameter();
const uint level = 0;
const uint baseNodeIndex = 0;
const uint otherNodeIndex = 1;
@@ -51,90 +51,90 @@ protected:
// create a domain with only three layers of nodes
// nodes are at the coordinates 0.0, 1.0 and 2.0
- parH->gridSpacing = 1.0;
+ parH.gridSpacing = 1.0;
- parH->coordinateX = new real[2];
- parH->coordinateY = new real[2];
- parH->coordinateZ = new real[2];
+ parH.coordinateX = new real[2];
+ parH.coordinateY = new real[2];
+ parH.coordinateZ = new real[2];
- parH->coordinateX[baseNodeIndex] = coordinates[baseNodeIndex];
- parH->coordinateY[baseNodeIndex] = coordinates[baseNodeIndex];
- parH->coordinateZ[baseNodeIndex] = coordinates[baseNodeIndex];
- parH->coordinateX[otherNodeIndex] = coordinates[otherNodeIndex];
- parH->coordinateY[otherNodeIndex] = coordinates[otherNodeIndex];
- parH->coordinateZ[otherNodeIndex] = coordinates[otherNodeIndex];
+ parH.coordinateX[baseNodeIndex] = coordinates[baseNodeIndex];
+ parH.coordinateY[baseNodeIndex] = coordinates[baseNodeIndex];
+ parH.coordinateZ[baseNodeIndex] = coordinates[baseNodeIndex];
+ parH.coordinateX[otherNodeIndex] = coordinates[otherNodeIndex];
+ parH.coordinateY[otherNodeIndex] = coordinates[otherNodeIndex];
+ parH.coordinateZ[otherNodeIndex] = coordinates[otherNodeIndex];
}
void TearDown() override
{
- delete[] parH->coordinateX;
- delete[] parH->coordinateY;
- delete[] parH->coordinateZ;
+ delete[] parH.coordinateX;
+ delete[] parH.coordinateY;
+ delete[] parH.coordinateZ;
}
};
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsNotPeriodic)
{
- EXPECT_FALSE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_FALSE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ EXPECT_FALSE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_FALSE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInX)
{
- parH->coordinateX[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateX[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInY)
{
- parH->coordinateY[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateY[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInZ)
{
- parH->coordinateZ[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateZ[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInXY)
{
- parH->coordinateX[1] = 2.0;
- parH->coordinateY[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateX[1] = 2.0;
+ parH.coordinateY[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInXZ)
{
- parH->coordinateX[1] = 2.0;
- parH->coordinateZ[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateX[1] = 2.0;
+ parH.coordinateZ[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInYZ)
{
- parH->coordinateY[1] = 2.0;
- parH->coordinateZ[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateY[1] = 2.0;
+ parH.coordinateZ[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
TEST_F(WriterUtilitiesPeriodicCellTest, cellIsPeriodicInXYZ)
{
- parH->coordinateX[1] = 2.0;
- parH->coordinateY[1] = 2.0;
- parH->coordinateZ[1] = 2.0;
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), baseNodeIndex, otherNodeIndex));
- EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH.get(), otherNodeIndex, baseNodeIndex));
+ parH.coordinateX[1] = 2.0;
+ parH.coordinateY[1] = 2.0;
+ parH.coordinateZ[1] = 2.0;
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, baseNodeIndex, otherNodeIndex));
+ EXPECT_TRUE(WriterUtilities::isPeriodicCell(parH, otherNodeIndex, baseNodeIndex));
}
class WriterUtilitiesNeighborOctTest : public testing::Test
{
- static void setUpNeighborsNeighborsForOct(LBMSimulationParameter* parH, const std::array<uint, 8>& nodeIndices)
+ static void setUpNeighborsNeighborsForOct(LBMSimulationParameter& parH, const std::array<uint, 8>& nodeIndices)
{
// node indices: MMM, PMM, PPM, MPM,
// MMP, PMP, PPP, MPP
@@ -142,28 +142,28 @@ class WriterUtilitiesNeighborOctTest : public testing::Test
for (uint i = 0; i < (uint)nodeIndices.size(); i++) {
const uint currentNodeIndex = nodeIndices[i];
if (i < 4)
- parH->neighborZ[currentNodeIndex] = nodeIndices[i + 4];
+ parH.neighborZ[currentNodeIndex] = nodeIndices[i + 4];
else
- parH->neighborZ[currentNodeIndex] = 99;
+ parH.neighborZ[currentNodeIndex] = 99;
if (i == 0 || i == 4)
- parH->neighborY[currentNodeIndex] = nodeIndices[i + 3];
+ parH.neighborY[currentNodeIndex] = nodeIndices[i + 3];
else if (i == 1 || i == 5)
- parH->neighborY[currentNodeIndex] = nodeIndices[i + 1];
+ parH.neighborY[currentNodeIndex] = nodeIndices[i + 1];
else
- parH->neighborY[currentNodeIndex] = 999;
+ parH.neighborY[currentNodeIndex] = 999;
if (i == 0 || i == 4)
- parH->neighborX[currentNodeIndex] = nodeIndices[i + 1];
+ parH.neighborX[currentNodeIndex] = nodeIndices[i + 1];
else if (i == 3 || i == 7)
- parH->neighborX[currentNodeIndex] = nodeIndices[i - 1];
+ parH.neighborX[currentNodeIndex] = nodeIndices[i - 1];
else
- parH->neighborX[currentNodeIndex] = 9999;
+ parH.neighborX[currentNodeIndex] = 9999;
}
}
public:
- std::unique_ptr<LBMSimulationParameter> parH = std::make_unique<LBMSimulationParameter>();
+ LBMSimulationParameter parH = LBMSimulationParameter();
std::array<uint, 8> nodeIndices;
void SetUp() override
@@ -172,24 +172,24 @@ public:
std::iota(nodeIndices.begin(), nodeIndices.end(), 0);
std::reverse(nodeIndices.begin(), nodeIndices.end());
- parH->neighborX = new uint[8];
- parH->neighborY = new uint[8];
- parH->neighborZ = new uint[8];
- setUpNeighborsNeighborsForOct(parH.get(), nodeIndices);
+ parH.neighborX = new uint[8];
+ parH.neighborY = new uint[8];
+ parH.neighborZ = new uint[8];
+ setUpNeighborsNeighborsForOct(parH, nodeIndices);
}
void TearDown() override
{
- delete[] parH->neighborX;
- delete[] parH->neighborY;
- delete[] parH->neighborZ;
+ delete[] parH.neighborX;
+ delete[] parH.neighborY;
+ delete[] parH.neighborZ;
}
};
TEST_F(WriterUtilitiesNeighborOctTest, getIndicesOfAllNodesInOct)
{
std::array<uint, 8> resultingNodeIndices;
- WriterUtilities::getIndicesOfAllNodesInOct(resultingNodeIndices, nodeIndices[0], parH.get());
+ WriterUtilities::getIndicesOfAllNodesInOct(resultingNodeIndices, nodeIndices[0], parH);
for (uint i = 0; i < 8; i++)
EXPECT_THAT(resultingNodeIndices[i], testing::Eq(nodeIndices[i])) << "for index i = " << i << " in nodeIndices";
}
@@ -208,7 +208,7 @@ TEST(WriterUtilitiesTest, calculateRelativeNodeIndexInPart)
class WriterUtilitiesTestNodeValidity : public testing::Test
{
protected:
- std::unique_ptr<LBMSimulationParameter> parH = std::make_unique<LBMSimulationParameter>();
+ LBMSimulationParameter parH = LBMSimulationParameter();
std::array<uint, 8> nodeIndices;
std::array<uint, 8> typeOfGridNode;
@@ -218,32 +218,32 @@ protected:
std::iota(nodeIndices.begin(), nodeIndices.end(), 0);
std::fill(typeOfGridNode.begin(), typeOfGridNode.end(), GEO_FLUID);
- parH->typeOfGridNode = typeOfGridNode.data();
+ parH.typeOfGridNode = typeOfGridNode.data();
}
};
TEST_F(WriterUtilitiesTestNodeValidity, allNodesInOctValidForWriting)
{
uint endPositionOfPart = 7;
- EXPECT_TRUE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH.get(), endPositionOfPart));
+ EXPECT_TRUE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH, endPositionOfPart));
}
TEST_F(WriterUtilitiesTestNodeValidity, areAllNodesInOctValidForWriting_NodeOutOfPart)
{
uint endPositionOfPart = 6;
- EXPECT_FALSE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH.get(), endPositionOfPart));
+ EXPECT_FALSE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH, endPositionOfPart));
}
TEST_F(WriterUtilitiesTestNodeValidity, areAllNodesInOctValidForWriting_NonFluidNode)
{
uint endPositionOfPart = 7;
typeOfGridNode[0] = GEO_SOLID;
- EXPECT_FALSE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH.get(), endPositionOfPart));
+ EXPECT_FALSE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH, endPositionOfPart));
}
TEST_F(WriterUtilitiesTestNodeValidity, areAllNodesInOctValidForWriting_NonFluidNodeAtEnd)
{
uint endPositionOfPart = 7;
typeOfGridNode[7] = GEO_SOLID;
- EXPECT_FALSE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH.get(), endPositionOfPart));
+ EXPECT_FALSE(WriterUtilities::areAllNodesInOctValidForWriting(nodeIndices, parH, endPositionOfPart));
}
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
index 2b30f0c29..9f11bfe4b 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
@@ -1738,14 +1738,14 @@ std::shared_ptr<LBMSimulationParameter> Parameter::getParH(int level)
return parH[level];
}
-std::shared_ptr<const LBMSimulationParameter> Parameter::getParDConst(int level) const
+const LBMSimulationParameter& Parameter::getParDConst(int level) const
{
- return parD[level];
+ return *parD[level];
}
-std::shared_ptr<const LBMSimulationParameter> Parameter::getParHConst(int level) const
+const LBMSimulationParameter& Parameter::getParHConst(int level) const
{
- return parH[level];
+ return *parH[level];
}
const std::vector<std::shared_ptr<LBMSimulationParameter>> &Parameter::getParHallLevels()
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
index 598c43015..32eca128c 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
@@ -470,8 +470,8 @@ public:
//! \brief Pointer to instance of LBMSimulationParameter - stored on Device (GPU)
std::shared_ptr<LBMSimulationParameter> getParD(int level);
- std::shared_ptr<const LBMSimulationParameter> getParHConst(int level) const;
- std::shared_ptr<const LBMSimulationParameter> getParDConst(int level) const;
+ const LBMSimulationParameter& getParHConst(int level) const;
+ const LBMSimulationParameter& getParDConst(int level) const;
const std::vector<std::shared_ptr<LBMSimulationParameter>>& getParHallLevels();
const std::vector<std::shared_ptr<LBMSimulationParameter>>& getParDallLevels();
--
GitLab